I wonder if the slowdown in non-ai features this release was influenced in some way by their migration away from AMD modules to ES modules.

Putting myself in their shoes and taking codemods into account, I wouldn’t want to make a big feature and have to worry about AMD/ES module concerns. Why do that when instead I could get a bunch of checking and smaller (but non headline) tasks out of the way and get back onto the larger features in 1-2 months after the ES modules are proven to work and I don’t have to worry about rolling back changes.

Either that, or sometimes by statistical eventuality we end up with changes (which all take a different time to be completed) just not being released within a small period of time.

There’s no official announcement per se, but the windows version is built with .net which has been getting better linux support over the last two years.

There are unofficial instructions to run it through wine on their issue tracker.

It’s basically just a better sourcetree.

If you’re already used to sourcetree, it’s a really smooth transition.

The main reason to switch away from sourcetree is the bugs and papercuts.

• Bugs: Sure, bugs happen with everything but you’re stuck with them when they happen with sourcetree. There was an issue not too long ago where sourcetree couldn’t scroll. It was classed as a low priority bug and took about a year for it to be fixed. Imagine needing to use your keyboard to scroll up and down, but then git would refresh and take you back to the top where you’d need to start again. Now imagine trying to do that for a whole year. And that was just one bug.

• Papercuts: It’s so good at some things that you want to forgive the flaws in other things and find workarounds to bugs, but after a while they build up into poisoning you’re experience. For example: things going slow in larger repos, getting git errors when staging certain lines because a different line in the middle had to be staged/removed in a different order, the bi-yearly account issues, etc…

The thing is, you don’t need to put up with it since fork already does everything that sourcetree does (and a bit more), and they actually spend time sanding off the papercuts so you don’t need to worry about finding workarounds when something goes wrong.

Just losing the bugs without losing any features is already reason enough to switch.

But there’s also the improvements over sourcetree as well:

• Collapsible and sortable git graph (by date or topology)
• Better staging – Sourcetree supports staging changed content by file, hunk, and sometimes by line when it doesn’t bug out. – Fork supports staging changed content AND original content by file, hunk, and by line. That way if you changed a line, you can keep both the old version and new version in a commit. (e.g. You altered a comment in your code, but then upon self review when staging changes you realised you don’t want to change the comment, but instead you want the new comment to exist under the old comment. Instead of copying the change, undoing the change, then pasting the change into the code, you can simply stage the addition of the line, but discard the removal of the old line. Now both lines exist in your code)
• Better rebasing
• Supports new git features (e.g. worktrees, new diff algos, etc)
• Just how snappy the program is compared to sourcetree, it keeps you in that flow state

Looks quite good if you want to use git exclusively in vscode.

IMO, fork is the best git client for macOS/Windows but lacks native linux support (although they are experimenting with it).

Until fork gains linux support, this seems like a nice alternative if running on linux (and if it supports the remote development APIs: running on a linux docker image)

Watching web developers react to this change on mastodon has been… interesting to say the least

This doesn’t seem overly useful.

It’s a list taken out of a bunch of books with no regard for how something can be the best path in one language and a smell in another language.

Look at this page for example: https://luzkan.github.io/smells/imperative-loops

It suggests using functional loop methods (.map(), .reduce(), .filter()) instead of using imperative loops (for, for in, for each) but completely disregards the facts that imperative loops also have access to the break, continue, and return keywords to improve performance.

For example: If I have an unsorted list of 1000 cars which includes a whole bunch of information per car (e.g. color, year manufactured, etc…), and I want to know if there were any cars were manufactured before the year 1980, I can run an imperative loop through the list and early return true if I find one, and only returning false if I haven’t found one by the end of the list.

If the third car was made in 1977, then I have only iterated through 3 cars to find my answer.

But if I were to try this with only functional loops, I would have to iterate through all 1000 cars before I had my answer.

A website with blind rules like this is going to lead to worse code.

QOI is just a format that’s easy for a programmer to get their head around.

It’s not designed for everyday use and hardware optimization like jpeg-xl is.

You’re most likely to see QOI in homebrewed game engines.

Are you not made primarily of water?

The syntax is only difficult to read in their example.

I fixed their example here: https://programming.dev/comment/12087783

I fixed it for you (markdown tables support padding to make them easy to read):

|markdown|table|
|--------|-----|
|x       |y    |

Chromium had it behind a flag for a while, but if there were security or serious enough performance concerns then it would make sense to remove it and wait for the jpeg-xl encoder/decoder situation to change.

It baffles me that someone large enough hasn’t gone out of their way to make a decoder for chromium.

The video streaming services have done a lot of work to switch users to better formats to reduce their own costs.

If a CDN doesn’t add it to chromium within the next 3 years, I’ll be seriously questioning their judgement.

I’m under the impression that there’s two reasons we don’t have it in chromium yet:

