Ruby Midwest 2011 - Keynote: Architecture the Lost Years by Robert Martin

What Hacker News said

Strong rec mpweiher · 2014-04 · on “TDD is fun”

Excellent riposte! Mine was going to be somewhat less polite :-) Can't stress enough that TDD is not about testing (sth. DHH, like many if not most critics gets wrong). It is about development and design. The fact that you get a pretty decent test suite out of it is a nice side effect. (Love me those side-effects, wouldn't want to program without 'em). I also find that whenever I skimp, it always comes back to bite me. And usually it was because I hadn't understood the problem-space well enough to write a proper test. That's one important part of TDD for me: I have to understand the requirements well enough to actually write a test for them. And the OP is also right in that Rails is a bad en

Strong rec catwell · 2018-10 · on “Ask HN: What are some of the best technical talks you've heard?”

The talk that had the most influence on how I write software is Robert 'Uncle Bob' Martin's "Architecture: The Lost Years" [1]. Being a Ruby conference keynote, it helps if you know how Ruby on Rails works, but the lessons apply to all software. Another one would be "Let It Crash! The Erlang Approach to Building Reliable Services" by Brian Troutwine. [2] I don't know if you would call it "technical" but Brett Slatkin's talk on Cohort Analysis is something anyone interested in tools to analyze how our users behave should watch. [3] [1] [this video] [2] [LINK] [3] [LINK]

Strong rec SevenNation · 2022-10 · on “Using a framework will harm the maintenance of your software”

> Many people will argue that not using a framework means write everything yourself. This is a false dichotomy. We can use libraries and frameworks just fine. ... > But we should give them a clear, and well-isolated place in our project. ... There's an excellent, if older, presentation called "Architecture, the Lost Years" that addresses exactly this problem and gives very specific, actionable guidance on how to solve it: [this video] But how to pull off this decoupling? The answer is both obvious and surprising. Define a boundary. On one side is the framework. On the other side is your code. Through the boundary, only dumb data structure can pass. JSON works. So do structs. So does XML. The poin

Recommends jared314 · 2013-04 · on “Code Organization in Large AngularJS and JavaScript Applications”

This reminds me of the beginning of Bob Martin's keynote[0] at Ruby Midwest 2011[1]. I don't agree with everything he said, but the code organization point is sound. [0] [this video] [1] [LINK]

Recommends Anchor · 2013-09 · on “Slow Tests Are the Symptom, Not the Cause”

Here's Uncle Bob talking on his version of the idea extensively: [this video] The main idea is to separate the system into entities, interactors and boundaries, which correspond roughly to model, controllers and interfaces+DTOs (Data Transfer Objects), but with the difference that model classes are not exposed through the interfaces. Rather, the DTOs are used to communicate the changes in the data. We have been using this approach for a year now, with REST on top, and it so far has worked beautifully. The entities map naturally to REST resources and DTOs makes nice request and response classes. Armed with CQRS (now I sound enterprise-y), the data storage is easy to work with using the same DTOs (

Recommends programminggeek · 2014-11 · on “Crystal: the programming language”

It might do that wildly inefficient thing... Or, you might do something where you have a list of pointers, and you point at a different value instead of mutating an existing value. I haven't dug into the details of how immutable data structures can be made to work efficiently, but part of the charm is that in many cases you don't mutate the array at all. What I mean is, there are certain behaviors around mutation that programmers do because they can. When you take away the ability to mutate data, you design differently and without side effects. All of a sudden testing becomes easier, faster, cheaper for large parts of your codebase. You have simpler solutions that are potentially easier to r

Recommends jxxcarlson · 2016-05 · on “Hanami – web framework for Ruby”

My (limited)experience is that when a rails app gets too big, it becomes hard to manage. That was my case, anyway. The architecture of hanami promotes longterm developer sanity. The fact that views are objects and the existence of interactors is a real plus. See this old Uncle Bob video re interactors: [this video]

Recommends dreistdreist · 2016-08 · on “Ask HN: 8 years working, now 3-4 months off to learn. Looking for advice”

Microsoft Application Architecture Guide [LINK] Domain Driven Design (The book is hard to read, but worth it I think) [LINK] This uncle bob talk is not too bad [this video] I think the microsoft guide is the most comprehensive, but don't limit yourself to it.