<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: R.G. Lefever</title>
    <description>The latest articles on DEV Community by R.G. Lefever (@rgfaber).</description>
    <link>https://dev.to/rgfaber</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F774582%2F85fae94a-c4b0-4694-8e68-54f6d395d692.jpg</url>
      <title>DEV Community: R.G. Lefever</title>
      <link>https://dev.to/rgfaber</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/rgfaber"/>
    <language>en</language>
    <item>
      <title>The other half of the software factory</title>
      <dc:creator>R.G. Lefever</dc:creator>
      <pubDate>Fri, 13 Nov 2026 19:45:52 +0000</pubDate>
      <link>https://dev.to/rgfaber/the-other-half-of-the-software-factory-2dlj</link>
      <guid>https://dev.to/rgfaber/the-other-half-of-the-software-factory-2dlj</guid>
      <description>&lt;p&gt;Software factories are back in my feed, and the argument is the one I thought we had settled twenty years ago.&lt;/p&gt;

&lt;p&gt;Between 2000 and 2020 offshore development promised businesses cheap custom software, and what they often got was cheap software. The quality problems were real, and the answer the industry found was not to shout at the suppliers but to make coding, testing and deployment mechanical: boring, repeatable, and checked by a machine rather than by a hero.&lt;/p&gt;

&lt;p&gt;That part is done. A linter runs on every commit, a test suite runs on every push, a pipeline builds, signs and releases, and a fleet pulls its own desired state from a repository. In our own shop a release is a tag, a deploy is a reviewed commit, and nobody logs in to a box to restart anything. None of that is clever any more, which is the highest compliment engineering can pay a practice.&lt;/p&gt;

&lt;p&gt;That is half of the problem, and it is the half that was always going to yield to tooling, since it is about how code is handled rather than about what the code does.&lt;/p&gt;

&lt;h2&gt;
  
  
  The half that does not yield to tooling
&lt;/h2&gt;

&lt;p&gt;The other half is the functional one: deciding what the software should do, and writing it so that the decision survives contact with a team, a successor, or now a coding agent. You cannot make that mechanical by buying a tool, but you can make it mechanical by changing the shape of the work, and three practices do it together. Some people have started calling the combination EVE, and I will use the name.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Event storming&lt;/strong&gt; comes first. Before anyone draws a database, the people who know the work stand at a wall and name what happens, in the past tense: a member registered, a book was procured, a reading finished. The orange notes on that wall are the vocabulary of the business and nothing else, and the commands that cause them and the rules that react to them are added only once the events are agreed. Anyone who runs the club could read that wall, which is the test it has to pass, since the owner of the business will be reading it too.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Vertical slicing&lt;/strong&gt; decides where the code lives. One capability, one folder, and everything that capability needs inside it: the command, the event it produces, the rule that decides, and the door the outside world knocks on. Not a folder of controllers and a folder of services with the feature smeared across both, but one folder called &lt;code&gt;register_member&lt;/code&gt; that contains the whole of registering a member.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Event sourcing&lt;/strong&gt; decides what the state is. The state of a club is not a row that gets overwritten but the list of what happened to it, in order, and any table you need for reading is built from that list afterwards, by a separate part of the system that only writes tables, and read by a third that only answers questions. Writing, recording and answering are kept apart on purpose, which is the CQRS part of the name if you like acronyms, and which means each part can be small and dull.&lt;/p&gt;

&lt;p&gt;Put the three together and the code that comes out is boring and predictable, and I mean that as praise. The same shapes repeat. In the book club below a desk is four files, an event is one module, a projection is one event to one table, and a query is one question with one answer. That is the property that matters for a factory: when the shapes repeat, they can be produced by a template or by a language model, and checked by a machine.&lt;/p&gt;

