Conway's Law Shapes Software Architecture Even in Two-Person Startups

·1 views

Conway's Law, a well-known principle in software development, states that a system's architecture tends to mirror the communication structure of the team that built it. At bundle.social, a two-person startup running a unified social media API, the founders observed this law playing out in an unexpected way: their codebase began reflecting individual mental models rather than any formal org chart. With no dedicated teams for infrastructure, analytics, or product management, the duo found that frictionless communication tempted them to skip formal boundaries, creating fragile 'hero services' only one person fully understood. A 2 AM background job failure made clear that any part of the system needed to be understandable by either developer without lengthy explanation. To counter this, the team intentionally leveraged Conway's Law by adopting a clean modular monolith and enforcing explicit code boundaries instead of drifting into informal, person-specific ownership.

Read the full story at DEV Community

This is an AI-generated summary. ShortSingh links to the original source for the complete article.

Discussion (0)

Developer Shares Solution for Data Grid CRUD Challenge with Bug Fixes and API Tests

A developer has published their solution to Challenge 2, which involved building data grid validation and CRUD operations for a server management API. The solution addressed several bugs, including a 500 error triggered by duplicate IDs on the POST endpoint and a missing confirmation dialog before delete actions. Fixes included returning descriptive, language-specific error messages via a custom X-UI-Lang request header. The developer also wrote a comprehensive suite of API tests covering authentication, validation, and all CRUD endpoints using Postman. A pre-request script was added to automate admin login and Bearer token management across all server-related requests.

0 comments Read more at DEV Community

ProgrammingDEV Community ·

Why 'free -h' Lies: A Developer's Deep Dive into Linux Memory Metrics

Developer Maneshwar, while building a terminal system monitor using Rust and the ratatui library, discovered that Linux's MemFree metric is widely misunderstood and nearly always misleadingly low. The Linux kernel intentionally fills spare RAM with page cache to maximise efficiency, meaning MemFree trends toward zero on a healthy system — not a struggling one. The correct metric to read is MemAvailable, introduced in kernel version 3.14 specifically because so many tools and users were misreading MemFree. Maneshwar also uncovered a subtle parsing bug in /proc/meminfo, where the field SwapCached can silently overwrite the Cached value if labels are matched loosely rather than exactly. He adopted btop's simpler formula — used equals MemTotal minus MemAvailable — and added a dedicated unit test to prevent future regressions in the parser.

0 comments Read more at DEV Community

ProgrammingDEV Community ·

Tech Is Outpacing Our Ability to Form Opinions About It, Developer Argues

A developer and writer on DEV Community argues that the pace of modern technology has surpassed humanity's capacity to meaningfully evaluate and adapt to it. Drawing on personal experience with rapidly evolving JavaScript tooling, the author notes that working familiarity now replaces deep expertise, as tools are replaced faster than mastery can be built. The piece identifies the real lag not in human biology but in the slower-moving social structures built atop it — norms, laws, professional identity, and institutions — which evolve over decades while technology iterates in months. The author acknowledges historical parallels, noting that similar fears accompanied the printing press, radio, and the internet, all of which humanity eventually absorbed. Still, the central concern remains: the widening gap between technological speed and institutional adaptation may carry consequences that are harder to dismiss this time.

0 comments Read more at DEV Community

ProgrammingDEV Community ·

Single TPU Chip Tested for Small Agent Workloads Using Raw JAX After vLLM Gaps Found

A developer tested Google's Cloud TPU v6e-1 chip to serve small agent workloads of two to eight concurrent agents, finding that standard inference benchmarks optimized for high concurrency poorly represent real-world agent use cases. The experiment highlighted that serial agent loops with human users at the end are latency-bound, while machine-to-machine parallel fleets are throughput-bound, with 'goodput' proposed as a metric covering both scenarios. Context growth was identified as a key challenge, as decode speed on similar TPU hardware drops sharply from roughly 8,300 to 2,900 tokens per second as conversation history accumulates over many turns. Attempts to load quantized Gemma 4 E2B checkpoints via vLLM on TPU failed due to unimplemented int4 schemes and missing weight tensors, with only the full BF16 checkpoint loading successfully. The author attributed the loading failures to the vLLM loader rather than the checkpoints themselves, noting the QAT exports are architecturally correct, and filed a bug report accordingly.

0 comments Read more at DEV Community