DHH

Read everything DHH wrote, he has lots of insights on this. Scroll down to his books: https://dhh.dk I found Lean Startup to be very good too.

> difference/explanations of when to use bare-metal v. vps v. vm; what there is to know about reverse-proxying and load balancers and how to correctly setup and deploy those and so on? Aren't that exactly the things, modern dev teams trying to avoid to know about in their march into bright future with Lambda/Serverless? Or from another angle - most of the crowd in the "exciting" camp, decreasing the chances for such book to be born. DHH aka DAVID HEINEMEIER HANSSON ( https://dhh.dk/ ) may be? This podcast was not bad https://podcasts.google.com/feed/aHR0cHM6Ly9jaGFuZ2Vsb2cuY29tL3NoaXBpd…

this remind of a great article written by DHH https://dhh.dk/2012/rails-is-omakase.html > Rails is omakase. A team of chefs picked out the ingredients, designed the APIs, and arranged the order of consumption on your behalf according to their idea of what would make for a tasty full-stack framework.

My experience is that the resulting architecture will sometimes end up with characteristics that makes it easy to test but more complex, exposes things it should not and too many layers of indirection. DHH wrote some about it here: https://dhh.dk/2014/test-induced-design-damage.html I do like automated tests (unit and integration) and often TDD is appropriate. However tests are not the end goal of an architecture. The code should be maintainable, easy to follow and simple to reduce number of bugs. If TDD starts to change that by adding layers of indirection or changing the purpose of something just so you can do a fast unit test then something is wrong.

This is a very good article on the same topic by DHH. A great read if you haven't read it before: > Test-first fundamentalism is like abstinence-only sex ed: An unrealistic, ineffective morality campaign for self-loathing and shaming. https://dhh.dk//2014/tdd-is-dead-long-live-testing.html

I built my last company with Go, Vue.js, gRPC, and Kubernetes. And, wow was it a slog. It was hard for new developers to jump in, we had separate engineers for frontend + backend, and there were things we never even touched - such as real-time/websockets or end-to-end testing. I recently started a new project in the same stack [1], and partway through paused because it was taking so long to deliver customer value. I jumped back into Rails, inspired by their new Hotwired framework [2]. And, holy shit - the speed of development became insanely quick. Not only that, but I've been able to achieve a higher level of polish than I would have with a single-page JS app. Specifically - building in real-time updates only took a few lines of code. It was possible to achieve this level of polish with an SPA, but realistically it would have taken me so much time that I would have never prioritized it. I hadn't touched Rails in over a decade. As a junior developer, I felt overwhelmed because Rails had solutions for so many problems I had not yet encountered. But, returning to Rails with some more experience - I appreciate its "omakase" [4] approach so much more. So many best practices are built in or easy-to-install. Queues, cron, async jobs, audit logs, email click tracking, end-to-end testing, real-time updates, caching, sessions, URL slug "friendly IDs", image resizing, rate limiting, admin interfaces, rich text fields, S3 integrations, sitemaps - they all just work! With the new…

> You can't refactor code without tests See this is where the conversation goes south. You will use the phrase "unit tests" when it suits you, and then, like a magician using indirection, generalize to the word "tests" when it suits you. Why are you listening to Uncle Bob so much? I mean you can do as you like. However, the strong "Uncle Bob" style assertions should probably be left out of most articles in favor of a more humble "this is what worked for me/us" approach. Universal rules for any discipline are very hard to come by. Sharing what worked for you on your projects is great but it becomes somewhat obnoxious when you try to generalize it to universal rules that works in all environments for everyone. Also, I think that large unit test suites, where most of the tests are redundant, come about in competitive environments where if you try to make a commit without a test some other competitive coder will try to use it as a "I know better" stepping stone and call you out on the change - "Where is the test". After 3 years of this behavior what do you think your going to have. A nice clean suite of tests or a monstrous big ball of stubs, mocks, faked, copy pasta that resulted from defensive social coding. Honestly, write a light suite of tests that get to the point, and keep your ability to code swiftly and make changes quickly. As the code matures you'll find the trouble spots and focus testing on those areas. Don't blindly follow methodologies that are going to have…

Rails takes this approach[1] to some extent, but it's still possible to plug in different things, it's still all flexible enough to build any type of web app pretty much, and it still requires a ton of developer (or LLM) involvement. I'm thinking of going far further, to the point that perhaps we should use a new language designed only for web-app development. I'm thinking about removing almost all options so that the LLM only gets to write custom business logic and data modelling and doesn't need to do much else. Again this is all at the cost of being more generally applicable, but I see a lot of software that is fundamentally CRUDL and it's still hard to build well, and I also see a lot of LLMs reinventing the wheel but implementing too many sides on that wheel. They need guardrails. [1]: https://dhh.dk/2012/rails-is-omakase.html

You need more than tests. Test induced design damage: https://dhh.dk/2014/test-induced-design-damage.html

It's no surprise given the distro name, and DHH's previous use of the word Omakase [1, or, perhaps, 2] [1]: https://dhh.dk/2012/rails-is-omakase.html [2]: https://www.youtube.com/watch?v=E99FnoYqoII

Link prefetching is generally something you would want a website to retain control over, because it can distort stats, cause resource starvation, and even (when web developers are idiots) cause things like deletions (when a clickable link has a destructive outcome). I am reminded of the infamous time when DHH had to have it explained to him that GET requests shouldn’t have side effects, after the Rails scaffolding generated CRUD deletes on GET requests. https://dhh.dk/arc/000454.html Google were not doing anything wrong here, and DHH was merely trying to deflect blame for the incompetence of the Rails design. But the fact remains, alas, that this kind of pattern of mistakes is so common, prefetching by default has risks.

