Quekid5

The Gell-Mann Amnesia effect is always important to keep in mind.

I wonder if there is a name for such a mapping table in RDBMS-land...?

The C version of TeX is also terrible code in the modern day (arbitrary limits, horrible error handling, horrible macro language, no real Unicode support, etc. etc), hence LuaTeX (et al.) and Typst and such.

The backward-compat story is also oversold because, yes, baseline TeX is backward compatible, but I bet <0.1% of "TeX" document don't use some form of LaTeX and use any number of packages... which sometimes break at which point the stability of base TeX doesn't matter for actual users. It certainly helps for LaTeX package maintainers, but that doesn't matter to users.

Don't get me wrong, TeX was absolutely revolutionary and has been used for an insane amount of scientific publishing, but... it's not great code (for modern requirements) by any stretch.

Fair observation, but just opening a local lexical scope (in an expression-oriented language) can help with that. Also ... something something ST monad :)

Yeah, the "problem" with reduce is that it can do anything, and so doesn't offer much over a traditional for loop with mutable local variables to accumulate into. Of course, if you can replace a reduce() with a filter and/or map or whatever (which more clearly states intent), by all means do so!

If you really need arbitrary computation, I'm not sure there's any real readability benefit to reduce() over local mutation (emphasis on local!). Sure, there's immutability and possibly some benefit to that if you want to prove your code is correct, but that's usually pretty marginal.

In a word: it's fungible[0].

[0] https://en.wikipedia.org/wiki/Fungibility

I never wrote a blog... and it's fine.

Congrats, you got the joke! (Not being sarcastic.)

Are we just talking MTL style then? Because those compose in some sense, but ... it might not be in the sense anyone actually wants.

That's the thing about free choice. I don't believe it fundamentally exists, but I can't help behaving as if it does.

I'm not if sure if this is what you're asking for, but to make it very explicit, e.g. Console Output might be modeled as

   data ConsoleOutput =
        PrintLn String
      | PrintWithMode (Mode * String)
      | ...

where | is another spelling of + (which is pretty standard if you look at boolean algebra) and the product is the usual tuple constructor. The is a simple algebraic data type which defines 'an effect' ... it doesn't define the semantics (that's defined by a handler), but it's an 'api' for an effect of some sort.

Obviously, the above definition is a bit contrived, but that's my understanding of why these things are called 'algebraic' effects. It's not that ConsoleOutput and ConsoleInput (however you define that using + or *) are magically 'composable' just because they're both algebraic... for that composition you need extra rules (however you specify that) because effects don't (in general) compose.

Incredibly good writing throughout... only Armando Ianucci gets close, IMO. Of course he leans a bit more heavily into straight up farce, which may not be to one's taste, but still...

Go is slowly becoming Java 1.5+ -- see the addition of generics.

Btw, you can AOT compile Java if you wish... it'll probably be a larger binary than a Go binary, but that's whatever...

[Meta] ... God, I'm turning in pjlmp here, lol

You usually have to explictly opt-in to installing an Oracle JDK because... you know, they have a license agreement that you must agree to.

So there's no friction, everyone uses the OSS ones unless you have very specific needs.

What, exactly, are the JVM's competitors (not Java, btw)? You can always use Kotlin or Scala if they take your fancy. They both interop fantastically with 20+ years of the Java ecosystem.

EDIT: The only remotely competitive ecosystem is JS/TS (because billions of pre-installs) and C#.

> Even using OpenJDK is a sword of damocles waiting to fall. If I forget to update OpenJDK, Oracle could come after me. It's just risk that I don't have to worry about by choosing not to go with Java. It's probably not a lot of risk, but it's risk nonetheless that doesn't exist with Java's competitors.

This is absurd hyperbole.

