The hottest Software Design Substack posts right now

And their main takeaways
Category
Top Technology Topics

Taming the Genie: "Like Kent Beck"

Software Design: Tidy First? • 1104 implied HN points • 20 Jan 26
🕹 Technology Software Design
  1. Telling a model to adopt a persona improves small-scale behaviors like clearer variable names and modular, test-driven code. It doesn’t reliably change the overall architecture on its own.
  2. Giving explicit design constraints (for example, prescribe the Composite pattern and small specialized classes) reliably drives macro-architecture and produces simpler, finer-grained designs. These structural prompts change high-level decisions even without a persona.
  3. Combining a persona with clear architectural constraints gives the best result—good style plus the right structure. Scaling this by generating many variants and selecting the lowest-cost successful implementations can further evolve better model-driven development.

Meaningmaking at work.

The Uncertainty Mindset (soon to become tbd) • 259 implied HN points • 21 Aug 24
🕹 Technology Software Design
  1. AI tools often fail because they can't understand the deeper meaning behind our decisions. They confuse what humans can intuitively interpret.
  2. Meaningmaking is crucial in many business processes. Humans make subjective decisions all the time that machines simply can't replicate.
  3. To create better AI products, we need to separate meaningmaking tasks from other work. This helps us design tools that support human decision-making instead of trying to replace it.

Senior Developers understand Composition Over Inheritance.

System Design Classroom • 599 implied HN points • 15 Jun 24
🕹 Technology Software Design
  1. Using composition is often better than inheritance because it allows for more flexible and maintainable code. You can mix and match simpler components to create complex systems.
  2. With composition, you can easily swap out parts of your code at runtime, making it better for projects that change frequently. It's all about keeping things modular and manageable.
  3. Though inheritance can be useful for stable hierarchies, focusing on composition is generally a safer bet, especially when you expect to make a lot of changes to your code.

New Is The New Black

Software Design: Tidy First? • 1612 implied HN points • 15 Aug 25
🕹 Technology Software Design
  1. Trying new things can be hard, but it's essential for learning. Embrace the unfamiliar instead of being afraid of it.
  2. When you feel lost while learning, take a break. Clearing your mind can help you reset and make connections later.
  3. When you start to understand something, slow down and think carefully. This moment is special and deserves focus.

Apache Kafka - Important Designs

VuTrinh. • 259 implied HN points • 13 Jul 24
🕹 Technology Software Design
  1. Kafka uses the operating system's filesystem to store data, which helps it run faster by leveraging the page cache. This avoids the need to keep too much data in memory, making it simpler to manage.
  2. The way Kafka reads and writes data is done in a sequential order, which is more efficient than random access. This design improves performance, as accessing data in a sequence reduces delays.
  3. Kafka groups messages together before sending them, which helps reduce the number of requests made to the system. This batching process improves performance by allowing larger, more efficient data transfers.
Get a weekly roundup of the best Substack posts, by hacker news affinity:

TDD Prerequisites

Software Design: Tidy First? • 1631 implied HN points • 02 Nov 23
🕹 Technology Software Design
  1. TDD outcomes include ease, reliability, sustainability, and responsibility.
  2. Prerequisites for TDD include predicting inputs/outputs, predicting/discovering cases, and ensuring micro-tests yield macro-results.
  3. Apply TDD only when the costs are reasonable and constraints are manageable.

The First Feedback Filter

Software Design: Tidy First? • 883 implied HN points • 15 Jul 25
🕹 Technology Software Design
  1. Ask yourself what feedback is about you and what is about the person giving it. This helps you handle feedback without letting it control your feelings.
  2. Be cautious with feedback from people who only critique or compliment you. If they never provide a balanced view, their comments might not be that useful.
  3. Take your time when responding to feedback. Walking or resting can help you process your feelings, so you can respond more thoughtfully.

The CAP Theorem needed an update.

System Design Classroom • 359 implied HN points • 28 Apr 24
🕹 Technology Software Design
  1. The CAP theorem says you can have consistency, availability, or partition tolerance, but only two at a time. This means systems have to make trade-offs depending on what they prioritize.
  2. The PACELC theorem expands on CAP by considering what happens during normal operation without network issues. It adds more options about choosing between latency and consistency.
  3. Real-world examples, like a multiplayer game leaderboard, show how these principles apply. You can have quick updates with potential outdated info or consistent scores that take longer to change.

