Live data from Hacker News

Steel Threads are a powerful but obscure software design approach

rubick.com

71–80 of 89 posts

Re: Steel Threads are a powerful but obscure software design approach

#71

I hope people will excuse my cynicism Step 1: Rehash a bunch of existing ideas together (PoC, vertical slice, strangler pattern). Step 2: Give it a flashy new name. Step 3: Market your consulting services as an expert for flashy new name. Sell to companies how they can build high performing organizations with this new technique.

Why are you calling out Uncle Bob like this?

Re: Steel Threads are a powerful but obscure software design approach

#74
I think the concept is good, but the name is pretty bad - I mean, we have "green threads," "POSIX threads," "kernel threads," "user threads," etc. Given that this concept from software engineering has absolutely nothing to do with execution threads, it needs a less confusing name.

Re: Steel Threads are a powerful but obscure software design approach

#75
post #4

This reminds me of something John Carmack tweeted once (can't find the tweet). In the tweet, he said that when coding, he'd start by the smallest possible PoC, and code it entirely front to back. That'd give the general structure, and then he'd build upon that. (this is what I remember of it fwiw). I do this all the time too, which I think is a vastly superior approach to TDD, which assumes how an API is going to be…

IMO this style isn't at odds with the spirit of TDD. TDD is mainly a technique to teach people about loose coupling and designing for maintenance. The main takeaway has always been that you should be able to run/exercise your code at every step and that you should use code to do that. No matter if it's an API or the whole program, that code you use to exercise it is what is key as it not only exercises the code it also helps you understand the problem.

Re: Steel Threads are a powerful but obscure software design approach

#76

The example in the article doesn't make sense to me. It basically says "You want to switch out a piece of a monolith to a new service, you do it with feature flags etc. That's hard." Which is true. But then it says "Steel Threads is better. Instead of switching out a part of your monolith, you... switch out a part of your monolith but it's a smaller part. That's not as hard". Which is true but isn't that the same thi…

The main difference between the two is that the cutter approach means that the two features must coexist at more or less the same place in the code and that the architecture must be adapted to accommodate this half-dead half-alive chimera.

In the end you have three states two deal with with the code before the new feature, the chimeric code and then the code with the new code enabled.

With the steel thread approach the feature exists on its own and is used and tested in production at the very beginning, although with limited traffic first. Important to note that the author seems to assume a micro-service architecture.

Re: Steel Threads are a powerful but obscure software design approach

#77
post #4

This reminds me of something John Carmack tweeted once (can't find the tweet). In the tweet, he said that when coding, he'd start by the smallest possible PoC, and code it entirely front to back. That'd give the general structure, and then he'd build upon that. (this is what I remember of it fwiw). I do this all the time too, which I think is a vastly superior approach to TDD, which assumes how an API is going to be…

That reminds me of a quote from John Gall:

A complex system that works is invariably found to have evolved from a simple system that works.

Re: Steel Threads are a powerful but obscure software design approach

#78
post #4

This reminds me of something John Carmack tweeted once (can't find the tweet). In the tweet, he said that when coding, he'd start by the smallest possible PoC, and code it entirely front to back. That'd give the general structure, and then he'd build upon that. (this is what I remember of it fwiw). I do this all the time too, which I think is a vastly superior approach to TDD, which assumes how an API is going to be…

You see this pattern with almost anyone who is proficient at almost anything. Start with something in the simplest, smallest or most general way you can and master it, then build from there.

Mathematicians and physicists make a career out of this, but it works with almost anything, including sports.

Re: Steel Threads are a powerful but obscure software design approach

#79
post #4

This reminds me of something John Carmack tweeted once (can't find the tweet). In the tweet, he said that when coding, he'd start by the smallest possible PoC, and code it entirely front to back. That'd give the general structure, and then he'd build upon that. (this is what I remember of it fwiw). I do this all the time too, which I think is a vastly superior approach to TDD, which assumes how an API is going to be…

That’s the vertical slicing mentioned in the article.

https://en.wikipedia.org/wiki/Vertical_slice

Re: Steel Threads are a powerful but obscure software design approach

#80
post #4

This reminds me of something John Carmack tweeted once (can't find the tweet). In the tweet, he said that when coding, he'd start by the smallest possible PoC, and code it entirely front to back. That'd give the general structure, and then he'd build upon that. (this is what I remember of it fwiw). I do this all the time too, which I think is a vastly superior approach to TDD, which assumes how an API is going to be…

I was working with a newer developer once, and we started working on some app that was going to be something moderately complex. I literally started with a single class that looked like:

  public class Foo
  { 
     public static void main( String[] args )
     {
       System.out.println( "Done" );
     }
   }
And he was really struck at first, like "Why would you write Hello World when we're building a $WHATEVER? My response was that the very first thing I always want to see, in any new project, is something compiling, packaging and executing. It's my way of ensuring that at a minimum the environment is set up, cosmic radiation hasn't fried my CPU or RAM, etc. And once I have that trivial program running, I just start building up from there.

I more or less follow that same pattern for everything I write to this day. At most, the slightly more complex version I start with is something like a "template" or "skeleton" project. For example, I keep a sample Spring Boot project around that as a pom file, the directory structure, a package named something like org.fogbeam.example, and a simple controller that just returns "Hello World". Once I can build and run that, and hit localhost:8080 and see my "Hello World" page I start iterating from there.

I can't tell you exactly how I developed this habit over the years, but it's worked well for me.

Post reply on HN