nsm

If you are on macOS, there is https://nova.app/

Not the OP, but for me ST can't be beat in terms of how easy it is to write a plugin. It uses Python (Zed is Rust). Plugins generally auto-reloads. If extensibility is important to you, ST is still the way to go.

Two counterpoints:

1. Implying that there are only "a few islands left" shoes a strong bias towards assuming that only thins humans do in the digital realm is relevant, when in fact, the vast majority of things humans do are not in the digital sphere at all.

2. It's pretty clear when most people say that machine intelligence is close, right now, they are alluding to LLM or Deep Learning based approaches. I don't think you should assume they mean machines will catch up in a 100 years. They seem to imply it will be by 2030 or sowmthing.

https://without.boats/blog/revisiting-a-smaller-rust/

I think there is a programming language hole for a Rust-like language, but with GC and green threads. One that dispenses with single-ownership, and async/await footguns.

Something like F#/Kotlin is closest in terms of developer experience.

Unfortunately, we are really lacking a language that skews badly on some other axis

- F# - tainted by being Windows only for really long and being Microsoft. - Kotlin - tainted by the JVM - Java 24+ - has virtual threads, sum types, match expressions and other niceties, but tainted by the JVM again (Verbosity included, but this is not really a factor with IDEs and LLMs.)

Note that the opinions above are not mine, but "consensus". I'd say they are all unfair opinions.

I feel like people end up favoring new languages, simply because of novelty. Like, inevitably, somebody is gonna say Gleam. I'm all for having existing BEAM users getting access to new languages, but I'm not sure why one would pick a BEAM language for non-server applications when the developer tooling story for CLI apps, line-of-business apps and so on is so much stronger for the .NET and JVM ecosystems. No offense to the Gleam folks intended.

Aider has an ide mode close to this. Check out https://nikhilism.com/post/2026/nudge-skill/ to add similar behavior to certain agents. I too, am waiting for IDEs to do this in a polished way. next tab edit is not quite it

Can people give examples of how they use pre-commit hooks that _cannot_ be replaced by a combination of the following?

* CI (I understand pre-commit shifts errors left)

* in editor/IDE live error callouts for stuff like type checking, and auto-formatting for things like "linters".

Do you run tests? How do you know _which_ tests to run, and not just run every test CI would run, which could be slow?

Seconded. anecdotally. Heck, the best startup _founders_ I've worked with had young kids while in the most intense phases of the company!

Highly recommend the LookAway app if you are on macOS and looking for something encouraging you to take breaks and maintain good posture.

What money do you think pays for most of the development of the Linux kernel? I assure you, it is not the altruistic goodwill of people around the world.

This is only true for a subset of software like mobile apps. Web developers are not paying for anything except compute.

Would you pay for source-available products? GPL and paid license?

Along with a guarantee that you get to keep access to older versions (Jetbrains and Sublime Text models)?

The plain truth is that developers expect to get their tools free of charge.

This is an accurate, but damning indictment of how some of the most highly paid workers on the planet won't pay for tools. Unlike nearly every other profession.

Folks, if you can afford it, please pay for quality software, instead of relying on FAANG and VC money to keep the tools going!

https://randomascii.wordpress.com/ - former Chrome engineer about all things performance engineering and particularly focused on Windows.

But at present, there is a big gap in the workflow: You leave your editor, open a browser, navigate to some page or tab, then navigate to the exact same place in the code you were just looking at, click on a line to open a text box, and finally you can write your comment.

Jetbrains can review GitHub PRs right in the IDE.

The fees are paid by employers and not workers.

Have you considered sublime text as the lightweight editor?

After reading Careless People, I would be more surprised if Meta was _not_ doing these things. The company is amoral/immoral in the truest "responsibility to shareholders" (number go up) way. It needs to be made to lose everything.

The "integrated" part. I've written some here https://news.ycombinator.com/item?id=42871586

Highly recommend the Early Access book Data-Oriented Programming with Java by Chris Kiehl as another resource.

I’m confused about the assertion that green threads perform badly. 3 of the top platforms for high concurrency servers use or plan to use green threads (Go, Erlang, Java). My understanding was that green threads have limitations with C FFI which is why lower level languages don’t use them (Rust). Rust may also have performance concerns since it has other constraints to deal with.

