I’m not sure what you mean by “locality of reference”. I assume you mean something other than the traditional meaning regarding how processors access memory?

Anyway, it’s often been said (half-jokingly) that Haskell is a nicer imperative language than imperative languages. Haskell gives you control over what executing an “imperative” program actually means in a way that imperative languages don’t.

To give a concrete example: we have a custom monad type at work that I’m simply going to call Transaction (it has a different name in reality). What it does is allow you to execute database calls inside of the same transaction (and can be arbitrarily composed with other code blocks of type Transaction while still being guaranteed to be inside of the same transaction), and any other side effects you write inside the Transaction code block are actually collected and deferred until after the transaction successfully commits, and are otherwise discarded. Very useful, and not something that’s very easy to implement in imperative languages. In Haskell, it’s maybe a dozen lines of code and a few small helper functions.

It also has a type system that is far, far more powerful than what mainstream imperative programming languages are capable of. For example, our API specifications are described entirely using types (using the servant library), which allows us to do things like statically generate API docs, type-check our API implementation against the specification (so our API handlers are statically guaranteed to return the response types they say they do), automatically generate type-safe API clients, and more.

We have about half a million lines of Haskell in production serving as a web API backend powering our entire platform, including a mobile app, web app, and integrations with many third parties. It’s served us very well.

As a senior engineer writing Haskell professionally, this just isn’t really true. We just push side effects to the boundaries of the system and do as much logic and computation in pure functions.

It’s basically just about minimizing external touch points and making your code easier to test and reason about. Which, incidentally, is also good design in non-FP languages. FP programmers are just generally more principled about it.

I’m confused. Are you saying all of that is a consequence of not using ORMs? Because if so, that’s absolutely not true. ORMs truly are complete trash.

Because they are universally incapable of coming anywhere close to the full power of git.

I can’t tell you how many times I’ve had GUI-only people ask me to unfuck their repo (fortunately not at my current job, because everyone uses the CLI and actually knows what they’re doing). It’s an impedance to actually learning the tool.

Ultimately any GUI is a poor, leaky abstraction over git that restricts many of the things you can do for little actual benefit.

https://www.target.com/p/downy-april-fresh-liquid-fabric-conditioner-140-fl-oz/-/A-82823990

Here’s a typical fabric softener at Target. $13 before tax. Still not a lot, but it’s not nearly as cheap as $2.

The point of the joke is not that the Python interpreter will change types mid-program on its own, but that you don’t have any real way of knowing if you’re going to get the type you expect.

Programs are messy and complicated, and data might flow through many different systems before finally being used for output. It can and often does happen that one of those systems does not behave as expected, and you get bugs where one type is expected but another is used in actuality.

Yes, most likely what would happen in Python is a TypeError, not actual output, but it was pretty clearly minor hyperbole for the sake of the joke.

You don’t see how type mismatch errors can happen in a dynamically-typed language? Then why do they happen all the time? Hell, I literally had a Python CLI tool crash with a TypeError last week.

Not true! I installed it and played for 5 minutes once!

I just assumed they were already doing this and have never considered them to be something anyone should ever put in their home.

Kids are just really good at learning quickly. That’s all it is, really. Chess is all about study and learning, so kids are very adept at getting good quickly. Obviously there are some who are prodigies, but that’s pretty exceptionally rare.

Adult learners also can get good quickly, but it requires a lot of meta-cognitive thinking (thinking about how you think, or “learning to learn”), time, and discipline. The guy that runs my local chess club is probably in his 60s, and he told me that he was sitting around ~1100 for a long time until recently he started studying, where he rapidly jumped up to ~1600 after, as he put it, “things clicked”.

It’s never too late to rapidly improve your own abilities, which is what I really love about the game, because I find it teaches you to apply that mindset to all aspects of life.

Just sounds like a win-win. The fascists no longer have their travel cops, and people no longer have to deal with the useless bullshit of the TSA.

You were being a massive dick.

Think about how many columns you can fit!

We have someone at work who uses it and he’s constantly having tooling issues due to compatibility problems, so… yeah.

I’m sure it’s fine for sticking in the shebang and writing your own one-off personal scripts, but I would never actually main it. Too much ecosystem relies on bash/posix stuff.

Seems unlikely and frankly doesn’t matter much.

1GB of files is not configuration.

It came out in 2013, so no, not new at all. It was an incredibly popular song, with over a billion listens on Spotify.

1. Supposedly there’s a way to install nix without root access, but I can’t speak to it as I’ve never tried. Ofc it doesn’t require sudo to install packages or anything, though.
2. I don’t think it does this right now, largely because it’s super fucking complicated (as is basically everything Apple) and homebrew casks themselves have had a ton of headaches around it. But nevertheless, I think home-manager has some workarounds it uses itself to enable many common GUI apps on MacOS.
3. Not sure exactly what you mean, but I think it does that?

If you want to install packages purely by name, you can use nix-env -i hello or whatever. But it’s pretty janky and not really a recommended way of doing things.

Nix. I use it for everything, including all of my tools I use on my work MacBook.

There are many ways to use nix for this stuff, but personally I use home-manager in a flake-based setup. Versions of tools are all pinned in a lockfile which is committed to source control, so it’s easy to get my config and all my tools on a new machine without any breakage (it does require installing first, though).

It’s a great tool and has largely solved the pain of dealing with having to work on MacOS, for me.

Have you used Jira? It’s a memory guzzler