Considering other venerable classics with similar dynamics, I’ve seen far more people be far saltier about betrayal at the end of a game of Twilight Imperium (even though there can only be one winner) than they do in something like Cosmic Encounter (where they could have played for an almost guaranteed joint win).

Much easier to laugh off a 20-30 minute game and go again, than watching an entire day of scheming and planning go up in smoke at the hands of a supposed ally.

You could create a third-party tap to install wine via homebrew.

I think Teletext might be even worse. IIRC, it only has three heights for its triangles.

If you’re interested in multiline plotting with braille characters, Ian Henry’s bytemap for Janet (https://github.com/ianthehenry/bytemap) is worth a look (or my Clojure port: https://github.com/waddie/bytemap.clj).

Very curious what’s happening there. With empty helix.scm/init.scm, there is essentially zero measurable impact on startup for me.

Bytecode caching isn’t yet enabled (it is in progress), so I can see that kind of delay if I’m giving it tens of thousands of lines of code to evaluate on startup, but it took a lot of effort to get there.

The Scheme-based plugin system (https://github.com/mattwparas/helix/tree/steel-event-system) is almost ready to go. The plan is to merge it to master after the next release, whenever they get round to that.

It’s easy to build from source though, I’ve been using it daily for over a year, and there already are several dozen reasonably sophisticated plugins available. You can browse a list of mine here: https://github.com/stars/waddie/lists/helix-plugins-steel-li...

In my own testing, Pangram is excellent at detecting the default output styles of LLMs.

If you tell the LLM to change its output style, so it’s not full of “load-bearing spaced em dashes that aren’t X, they aren’t Y. they’re Z.” constructions (which humans are pretty good at detecting on their own), the false negative rate soars.

A name clash is the least damning evidence in my opinion. Last year my previous employer asked us for suggestions for naming an AI agent. Everyone produced pretty much the same list, because everyone just asked ChatGPT.

Except me. I had also asked ChatGPT, but I bothered to google the suggestions and found there were already like half a dozen AI agents for every suggestion.

(they ultimately launched what was by then the 7th or 8th AI-related product with essentially the same name)

Creativity in naming doesn’t seem to be their strongest suit.

Did Godier copy the other guy’s repo, name and all, and try to pass it off as his own work? That seems like the obvious conclusion, albeit brazen to the point of insanity.

Did Claude copy the repo, in response to a prompt? If Claude copies a Claude vibe-coded project, can any plagiarism really be said to have taken place?

Or is this just what Claude is statistically likely to spit out if you prompt it to build an astronomy app and leave it to it?

“Concurrency Oriented Programming in Termite Scheme”: http://scheme2006.cs.uchicago.edu/09-germain.pdf

Implemented in Gambit Scheme: https://github.com/FredericHamel/termite-scheme

I thought this bit was interesting:

> TE has no register for hedging, ownership of an opinion, or acknowledging that a reasonable person would disagree. Modality is roughly can / must / do not. […] Where a thought can't be said in STE without becoming a lie, I'd mark it and say it plainly rather than mangle it. Confidence and disagreement are the two things I'd insist on smuggling through.

  jshell> new ObjectMapper().valueToTree(Map.of("providers", List.of("SUN", "SunRsaSign", "SunEC")));
  $4 ==> {"providers":["SUN","SunRsaSign","SunEC"]}

It’s less “make me a Java LSP” than “rewrite javac around incremental compilation and exposing a semantic DB”. Which sounds like a much harder problem.

I think that was true last year. In my experience, it’s no longer the case with Claude Code or Codex.

Recently, I’ve been quite impressed, at least with Claude. At some point they figured out the parens issue, and the code is largely solid and idiomatic. I’ve mostly used it with Polylith apps, so the context for any given change is naturally well-defined. Usual issues with failing to reuse existing functions or make sound decisions about architecture, but no more so than I’ve seen with TypeScript or Rust.

I think there are a few points in its favour: it’s a very concise language, the documentation is terse but precise and comprehensive, and while there’s obviously nowhere near as much Clojure out there as there is JavaScript or Python, there is a lot. As the Clojure demographic skews toward experienced, senior programmers, I’d guess the quality of that corpus is probably well above average.

Java stack trace errors might even be an advantage now.

But it’s still never going to be a language I like, and I’m yet to encounter any of these modern codebases in the wild. It’s invariably a crusty old relic, much closer to the PHP of 2006 than the PHP of 2026.

Clojure’s abstraction is a bit more far-reaching than Common Lisp’s SEQUENCE, implemented as interfaces rather than types.

A Clojure sequence is anything “seqable” (either implements the Seqable interface, or special case handling for host platform collections), not just lists and vectors. Hash maps, sets, Java Iterables, etc. are all seqable and work with the same standard collection functions.

e.g. you can `(map (fn [[k v]] …) {:a 1 :b 2})`, rather than needing a separate MAPHASH function.

Long answer, well, there are blog posts[0], the Design Principles of the Elixir Type System paper[1] and related presentations[2, 3, 4] that talk about it at length. Giuseppe Castagna’s site has many more related papers: https://www.irif.fr/~gc/topics.en.html

[0]: https://elixir-lang.org/blog/2022/10/05/my-future-with-elixi...

[1]: https://www.irif.fr/~gc/papers/elixir-type-design.pdf

[2]: https://www.youtube.com/watch?v=gJJH7a2J9O8

[3]: https://www.youtube.com/watch?v=VYmo867YF6g

[4]: https://www.youtube.com/watch?v=giYbq4HmfGA

The most important difference is that they invert the editing model from verb-noun to noun-verb. Meaning you always see exactly what you’re going to be operating on before you do it.

The second most important difference is that they were designed from the ground up around multi-selection editing as a primitive, rather than a plugin or late addition.

That model is typically less efficient purely in terms of keystrokes, for some operations significantly so, but it’s somewhat mitigated if having the state on-screen rather than in your head means you undo less often.

I wouldn’t suggest either approach is superior. I suspect most people (“most people” in the subset of people who jibe with modal editing to begin with, anyway) will find that one just fits their brain better than the other.

Personally, even having used Vim almost daily since finding it on a Fish Disk sometime in the mid-90s, I still turned out to be in the kak/hx group. I can still use vi quite comfortably when I need to, but Helix removed a bit of friction I’d barely been aware of.

There’s a steady stream of NeoVim exiles to Helix forums, I think who mostly found its Lua-based config too complex/brittle, asking why the devs don’t add settings to make it work like Vim, include a *Vim keymap as standard, etc.

It’s kind of wild to me that people would choose their editor based on how minimalist its config/how batteries-included it is, rather than its fundamental editing paradigm.