alt.hn

5/12/2026 at 9:30:21 AM

Learning Software Architecture

 https://matklad.github.io/2026/05/12/software-architecture.html

by surprisetalk

5/12/2026 at 1:02:24 PM

I'll give you the cheat sheet:

- Good design is a single idea pervaded throughout.

- More generally, your goal should be to minimize surprise.

- If your system allows it, people will do it.

- Everyone will not just. If your solution starts with "if everyone will just..." then you don't have a solution.

- Isolate the parts of your system that transform data from the ones that use it. Data models outlive code.

- Coupling is the root of most evil.

- Versioning is inevitable.

- Make state explicit.

- Every piece of information should have a single source of truth.

- You should spend more time thinking about naming things correctly.

- If testing is difficult, the design is wrong.

- You will regret every undocumented decision.

- Communication is a tax that you should justify before paying it.

Remember that the job of an engineer at any level is to use rules of thumb to solve problems for which there is incomplete information.

by CSMastermind

5/12/2026 at 7:08:45 PM

I don't agree with all of these, but I'll add a couple of my own:

- The ultimate goal of software is to solve the immediate problem at hand. The secondary goal of software is to solve likely future problems with as little work as possible. Any bad design which is better on those goals than a good design is actually a good design.

- Make your interfaces easy to use correctly and hard to misuse. Think of how people unfamiliar to the project will interact with them, make the obvious way be the correct way.

- Correct code should be easy to write; suspicious code should stand out.

- Shift bugs left.

- Fixing a bug class is better than fixing a bug.

- Interfaces are harder to change than implementations. An ugly implementation is ok if it has the correct interface.

- Use comments and documentation to explain why the code is the way it is. If it feels like there's a simpler way to do it, but that simpler way wouldn't actually work due to a constraint some people may be unaware of, document that.

- Don't repeat yourself; when it comes to data. If you store a single fact in multiple places; those places will inevitably get out of sync, and that causes bugs.

- There's a cost to straying off the well-trodden path. Don't be afraid to do so when it's truly worth it, but don't underestimate that cost. Worse (boring) technology is often better technology.

- Think in terms of expected value. Think not "Is this thing worth doing?", but "Is this thing worth doing, compared to the other things we could be doing instead?"

- Even if you think you're smarter than everybody else, intelligence isn't always enough, some problems can't be discovered until they happen. Other people have worked longer on this problem than you have. Learn from their mistakes.

- Friction is the silent killer.

by miki123211

5/13/2026 at 1:08:10 AM

> The ultimate goal of software is to solve the immediate problem at hand. The secondary goal of software is to solve likely future problems with as little work as possible.

Not really. Today I learned of a story where a vibe coding PM deployed a vercel app, which was in its entirety a single react component that serves a banner, that was embedded via an iframe into an entirely separate web app, whose repo they have full access to, because they needed to get a modal component out the door, but were blocked because they “couldn’t upload the image to s3.” (They could just use the public/ or assets/ directory and have the cdn pick it up, too.)

People do the most insane things when they are tight on time and don’t have the intuition to do a bit of research up front. If you ask them, they’re solving the immediate problem at hand. If you ask anyone else who interacts with their work, they’re disrupting our days/weeks/months/years when we have to step through systems that don’t know any better.

If you have the muscle to plan ahead, even a little bit, which is usually just following the same pattern over and over again, then you are fine.

In this world you are still optimizing for the now problem but you have also solved, to some and ideally a better degree, some future problems for free

by dirtbag__dad

5/12/2026 at 1:09:20 PM

I'd add

- data migrations are inevitable and should be planned for (corollary of versioning)

- planning is good, sometimes you just have to try things out

- everything costs money. Designing without costs in mind will force hard choices down the line

by laszlojamf

5/12/2026 at 2:15:01 PM

I'll add another to that:

- Code lives longer than you expect. You forget sooner than you expect. Make a readme/architecture overview/theory of operation document. Put more in it than you think is needed. Check it in with the code.

by AnimalMuppet

5/12/2026 at 11:31:38 PM

If I had a dollar for every time "throwaway code" became foundational code...

by abustamam

5/12/2026 at 1:58:39 PM

I wish I could buy you a beer, as this is very validating. I have been building a video game for over a year. But more importantly I have been building a sustainable engine with a distinct data pipeline, resource rendering/management layer fully decoupled, explicit catalogueing of viable state transformation modes, and honestly, most of your list is absolutely applicable. Even tho it is solo, the constraints of my engine guides forgetful me to 'this is the way to add this weird new feature that arose from testing because reasons' without having to have a tome of 'if you want to build a new sound effect that executes at a particular state transformation multiple times, here is how you do it'

Cheers

by RobRivera

5/12/2026 at 6:10:12 PM

Ah, the infamous "I believe I'm building a video game, but in reality I'm building a video game engine and I don't realize it yet" every game developer goes through at least once, god speed to you :)

by embedding-shape

5/12/2026 at 7:36:44 PM

Its been such a fun endeavor

by RobRivera

5/13/2026 at 4:34:59 AM

I have nothing to add other than I love seeing this attitude of someone enjoying getting "lost" down what many would consider a mistaken path.

Good reminder for the rest of us to enjoy the journey once in a while.

by dodu_

5/12/2026 at 3:26:48 PM

Missing the single most important thing, that people seemingly are purposefully trying to avoid nowadays for some reason:

- It depends

No solution I've come across, is a solution for everything, everywhere. It's almost always context dependent, and something that is right in one place, can be utterly wrong in another, and there is no universal truths regarding design and architecture.

The more flexible you can be with "right tool for the right job", the easier time you'll have designing, because you're no longer trying to shoehorn in things that are "right" and "correct".

