Hacker News with Generative AI: Software Architecture

MCP explained without hype or fluff (nilenso.com)
Model Context Protocol, like most protocols, solves the M ⨯ N integration problem by turning it into an M + N integration problem.
Ask HN: What's your go-to message queue in 2025? (ycombinator.com)
The space is confusing to say the least.<p>Message queues are usually a core part of any distributed architecture, and the options are endless: Kafka, RabbitMQ, NATS, Redis Streams, SQS, ZeroMQ... and then there's the “just use Postgres” camp for simpler use cases.<p>I’m trying to make sense of the tradeoffs between:<p>- async fire-and-forget pub/sub vs. sync RPC-like point to point communication<p>- simple FIFO vs. priority queues and delay queues<p>- intelligent brokers (e.g. RabbitMQ, NATS with filters) vs. minimal brokers (e.g.
Implementing a Struct of Arrays (brevzin.github.io)
Recently, I watched Andrew Kelley’s talk on Practical Data Oriented Design. It goes into some of the architectural changes he’s been making to the Zig compiler, with pretty significant performance benefit. Would definitely recommend checking out the talk, even if you’re like me and have never written any Zig.
CORBA: Catching The Next Wave (1997) (archive.org)
Distributed objects are the next wave in Internet innovation. CORBA, the Common Object Request Broker Architecture defined by the Object Management Group (OMG), specifies how software objects distributed over a network can work together without regard to client and server operating systems and programming languages.
A Principled Approach to Querying Data – A Type-Safe Search DSL (claudiu-ivan.com)
The rise of local-first web applications demands a rethinking of traditional client-server architectures.
Why I'm No Longer Talking to Architects About Microservices (container-solutions.com)
It happened again last week. I was at an architecture review meeting when a fellow architect eagerly started another debate about *microservices*. Within minutes, eyes glazed over and we were knee-deep in an absurd discussion about something that should have been a means to an end, but had morphed into the end itself. At that moment, I realized: I’m done. I’ve finally sworn off talking to architects about microservices. Why? Because these conversations usually go nowhere productive.
The Synchrony Budget (morling.dev)
For building a system of distributed services, one concept I think is very valuable to keep in mind is what I call the synchrony budget: as much as possible, a service should minimize the number of synchronous requests which it makes to other services.
Krazam: Microservices [video] (youtube.com)
The New Three-Tier Application (dbos.dev)
In the beginning (that is, the 90’s), developers created the three-tier application. Per Martin Fowler, these tiers were the data source tier, managing persistent data, the domain tier, implementing the application’s primary business logic, and the presentation tier, handling the interaction between the user and the software. The motivation for this separation is as relevant today as it was then: to improve modularity and allow different components of the system to be developed relatively independently.
Software Architecture Is More Than Boxes and Arrows (planetgeek.ch)
I watch many software architecture talks (on-site and virtually), and I am starting to think that my understanding of software architecture differs from that of most speakers.
Conway's Law (2022) (martinfowler.com)
Pretty much all the practitioners I favor in Software Architecture are deeply suspicious of any kind of general law in the field. Good software architecture is very context-specific, analyzing trade-offs that resolve differently across a wide range of environments. But if there is one thing they all agree on, it's the importance and power of Conway's Law. Important enough to affect every system I've come across, and powerful enough that you're doomed to defeat if you try to fight it.
Building a Generative AI Platform (huyenchip.com)
After studying how companies deploy generative AI applications, I noticed many similarities in their platforms. This post outlines the common components of a generative AI platform, what they do, and how they are implemented. I try my best to keep the architecture general, but certain applications might deviate. This is what the overall architecture looks like.
Turning the database inside-out (2015) (kleppmann.com)
Databases are global, shared, mutable state. That’s the way it has been since the 1960s, and no amount of NoSQL has changed that. However, most self-respecting developers have got rid of mutable global variables in their code long ago. So why do we tolerate databases as they are?
REST is the new SOAP. A journey through a trendy hell (2017) (medium.com)
REST promised simplicity and delivered complexity. REST promised robustness and delivered fragility. REST promised interoperability and delivered heterogeneity. REST is the new SOAP.
The Microservices Fallacy (ufried.com)
If you listen to discussions about microservices, they often feel like: Microservices are it! It’s how modern IT systems are built! Microservices reduce complexity! Microservices are needed for scalability! Everybody does Microservices! We want them! We need them!
The Raw Truth About Self-Publishing My First Technical Book (fractionalarchitect.io)
A week ago, my “Master Software Architecture” book reached a milestone: 800 copies sold (combining ebooks and physical copies). While I am incredibly happy about this achievement, you might wonder: is this a lot compared to what I planned? That is one of the many topics I will explore in today's post.
Clojure core.async.flow (github.com/clojure)
The fundamental objective of core.async.flow is to enable a strict separation of your application logic from its topology, execution, communication, lifecycle, monitoring and error handling, all of which are provided by and centralized in, c.a.flow, yielding more consistent, robust, testable, observable and operable systems.
The Architecture of Open Source Applications (aosabook.org)
Architects look at thousands of buildings during their training, and study critiques of those buildings written by masters. In contrast, most software developers only ever get to know a handful of large programs well—usually programs they wrote themselves—and never study the great programs of history. As a result, they repeat one another's mistakes rather than building on one another's successes.
Building AI Products–Part I: Back-End Architecture (philcalcado.com)
In 2023, we launched an AI-powered Chief of Staff for engineering leaders—an assistant that unified information across team tools and tracked critical project developments.
Ask HN: Are there any courses specifically for software architecture? (ycombinator.com)
Are there any online courses specifically for software application architecture (rather than learning syntax, math, etc.)?
Hexagonal Architecture and Rails (codegardener.com)
Last night, Fito and I watched Alistair Cockburn's Hexagonal Architecture talk from the Tech Excellence Conference. We really enjoyed it, and despite thinking I already understood the pattern, I learned a ton. In fact, before you continue reading, you should go watch it. Go ahead! I'll wait...
Domains listening to many other domains in Event-Driven Architecture (reactivesystems.eu)
Usually, in an event-driven architecture, events are emitted by one service and listened to by many (1:n). But what if it’s the other way around? If one service needs to listen to events from many other services?
Thinking in Actors – Challenging your software modelling to be simpler (jeremycarterau.substack.com)
Challenging your software modelling techniques to be simpler
I don't know how to build software and you don't either (seangoedecke.com)
Are microservices better than monoliths? Should teams set their own technical direction, or is it better to have that dictated by some external architect? Should you write long-term complex projects in an untyped language? If you’re on the internet for ten seconds, you’ll see many engineers who argue about these topics as if the answer was obvious.
Why microservices might be finished as monoliths return with a vengeance (venturebeat.com)
The shift towards microservices started gaining momentum in the early 2010s, as tech companies recognized the limitations of monolithic architectures. However, many companies such as Amazon (Prime Video), Invision, Istio and Segment are moving back to monolithic architectures. This article will explore why many organizations fail when transitioning to a microservices architecture.
A Reconfigurable Architecture for Industrial Control Systems (mdpi.com)
The closed architecture and stand-alone operation model of traditional industrial control systems limit their ability to leverage ubiquitous infrastructure resources for more flexible and intelligent development.
Ask HN: Good books about architecturing cloud solutions for performance? (ycombinator.com)
What are some good books for architecture of web software for performance? Preferably ones targeted to Spring but also other technologies
Data Modeling with Sums and Products (funktionale-programmierung.de)
Data Modeling is often an underappreciated aspect of software architecture, yet it plays a crucial role in achieving not only functional but also usability and maintainability goals.
The Practical Guide to Scaling Django (slimsaas.com)
Most Django scaling guides focus on theoretical maximums. But real scaling isn’t about handling hypothetical millions of users - it’s about systematically eliminating bottlenecks as you grow. Here’s how to do it right, based on patterns that work in production.
Why software only moves forward (swizec.com)
At scale there are no rollbacks and no cut-overs. Your software only moves forward.