Hacker News with Generative AI: Software Architecture

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.
No such thing as exactly-once delivery (sequinstream.com)
We say Sequin is system with "at-least-once delivery" and "exactly-once processing" guarantees.
Microprogramming: A New Way to Program (breckyunits.com)
All jobs done by large monolithic software programs can be done better by a collection of small microprograms (mostly 1 line long) working together.
Microservices Are Technical Debt (youtube.com)
Monolith First (2015) (martinfowler.com)
As I hear stories about teams using a microservices architecture, I've noticed a common pattern.
Should we decompose our monolith? (lethain.com)
From their first introduction in 2005, the debate between adopting a microservices architecture, a monolithic service architecture, or a hybrid between the two, has become one of the least-reversible decisions that most engineering organizations make.
From Event-Driven to Durable Execution: Distributed Execution Flow Paradigms (metatype.dev)
In this age of cloud development and microservices architecture, problems start to arise with the increased workloads that run in the system.