> - You should spend more time thinking about naming things correctly.

This should almost be on the list twice too, the amount of people who couldn't care less about naming, is so damn high, but if people just cared a tiny bit, it'd solve so much future confusion. Whenever I get pulled into helping a "legacy project" or whatever, establishing a "true vocabulary" based on what people actually call things, is the very first thing to do, because it always uncovers that people been talking about different things the entire time.

by embedding-shape

5/12/2026 at 10:09:08 PM

To be honest, "It depends" is also exhausting. I have some defaults that I push until the breaking point, though I apply this more often on personal projects. DDD is an exception, as even professionally I will vomit DDD concepts as solutions for literally anything. "This could have been an aggregate", I will say like a mantra.

by rafael-lua

5/12/2026 at 11:35:16 PM

I found I did pretty well in the interview stage whenever I'd start an answer with "it depends"

Of course, I'd have to back that up with assumptions and goals and such, but I think that's the point. X technology is great at Y but not so great at Z, so if you want to optimize for Z maybe don't use X.

by abustamam

5/13/2026 at 12:24:26 AM

I don't actually think this has much to do with software architecture. Except maybe the "Isolate parts of your system..."

In fact the article itself didn't really seem to be too coherent on software architecture. I think the 4+1 view of software architecture is a good conceptual way to think about things (minus all the UML). It's not a complete picture but it addresses the bigger picture. The book series Pattern-Oriented Software Architecture is pretty good and outlines a number of architectures people tend to land on. One stage Grady Booch was working on a handbook of software architecture, but seems to be kind of dead ish, but he did have a mailing list where he'd go to companies or look at large open source projects and look document big system architectures (and some smaller scale), not sure where you can see this anymore. All of these things are worth diving into if you want to learn about software architecture. You can see these architectures are built for different focuses, things like scale, safety, performance, interoperability, failsafe, etc. i.e. there are very specific goals of an architecture with very real tradeoffs.

by keithnz

5/13/2026 at 1:17:43 AM

Good architecture is not about the patterns you pick. It’s about having a team dev cohesively on any pattern(s)

- programmatically enforce your style with in-house linters and scaffolders. Be highly opinionated

- if you # ignore anything, leave a comment explaining why

- use bdd so your cases are human readable and must update with the code (unlike a stale comment)

- follow the same pattern in all your services (I love hexagonal design for backend). If you break from the design have a good reason for it

- COMPOSE your code. It’s almost always the case that two endpoints or jobs or whatever happen to have a few things in common, but differ wildly. Don’t get DRY, just import those things in each spot and don’t entangle them with each other, it’s too confusing

- scope your interfaces tightly. No optional params unless the domain is actually optional. Make separate jobs or endpoints for different configs. I can’t figure out wtf all your configs were from 4 years ago and neither can you

- code is default testable with DI/DIP

- always run tests running real infra like testcontainers - cement ci/cd as your guardian. Employ every linter you can.

- hammer workarounds with comments in the code

- break all systems into small problems and nothing is challenging technically (though the domain might be!)

- work with less people on your code. It’s easier to stay aligned and follow the same patterns

- don’t expect anyone to figure it out. You need to champion your changes. Do code reviews, hold their hand, show them the way

- clear out mundane items like installfests, local auth, server reloads. Slow dev pisses people off

- finally, and most important, employ an org policy for review. Don’t let shit fall through the cracks unknowingly. It compounds. You have skills now as a quick and dirty to eval and enforce. Use them!

by dirtbag__dad

5/12/2026 at 7:45:57 PM

I work in this space as well - I know that my particular work is much less abstract (we're modeling the healthcare industry) than some others.

But as a designer of the system you must understand the industry and while you don't need to embrace their terminology and modeling habits fully, you must understand their rationale and how they view the data set. There are some places where we've intentionally simplified complications of the healthcare market to eliminate needless (to us) over definitions and provide a more unified modeling. But these changes took significant comprehension of the problem area to make with confidence.

> You should spend more time thinking about naming things correctly.

On this point in particular. Names never die - that's a lie, occasionally they do, but it takes an extreme amount of effort to enforce a renaming. It really is worth spending a big bulk of time letting SMEs stew with naming proposals to make sure you bases are covered. You can force through a few concepts but your business wing (sales, marketing) will constantly put pressure on you towards industry terminology and force your model to adhere to the current view of the industry. If you decide to break with that that break must be decisive and obvious in intent.

Oh, the single biggest attribute of software to emphasize is maintainability. How much will this cost to build is one question - how much will this cost to run (not just infra but compounding feature requests and code refactoring and maintaining third party software versions etc...) is the far more impactful.

by munk-a

5/12/2026 at 4:53:30 PM

Great list but I dunno about coupling being evil, it is literally the only place anything important happens.

by bfivyvysj

5/12/2026 at 10:11:24 PM

Coupling is evil, as it is the main root of all the nastiest problems I have found in many projects I worked on. It is the main cause of "throw it all away and start greenfield" in my experience. I mean, it is important and needs to be done right, but it is yet evil.

by rafael-lua

5/12/2026 at 5:22:11 PM

What exactly do you mean by “make state explicit”?

by kachnuv_ocasek

5/12/2026 at 7:52:17 PM

Minimizing side effects (e.g. functional programming) is a good habit in general. But when we're talking at the scale of a company's entire software solution state is the enemy of everything that is good.

You never want to work on a platform with 500k lines of code any of which could mutate variable state at will and the more you can isolate or simplify state usage the better your life will be.

by munk-a

5/13/2026 at 12:30:57 AM

It's also the enemy of evil things your company does.

by topaz0

5/12/2026 at 7:14:03 PM

Depends on the language I'd say, but overall, try to keep state in as few places as possible, and make it more obvious when it's being used. Modern example would be Rust defaulting to immutability for variables, and makes it very clear when you should expect that this variable actually carries state rather than just a value, by prefixing it with `mut `. Other languages might make it the other way around, making constants/read-only variables stick out, and defaulting to "hiding that they have state" basically.

by embedding-shape

5/12/2026 at 1:22:09 PM

Can you explain the last one? What types of communications are you suggesting an arch would avoid?

Otherwise, a very wise list!

by mwexler

5/12/2026 at 2:45:06 PM

Not the OP. However, in my experience, the "tax" of communication is that everything has winners and losers. You can state that the "1+1=2" or "the sky is blue" and someone will lose politically. You have to prepare yourself to defend your position even if 19 out of 20 agree with you; because the one person who disagrees with you has the most to lose.

by rawgabbit

5/12/2026 at 1:51:03 PM

You can make the feature with one colleague, or you can call in five more people to weigh in and do their parts of the work.

If you involve five more, the result could be better in theory, but it will certainly take MUCH more time because of communication overhead.

by murkt

5/12/2026 at 7:55:13 PM

Pretalking is highly valuable. Making sure that key stakeholders have an aligned vision and are invested in defending it before opening up a discussion (or dictate, depending on the culture) to a wider audience is necessary. Occasionally expect that the stakeholders and you got it wrong and you'll need to invest time into rebuilding the solution, but, if you're honest with yourselves and diligent, assume that generally the expert subgroup will supply a comprehensive solution.

by munk-a

5/12/2026 at 4:22:16 PM

When I read it, I assumed it meant like network communication in your program. File and network I/O having/being a "tax" makes sense to me.

by ragnese

5/12/2026 at 7:01:30 PM

Just one more alternative interpretation… I thought it’s about systems calling into other systems, making everything slower, more complicated and brittle…

But maybe it’s about discussing an issue with 10 other people from different teams when it’s not necessary.

But we will never now. I guess OP didn’t want to pay the communication tax on expressing this idea clearly :)

