I’m sure someone will be like “um akchuly” to my explanation. But for me it’s good enough to think if it that way.

I’ve worked in Haskell and F# for a decade, and added some of the original code to the Unison compiler, so I’m at least passingly familiar with the subject. Enough that I’ve had to explain it to new hires a bunch of times to get them to to speed. I find it easier to learn something when I’m given a practical use for it and how it solves that problem.

In practical terms, it’s most commonly a code pattern where any function that interacts with something outside your code (database, filesystem, external API) is “given permission” so all the external interactions are accounted for. You have to pass around something like a permission to allow a function to interact with anything external. Kind of like dependency injection on steroids.

This allows the compiler to enhance the code in ways it otherwise couldn’t. It also prevents many kinds of bugs. However, it’s quite a bit of extra hassle, so it’s frustrating if you’re not used to it. The way you pass around the “permission” is unusual, so it gives a lot of people a headache at first.

This is also used for internal permissions like grabbing the first element of an array. You only get permission if the array has at least one thing inside. If it’s empty, you can’t get permission. As such there’s a lot of code around checking for permission. Languages like Haskell or Unison have a lot of tricks that make it much easier than you’d think, but you still have to account for it. That’s where you see all the weird functions in Haskell like fmap and >>=. It’s helpers to make it easier to pass around those “permissions”.

What’s the point you ask? There’s all kinds of powerful performance optimizations when you know a certain block of code never touches the outside world. You can split execution between different CPU cores, etc. This is still in it’s infancy, but new languages like Unison are breaking incredible ground here. As this is developed further it will be much easier to build software that uses up multiple cores or even multiple machines in distributed swarms without having to build microservice hell. It’ll all just be one program, but it runs across as many machines as needed. Monads are just one of the first features that needed to exist to allow these later features.

There’s a whole math background to it, but I’m much more a “get things done” engineer than a “show me the original math that inspired this language feature” engineer, so I think if it more practically. Same way I explain functions as a way to group a bunch of related actions, and not as an implementation of a lambda calculus. I think people who start talking about burritos and endofunctors are just hazing.

I suppose this is a hot take, but I’d never intentionally select a closed source paid database or programming language. Your data is the most valuable thing you have. The idea that you’d lock yourself into a contract with a third party is extremely risky.

For example, I’ve never seen a product on Oracle that didn’t want to migrate off, but every one has tightly coupled everything Oracle so it’s nearly impossible. Why start with Oracle in the first place? Just stay away from paid databases, they are always the wrong decision. It’s a tax on people who think they need something special, when at most they just need to hire experts in an open source database. It’ll be much much cheaper to just hire talent.

Meanwhile I’ve done two major database shifts in my career, and you are correct, keeping to ANSI standard SQL is extremely important. If you’re on a project that isn’t disciplined about that, chances are they are undisciplined about so many other things the whole project is a mess that’ll be gone in ten years anyway. I know so few projects that have survived more than fifteen years without calls for a “rewrite”. Those few projects have been extremely disciplined about 50% of all effort is tech debt repayment, open source everything, and continuous modernization.

I don’t think it’s going away until ECMA supports native types. Until then it’s the best game in town.

If a team decides to move away from it, it’s only few hours work to entirely remove. So even if it’s going away, it’s risk free until then.

But I cannot imagine why any team would elect to remove Typescript without moving to something else similar. Unless it’s just a personal preference by the developers who aren’t willing to learn it. It removes so many issues and bugs. It makes refactoring possible again. I think teams that want to remove all types are nostalgic, like a woodworker who wants to use hand tools instead of power tools. It’s perfectly fine, and for some jobs it’s better. But it’s not the most efficient use of a team to build a house.

Thanks you made me laugh so hard I woke up my partner

Fantastic meme, I’m dying over here

“You’re going the wrong way!!”

“How does he know where we’re going?”

“Oh yeah”

Bashir realizes they are going to crash into two other ships

“AHHHHHHH”

ship shudders as it scrapes between the two incoming ships. Sparks fly dramatically, and Bashir looks over to see O’Brien dressed in a devil costume laughing maniacally

This is fantastic

I like React because these days it’s pretty well known and just about anything I need I can find easily. There’s newer similar tools like Vue, or entirely different approaches like Next, but React remains a dominant choice for the time being. I’m sure fashion will move the industry along soon enough, but none of the newer tools I’ve seen really are such a huge leap forward that I couldn’t get stuff done in a few days of prep and tutorials. So for now, I’ll stick with react until I need to move or a client requests it.

For backend I’m increasingly preferring simple Restful APIs. If it can map an endpoint to a function and convert JSON into a dictionary or object, it’s probably good enough. I just wrapped up a project in ASP.Net Core and that pretty much just got out of the way and let me make web API endpoints.

Who’s cutting onions in here

But you can’t see the code that runs those services, stores your settings, deploys your code, etc. Services are still a liability if they go away and your project depends on it

Yeah but are you using it or are you using the closed source options?

If AWS decides tomorrow to pull a Unity, can you fork it and keep your business running? Or do you need to rebuild an entire deployment infrastructure?

deleted by creator

Stamets you brighten my day and I only have upvotes to give back

I suppose it doesn’t roll away and is easier to stow but the ergonomics on that Starfleet Glo-CubeXtreme 2 seem dubious at best

“Why don’t you step outside an airlock Spez?” - Kira (probably)