&lt;h2&gt;
  
  
  What a stranger sees
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fhq8t24x4xdwshwd0e070.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fhq8t24x4xdwshwd0e070.png" alt="Three apps, one book club: what it can do, what happened, what you can ask" width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Here is &lt;a href="https://github.com/macula-services/mcl-bookclub" rel="noopener noreferrer"&gt;a book club, built this way&lt;/a&gt;, with the code public. There are three applications. The first holds what the club can do: initiate a club, register a member, procure a book, start and finish a reading, plan a party, archive the club. The second is organised around the events, one folder per event, each turning it into rows in the tables the third app reads. The third answers questions: a book, a member, a reading, by id.&lt;/p&gt;

&lt;p&gt;Open the first folder and you can read the process of running a book club without opening a file. You can also read a policy as a sentence, since one folder is named after it: on member registered, maybe plan a party. And you can tell which three facts the club shares with the outside world, since those folders start with &lt;code&gt;emit&lt;/code&gt;. That is screaming architecture: the names say what the code does, not how, and the structure is the documentation. We call it the stranger test. A stranger opens the repository and tells you what the business does, and if they cannot, the names are wrong.&lt;/p&gt;

&lt;p&gt;Those three folders are also the whole of the club's public contract, and the only thing anyone outside the club can depend on. The nine events inside are ours to change. A fact that has left the club is not: its version is in its name, a published version never changes and never disappears, and when the club has more to say it publishes a &lt;code&gt;_v2&lt;/code&gt; next to the &lt;code&gt;_v1&lt;/code&gt;, which is the open/closed principle applied to a contract. Who consumes a fact is not the club's business, and that is the point of publishing facts rather than calling consumers: the club keeps no list of them, cannot break them by accident, and does not wait for them when it ships. Who owns the club is equally short. One division, one repository, one owner, and a person's yes before anything reaches main.&lt;/p&gt;

&lt;p&gt;Onboarding changes character when the test passes. A new colleague reads one folder and owns one capability by the afternoon, and a coding agent, which is the newest colleague in every shop now, reads the same folder and produces the next one in the same shape, because there is only one shape to produce.&lt;/p&gt;

&lt;p&gt;The same club, walked through from the wall to the stored event, in sixteen minutes:&lt;/p&gt;

&lt;p&gt;  &lt;iframe src="https://www.youtube.com/embed/Xo9TaKFg4Kk" width="710" height="399"&gt;
  &lt;/iframe&gt;
&lt;/p&gt;

&lt;h2&gt;
  
  
  The D5 model
&lt;/h2&gt;

&lt;p&gt;Simon Brown's &lt;a href="https://c4model.com" rel="noopener noreferrer"&gt;C4 model&lt;/a&gt; gives architects four zoom levels for drawing a system: context, container, component and code. It is good and we use it. For the process side we have five levels of our own, each starting with D, and we call them &lt;a href="https://github.com/macula-services/mcl-corpus/blob/main/philosophy/D5_MODEL.md" rel="noopener noreferrer"&gt;the D5 model&lt;/a&gt;: four nested places and one thing that moves through them. The nod to C4 is intended, and the fifth one is the point.&lt;/p&gt;

&lt;p&gt;A Domain is the whole business endeavour. A Division is one cohesive piece of software inside it, the bounded context, the thing that gets its own repository. A Department is one of three roles inside a Division: commands, projections, queries. A Desk is one capability inside a Department, the folder you saw above and the atomic unit of work. And the Dossier is the aggregate: the folder of event slips that passes from desk to desk and grows as it goes. C4 tells you where the boxes are, and the fifth D tells you what moves through them.&lt;/p&gt;

&lt;p&gt;The desk is also why the factory idea stops being a metaphor. A desk is small enough to describe on one sticky note, strict enough to template, and complete enough to test on its own. Give one desk to one person or one agent as a work package, ask for the failing test first, have a second pair of eyes pass the change, and let a person say yes before it reaches main, and you get the same quality from the tenth desk as from the first. If a desk is a unit of work it is also a unit you can price, which is where I want to take this.&lt;/p&gt;