by serial_dev

5/12/2026 at 1:43:32 PM

Completely agree. Had me until the very last point. WTF. Communicate.

by theteapot

5/12/2026 at 1:52:34 PM

The last one is about involving less people. You don't have to read it as "shut up and keep your thoughts for yourself". I read it more like "Do we really need to have six people working on this feature/present in this call?"

by murkt

5/12/2026 at 7:56:34 PM

I strongly prefer the phrasing of "When do we actually need to have six people involved on this?" It's often valuable to set a momentum and prune obviously poor decision branches before bringing proposals to a wider audience.

by munk-a

5/12/2026 at 2:08:55 PM

well, it needs to be communicated better.

by ulbu

5/12/2026 at 1:58:53 PM

I wonder if they don't mean "between systems".

by gavmor

5/12/2026 at 2:13:27 PM

> Communication is a tax that you should justify before paying it.

I thought it meant like keep things as local as possible. Like within the same process, within the same machine, avoid going through the network because staying on the processor is always the fastest, going to ram is next fastest, and if you need to communicate across the network it is always slowest

by collabs

5/12/2026 at 2:30:47 PM

I don't think performance advice should be part of a general architectural principles list, so I don't think that's what they meant. Otherwise might as well add "avoid nested loops", etc, and then it devolves into a general programming advice list.

Performance is and always was something dependent on the domain rules. You don't start architecting for performance before understanding requirements so why make it a pillar of all architecture.

by alternatex

5/12/2026 at 1:57:54 PM

> - Make state explicit.

Don't save the same state in more than one place.

by ofrzeta

5/12/2026 at 7:58:21 PM

You can and you must replicate state in a complex system. The key is that state should always have an explicit owner and other carriers of that state should understand that their version of the state has some inherent lag or inconsistency off the true state.

There's a reason caching (and it's invalidation) is one of the two hardest problems in computer science.

by munk-a

5/12/2026 at 1:55:39 PM

Good list!

One addition?

* start with a modular monolith

by electrosphere

5/12/2026 at 10:20:45 PM

This one has yet to enter my head. I read Martin Fowler's related article* a few times, and it is sound... But I still can't see microservices being so "complex" to be so avoided early on. Especially in 2026, with the level of IaC and pipelines we have. I might be naïve, but I just don't get it.

(*) https://martinfowler.com/bliki/MonolithFirst.html

by rafael-lua

5/12/2026 at 8:02:19 PM

I don't want that to be limited to just architecture though - proper initial factoring of a software product is invaluable at the large and most microscopic level.

by munk-a

5/12/2026 at 4:32:30 PM

Yes. I’d add: design the module boundaries before splitting deployment.

A modular monolith still forces you to name ownership, data boundaries and invariants, but without making every mistake a networking/ops problem.

by perkovsky

5/12/2026 at 5:31:36 PM

Good list, although things get weird when you are limited by some legacy software/database.

by avgDev

5/12/2026 at 8:00:35 PM

You are always limited by some legacy software/database.

If you're not limited by some legacy software/database initially then you will have such a large problem scope that you'll create your own legacy software/database internally.

I'll grant that if your problem is really simple and straightforward you can sometimes just build an ideal greenfield solution that's perfect and wonderful - but those problems are rarely the problems that are profitable to solve.

by munk-a

5/12/2026 at 1:20:31 PM

Thanks for sharing! Really agree with #2 even though ultimately - we can only minimise rather than totally eliminate.

by thedetailsguy

5/12/2026 at 3:43:19 PM

> If testing is difficult, the design is wrong

Or domain/IO is cumbersome. Think videogames.

by ivanjermakov

5/12/2026 at 4:00:00 PM

