2,508 karma · joined March 4, 2010
meet.hn/city/43.1009031,-75.2326641/City-of-Utica
---
Edit: Here's the initial commit in 2004, with MIT License already in there, way before Github launched in 2008 — https://github.com/rails/rails/commit/db045dbbf60b53dbe013ef...
Personally, I love the debates that stress-test my posts, they're the most interesting part for me. If I put effort into writing something, might as well defend it, and wouldn't want any punches pulled. Oftentimes people's attempts at debunking my message end up doing quite the opposite to what I'd expect — further validating what I wrote. Other times I need to clarify something in the post.
I posted a question[1]. Got some answers, but not quite complete. Then someone came along and provided a good detailed answer. A couple of upvotes later, that answer got deleted by Community Bot. I voted to undelete it, but it still needs another vote to undelete. So I ended up copying it into my own notes blog[2].
I'm not sure why the best answer was deleted. It would've been a loss if it wasn't preserved somewhere I think.
[1]: https://stackoverflow.com/q/73954228/155351
[2]: https://notes.max.engineer/creating-common-interfaces-in-gol...
I'm sure it will go down in history as some sort of intentional movement, and then someone will occasionally point out "did you know that originally this idea was never meant to be used for serious work, Andrej literally said it was only okay for throwaway weekend projects." Big not-always-good things[1] started this way — by misinterpreting something.
Of course, it's possible that in the future code written this way will actually be maintainable, performant, and secure enough that you could start trusting it, and this will morph into a legit way of writing software, but right now the hype is way ahead of what Andrej meant when he coined the term.
[1]: Examples come to mind: Agile, Scrum, Javascript (2 week project originally), there're definitely more examples.
There's a non-committal way of designing software that I think we should all strive to follow. It's not things like "let's use an ORM so that we can swap the database later" or "let's write abstractions over everything so we can swap everything later". It's more that you're trying to keep the code as simple and static as possible, naively doing the exact business function, and rarely generalizing. There are a few practices I've picked up over the years for non-committal architecture of this kind (for example: doing more at "build" time, passing the functions what they need instead of what you have, keeping IO in shell layer, and a few more). The goal is not to end up with a codebase that has foretold all the possible futures, but that implements just what it needs to do now in the most straightforward way, such that it's easy to read, understand, and change. I think this kind of non-commitment is the ideal to strive for. The less committed you are in this way, the easier it remains the change the codebase as it evolves, the less shackled it is with over-engineered "solutions".
It's deceptively hard to do this in practice. Everybody wants to implement their over-engineered "system for doing a thing" layered on top of the programming language. Sometimes we forget that the programming language itself is a great tool for expressing business logic.
The only reason you're afraid of some things more than others is because you came across some stories, and not others. We're all wired like this evolutionarily, on purpose. When we see stories, we're supposed to alter our behavior, because all the stories used to be local and relevant. "A bear ate Timmy near the river" is a good warning to be extra careful near there. Now that we have internet, and the entire planet's worth of carefully selected bears eating Timmys is getting fed into everyone's mind, we must learn a new trick: understanding how odds and relevancy works.
All teaching works this way. Would it be totally reasonable to have junior pilots only practice with autopilot?
https://www.youtube.com/@CainOnGames
[1]: Tim Cain created the original Fallout (pretty much designed the whole universe), and a number of other successful games after. He's an engineer through and through, but wore a lot of different hats, and has an interesting perspective on all aspects of game dev.
No, it’s an actual debate between the actual John and Bob. Them debating each other. It’s an amazing read.