&lt;h2&gt;
  
  
  The first storm
&lt;/h2&gt;

&lt;p&gt;Granted, the first storm is the hard part, and no factory removes it. Getting the right people in front of the wall, naming the events honestly and finding where one division ends and the next begins is thinking, and it stays thinking. What the method does is make everything after the wall boring, so that the thinking is the only thing a person has to spend attention on.&lt;/p&gt;

&lt;p&gt;The book club above is our teaching repository, in Erlang, which is one language and not the one most readers write in. The rules it follows live in &lt;a href="https://github.com/macula-services/mcl-corpus" rel="noopener noreferrer"&gt;a public corpus&lt;/a&gt;, with the naming rules, the templates, and a long list of the mistakes we made and wrote down so we would not make them twice. The crew of coding agents that builds this way is called &lt;a href="https://github.com/macula-io/martha" rel="noopener noreferrer"&gt;Martha&lt;/a&gt;, and it still needs a person to say yes before anything reaches main.&lt;/p&gt;

&lt;p&gt;The first half of the factory is a product you can buy. The other half is a way of working, and it is the half that decides whether the code an agent writes tomorrow is something you can still read in five years.&lt;/p&gt;

&lt;p&gt;Would you let a factory like this build your next system, and if not, which half worries you?&lt;/p&gt;

</description>
      <category>architecture</category>
      <category>eventsourcing</category>
      <category>erlang</category>
      <category>ai</category>
    </item>
    <item>
      <title>Macula - An Ecosystem for Mesh-native Computing</title>
      <dc:creator>R.G. Lefever</dc:creator>
      <pubDate>Sun, 30 Aug 2026 22:22:13 +0000</pubDate>
      <link>https://dev.to/rgfaber/an-ecosystem-for-mesh-native-computing-4f8l</link>
      <guid>https://dev.to/rgfaber/an-ecosystem-for-mesh-native-computing-4f8l</guid>
      <description>&lt;p&gt;Macula is a mesh network for services and applications, built on Erlang/OTP: a node dials out over QUIC to one or more relay stations, which route its RPC calls, fan out its pub/sub events, and move content and streams between it and everyone else on the mesh. No inbound ports on the client side, no VPN, no central broker any one operator controls. Think of it less as "a client library for my server" and more as "the internet is one big distributed event bus, and here's how you dial into it."&lt;/p&gt;

&lt;p&gt;It's been in continuous development since late 2025, &lt;code&gt;macula&lt;/code&gt; (the core SDK) is at v10.14.1 on hex.pm, and the station side runs our own production fleet today. Four language ports exist beyond Erlang (Go, Rust, PHP, .NET), plus a CLI, an MCP server, and the relay itself.&lt;/p&gt;

&lt;h2&gt;
  
  
  What's actually in the SDK, and what it's built on
&lt;/h2&gt;