That's one of the few places where creating abstractions makes a lot of sense, especially in video games. You really, really want as much to be automated tested as humanly possible, because the user/player surface ends up enormous and testing gets "expensive" much quicker than a typical SaaS.

by embedding-shape

5/12/2026 at 4:04:50 PM

Nope, that's just the design being wrong. Factorio has no issues with testing.

It doesn't matter if nobody is interesting it fixing it, video games have been and almost always are written like shitty single use code, (Even when it's not) so it shouldn't surprise anyone that proper test harnesses aren't available in engine.

by nullsanity

5/12/2026 at 1:56:15 PM

As a corollary to

> Communication is a tax that you should justify before paying it.

> Every piece of information should have a single source of truth.

- Do as much as possible on a single system and minimize sharing state.

- Recognize that every system is distributed, it's just a question of how and where.

One of the biggest ills I observe with most modern software systems is that we've gone full tilt towards things like microservices which require synchronizing state across multiple interdependent parts. Regardless of how clean the abstractions or how well contracted the APIs, doing all of that copying and state synchronization is going to result in problems: performance problems, cost problems, and synchronicity problems.

by tristor

5/12/2026 at 4:05:23 PM

Good, really good. But not real. You can achieve such ideal only without human which makes no sense.

by dmitrijbelikov

5/12/2026 at 7:33:15 PM

then comes the order from your manager: "Put it in production and we can work through this list later".. or even worse, now with Claude, managers are putting stuff "Quick and Dirt" in production and you have to maintain it.. sadly true story..

by pelasaco

5/12/2026 at 8:04:42 PM

The job of an architect and good technical management is to teach non-technical management the true costs of their decisions. It's not an easy job by any measure and LLM driven know-nothings in management can make it far more frustrating. But, you need to make sure you're capturing the true[1] costs of decisions to the best of your ability including externalities.

1. You're allowed to lie for expediency, but make sure you never delude yourself into believing your own lies.

by munk-a

5/12/2026 at 1:18:30 PM

great list! ty

by john_builds

5/12/2026 at 11:23:25 AM

The recommendations are often very good, for example Ousterhouts A Philosophy of Software Design, but seem to be on software development in general, not actually software architecture in particular.

For that, I would recommend the classic texts, such as Software Architecture: Perspectives on an Emerging Discipline (Shaw/Garlan) and really anything you can find by Mary Shaw. Including more recent papers that explore why the field of software architecture did not go the way they foresaw, for example Myths and Mythconceptions: What Does It Mean to Be a Programming Language, Anyhow? or Revisiting Abstractions for Software Architecture and Tools to Support Them

More practically: look at why Unix pipes and filters and REST are successful, and where they fall down and why. Hexagonal architecture is also key.

And a plug for my own contribution, linking software architecture with metaobject protocols as a new foundation for programming languages and programming: Beyond Procedure Calls as Component Glue: Connectors Deserve Metaclass Status. An answer to Mary Shaw's Procedure Calls Are the Assembly Language of Software Interconnection: Connectors Deserve First-Class Status.

Answering the question: if procedure calls are the assembly language, what might a high level language look like? And also maybe that software architecture might have a brighter and more practical future ahead of itself.

by mpweiher

5/12/2026 at 1:04:47 PM

> if procedure calls are the assembly language, what might a high level language look like?

I’m not well versed in PLT and SWE tooling, but isn’t that the base concept around lambda calculus, LISP, APL, clojure, TCL,…? You only need a few data structures and types, a small collection of fundamental functions, then you compose them.

If there’s one thing that I like about Lisp is that more complex type are always opaque (especially the ones from FFI). I would love to see CLOS implementation for a C-like language, where when you define a struct, what you get is a standard collection of functions.

by skydhash

5/12/2026 at 2:36:41 PM

> You only need a few data structures and types, a small collection of fundamental functions

For the implementation: yes. Hence "assembly language". The mistake almost universally made is to confuse that with the abstraction mechanism.

She showed that it's necessary.

I showed how to do it.

by mpweiher

5/12/2026 at 10:11:40 PM

The best way to learn architecture is to:

1. Maintain a large enough project. Not create, but support.

2. Do it for at least couple or few projects.

If project is too small, any architecture works fine. "Large" can be in terms of lines of code, but better in terms of people who ever worked on it, or even better -- teams.

At least two different projects is to have something to compare. I've seen people stuck for decades on one project and not knowing any modern ways to solve a problem.

But often the architects who get promoted because they created, not maintained a project. Especially visible in Google, as you don't get promoted for maintaining anything, only for shipping something new (and better jumping off as soon as possible afterwards).

Counterintuitively, people in the best position to be architects are actually side contractors from head shops, who get invited to maintain an existing project no one from a company is willing to (as they all jumped off where promotions go). First, they have to maintain an architecture, and second they did it on several projects, so can compare. The downside though, is if they bill by the hour, the tend to over-complicate architecture to bill more hours.

by deepsun

5/12/2026 at 11:41:34 AM

In this vein, I really recommend "Architecture of Open Source Applications."[1] It's a book series where you learn architecture by example, with each chapter written by a maintainer of the project in question. This lets you learn not only what the architecture is, but what are the constraints that shaped it, usually history and changing project visions.

Not all chapters are equally good or equally interesting, that's the curse of a multi-author book, and all of them are dated, but I think the book is worth reading nonetheless.

[1] http://aosabook.org/

by miki123211

5/12/2026 at 2:23:48 PM

I think that words like "clean code" or "beautiful code" does help juniors to learn best practices of software architecture.

  - Junior asks to senior: what did you we use an ORM ?
  - senior answers: because it's cleaner.
  - junior: ???
