Hacker News with Generative AI: Software Architecture

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.
Leveraging the lightcone around the source of truth with Postgres (benoitessiambre.com)
To summarize, the postgres-centrism hypothesis says that integrated, entropy-minimizing systems that reduce dependency distances, and anchor logic near the source of truth, leveraging the efficiencies of proximity, often better aligns with fundamentals of computing, physics, information theory, thermodynamics and intelligence.
Killing the Command message: should we use Events or Documents? (2007) (microsoft.com)
If we want to decouple a SOA system, we must get away from the notion of the remote procedure call.  In other words, our services need to have as few "command" messages as we can get away with.  This is a design philosophy but it is easier said than done.
Using the Strangler Fig with Mobile Apps (martinfowler.com)
Incremental replacement of a legacy mobile application is a challenging concept to articulate and execute. However, we believe by making the investment in the pre-requisites of legacy modernization, it is posible to yield benefits in the long term. This article explores the Strangler Fig pattern and how it can be applied to mobile applications. We chart the journey of an enterprise who refused to accept the high cost and risk associated with a full rewrite of their mobile application.
The Dual Nature of Events in Event-Driven Architecture (reactivesystems.eu)
Given that events play such a central role in event-driven architecture, there’s an astonishing lack of agreement on what should be contained in an event.
Designing a Query Execution Engine (trychroma.com)
Distributed Chroma is a multi-tenant system. Query and Compactor nodes serve queries and build indexes for multiple tenants. By leveraging multi-tenancy we can maximize utilization of nodes in our system, resulting in lower costs for our users. However, building with multi-tenancy in mind presents the challenge of how to optimally structure, dispatch, and schedule work such that resources are fairly used across all tenants.
An incremental approach to modernizing legacy mobile application: Strangler Fig (martinfowler.com)
Incremental replacement of a legacy mobile application is a challenging concept to articulate and execute. However, we believe by making the investment in the pre-requisites of legacy modernization, it is posible to yield benefits in the long term. This article explores the Strangler Fig pattern and how it can be applied to mobile applications. We chart the journey of an enterprise who refused to accept the high cost and risk associated with a full rewrite of their mobile application.
What Message Queue-Based Architectures Reveal About Distributed System Evolution (redmonk.com)
What’s new in message queues? Message queue-based architectures, a dominant paradigm in distributed systems, are essential, well understood, and therefore increasingly ho-hum.
Rama on Clojure's terms, and the magic of continuation-passing style (redplanetlabs.com)
Rama is a platform with huge applicability, able to express all the computation and storage for a backend at any scale. Just like the UNIX philosophy of composing simple programs to do more complex tasks, Rama is based on simple building blocks that compose for any backend use case.
A Brief Intro to Clean Architecture, Clean DDD, and CQRS (jacobsdata.com)
In this blog entry I give a primer on Clean Architecture, which is a modern, scalable formal software architecture which is appropriate for modern web applications.
Five Common Misconceptions About Event-Driven Architecture (reactivesystems.eu)
An opportunity for everyone to do a little self-test. Do you believe any of these five statements? If so, don’t worry, you’re not the only one, I’ve come across them many times. I’m very convinced they’re untrue, though. This is my humble attempt to improve our shared understanding of some properties of event-driven architecture.