&lt;p&gt;&lt;code&gt;macula&lt;/code&gt; (hex.pm, Erlang/OTP) is the client side: the primitives an application dispatches against. &lt;code&gt;macula-station&lt;/code&gt; (separate repo, also Erlang/OTP) is the relay: it's what actually does the routing, and it's where most of the algorithmic work lives.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;QUIC (HTTP/3) transport&lt;/strong&gt;: every connection is outbound-only, so a client never needs an open inbound port. Independent stream multiplexing means one slow stream doesn't head-of-line-block the others (the actual problem QUIC was designed to fix over TCP-based HTTP/2), and connection migration means a session survives a network change, which matters once you're talking to a phone switching from wifi to cellular mid-call. TLS 1.3 is built in, not bolted on. The transport itself is a Rust NIF (Quinn underneath), shared by the SDK and the station.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Kademlia DHT&lt;/strong&gt;: the routing table. Signed, TTL'd records for advertisements, endpoints, and presence, resolved via multi-round iterative lookup. This answers "which station is this capability actually reachable through": resolve once against the DHT, then dial that station directly. One hop, no relay sitting in the data path afterward.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;SWIM-Lifeguard&lt;/strong&gt;: membership and failure detection, no central heartbeat server. Direct and indirect probing plus gossiped dissemination is plain SWIM; Lifeguard adds the adaptive suspicion timeout that keeps a busy node from getting falsely marked dead under load.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;HyParView + Plumtree&lt;/strong&gt;: the newest layer (landed in the core SDK around 9.2.0-10.5.0, additive, no supervised OTP wrapper around it yet). HyParView keeps a bounded partial view of the mesh per realm instead of every station knowing about every other station; Plumtree builds an epidemic broadcast tree over that view so a fact reaches everyone without flooding the whole mesh to do it. This is what keeps pub/sub fan-out and multi-hop RPC relay from becoming an all-to-all problem as the mesh grows.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Content addressing&lt;/strong&gt;: BLAKE3-hashed blocks, MCID identifiers, chunked put/get with discovery. Cancel is a real peer-visible QUIC &lt;code&gt;RESET_STREAM&lt;/code&gt;, not a local give-up that leaves the other side hanging.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Identity and authorization&lt;/strong&gt;: Ed25519 keypairs, UCAN capability tokens (mint/verify/introspect), DID documents, NIF-accelerated. Authorization is capability-based, a UCAN the caller presents, not a session or account the station has to look up.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;code&gt;macula-station&lt;/code&gt; is realm-agnostic and holds no application data of its own, realm membership and identity belong to whatever connects through it. One process, one Ed25519 identity, peers outbound with other stations to form the mesh; run one and it's an island, give it peers and it's part of something bigger. It's been running our own multi-station fleet continuously since 2026-04-14 (500+ commits at this point) against real traffic: DHT, SWIM, pub/sub relay, RPC relay (including genuine multi-hop, a call can cross two stations with no direct peering edge between them), streaming relay, content transfer.&lt;/p&gt;

&lt;p&gt;It's already got real consumers beyond its own tooling. &lt;code&gt;hecate-services&lt;/code&gt; (a separate org) builds independently-deployed services on Macula: RAG, an LLM gateway, DNS, git, mail, each an ordinary outbound-only Macula client, several sharing a common substrate library, &lt;code&gt;hecate-om&lt;/code&gt;, for identity, health, and capability-advertising boilerplate. The most fun one to actually look at is &lt;code&gt;hecate-whiteboard&lt;/code&gt;: a real-time collaborative whiteboard, Miro minus the company, a host runs it on their own node and collaborators dial into that host over Macula to draw together. It talks to Macula directly rather than through hecate-om, and cross-node sync is still the next piece; today it's real-time within one host, but the mesh-hosting and identity side already works end to end.&lt;/p&gt;

&lt;h2&gt;
  
  
  Beyond Erlang: the other language ports
&lt;/h2&gt;

&lt;p&gt;Four ports exist so far: Go, Rust, PHP, .NET, each a from-scratch reimplementation of the wire protocol, not a wrapper around the Erlang node. All are real, shipped, hex/npm-equivalent published.&lt;/p&gt;

&lt;p&gt;The Rust one is worth a closer look: its own README tagline is "mobile first, not mobile-only". It's feature-complete for a leaf/edge client and live-verified against the production station fleet: handshake (pinned or WebPKI trust), unary RPC, pub/sub, content transfer, and streaming RPC in both caller and provider roles, direct-dial with cert-chain authorization, UCAN mint/verify/introspect, and a per-platform-overridable &lt;code&gt;KeyStore&lt;/code&gt; for identity persistence. A separate &lt;code&gt;macula-rust-ffi&lt;/code&gt; crate (structured the way &lt;code&gt;iroh-ffi&lt;/code&gt; sits on top of &lt;code&gt;iroh&lt;/code&gt;) wraps almost that entire surface with UniFFI and generates Kotlin and Swift bindings on every push, CI-checked both ways: one Rust core, generated bindings on both mobile platforms, instead of hand-maintaining two implementations of the same wire protocol. The mobile apps built on top of it are still early; the FFI layer underneath them is not.&lt;/p&gt;