I prefer when people are able to define a clear list of objectives:

  - maintenable;
  - performant, scalable;
  - efficient;
  - resilient;
  - observable;
  - testable (and tested);
  - secured;
  - readable for new devs that come on board.
Each criteria balance the others, and the more we add criteria the more it helps to make good choice when we hesitate. It is also meaningful for people outside of the dev team, we can reach an agreement with the customer so he knows what he pays for.

"maintenable" can be also defined, since a project is mostly in maintenance mode during its lifetime (which means the project is successful, which is good !). The ability to incorporate new features without breaking architecture or even without breaking a single method signature is a good starting point.

Being super careful with abstractions. Here someone wrote something like that: "abstraction often hides how what you want is simple". True, ORM I am looking at you. In most case data should be threaten as first class citizen, it also fosters good collaboration with the DBA.

Thinking beyond "the happy path" without falling in premature optimization is also a challenge. A nice one, once again to it avoids to go head first in implementing a good idea without considering drawbacks.

I also tend to imagine that the one that will work on my code had a very bad day so it must be pleasant to read what I wrote. Comments here and there, locale variable here and there even if they can be avoided, variable naming, etc...

Being selective about frameworks. They are good servant but bad leaders. "Be an engineer, not a frameworker" says an article.

by ah1508

5/12/2026 at 8:14:55 PM

Modular frameworks are worth their weight in gold when compared to "highly opinionated frameworks". I don't mind something that's highly opinionated - and highly opinionated is an excellent trait for a library or tool. That lib/tool likely has a large amount of domain expertise in the particular area it operates in.

When it comes to frameworks - highly opinionated tends to get corrupted into "We have this hammer and suddenly everything looks like a nail" - it doesn't always happen and it doesn't always bite you but when orthodoxies are taken from one domain and applied broadly you run the risk of some of the justifications for that orthodoxy being domain specific and being violated in the wider context.

So, when it comes to frameworks, I like modularity where I have options to plug in a different ORM or persistence integration layer - where I can swap out the router - or the validator - or any other component that proves a poor fit for our problem. It is especially valuable if there are multiple paradigms expressed in alternatives within the framework's ecosystem since you may find a pre-baked tool that mostly works where you can choose an option with shortcomings that are clear and addressable if ever the need arises.

To support maintainability it's very important to fight against NIH-ism, that is a constant danger that can soak up resources at an alarming pace - but it's also important to realize that there are some components that you will greatly benefit from tweaking or taking full ownership of with the most difficult problem being trying to figure out which is which.

I appreciate deeply that your list put maintainability first - that's my opinion as well!

by munk-a

5/12/2026 at 11:52:10 AM

I think there is huge space for architecture case studies that help a non coder learn how to critique llm architecture decisions.

I’m a NP - lots of learning came in clinical rotations where you see real life situations and how they are addressed. I want something like this for software architecture.

The closest I’ve seen is the open source case study books referenced previously but these are older.

I’d like to be able to see explanations at various layers of abstraction about why certain decisions are made or not.

by npl

5/12/2026 at 12:20:07 PM

I'm surprised that it seems no-one has brought up Residuality (see https://www.architecture-weekly.com/p/residuality-theory-a-r...) which is a very interesting take on architecture (as opposed to design) which aligns with my own experiences.