Fruits & Roots

Software Design: Tidy First? • 2187 implied HN points • 15 Nov 24
🕹 Technology Software Design
  1. The Forest represents a way of working where teams can deliver value quickly and effectively, highlighting benefits like fewer bugs and delivering good news often.
  2. Achieving the success of The Forest requires commitment to its roots, which involve working together, learning actively, and not over-planning.
  3. Communicating a shared purpose and fostering a strong community are crucial for maintaining the balance between roots and fruits in a productive team environment.

Forest & Desert

Software Design: Tidy First? • 1900 implied HN points • 11 Nov 24
🕹 Technology Software Design
  1. In software development, there are two environments: a challenging 'desert' where mistakes are costly, and a supportive 'forest' where teams can work collaboratively and learn from their errors.
  2. Strategies that work in a desert, like detailed planning and strict reviews, won't help in a forest, which thrives on testing, incremental growth, and collaboration.
  3. To shift from a desert to a forest, teams need to understand why their current situation exists and take small steps toward creating a more supportive and effective work environment.

Attracted To The Desert (Or The Forest)

Software Design: Tidy First? • 1634 implied HN points • 12 Nov 24
🕹 Technology Software Design
  1. Software development has different styles that often lead to similar outcomes, guided by underlying trends called attractors. These attractors influence how teams change over time, pulling them towards certain approaches.
  2. It’s not just about adding more value in software projects. Instead, the focus should be on removing waste and improving efficiency in how teams work together.
  3. The environment where a team operates, whether it's a productive forest or a limiting desert, greatly affects their potential for growth. The forest offers more opportunities for improvement than the desert.

Dialogical Design

the shimmering void • 93 implied HN points • 08 Dec 25
🪑 Design Software Design
  1. Your computer should feel like a personal world built from people, places, and things, where structure emerges as you use it rather than being forced by pre-set apps or folders.
  2. Current software habits create silos and rigid schemas that ossify your life’s data, so designers must stop assuming they know what users need and enable iterative, user-driven structure instead.
  3. Large language models make fuzzy, dialogical interaction possible and can help shape meaning, but we also need new technical substrates that support flexible subdivision, derivation, and coherent sharing/privacy.

Anatomy of Oscillation

Software Design: Tidy First? • 1060 implied HN points • 10 Feb 25
🕹 Technology Software Design
  1. Oscillation occurs when systems swing between extremes, like adjusting a thermostat. A delay between making a change and feeling the effect can cause back-and-forth adjustments.
  2. In nature, predator and prey populations can also oscillate, like rabbits and hawks. More rabbits lead to more hawks, which eventually can cause the rabbit population to drop, repeating the cycle.
  3. Calls for comprehensive documentation in software may lead to oscillation. As information decays over time, teams might swing between needing more documentation and finding fewer resources to support that need.

Background Work

Software Design: Tidy First? • 1568 implied HN points • 28 Oct 24
🕹 Technology Software Design
  1. Background work is doing extra research or tasks beyond what's necessary. It's a way to learn and grow your skills.
  2. Successful programmers often engage in background work, which helps them become more knowledgeable and credible.
  3. While background work can sometimes feel like extra effort, it usually pays off quickly and can save time in the long run.

Intentions & Actions

Software Design: Tidy First? • 1082 implied HN points • 16 Dec 24
🕹 Technology Software Design
  1. People often come to computers with intentions, like wanting to watch a show or add a stop to a trip. But the actions needed to achieve those intentions can be confusing and hard to remember.
  2. When the computer does what we want easily, we feel amazed and grateful. But this happens less often because of complicated menus and actions we have to figure out.
  3. Kids find it easier to use technology because they learn quickly from their friends and practice a lot. They navigate digital worlds more smoothly, while others often struggle with the basics.

Remote Site Growth Is Not A Conquest Game