This post does a fantastic job of laying out the reasoning and implementation of various concurrency methods and their trade-offs. It is one of the rare nuanced views on async/await vs green threads. Plus it makes the links between CPS, delimited continuations and effects, thus generalizing concurrency into one of several possible "stackful" operations.

In terms of ocaml and the authors concerns about continuation capturing and memory/performance, this is a good paper - http://manticore.cs.uchicago.edu/papers/pldi20-stacks-n-cont...

I think the _only_ thing the author didn't cover about concurrency is that "waiting for one of several things to complete" is a powerful primitive for concurrency that very few platforms provide direct access to. I.e. most async event loops are powered by OS primitives that allow such "heterogenous selects" and they are used under the hood but not exposed. I think Go's select, Tokio's equivalent, ConcurrentMLs/Racket more powerful choice operator. All of these allow expressing some nice patterns that other languages make impossible (sad Promise.race) or not user facing (cancellation in structured concurrency)

Great job!

I've had good experiences with Junie and AI assistant at their bread and butter languages of Java and Kotlin. I haven't tried it in anger though.

Jdk improvements and the new Nova/Rider backend how dramatically improved JetBrains performance. I highly encourage you to give it another shot.

Racket is related to LISP and already has a mature GUI implementation that uses native widgets on Windows and MacOS, and on Linux goes to GTK3 or falls back to GTK2. https://docs.racket-lang.org/gui/index.html

It is used to create their full featured teaching IDE.

It is worth looking at before re-inventing the stack.

To quote Iain M. Banks, probably not :)

"Sma," the ship said finally, with a hint of what might have been frustration in its voice, "I'm the smartest thing for a hundred light years radius, and by a factor of about a million ... but even I can't predict where a snooker ball's going to end up after more than six collisions." [GCU Arbitrary in "The State of the Art"]

This seems like introducing unnecessary complexity in the final artifact in order to use LLMs. Square peg, round hole.

Yes! Please support good paid software companies if you can afford them. Jetbrains, Sublime Text, others.

Reminds me of Adrian Tchaikovsky's new book Saturation Point. I don't want to reveal any spoilers, but it is about warm-blooded/cold-blooded and applicability to quicker adaptation.

Aren't checked exceptions the same as effect systems in the narrow case of error handling?

IDEs can have just as powerful keyboard shortcuts. IdeaVIM within Jetbrains is probably the most feature complete vim emulation?

What sets IDEs apart from trying to convert an editor to an IDE with a bunch of plugins is:

- somebody somewhere is hopefully sitting down with a cohesive vision of tying these tools together, instead of an assemblage of plugins each with their own visions. I would very much prefer to use their vision (a la macos/windows/Ubuntu) vs trying to configure each plugin to my own (arch/Gentoo). It could be an age thing, but at this point I really don't have the enthusiasm to become an expert at 12 different config file syntaxes and read the docs for all the options for each plugin i would need to tweak.

- an IDE is all encompassing in certain ways that is amazing. For example, Jetbrains is not only a fantastic code editor/refactoring swiss knife, it also has excellent git integration, and can leverage the same code navigation capabilities within diffs and PRs. It will autostash in branch specific stashes, and I can visually browse and diff these. I can attach to databases and get full SQL query and view capabilities, so it isn't just about general purpose programming languages.

- it can be hard to explain to people who haven't used a language specific IDE, how much further along its refactoring capabilities are compared to any LSP. Note that this applies much more to Java/C# than to something like python, both because of static typing and decades of investment.

- as an example of integration, say you add a new function in a file. Not only does Jetbrains highlight the modified file in the Git commit panel, but the structure panel will actually color that function differently and so on.

- due to widespread use of Jetbrains in certain communities, people will build valuable plugins to relatively niche things. So Jetbrains has excellent CMake support and decent Bazel support.

- I like the keyboard, but I also like and acknowledge that the mouse is much better at certain things. For interactive reading, I like I can right click on a commit and say "rebase from here" instead of looking up, copying and posting the red into my git rebase -i command. Conflict resolution, line by line inclusion etc. is also easier with a mouse.

I am very competent at the command line, but beyond a certain project size, IDEs just make sense to me.