As well as the book (https://leanpub.com/residuality) the author has one on the philosophy of architecture (https://leanpub.com/architectsparadox).

by finnnk

5/12/2026 at 6:09:32 PM

Wanted to say thanks for posting this. I found the NDC talk interesting and well presented. Will try to read more about it and, as an exercise, try applying it to my own solutions to see what insights I could gain.

by grusgrus

5/12/2026 at 2:59:24 PM

Residuality is very interesting. Have you used it in practice?

by 4b11b4

5/12/2026 at 11:13:58 AM

I would like to spend my time more on gaining a mental model of the projects I work on, but I get very demotivated if I start disliking things like the programming language, certain arch. Choices or anything that gets too complex that doesn't seem like its worth my time

It's heavily dependent on the project, but I feel like working as a "fullstack dev" kind of removes the fun of programming. I'm already spending 40 hrs a week looking at the most dull project I can imagine

by ramon156

5/12/2026 at 1:24:32 PM

> I would like to spend my time more on gaining a mental model of the projects I work on, but I get very demotivated if I start disliking things like the programming language, certain arch. Choices or anything that gets too complex that doesn't seem like its worth my time

Let it go...

Not one single project is free of warts. Not a one. And honestly, if the programming language is that big a deal, you're better off jumping ship. We should all be polyglots, but that's up to you.

by HumblyTossed

5/12/2026 at 8:17:53 PM

Analysis paralysis is a danger always - don't aim for perfect, but aim for flexible. Make sure the decisions you're spending the most time on are the most important.

A well designed data structure is far more impactful on performance and maintainability than framework, language or platform.

Personally, I work alongside ADHD every day so I need to constantly push to make sure that progress is happening which means picking unimportant decisions and resolving them to focus the remaining open problem space on the decisions that require a lot of careful thought.

by munk-a

5/12/2026 at 1:59:08 PM

Sounds like you need better emotional regulation.

by ambicapter

5/12/2026 at 12:07:02 PM

Nice read. “ Learning Software Architecture” means understanding that there is no single good answer. It is art and science.

Read tip: Simplify IT - The art and science towards simpler IT solution https://nocomplexity.com/documents/reports/SimplifyIT.pdf

by runningmike

5/12/2026 at 10:31:11 AM

The Gary Bernhardt talk is truly special. Lots of concepts which will lead you to other interesting places

by abhik24

5/12/2026 at 1:57:34 PM

As relates to Systems Engineering: Software architecture is like plumbing architecture. It's certainly very important, but you don't live in plumbing pipes, you live in a house with plumbing. If your plumbing doesn't take the rest of the house into account, it could be a very expensive fix.

by 0xbadcafebee

5/12/2026 at 10:41:17 AM

I think this really down plays the value of mental model or strategies for organizing code. Take a compiler: often described as a sequence of transformations on an AST, taken to the extreme in the nanopass framework. That's a really useful mental model, and you can extract that model and apply it in other contexts. For example, many business applications are a sequence of transformations on JSON. So they're basically compilers. That can be good architecture in the right situation.

You don't have to call a sequence of transformations a compiler. You can say your AST is an algebraic data type, and your transformations are folds (or structural recursions; same thing). Now you have an abstract model that isn't tied to a particular application, and you can more easily find uses for it.

If you know a bit of maths you might wonder about duals. You will find codata---objects---are the dual of algebraic data. Ok, now we're programming to interfaces. That's also useful in the right context. What's the dual of a fold? An unfold! So now we have another way of looking at transformations, from the point of view of what they produce instead of what they consume. At this point we've basically reinvented reactive programming. And on and on it goes.

You can find most of this in the literature, just not usually presented in a compact and easy to understand form.

(Note, the above description is very quick sketch and I'm not expecting anyone to understand all the details from it alone.)

Shameless self promotion: the book I'm writing is about all these concepts. You can find it here: https://functionalprogrammingstrategies.com/

by noelwelsh

5/12/2026 at 11:27:11 AM

I’m not sure what part of the article this is attempting to critique.

But I would say that just because your preferred mental model is an abstract algebraic one where you build an abstract model that can apply to multiple situations doesn’t mean that such an architecture is best for every situation.

The article talks very clearly about the system and social constraints that it is optimizing for architecturally and ‘turning everything into a fold’ doesn’t immediately strike me as helping to meet the fast-build-feedback needs of the deep contributors and easy-and-safe-to-hack-in-modules needs of the weekend warrriors, which is what are described as the goals of the architecture.

But it also doesn’t strike me as very clearly not the case that the architecture has some of the features you’re describing.

It feels rather like you have a pet mental model which you think all architecture should subscribe to, and… I’m sorry but that seems naive.

by jameshart

5/12/2026 at 11:42:21 AM

You misinterpreted my comment. Algebraic data types and folds are an example of an architecture, that has application to many situations. They are not the only architecture, and I'm not presenting them as such.

I am trying to show 1) software architectures are useful, 2) if you abstract them you can find principles and relationships that allow you to transfer them to different domains, and transform them into different models, and 3) there is a lot of depth in software architecture and utility in learning it.

The article spends most of its time discussing social context in which architecture is developed (I agree it is important, but not everything) and in general downplays the utility of learning about software architecture (e.g. "“software design” is something best learned by doing", and later suggests there is little useful writing on software architecture).

by noelwelsh

5/12/2026 at 1:33:57 PM

This guy knows exactly what he's talking about. However, it feels more like a "if you know, you know" rather than relaying the experience/data he's accumulated.

Let me just say: A lot of people think architecture is how do you build a very complex system with tons of moving components (databases, queues, scaling, reduandancy, failover, dozens of services). I think expert achitecture is being able to answer how do I correctly solve the problem using the fewest of those.

Genius-level engineering is inventing the zipper, usable anywhere, lightweight, cheap, sturdy, simple to make.