Software Design: Tidy First? • 839 implied HN points • 24 Jan 25
🕹 Technology Software Design
  1. When growing a remote site, it's better to explore many projects at once rather than stick to just a few. This can help increase chances of success early on.
  2. Balancing between immediate growth and long-term profitability is key. Sometimes, a quick push in new projects can lead to bigger rewards down the line.
  3. Bringing in new talent to fresh projects can provide new ideas and perspectives. It's important to believe in their potential to contribute quickly.

Survival, Cash Flow, & Options

Software Design: Tidy First? • 331 implied HN points • 11 Jul 25
🕹 Technology Software Design
  1. Sometimes the best design choice is not to design anything at all. It's important to know when to hold back on creating features.
  2. Understanding the trade between features and options can help in making better decisions in software development. Prioritizing options can lead to long-term benefits.
  3. Reading insightful books like 'Ergodicity' can shift your perspective on important concepts in software and economics. Gaining new insights can help you better navigate complex problems.

Theory

Software Design: Tidy First? • 220 implied HN points • 21 Jul 25
🕹 Technology Software Design
  1. Software design is all about balancing behavior and structure to create value.
  2. Coupling affects the cost of software changes, meaning changes can get expensive if things are too tightly linked together.
  3. Understanding these principles helps in making better decisions about how to organize and maintain software.

The Open/Closed/Open Principle

Software Design: Tidy First? • 1634 implied HN points • 12 Mar 24
🕹 Technology Software Design
  1. In software design, there are ordinary phases (small changes) and revolutionary phases (fundamental changes) - understanding when each is needed is important.
  2. Revolutionary design violates the open/closed principle by requiring new elements and relationships that don't fit with the existing design.
  3. Revolutionary changes in design require different values and care compared to ordinary design - they are essential for accommodating new types of features.

Designing for a single purpose

Product Identity • 118 implied HN points • 07 May 24
🪑 Design Software Design
  1. Focusing on one clear purpose can make products stand out and be more appreciated. For example, stores or brands that specialize in a single item often attract loyal customers.
  2. In tech, many products have become complex and cluttered by trying to do too much. This often leads to products losing their original charm and purpose.
  3. Going back to basics and simplifying can bring more joy to experiences, like reading on a Kindle without distractions. It helps us focus on what truly matters.

Transaction-Oriented Programming

Burning the Midnight Coffee • 64 implied HN points • 15 Nov 25
🕹 Technology Software Design
  1. Transaction-Oriented Programming focuses on breaking down tasks into user-relevant units of work, which can help structure software and make error handling clearer.
  2. Each unit of work should be treated as a transaction, ensuring it is either completed fully or not at all, which can improve reliability in software applications.
  3. Implementing ACID properties (Atomicity, Consistency, Isolation, Durability) helps maintain integrity in software, especially when errors occur, making it easier to manage transactions.

Good Luck/Bad Luck. Good Design/Bad Design

Sunday Letters • 99 implied HN points • 28 Apr 24
🕹 Technology Software Design
  1. Software can be easy to create but hard to maintain. It's important for engineers to think about how their choices today will affect the future.
  2. Using simple designs and clear roles in a project can help avoid complicated problems later. Teams should focus on making changes quickly and smartly.
  3. Sometimes, the best solution is to remove unnecessary parts instead of adding more. If something isn't needed right now, it's better to not include it.

Tidy First Example

Software Design: Tidy First? • 463 implied HN points • 30 Jan 25
🕹 Technology Software Design
  1. It's important to make hard changes easier before tackling them. This means breaking down tough tasks into simpler steps.
  2. Many people want to make the easy changes they envision, but they often overlook the complexity involved.
  3. Always pay attention to examples in learning; they can provide valuable insights that you might miss if you skim over them.

Augmented Coding: Coached by the Genie

Software Design: Tidy First? • 154 implied HN points • 11 Jun 25
🕹 Technology Software Design
  1. Improvement is great, but when improvements lead to even more rapid progress, that’s revolutionary. We should strive for advancements that keep building on each other.
  2. There are limits to how much we can improve, influenced by natural laws. This means while we can grow, there will also be things that slow us down.
  3. Having support or guidance, like a 'genie', can help us make better progress. It’s helpful to have tools or mentors that guide us in our journey.

