I like flakes a lot, speaking as a type of user which I’ll call a “casual packager”.

This is to say that I like being a good citizen and sharing my packaging efforts… while also simultaneously feeling totally uninterested in becoming an owner-for-life. Flakes let me share a package without those pesky strings – when the user installs a package using one of my flakes, a personal lockfile gets generated at the latest git commit and that’s that. If the user doesn’t like the version they get, then the power is in their hands to choose a different git ref via their own generated lockfile.

Obviously this is something of a user footgun, especially for consumers of high-impact or security-critical applications, but most of those things are already important enough to get packaged. When it comes to niche, infrequently updated stuff, this approach works super well and helps to draw many reluctant packagers like myself out into the open.

This article is good, really good. Somehow despite having used plenty of builders in the past I barely even knew half of the stuff documented here.

I’m particularly interested in learning more about the special paths that derivation outputs can provide – looking forward to seeing that section expanded.

You’re about 20 years late for that particular shitshow, but here’s a fun video retrospective on the war on Pokemon if that’s your thing.

Time to call a doctor 😳

Though, for the record, this is one of the few situations where humanity would have been better off if Google had simply paid their web engineers to go out into the world and kick animals all day long instead.

You can improve the reliability if you provide it test cases. You can now be the PM you wish you had for the robot that will eventually replace you.

Look at me! I am the product owner now!

You’re clearly not yet a Sr. Developer. Everyone knows that you start getting apocalyptic software visions the day after promotion.

Source: It was revealed to me in a dream

Ah, yes. The problem commonly known as PM-who’s-also-the-BPC-but-also-doesn’t-understand-what-either-role-actually-does, or “PMWATBPCBADUWERAD” for short.

Quick little followup question to my own comment: I’m considering picking up Rust because I’m a big fan of what they’re doing with immutables and pattern matching. Are there any Rustaceans on this community? What do you think of it as far as the FP experience goes?

I was learning Java 6 in highschool. One day my brain wrinkled and I asked the teacher a big question:

“Why can’t methods be more like variables? I want to try, like, making an array of methods out of it”

My teacher, bless his heart, replied:

“I’m just a P.E. teacher filling in electives because the county can’t afford to hire anyone with a computer science degree, but go ahead and install whatever you want if you feel like experimenting”

So I stumbled around Google for a while playing with phrases like “passing methods without anonymous inner classes” and “public final methods” until I eventually stumbled across a bunch of blog posts by this guy called Martin Odersky. That led me directly into dropping Java and picking up Scala, the JVM language he designed.

Scala basically blew my world open. I discovered the beauty of first-class functions, immutability, currying, and pattern matching. Unfortunately, Scala was sort of peaking at the the time, so I eventually had to pack up and learn other languages. I experimented with Haskel (too hardcore for me!), Elixir (good but tiny ecosystem), and Groovy (cool, but unfocused). I always ended up returning to lame languages like JS (meh…), Python (ugh…), and Lua (ugh!!) because that’s where the projects that most interested me were happening.

These days I mostly work in JS professionally. It’s not ideal (hungrily eyes tc39/proposal-pattern-matching & tc39/proposal-pipeline-operator)… but my FP background still has a lot of applicability in JS-land. I frequently receive compliments on my code and I attribute a large part of that to the lessons and discipline which FP has taught me.