This has been on my mind lately! Especially in light of the many incomprehensible but machine-checkable proofs we've been hearing about.

Occam's Razor is a useful heuristic, but it biases us towards simpler explanations.

But those proofs are showing that the fundamental axioms (which are generally simple and elegant) are still enough to build a complex result.

I think of elegance as not having to add epicycles, not that everything in the system has to be simple.

Also, without a working theory the, the space of possible solutions is near infinite. LLMs manage to pluck out the space of comprehensible English strings from n-dimensional hell. Even if this is done with a black box of billions of parameters, it’s still elegance in the sense that such a space even exists and was found

They're targeting something like a 5th grade reading level — I'm not convinced it's slop.

When you have two monitors, is your head always turned to one side? That always hurts my neck, so I wind up with the second monitor relegated to the side, where I never actually look at it.

When I had five monitors, they each had a job. Front of me were two ultrawides on top of each other, the one directly in front of me was for 'the action' as it could handle "two screens" worth of info next to each other.

The ultra wide above was mainly dedicated to various chat programs (teams, telegram, iMessage, etc).

The laptop's screen to the left was my mail screen (both home and work).

To the right was a 4k on its side, for documentation reference or output work.

And above the laptop was a "scratch" monitor for whatever was needed (often a music player, etc).

You quickly get used to glancing at what you need and moving on; if something needs more attention it's easy to bring it front and center or turn your chair.

Power fluctuations took out the ultrawides and one of the 4ks so now I just have one supermegaultrawide with a 4k above it (still laptop for mail, "above" for chat, and main for main things).

This is why ultrawides are very comfortable, you can focus on the center region where 2x monitors likely have their edges meeting.

I repurposed a 43” 4K TV as a monitor. The thing I’m working on goes roughly in the middle, everything else is sprawled out wherever.

Which? I like this idea.

It is an older $299 Toshiba Fire TV that isn’t powerful enough to stream 4K content smoothly. Displays 4K@60Hz fine over HDMI fine.

Wouldn’t recommend it, but I already had it.

Ah. Got it. Thanks!

I do this too, and just put less-important stuff on the second monitor. Work chat, music, logs, whatever.

I have three monitors. The left and right are turned vertically. They're all 30". So the main screen is in the center and I keep slack/email/web browser with docs/info on the left and usually Twitch DJs or Spotify on the right. So usually I'm looking forward but I look left briefly throughout the day.

Why would your head always be turned to one side? Have one monitor in the middle (the main one) and secondary either left or right. Having split screen right in the middle of my field of view is ridiculously unpleasant

I have a rotating chair (normal desk chair) and I rotate the whole chair to look at the other screen If I need to look at it for more than one second.

The proper setup is 3 monitors: [ stdout ][ stdin ][ stderr ]

There are languages like Dafny that permit you to declare pre- and post-conditions for functions. Dafny in particular tries to automatically verify or disprove these claims with an SMT solver. It would be neat if LLMs could read a human-written contract and iterate on the implementation until it's provably correct. I imagine you'd have much higher confidence in the results using this technique, but I doubt that available models are trained appropriately for this use case.

Ask it to do so, show it how, and it will do it.

Maybe this isn't what you're suggesting, but it's already possible to make an interface that prevents callers from doing math on indices in Rust — just return a struct that has a private member for the index. The caller can pass the value back at which point you can unwrap it and do index arithmetic.

More than that, in theory an opaque handle would also do things like statically prevent a handle taken from one array from being used to access a different array. I feel like this should be possible in Rust with type-level shenanigans (e.g. GhostCell).

this is possible in rust, albeit with a lot of shenanigans. See this article where someone made a GC in rust where the external references are bound to a specific GC via a unique lifetime: https://kyju.org/blog/tokioconf-2026/

And If `jj absorb` gets it wrong, you can run `jj undo`.

This is such a killer feature to me. I'm not scared to start potentially gnarly rebases anymore because I can painlessly undo.

Yes. With "jj undo", I'm not scared to do anything. The brief time I had to go back to using vanilla "git", I didn't enjoy being extra cautious.

Using a version control tool shouldn't require much self discipline.

yeah, i regularly try absorb then undo when it moves it to a commit from 7 years ago, then manually squash where appropriate

In response, I expect the open-source community to make an optimal square packing window manager. https://en.wikipedia.org/wiki/Square_packing

Is this the Stephen Dolan of "mov is Turing Complete" fame?

Is this the Stephen Dolan creator of jq?

https://jqlang.org/

Yes, its exactly that Stephen Dolan.

I believe so.

Are you suggesting we move to C++++?

It's already there. It's called C#

Well, C# also has its quirks already. Like the crippled finalizers which are never to be used. If the IDisposable interface had been correctly designed, finalizers could become be the "public void Dispose(void)". Or the manual passing of Task in case of async methods, which is... kinda smelly.

It's possible you didn't realise, but C# is sometimes said to be named that way because # is the symbol you get if you draw ++ small and then on the line below ++ again. Hence C++++

All languages have some spikier edges, there are no languages I know where I think "Well, even if we could start over I have no idea how to improve this". What's notable about C++ is just how rich that "could do better" seam is, so very many of their defaults are wrong, so many of their keywords are the wrong word, so many of their standard library features are allowed, sometimes even mandated to be crap.

I don’t know if that’s true or not, but while the thought never crossed my mind before your comment, it’s now canon in my mind. Yes, C# is spelled C++++ with a ligature.

The name is actually pretty clever (the fact that it was originally un-googlable notwithstanding). There are at least three interpretations:

* "C sharp" as in "C but higher",

* C with four pluses, and

* a homophone of "see sharp"

I think you meant to get that to the original poster, who seems to imply C# is the flawless, bestest incarnation of C\+\+(\+\+)+.

This is a fundamental problem with GC-ed languages. You can't get predictable finalization, so IDisposable can never be implemented reliably.

“#” is just two “+”. Count the lines.

Personally I like C+. Picking the nice parts of C++, but skipping all the nonsense. I just wish C++ hadn't deliberately screwed up designated initializers with mandatory ordering. The C version of it that allows out-of-order assignments is clearly superior.

Didn't you read the article? That form is deprecated. The recommended one is C,++,++

You clearly didn't read it either. Going forward, it will be C++...

I've never verified this, but it feels like scp starts a new TCP connection per file. If that's the case, then scp-ing a tarred directory would be faster because you only hit the slow start once. https://www.rfc-editor.org/rfc/rfc5681#section-3.1