Personal Site Refresh

Software Design: Tidy First? • 176 implied HN points • 23 Jan 25
🕹 Technology Software Design
  1. Trying to manage many interests can be tricky, but it's important to embrace all parts of yourself. It helps to answer questions like 'What are you up to?' more honestly.
  2. A personal website can serve as a great way to showcase your thoughts and projects. It's like a digital home where you can share what you're passionate about.
  3. Adding new topics to your website can keep it fresh and engaging. It's a way to express your evolving interests and ideas.

How to save your systems from collapsing- Graceful Degradation [Technique Tuesdays]

Technology Made Simple • 99 implied HN points • 03 May 23
🕹 Technology Software Design
  1. Graceful Degradation is a design principle that ensures systems maintain limited functionality even when parts are rendered inoperative.
  2. Implement the 80-20 principle while integrating Graceful Degradation to focus on backing up critical components and keeping systems active.
  3. Combine Progressive Enhancement with Graceful Degradation to provide essential content to all users while delivering the best possible experience to modern browsers.

Measuring Lines/Function

Software Design: Tidy First? • 132 implied HN points • 05 Dec 24
🕹 Technology Software Design
  1. Measuring lines of code in functions can be more complicated than expected. It's helpful to keep track of this while working on software projects.
  2. Looking for patterns in software, like Pareto distributions, can provide valuable insights. It's good practice to analyze your own code for these patterns.
  3. Documenting your findings is important. Sharing your experiences can help others who are trying to understand their software better.

Discover What Is Code Smell and How to Overcome It?

Weekend Developer • 19 implied HN points • 04 May 24
🕹 Technology Software Design
  1. Code smells indicate potential problems with code design, readability, and bugs. They serve as warning signs to refactor before issues compound.
  2. Common signs of code smells include excessive code comments, frequent bugs in certain areas, code duplication, divergent changes, and shotgun surgery.
  3. Tools like static code analysis, IDE plugins, code visualization tools, code review tools, and code metrics tracking help in identifying and addressing code smells in a codebase.

Object-Oriented Brain Rot

Burning the Midnight Coffee • 96 implied HN points • 31 Jan 25
🕹 Technology Software Design
  1. When modeling objects like rectangles and squares, thinking too rigidly can lead to problems. Sometimes, it's simpler to just write a function to handle what you need rather than forcing everything into class hierarchies.
  2. Object-oriented programming can sometimes make things overly complicated. It's better to focus on solving the actual problem instead of worrying about fitting everything into a strict structure.
  3. Learning to think in terms of complex class hierarchies can actually harm your ability to solve problems. Simple, direct solutions are often more effective than trying to model everything in a complicated way.

Scaling Distributed Systems with the Scatter-Gather Pattern

Engineering At Scale • 60 implied HN points • 15 Feb 25
🕹 Technology Software Design
  1. The Scatter-Gather pattern helps speed up data retrieval by splitting requests to multiple servers at once, rather than one after the other. This makes systems respond faster, especially when lots of data is needed.
  2. Using this pattern can improve system efficiency by preventing wasted time waiting for responses from each service. This means the system can handle more requests at once.
  3. However, implementing Scatter-Gather can be tricky. It requires careful handling of errors and managing different data sources to ensure the information is accurate and reliable.

What Makes Payment Applications Different?

Money in Transit • 19 implied HN points • 16 Oct 23
🕹 Technology Software Design
  1. Payment applications need to focus on serving users well, not just at a large scale.
  2. Design documents are crucial for creating software that aligns with the needs of the payment domain.
  3. Building payment applications requires careful planning and considerations due to the complexity of handling transactions and data.

Let's add a whole bunch of simplicity

Sunday Letters • 119 implied HN points • 15 Nov 21
🕹 Technology Software Design
  1. Simplicity is about removing complexity, not adding it. We often think we can just make things easier, but the reality is that we have to eliminate the complicated parts.
  2. To create simplicity, we should clearly define our goals. Understanding exactly what we need to do helps us focus and decide what to avoid.
  3. Finding the simplest version of a project may mean letting go of features you like. It's important to be disciplined and recognize that simplifying can sometimes feel uncomfortable.