&lt;h2&gt;
  
  
  The tools: what you actually run
&lt;/h2&gt;

&lt;p&gt;Everything above is what you build with. Three things exist to actually run:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;macula-cli&lt;/strong&gt;: a small, scriptable Go binary, no TUI, no interactive mode. Every command works identically with or without &lt;code&gt;--json&lt;/code&gt;; human-readable output is a formatting choice, not a separate code path. &lt;code&gt;connect&lt;/code&gt; stages the handshake so a failure names which stage broke, &lt;code&gt;call&lt;/code&gt;/&lt;code&gt;serve&lt;/code&gt; do request/reply from either side, &lt;code&gt;pubsub watch&lt;/code&gt;/&lt;code&gt;publish&lt;/code&gt; stream events as newline-delimited JSON, and there's a &lt;code&gt;-direct&lt;/code&gt; mode that resolves and dials a station straight from its DHT advertisement instead of trusting gossip. It can also run as a background daemon for persistent subscriptions/served procedures rather than exiting after one call.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;macula-mcp&lt;/strong&gt;: an MCP server, so any agent harness that speaks Model Context Protocol (Claude Code, Cursor, Cline, Continue) gets five tools, &lt;code&gt;mesh_call&lt;/code&gt;, &lt;code&gt;mesh_put&lt;/code&gt;, &lt;code&gt;mesh_get&lt;/code&gt;, &lt;code&gt;mesh_publish&lt;/code&gt;, &lt;code&gt;mesh_watch&lt;/code&gt;, that invoke a peer's advertised capability, exchange content-addressed artifacts, and emit or watch facts on a topic, over the real wire protocol. It's deliberately thin: no QUIC/DHT logic of its own, it shells out to macula-cli for every mesh operation.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;macula-station&lt;/strong&gt;: covered above, the relay itself. Docker image on ghcr.io if you want to run one rather than just connect to one.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Where to find it
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Core SDK: &lt;a href="https://github.com/macula-io/macula" rel="noopener noreferrer"&gt;https://github.com/macula-io/macula&lt;/a&gt; (hex.pm: &lt;code&gt;macula&lt;/code&gt;)&lt;/li&gt;
&lt;li&gt;Station: &lt;a href="https://github.com/macula-io/macula-station" rel="noopener noreferrer"&gt;https://github.com/macula-io/macula-station&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Language ports: &lt;a href="https://github.com/macula-io/macula-go" rel="noopener noreferrer"&gt;https://github.com/macula-io/macula-go&lt;/a&gt; · &lt;a href="https://github.com/macula-io/macula-rust" rel="noopener noreferrer"&gt;https://github.com/macula-io/macula-rust&lt;/a&gt; · &lt;a href="https://github.com/macula-io/macula-php" rel="noopener noreferrer"&gt;https://github.com/macula-io/macula-php&lt;/a&gt; · &lt;a href="https://github.com/macula-io/macula-dotnet" rel="noopener noreferrer"&gt;https://github.com/macula-io/macula-dotnet&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;CLI: &lt;a href="https://github.com/macula-io/macula-cli" rel="noopener noreferrer"&gt;https://github.com/macula-io/macula-cli&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;MCP server: &lt;a href="https://github.com/macula-io/macula-mcp" rel="noopener noreferrer"&gt;https://github.com/macula-io/macula-mcp&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Everything's Apache-2.0. Happy to go deeper on any one piece of this, especially the overlay work since that's the newest and least battle-tested part of the stack.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>programming</category>
      <category>opensource</category>
      <category>architecture</category>
    </item>
  </channel>
</rss>
