The originals were much better. Lara Croft was a jet-setting dilettante with Girl Power from the era of “Cool Britannia” and the Spice Girls.

Comparatively, the reboots are utterly po-faced.

The issue here is that the author of that post, and potentially the fictional author of the thing being lampooned, are not drawing a distinction between a tutorial (or an explanation) and a how-to.

https://diataxis.fr/

Either you want to get a task done, or you want to spend a lot longer learning how to work that out for yourself.

(Many tutorials will include small set of how-to-like instructions because emulating the actions of a master will improve one’s vocabulary of what can be done as well as how it is achieved.)

Start with the core gameplay loop. Look for the fun. Look for what you can take out, not add.

Play-testing something like this with pencil and paper first might be a good idea. Once you work out why it always plays the same way, then you can look for how to perturb the gameplay.

Erlang wasn’t the first implementation of CSP.

Clojure has it’s own set of idioms; it comes with some small surprises for old lisp hands. There are some things it’s really brought into the mainstream: performant persistent data structures in particular.

As well as excellent tooling and pedagogy, the principle attraction of Racket is the macro system. There’s a great book about this (this is true of just about all aspects of Racket). Racket’s focus is on building a tower of languages via macro extension. Metaprogramming is thematically FP-adjacent but neither sufficient or necessary; but if you’re looking for a fun learning experience it’s really worth a look.

In terms of employment opportunities - I know of several Clojure shops (on the JVM it has the bonus of being able to take advantage of the hole ecosystem), but I’m not aware of anywhere that’s using Racket outside of the academic sphere.

Another great avenue into this world is Racket. The tooling is fantastic and the documentation culture is first-class.

I’ve a couple of GP friend who used to describe “Dr Google” as their online colleague.

The point being, they were somewhat trained in interpreting risk as opposed to the stereotypical googler-of-symptoms. Once upon a time search engines were quite useful.

I’d go with Erlang over elixir, but it sounds like you already have an interest in gleam.

FWIW: just pick one and get started. There are some major axes to consider: pure versus impure, lazy versus strict, static versus dynamic typing, but to kick off if you’ve done no FP before it’s probably better to just go for it.

There are some really intriguing “next steps”: SICP, the ML module system, the Haskell ecosystem, the OTP approach to state, but to begin with it’s just worth getting used to some basics.

I kind of expected a lot of this; I remember the sendmail 4 book from back in the day when O’Reilly had that, DNS and BIND, and Perl as the entirety of its corpus.

I’m primarily transfixed, not by the example in your comment, but that you don’t voice the “th” in “with”.

“…the barrel.” Apples don’t come in bunches, but at the time the saying was coined they were carted around like that. (Also it only took one, not a few.)

(I suppose the modern version is “one nazi spoils the bar.”)

I’m not quite sure why you fetishise a bit-for-bit over semantic equivalence. Doesn’t it turn “it works on my machine” into "it works on my machine as long as it has this sha: … "?

I am no messenger.

But I do bring you a message:

the message - of death!

It’d be nicer to see tagged unions first, with the machinery for those, and then take steps to provide a semantic fix for error handling.

And as for your specific question: typechecked code doesn’t get to production with a type error; it won’t compile. There’s a common phrase, “left-shifting errors”. It means catching bugs as early in the development cycle as possible. In terms of things like developer time (and patience), it’s far more cost-effective to do so.

I worked on OpenStack back in the day: millions of lines of untyped Python.

Let’s say you’ve got an X509 certificate. You know you can probably pull the subject out of it - how? Were I using Java (for instance), the types would guide my IDE and make the whole thing discoverable. The prevalent wisdom at the time was that the repl was your friend. “Simply” instantiate an object in the repl then poke at it a bit.

And it’s not just that kind of usability barrier. “Where is this used?” is a fantastic IDE tool for rapid code comprehension. It’s essentially impossible to answer for a large Python codebase.

Don’t get me wrong: python is still a great go-to tool for glue and handy cli tools. For large software projects, the absence of type enforcement is a major impediment to navigation, comprehension and speed of iteration.

Wait until you hear why Cambridge exists.

Morrissey might be a twat but he spent years writing stuff like this to the NME and then actually put his money where his mouth was.

He doesn’t want to be co-president. He’s a founder of the USA.

Fucking well said.