I take your point. There were some previous leaked docs about Thorn involvement (I'm pretty sure Palantir was mentioned in those docs, but not 100% sure), so yeah...

The biggest issue is the lack of transparency about the people/groups involved in those meetings and why this ineffectual privacy-destroying idiocy gets pushed so hard.

It was redacted ... and very obviously so. Did you read my post?

> We've just had a pretty prominent politician 7 years ago get convicted of being in possession of CSAM.

I don't disagree with your overall thesis about Danish politics at the moment, but... I think it's interesting that politicians are exempt from these monitoring schemes. So it wouldn't have prevented that guy from doing what he did. IIRC, Law Enforcement is also exempt, and they never get up to any of that, no sirree...

ANY time any legislation comes with exemptions for the people in power (legislature and law enforcement) you know it's time for extreme skepticism.

EDIT: It's just the inanity of it that has me despairing. Lobbyism at its finest (see my other comment).

It's surveillance companies, i.e. follow the money. Imagine if you can force every IM app to include your nonsense? BILLIONS of instant installs and subscription fees.

The EU ombudsman actually asked the EU Council to comply with a Freedom of Information request about who attended the meetings about this and all we got was a fully redacted PDF with a list of about 30-40 individuals/groups (literally blacked out in the PDF). It's absurd how non-transparently this is bought & paid for.

> why wouldn't we just look at this and say "this is a normal way for a human being to operate" and refuse to pathologize it

I don't think it's so much about that... it's more that having a label for a common set of behaviors/symptoms can be a shorthand to explain things more succinctly.

Btw, would you say the same thing about clinical depression? Why/why not?

> Why drug your way to a different thinking style?

Because ADHD (and other things) can be crippling when it comes to actually getting IRL shit that needs doing... done. "We live in a society" is a meme, but there's actually a lot of stuff that can present non-trivial hurdles for neuro-divergent people IRL ... like filing taxes, going to an unemployment office, etc. etc.

(Also, that's not quite what the drugs do if you have ADHD, but I digress)

> [Stallman/GNU] getting an open source version of Unix installed on billions of machines.

Agreed, funnily enough GNU tools/compilers also ended up getting installed on a lot of proprietary UNIXes because proprietary UNIX was mostly shit (in user space!). At least most of the ones I had the misfortune to have to work on.

Add a sane deprecation process and this is much less of an issue -- see e.g. the Java language. Sure, it's not ideal to have multiple implementations of the 'same' data structure (if a better way is found, say)... but at least you aren't stalling everything and causing API interop issues for years and years.

Yeah... or I could focus my energies elsewhere... where they'd be likely to have an impact. So it goes.

I think you'll find I used a slightly different word.

> No living language is only used according to the rules laid down by grammar teachers. The only languages that are are dead languages like Latin with zero native speakers.

Well, quite.

Eternal September is repeating itself.

Interesting use of "declare war" there... :)

I understand the feeling, but language is what language does. It will change and you will notice those changes if you're alive long enough :)

Even prescriptivist languages (as my own native language tends to be) cannot escape. I'm bad at my own native language because I've been living elsewhere for very long... but not as bad as the Kids These Days :)

> I find that the most common reason I go back to check a variable declaration is to determine the type of the variable,

Hover the mouse cursor over it. Any reasonable editor will show the type.

> In Rust, in particular, this leads to some awkward syntactic verbosity, because mutable variables are declared with `let mut`, meaning that `let` is used in every declaration.

Rust is very verbose for strange implementation reasons... namely to avoid parse ambiguities.

> In C or C++ the type would take the place of that unnecessary `let`.

OTOH, that means you can't reliably grep for declarations of a variable/function called "foo". Also consider why some people like using

    auto foo(int blah) -> bool

style. This was introduced because of template nonsense (how to declare a return type before the type parameters were known), but it makes a lot of sense and makes code more greppable. Generic type parameters make putting the return type at the front very weird -- reading order wise.

Anyhoo...

Haha... be the change! Program in INTERCAL! :)

> You can pull this off in other languages via careful attention to the details of your request-handling code. But, the creators of the Erlang language and foundational frameworks have set their users up for success via careful attention to the design of the system as a whole.

+10. So many people miss this very important point. If you have lots of mutable shared state, or can accidentally leak such into your actor code then the whole actor/supervision tree thing falls over very easily... because you can't just restart any actor without worrying about the rest of the system.

I think this is a large (but not the only[0]) part of why actors/supervisors haven't really caught on anywhere outside of Erlang, even for problem spaces where they would be suitable.

[0] I personally feel the model is very hard to reason about compared to threaded/blocking straight-line code using e.g. structured concurrency, but that may just be a me thing.

People sometimes accidentally do research. I'm not joking.