Some historical context and one of the more provocatively titled writeups during the last time this was widely debated: https://dhh.dk/2014/test-induced-design-damage.html

This has been a plague for so long it nearly threatened the rails project. It also inspired a very interesting article https://dhh.dk/2012/rails-is-omakase.html about the maintainer that provides a framework of sorts for thinking about issues regarding open source entitlement

Reminds my how Basecamp use to restart their Rails app 400 times/day. https://dhh.dk/posts/31-myth-2-rails-is-expected-to-crash-400-timesday

Sometimes it is an improvement, sometimes it is https://dhh.dk/2014/test-induced-design-damage.html

This is long overdue. Rails got very nice updates in the past years to make it easier to handle JS and other assets. Deploying it was still always a hassle and involved searching for existing Dockerfiles and blog posts to cobble together a working one. At the beginning I always thought I'm doing something wrong as it's supposed to be easy and do everything nicely out of the box. And dhh apparently agrees (Now at least: https://dhh.dk/posts/30-myth-1-rails-is-hard-to-deploy) as there's now a default Dockerfile and also this project he's working on, this will make things a lot nicer and more polished: https://github.com/rails/mrsk

It's "omakase" (in the words of Wikipedia) : > Omakase is a Japanese phrase, used when ordering food in restaurants, that means 'I'll leave it up to you' (from Japanese 'to entrust' (任せる, makaseru)) See the article: "Rails is Omakase" by David Heinemeier Hansson on Dec 27, 2012 https://dhh.dk/2012/rails-is-omakase.html > Rails is omakase. A team of chefs picked out the ingredients, designed the APIs, and arranged the order of consumption on your behalf according to their idea of what would make for a tasty full-stack framework.

It's been hard to find a timeline or more general history of TDD and I should have probably used the word "had" above. But my understanding is RSpec[0] was a huge driver of the test driven development hype cycle. While DHH[1] has, as of 2014, come out against TDD and was probably never 100% on-board he is not the whole community and that's still a gap of 9 years where, in my understanding, it was broadly popularised as both "the way you should be doing things in Rails" and, as with most things in Rails "the way everyone should be doing things". [0]: https://www.stevenrbaker.com/tech/history-of-rspec.html [1]: https://dhh.dk/2014/tdd-is-dead-long-live-testing

> Did you make that up? I stole the analogy from this article talking about Rails and applied it to Apple. https://dhh.dk/2012/rails-is-omakase.html

Many reasons. - Ruby is designed for Programmer Happiness. - Convention over Configuration - Omakase: https://dhh.dk/2012/rails-is-omakase.html - Its an Majestic Monolith: https://m.signalvnoise.com/the-majestic-monolith/ - Tons of libraries

Rails, from what I remember, has a strong my-way-or-the-highway attitude. It has many strengths, but deviating from the happy path isn't it's strength. It's creator claimed it was Omakase. [1] [1] https://dhh.dk/2012/rails-is-omakase.html

> If you find your testers splitting up functions to support the testing process, you’re destroying your system Why Most Unit Testing is Waste 4 architecture and code comprehension along with it. Test at a coarser level of granularity. This is very much in line with DHH's opinion about testing in general (the discussion "TDD is dead" is about this). He said that he doesn't want to split logic for the sake of testing, so HE drives the design NOT tests. I very much agree with this. I think a human can design better code (meaning that's easier to use, so easier to consume by other humans) than any automated process (like TDD). I noticed his blog post quotes this PDF: https://dhh.dk/2014/tdd-is-dead-long-live-testing.html

A horrible Rails-speak affectation. But it is well documented! https://dhh.dk/2012/rails-is-omakase.html

There was a back-and-forth between DHH and some of the original TDD advocates a while ago, which I thought was pretty interesting. Test-Induced Design Damage: https://dhh.dk//2014/test-induced-design-damage.html And a resulting conversation between Kent Beck, Martin Fowler, and David Heinemeier Hansson: https://martinfowler.com/articles/is-tdd-dead/ I think a lot can be learned from the exchange.

the core of TDD was to iterate by making a failing test, then making it pass Yes and when I first heard that 15 years ago (or whenever it was) it sounded like genius and I did it on a few projects. Its a useful crutch maybe if you're doing something very unfamiliar But as a dogma that must always be followed? And having a test for every single 'specification' and edge case? No - screw that, you end up faffing around for ages setting up mocks and testing stuff that doesnt deserve it. And you end up with a massive library of tests that get on your nerves. Also everything got completely bent out of shape for a few years because everything had to be injectable and testable. https://dhh.dk/2014/tdd-is-dead-long-live-testing.html http://web.archive.org/web/20180215225218/https://iansommerville.com/s… http://blog.cleancoder.com/uncle-bob/2016/03/19/GivingUpOnTDD.html https://rbcs-us.com/documents/Why-Most-Unit-Testing-is-Waste.pdf

It is so long ago now that I can't even find stuff about it on Google -- 2006 I think? Basically, well after they'd released the framework they had to change the Rails scaffolding (and I think their own apps) because parts of the scaffolding (CRUD deletes) would use GET to do the action that should only be done as POST. They discovered it about the time link-prefetching was invented ;-) Basically, browsers were pre-fetching all the clever scaffolded delete URLs and destroying records, seemingly at random. I was really impressed with Rails at the time but stayed well away from the scaffolded code in production, and I was gobsmacked by the idea that people talking about a clever, opinionated framework that did the right thing and produced magical, clean, elegant code to rescue you from terrible alternatives did not understand that GET requests should be idempotent. Edit: here is one bit about it: https://dhh.dk/arc/000455.html The unearned high-mindedness of this still makes me chuckle.