1. Google initially ignored jpeg-xl but then everyone jumped on it and now they feel they have to create a post-hoc justification for not supporting it earlier which is tricky and now they have a sunk cost situation to keep ignoring it
2. Google today was burnt by the webp vulnerability which happened because there was only one decoder library and now they’re waiting for more jpeg-xl libraries which have optimizations (which rules out reference implementations), good support (which rules out libraries by single authors), have proven battle-hardening (which will only happen over time) and are written safely to avoid another webp style vulnerability.

Google already wrote the wuffs language which is specifically designed to handle formats in a fast and safe way but it looks like it only has one dedicated maintainer which means it’s still stuck on a bus factor of 1.

Honestly, Google or Microsoft should just make a team to work on a jpg-xl library in wuffs while adobe should make a team to work on a jpg-xl library in rust/zig.

That way everyone will be happy, we will have two solid implementations, and they’ll both be made focussing on their own features/extensions first so we’ll all have a choice among libraries for different needs (e.g. browser lib focusing on fast decode, creative suite lib for optimised encode).

You should put this in codepen so people don’t need to clone a repo to see it.

For example, here’s a 3d css-only thing I was fiddling with: https://codepen.io/spartanatreyu/pen/yPyNjw?editors=0100

You keep saying “relevance”, and now other things like “gimmick” and “marketing”.

Why are you so focused on “relevance”?

They’re completely unrelated to Deno.

Node had problems, ts-node had problems, Deno fixes those problems for developers.

Separately, Bun trades solving some problems for solving other problems.

Developers are free to choose between runtimes based on what problems they encounter.

Personally I use node for existing web projects and deno for data processing and to compile scripts into redistributable binaries.

stdlib.io is a data process/vis library, not a standard library.

jQuery was a DOM/Utility DX library (and also a compatibility layer before all browsers finally focussed on standards), not a standard library.

Deno people are trying so fucking hard to be relevant. It’s embarrassing. Bringing nothing to the table has been their MO from day 1.

Let’s examine that.

Deno has always been:

(parapharing) “Hi, I’m the creator of Node and want to make it better but can’t get everyone on board with the changes. So I’m going to create a new JS runtime. Node will need to implement these improvements to keep up or everyone will switch away from node. Either way, developers win.”

We know it’s been that way since he was a month into Deno’s development in his famous talk: 10 Things I Regret About Node.js

Deno […] Bringing nothing to the table […]

Have a look through each of those 10 points he brought up, then compare that to node before, and node now. It’s pretty clear he gave them the swift kick in the ass to start making those changes. We win. That’s clearly a success.

What standard library?

JS has only had package/library hell

Who is this article for?

Firstly, it’s basically just a repost of existing info from the mozilla article but now with ads.

Secondly, the puppeteer team left years ago to work on playwright which is now the better product, which also supports firefox through the webdriver-bidi standard…

So now I’m wondering… just who was this article for?

I use git log --graph --all --remotes --oneline whenever I need to shell into another computer, but it’s still too barebones for regular use.

What specifically do you think is legacy in that comparison? The coloring? The horizontal layout? The whitespace?

Note: I’ve changed the first link from https://github.com/cxli233/FriendsDontLetFriends/network to https://github.com/zed-industries/zed/network. Still the same view, but just a different repo to highlight the problems

1. It’s in a small non-responsive box
2. Ridiculous spacing

• If you want to see the commit messages, you either need to hover over a dot which increases visual scanning durations or you need to go to the commits view which only shows the commits on a single branch

3. It doesn’t show commit messages
4. It’s scrolling horizontally
5. Branches cannot be collapsed
6. Branches cannot be hidden/ignored
7. No way to search for commits
8. No way to select multiple commits

• Which also means no way to diff any specific commits together
• And there’s also no way to perform an action over a range of commits
• And there’s also no way to start a merge/merge-request/pull-request/etc… between two commits

9. No way to sort by date/topologically
10. Keyboard controls only moves view instead of selecting commits

I’ll stop here at 10 reasons (or more if you count the dot points), otherwise I’ll be here all day.

The network view lays out forks and their branches, not only [local]/[local+1-remote] branches.

Yes, but the others can do that while still being usable.

I don’t know what IDE that miro screenshot is from. […]

It’s gitkraken

[…] But I see it as wasteful and confusing. The author initials are useless and wasteful, picking away focus. The branch labels are far off from the branch heads. […]

The picture doesn’t do it justice, it’s not a picture, it’s an interactive view.

You can resize things, show/hide columns, filter values in columns to only show commits with certain info (e.g. Ignore all dependabot commits), etc… Here’s an example video.

[…]The coloring seems confusing.

You can customise all that if you want.

The first link is a totally different purpose than the second two.

The first link is going to there because that’s the only graph view that github has.