JetBrains working on higher-abstraction programming language

Roc [1] is the language I think does the best trade-off among high-level instructions, design simplicity, performance, and pragmatism to handle real-world tasks.

It started as a purely functional language, but the authors are adding some escape hatches, such as imperative for loops, for cases where the functional approach is too complex (e.g., implementing quicksort). And it is pragmatic like Go when it comes to simplicity, compiling fast, and running fast.

AI programming and a compiler that catches bugs through good language design make a great match.

[1] https://www.roc-lang.org/

Maybe this will be a good way for users to communicate to the LLMs, but I wonder if it would be better for LLMs to generate code in a more disciplined language. Something like Eiffel with pre/post invariants or Lean/Rocq for provable correctness. Then a rigorous compiler can check the LLM emitted what it promised. The verbosity is unpleasant for conventional human programmers, but it's almost a non-issue for the LLM.

They keep calling it a language (Kotlin derivative), but then the CTO refers to it as "basically English", with maybe "some semantics".

Are we just talking about prompting with some enforced structure, or is it a programming language?

I'd love it if jetbrains worked on getting intellij to not hog so much resource and become unresponsive working on huge projects instead.

I admit that I'm kind of intrigued. On the one hand, this is a standard vaporware concept that people have promised time and again almost since the dawn of programming. On the other hand, LLMs that write and maintain code currently have to do it using tools designed for humans, and that's probably leaving some amount of value on the table.

Right now I think I'd bet that whatever this is won't ultimately impress me much, but not at very extreme odds.

Something I've been thinking about is language models aren't good at large software, but they're good at little demos. If you could build software by making little boxes, sort of like ActiveX controls back in the day, or microservices, and the model just focused on its own little microservice or object, and then you can build the software by connecting all of these.

Is there much meaningful space left between Python (for example) and English (or other written language of your choice)?

LLMs are pretty code at compiling clear descriptive or prescriptive instructions in English down to a programming language.

This sounds to be in the same area as their post on the OCaml forum last year https://discuss.ocaml.org/t/a-next-generation-ide-for-ocaml/... , though it seems they are going for a natural language approach instead of something like AST editing (which is what I had in mind when reading their original outreach message).

"A high-level language that's basically English."

COBOL, you're inventing COBOL.

While I think the idea of LLM-based tooling and languages co-evolving is interesting, from this limited description, I think this isn't a helpful direction.

> “So instead of writing three applications, you write it in a special programming language, which is basically English, which describes how you want to see this application in a very specified way, and then AI agents, together with JetBrains tooling, will generate the code of all of these platforms,”

Is the process of generating code for each platform from the high-level specification deterministic, predictable, and obeying some natural invariants? Or is it a stochastic and unpredictable? If Alice publishes her open source project with the specification code, and Bob has access to a slightly different set of models at a later date, will Bob be able to reproduce the same generated artifacts that Alice did?

If you _can_ make everything deterministic and well-behaved, does it need to involve AI agents? Or can this effectively turn into an DSL which happens to be English-like, and a code-generation tool?

  > So instead of writing three applications, you write it in a special programming language, which is basically English, which describes how you want to see this application in a very specified way, and then AI agents, together with JetBrains tooling, will generate the code of all of these platforms

i take it to mean no more kotlin multiplatform if ai will just generate platform specific code....?

So we've come a full circle now. From AI Will Replace Programmers to programming the AI to program =)

"So-called "natural language" is wonderful for the purposes it was created for, such as to be rude in, to tell jokes in, to cheat or to make love in (and Theorists of Literary Criticism can even be content-free in it), but it is hopelessly inadequate when we have to deal unambiguously with situations of great intricacy, situations which unavoidably arise in such activities as legislation, arbitration, mathematics or programming." -Dijkstra

I'd always assumed that was what MPS was about, but I guess that's about developing more precise DSLs than having one single language to rule them all. But I'm sure that approach will work this time by just throwing AI and gigawatts worth of handwaving at it :-|

JetBrains product quality has really gone downhill.

Didn't realize English was a derivative of Kotlin. Wow, I achieved enlightenment!

They’re going to reinvent HyperTalk and AppleScript?

Inform 7 ?

I wrote about why higher level abstractions may not work all the time.

https://simianwords.bearblog.dev/so-you-want-to-create-a-new...

TL;DR the overhead in learning the new abstraction and dealing with the inevitable edge cases (known or unknown) must be taken into account.

All abstractions sound good until you account for these things.

The new language can work if the edge cases of this language are known and minimal.

This is probably just marketing gimmick with unique angle and born from aspirations to sell you subscription based SAAS/PAAS/coding_agent that is supposedly not like every other agent out there.

Also, I do not believe in magic carpets.

Also, I do not want even more higher-abstraction level that will come with even more layers of bloat.

Work on making Junie a viable competitor to Claude Code instead. While I love its accuracy, its equivalent to CC launching a sub agent per file, takes just as long, and probably burns tokens similarly - except there's no way to disable that approach in Junie.

>“So instead of writing three applications, you write it in a special programming language, which is basically English, which describes how you want to see this application in a very specified way, and then AI agents [...] will generate the code of all of these platforms"

I wish they would focus on providing a better IDE experience and fixing existing bugs (and preventing releasing bugs) and keeping up with supporting their existing tooling.

I have difficultly determining what this company wants to deliver. I know what I actually give them money for.

About 80% of the code in our repos is language or framework baggage, delivers fuck all ROI and the LLM leverage is making about 25% of what is left go away, badly and without any determinism.

Whether or not this is the solution, I don't know, but it feels like the right direction.

Please don’t have it run in a virtual machine. Or at least the JVM. All of Jetbrains products would be 10x better if not written in Java. Native is best.

Ruby?

> the object-oriented architecture

Stopped reading here. Good luck with your shared mutable state! Enjoy!

That is another waterfall fantasy paired with Applescript/UML delusions. Perhaps they are seeking vibe investors or they'll indeed offer a toy IDE for vibe coders alongside with their real product.