The hottest Software Design Substack posts right now

And their main takeaways
Category
Top Technology Topics

Anatomy of Oscillation

Software Design: Tidy First? • 1060 implied HN points • 10 Feb 25
🕹 Technology Software Design Systems theory Documentation Agile development GenAI
  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.

Remote Site Growth Is Not A Conquest Game

Software Design: Tidy First? • 839 implied HN points • 24 Jan 25
🕹 Technology Software Design Remote work Project management Growth Strategy Collaboration
  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.

Tidy First Example

Software Design: Tidy First? • 463 implied HN points • 30 Jan 25
🕹 Technology Software Design Programming Development User Experience Agile Methodology
  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.

Scaling Distributed Systems with the Scatter-Gather Pattern

Engineering At Scale • 60 implied HN points • 15 Feb 25
🕹 Technology Distributed Systems Microservices Cloud Computing Software Design System Architecture
  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.

Fruits & Roots

Software Design: Tidy First? • 2187 implied HN points • 15 Nov 24
🕹 Technology Software Design Development Team Dynamics Project management Engineering Practices
  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.
Get a weekly roundup of the best Substack posts, by hacker news affinity:

Intentions & Actions

Software Design: Tidy First? • 1082 implied HN points • 16 Dec 24
🕹 Technology Software Design User Interface Machine Learning Programming User Experience
  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.

Forest & Desert

Software Design: Tidy First? • 1900 implied HN points • 11 Nov 24
🕹 Technology Software Design System Architecture Engineering Practices Project management
  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 Development Practices Optimization Collaboration
  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.

Personal Site Refresh

Software Design: Tidy First? • 176 implied HN points • 23 Jan 25
🕹 Technology Software Design Web Development User Experience Digital Media Tech Trends
  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.

Background Work

Software Design: Tidy First? • 1568 implied HN points • 28 Oct 24
🕹 Technology Software Design Programming Engineering Data Analysis Artificial Intelligence
  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.

Meaningmaking at work.

The Uncertainty Mindset (soon to become tbd) • 259 implied HN points • 21 Aug 24
🕹 Technology AI Development Product Management Human-Machine Interaction 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.

Object-Oriented Brain Rot

Burning the Midnight Coffee • 96 implied HN points • 31 Jan 25
🕹 Technology Software Development Object Oriented Programming Systems Engineering Software Design Computer Science
  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.

The Explore That Cannot Fail Is Not An Explore

Software Design: Tidy First? • 375 implied HN points • 17 Dec 24
🕹 Technology Software Design User Behavior Product Development Experimentation Externalities
  1. Exploring new ideas is important, but they should be tested carefully to see if they work.
  2. Sometimes, even if an idea works, it might have negative side effects that aren't worth it.
  3. The best experiments are those that try new things without risking too much; it's all about learning and improving.

Senior Developers understand Composition Over Inheritance.

System Design Classroom • 599 implied HN points • 15 Jun 24
🕹 Technology Software Design Development Practices System Architecture Modularity
  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.

Apache Kafka - Important Designs

VuTrinh. • 259 implied HN points • 13 Jul 24
🕹 Technology Data Engineering Software Design Systems Architecture Distributed Systems Programming
  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.

Measuring Lines/Function

Software Design: Tidy First? • 132 implied HN points • 05 Dec 24
🕹 Technology Software Design Programming Data Analysis Development Practices
  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.

The Open/Closed/Open Principle

Software Design: Tidy First? • 1634 implied HN points • 12 Mar 24
🕹 Technology Software Design Isolation Experimentation
  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.

The CAP Theorem needed an update.

System Design Classroom • 359 implied HN points • 28 Apr 24
🕹 Technology Data Systems Computer Science Software Design Networking Database Management
  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.

"Why? Because the thread count was too low, you idiot."

Sucks to Suck • 1002 implied HN points • 09 Jul 23
🕹 Technology Software Design Social Platforms Algorithm Competition
  1. The rise of new social media platforms like Threads could challenge existing giants like Twitter.
  2. The shift towards subscription revenue models might be essential for social media platforms like Twitter.
  3. Consumers are seeking stability and calm in online platforms, which could impact the future dynamics of social media.

Designing for a single purpose

Product Identity • 118 implied HN points • 07 May 24
🪑 Design Product Design User Experience Branding Software Design Cultural critique
  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.

Good Luck/Bad Luck. Good Design/Bad Design

Sunday Letters • 99 implied HN points • 28 Apr 24
🕹 Technology Software Design Engineering User Experience Coding Practices Project management
  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.

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

Technology Made Simple • 99 implied HN points • 03 May 23
🕹 Technology Software Design System reliability Web Development Software Engineering AI
  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.

Discover What Is Code Smell and How to Overcome It?

Weekend Developer • 19 implied HN points • 04 May 24
🕹 Technology Programming Software Design Code Refactoring Code Reviews
  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.

Let's add a whole bunch of simplicity

Sunday Letters • 119 implied HN points • 15 Nov 21
🕹 Technology Software Design User Experience Code Quality Product Development
  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.

The abstraction trap

Sunday Letters • 79 implied HN points • 08 May 22
🕹 Technology Software Design User Experience Accessibility Programming Abstraction
  1. Abstraction helps make complex things simpler, but not everyone understands it like tech people do. It's essential to remember that what seems easy to us can be quite confusing for others.
  2. When designing software, we should think about how users perceive it. Not all users will understand the technical thinking behind it, so we need to create a user-friendly experience.
  3. We have to be aware of our biases and design for those who find abstraction difficult. Gathering user feedback and constantly improving is key to making software accessible.

Worse is better

Sunday Letters • 59 implied HN points • 31 Oct 21
🕹 Technology Software Design Engineering User Experience Simplicity Innovation
  1. Simplicity in software design is really important. When software is simple, it’s often easier for users to understand and use.
  2. Many engineers feel pressure to add more features, which can make software more complex. This push for complexity can lead to better options for users who prefer easier solutions.
  3. Sometimes, simpler software can outperform more complex systems. Users appreciate clear and easy-to-use options, leading to the idea that 'worse is better'.

Beyond the Duolingo Dilemma: Unlocking Fluency through Context

primalkarma’s Substack • 2 HN points • 22 Apr 24
🚌 Education Language Learning Software Design
  1. Duolingo is good for starting a new language and building vocabulary, but it falls short in providing fluency due to lack of contextual learning.
  2. Children learn languages by immersing in contextual environments, showing the importance of context in vocabulary acquisition and articulation.
  3. Software design and language articulation have similarities, and a shift towards an object-oriented model in language learning software could enhance fluency by providing a contextual environment.

Episode 8: Burkhard on Qt Embedded Systems

burkhardstubert • 19 implied HN points • 31 Jul 20
🕹 Technology Embedded Systems Software Design Programming Linux
  1. Updating software can cause unexpected issues, as minor upgrades may change how the system works. It's important to check compatibility to avoid big problems.
  2. Good software design means creating deep modules with simple interfaces, making the software easier to understand and extend in the future.
  3. In testing and coding, having clear boundaries and small, focused modules help reduce complexity and make the code more manageable.

Test-driven data engineering

Reflective Software Engineering • 0 implied HN points • 30 Dec 23
🕹 Technology Data Engineering Software Design Refactoring
  1. Test-driven development (TDD) is a valuable tool for ensuring software quality and driving great software design.
  2. Testing data integrations and clients, especially in complex data platforms, can be challenging due to less control over underlying databases. Strategies like mocking HTTP interactions can help in testing.
  3. Separating concerns and creating small, testable units of code can enhance confidence in the system, reduce fear of regression, and improve overall software quality.