(I believe he's alluding to this by saying companies follow conways laws and essentially socially construct a lot of work to match up with the number of teams, hence creating a completely unnecessary nightmare of complexity just for the social incentives)

by zug_zug

5/12/2026 at 11:44:25 AM

Software design/architecture is a strange beast. It feels that if you want to learn it, you should spend time in legacy systems and large codebases of rewrite a project 3 times to explore counterfactuals. A lot of books on the subjects are abstract and give such simple examples, they are useless.

by NeutralForest

5/12/2026 at 12:02:48 PM

It's really hard to provide proper guidance on software architecture, because the fundamental deployment strategies differ for each project. For web projects, a lot of people will say Cloud is the best way to deploy, so now you're forced to build your whole project in a "Cloud friendly" architecture.

When I was learning and being formally educated I regularly only had like 50 bucks to my name, I couldn't even afford the cheapest VPS I could find. So for me learning the architectural ideas of using AWS services where you have to setup credit card information to even register was not feasible. After all I already had a computer, why not learn how to deploy from there? Especially after reading about horror stories of people racking up huge cloud bills due to some slip up. So AWS was out of the window. Next I got myself a book about Microservices which was popular at the time, but quickly learned that they are about organizational structure rather than software architecture, so I never had a reason to try that architecture.

I still have no idea how to chose the right architecture or make the "correct" decisions on it. I do whatever works and for some reason it still pays my bills. Currently I just use Laravel monoliths for everything and I am pretty sure this is good enough for most web services out there.

I know the original post wasnt about webapps, it's just where I find myself having the most issues.

by sevenzero

5/12/2026 at 12:53:44 PM

>Software design/architecture is a strange beast

Yes. At one point I thought a set of good programs can be composed into a good architecture. Then at another stage- with agile, etc.- I was thinking about evolutionary architectures.

But experience and dealing with different kind of problems and systems work best. Also, I have seen Conway's law hold when many other patterns, principles fail.

Books like Garlan Shaw are good but help if you have some experience. Some other books/ courses like Neal Ford's help, but for me those helped only to know the terms/ ideas. Practice and rewrites, tech-upgrades helped more. Also, books like Michael Nygard's Release It.

by atulatul

5/13/2026 at 1:53:53 AM

The abstraction and generic design is part of the point, though. It's not really about writing concrete examples, but experiences and how to be ready to structure based on those experiences.

by alfg

5/12/2026 at 12:54:31 PM

My example here is: it’s impossible to know what spaghetti code is until you experience it, and are on the hook for its bugs and outages.

We hear a lot about it prior and upon experiencing it I could name it. (Like love, I suppose?)

by andyferris

5/12/2026 at 4:21:34 PM

> A lot of books on the subjects are abstract and give such simple examples, they are useless

They are abstract because architecture is for dealing with pain, and you can’t explain pain. You need to experience it and reflect on what was done wrong to be in trouble. The examples are like a gentle pinch which does not prepare you for pulling a muscle in your back or having a nail in your foot.

My strategy is to read the books, try to implement the things at least once to get a sense of the costs, and then get back to it once you’re experiencing pain in your project. It may be too late, but you will then learn the lesson.

by skydhash

5/12/2026 at 2:48:29 PM

The architecture assignment that I found most useful did not come from a book. It involved the attempt to articulate my system to an agent session starting with no background information at all.

If the agent cannot deduce the constraint, then you have to write it out. Conventions for migration. Invariant properties of the authentication protocol. Multi-tenant behavior. This act of articulation – making your implicit reasoning explicit – led to a kind of clarity that several months of construction alone did not bring. Three architectural errors emerged instantly.

It’s true that learning by doing is the way to go. I would add: learn by explaining it. The agent is an unusually picky audience.

by luodaint

5/12/2026 at 12:44:38 PM

With AI we all have to make the switch from programmer to software architect, I suppose.

by amelius

5/12/2026 at 12:53:29 PM

With the amount of shit code generated it ain't gonna happen anytime soon.

by xyzal

5/12/2026 at 1:27:38 PM

there is also The Architecture of Open Source Applications books

https://aosabook.org/en/

by systems

5/12/2026 at 11:27:59 AM

Most codebases eventually take on similar shapes, depending on their size and on the IoC model imposed by the framework.

And when you try to prevent that IoC from leaking into the domain too much, the design often starts to look like hexagonal architecture.

Programming often feels like inventing a new form, but in the end we tend to converge on the shapes that previous programmers already discovered.

by jdw64

5/12/2026 at 11:33:29 AM

Perhaps the real job of programmers is (or has been) adapting to new requirements. The art lies in the process, not in the result.

by esjeon

5/12/2026 at 11:39:31 AM

> The art lies in the process, not in the result

nevertheless, I often deceive myself into thinking that I am inventing a new design. In reality, I am usually just being shaped by the IoC model imposed by the framework and by the pressure of business requirements.

Only the scale changes. Similar problems tend to leave similar structures behind.

Sometimes it feels as if earlier generations of programmers have already solved so many of the important problems that all that remains for me is rediscovery.

But I do not want mere rediscovery. I want to create a new kind of problem. Still, in front of the solidity of established engineering, my small mind sometimes feels as if there is no place left for me.

by jdw64

5/12/2026 at 2:18:03 PM

[dead]

by alex1sa

5/12/2026 at 2:34:56 PM

A lot of people seem to lean too much on Conway's Law. It takes social organization as primary instead of itself shaped by the nature of a problem. Maybe the reason Sales and Engineering are different departments is because they are different things.

by getnormality

5/12/2026 at 2:32:48 PM

Immediately favorited as this article and the comments underneath are great reference points and reminders. (Even as someone that's been doing this for awhile)

by sailfast

5/12/2026 at 12:39:49 PM

Learn by doing? Certainly helpful. But I feel like the real secret is to work with others who are good at software architecture. You can learn very efficiently that way.

by kevinwang

5/12/2026 at 4:21:04 PM

> the phenomenon of “scientific code”

I have some experience being a software engineer in a data science team or in a team adjacent to a DS team, a lot of problems that they think are "data science problems" are actually software engineering problems being solved in an extremely convoluted and weird way.

I think that if DS community wasn't so resistant to basic SE good practices, or involved engineers in making architectural decisions, total time and effort needed to solve some problems would be greatly reduced.

When I'm in a bad mood, I even entertain a silly conspiracy theory in my head: they do everything in the most ugly and weird way specifically to keep people like me out :)

by vova_hn2

5/12/2026 at 10:28:00 AM

[flagged]

by woodydesign

5/12/2026 at 1:13:20 PM

I think of it this way. Software architecture can not be taught. (This is not particularly uncommon, and so not a claim to being particularly special.) But you can sensitize people to the problems they will encounter and solutions they should consider. You can't "teach" someone into being a software architect of 10 "software architecture goodness units", but you can accelerate the rate at which they accumulate SAGUs by doing this.

In fact, per my parethetical, honestly I would say most things work like this. You can't just pluck people up and drop them five or ten years down the road of experience for nearly anything. What you can do is give them a car and show them the road rather than letting them hack through a jungle with a machete and no map.

One of my major criticisms of how we teach is that for the most part everyone in the system operates in the belief that we can just stand in front of people and say things for a few hundred hours and they will be magically equipped with completed and refined skills after that process. Too much focus on trying to drop people into some mythical state of "educated" rather than accelerating them through their own journey. A journey that can be highly guided and structured for sure, but where you understand that for all you can clear the road you can't actually take steps for the student.

"It is also subtraction: removing unnecessary abstraction, ceremony, cleverness, and control."

This reminds me of one of the most distinct menaces to software architecture I encounter on a regular basis, the person who follows Hexagonal Design or Clean Architecture or MVC or some other Answer To All Architecture, rigorously following it to the letter and insisting that any system that doesn't follow the Answer To All Architecture is prima facie a bad system that needs immediate redesign to bring it into conformance with the ATAA.

The "answer" to something as complicated as software architecture doesn't fit in a book. In fact it doesn't even fit in a human head; for all the experience I have in network servers I wouldn't expect to be able to sit down and architect a high-performance game engine that could compete in the marketplace. I have ideas about how to do it, sure, but I know that I don't know all the details that people who operate in that space do, and plenty of those details will matter. No one has the breadth of experience to truly tell us all how to architect software, under all circumstances and conditions. Anyone de facto operating as an architect needs to bear that in mind, and while consulting the prior experience is part of that "be in a car on a road and not hacking through a jungle", the supposed set of blessed answers must always be mediated through the task in front of you and not vice versa.

by jerf

5/12/2026 at 2:11:49 PM

It’s tangential to your point, which I agree with completely, but this is also exactly why I get so frustrated with the idea that higher education is about acquiring job skills. Ideally, regardless of major, a university teaches you how to think, critically and deeply, and how to learn. If you have those things, job skills are easy to pick up, but instead we treat college like an RPG skill tree, where you’ve got to put points into your intended career path in order to unlock the skills you’ll need to do the job.

Edit: although I do think university focus is important for subjects that are less about job skills and more about knowledge synthesis, such as most sciences, critical analysis, and so on, if you intend to not just do a job but contribute to the overall knowledge base of the field.

by mplanchard

5/13/2026 at 11:13:26 AM

I also quite resonate with the structural dilemma of modern education system. Learning should be life-long experience. And learning cannot separate with practicing, it's two sides of ONE process.

Two quotes I am keep revisit when I learn:

“To LEARN, and to PRACTICE what you learned at the RIGHT time, and from time to time, isn't that JOY indeed?” - Confucius

“Many have remarked the speed with which Muad'Dib learned the necessities of Arrakis. The Bene Gesserit, of course, know the basis of this speed. For the others, we can say that Muad'Dib learned rapidly because his first training was in how to learn. And the first lesson of all was the basic trust that he could learn. It is shocking to find how many people do not believe they can learn, and how many more believe learning to be difficult. Muad'Dib knew that every experience carries its lesson.” ― Frank Herbert, Dune

by woodydesign

5/12/2026 at 2:25:29 PM

I did this both

1. used Ruby on Rails, got familiar with it

2. Got rid of it, wrote the part i really need in Go.

And running with it.

Achieving scale on commodity VPS at Hetzner.

by faangguyindia

5/12/2026 at 11:19:11 AM

"code on, code off"

by jareklupinski

5/12/2026 at 12:02:27 PM

Haha... wax on, wax off. Love this analogy that learning coding as learning Kungfu

by woodydesign

5/12/2026 at 6:05:56 PM

We're all Code Benders now

by whattheheckheck

5/12/2026 at 2:11:25 PM

so Tao is coinductive

by ulbu

5/12/2026 at 12:17:55 PM

> Laozi gives the complementary warning: “In pursuing learning, every day something is added. In pursuing the Tao, every day something is dropped.” Mastery is not only accumulation. It is also subtraction: removing unnecessary abstraction, ceremony, cleverness, and control.

Well, your (or your LLM's) interpretation is a bit less nuanced than the original. The verse from DDJ you mention is more about letting go and living a simple life, a bit the opposite of programming where we actually need an adequate level of complexity to handle the complexity of the world.

As a side note, even if you are not a native English speaker, trying to formulate thoughts without the support of LLMs is very welcome here.

by dvfjsdhgfv

5/13/2026 at 10:57:22 AM

I do not think “letting go” simply means living a simple life, nor does simple life mean rejecting complexity in Laozi's wisdom.

I totally agree that programming needs enough complexity to handle the complexity of the world. However, elegant architecture should less accumulate unnecessary complexity or organizational burdens.

Sorry for the late reply since my account is fairly new and system do not allow me to reply too fast on yesterday.

by woodydesign

5/12/2026 at 1:13:17 PM

Definitely a 'your LLM' case here.

by joaohaas

5/12/2026 at 11:36:08 AM

[flagged]

by supriyo-biswas

5/12/2026 at 11:58:26 AM

Correct — LLM helped with the wording. The thought is mine.

As a non-native English speaker, I’m pretty happy that the final version is more readable and probably sharper than what I would have written alone.

by woodydesign

5/12/2026 at 7:05:20 PM

We understand you feeling like it's more important to post polished writing than imperfect writing, as a non-native English speaker. But neither the HN audience nor the guidelines (https://news.ycombinator.com/newsguidelines.html) see it that way.

AI-translation/editing/polishing takes away all the authenticity and makes the writing seem like it came from a machine, not a person. It's much better if you write in your own voice, even if there are imperfections. The HN audience appreciates the effort.

by tomhow

5/12/2026 at 12:05:54 PM

We can't even say something in public these days. All your comment needs is the trigger words or constructions

- That's why X works. - Not X but Y.

And some moron will be in the replies, saying "LLM comment". I hate this world. But probably yeah. llm comment.

by kaycey2022

5/12/2026 at 12:14:06 PM

Except that their entire profile is like this.

by supriyo-biswas

5/12/2026 at 12:23:34 PM

So. What.

People, particularly non-native English speakers, are going to use LLMs to help with their writing. Complaining about it adds nothing to the discussion.

by macintux

5/12/2026 at 1:51:26 PM

[flagged]

by lacymorrow

5/12/2026 at 4:00:40 PM

[flagged]

by maxothex

5/12/2026 at 3:44:00 PM

[dead]

by JoheyDev888

5/12/2026 at 10:39:35 AM

[dead]

by SadErn

5/12/2026 at 11:26:13 AM

[dead]

by rahadbhuiya