Clean Coder Blog

Introduction Good software architecture is crucial for a business to reach its goals. It provides a structured way to build software that is easy to maintain, reliable, and performs well. Key drivers of software architecture Several factors influence a software’s architecture: Business requirements: What the software needs to do. Quality attributes: How well the software performs, such as its speed, scalability, and availability. Agility: How quickly the development team can adapt to changes. Constraints: The limitations of the deployment environment, such as the hardware or operating system. Principles: Established practices, like automated testing and deployment, that guide the development process. Different Ways to Structure Software There are two main ways to build software applications:

Alan Kay mentions in a talk that the Smalltalk don't scale quite well to big teams and infrastructure. However, he had some ideas on how to make OOP scale.

Recently there has been substantial discussion around the downsides of service oriented architectures and microservice architectures in particular. While only a few years ago, many people readily adopted microservice architectures due to the numerous benefits they provide such as flexibility in the form of independent deployments, clear ownership, improvements in system stability, and better separation of concerns, in recent years people have begun to decry microservices for their tendency to greatly increase complexity, sometimes making even trivial features difficult to build.

SERIES: Building a backend with Ktor Part 1: Structuring a Ktor project Part 2: How to persist Ktor logs Part 3: How to use an in-memory database for testing on Ktor Part 4: How to handle database migrations with Liquibase on Ktor Part 5 Generate API documentation from Swagger on Ktor Part 6: How to schedule jobs with Quartz on Ktor Part 7: Moving from mobile to backend development with Ktor It’s been a few months since I’ve started working with Ktor to build the backend of Revelop. We decided to go with Ktor because it is a lightweight framework, easy to use and with a gentle learning curve even for a mobile developer.

A Command-Line Tool for Managing Recurring Architectural Decisions, implemented in Go - adr/ad-guidance-tool

A Command-Line Tool for Managing Recurring Architectural Decisions, implemented in Go - adr/ad-guidance-tool

explore how MVVM fits into SwiftUI, how to leverage its advantages, and how it compares to Clean Swift and the Composable Architecture.

SwiftUI provides several tools for managing navigation, and the introduction of NavigationStack and value-destination links improved programmatic navigation. However, in larger applications, vanilla SwiftUI navigation can pose challenges for testability, maintainability, and modularity. Navigation logic is distributed across views, introducing coupling and making the navigation code hard to locate. These problems can be addressed by ... Read more

In this tutorial, you’ll learn about using the VIPER architecture pattern with SwiftUI and Combine, while building an iOS app that lets users create road trips.

In "On Writing" Stephen King shares invaluable lessons for aspiring novelists which can be applied to software development too.

A practical guide to Clean Architecture folder structure, project organization, and dependency...

The enemy of well-designed software is coupling. When large bodies of code are tightly coupled, they become ultimately unchangable and difficult to test…

In this article, we'll look at the various different versions of the "clean architecture", simplify it, and understand how we can use it to write more flexible Node.js code with TypeScript.

Narrow integration tests are tests that only involve very few components, mostly relying on test doubles to simulate external dependencies. As always, we have Martin Fowler to thank for yet another excellent article on integration tests so I’ll simply refer to that for the details of what a narrow integration test is. That said, during 2019 I have grown increasingly convinced that the distinction between a narrow and wide integration (also know as system tests or end-to-end tests) is an important one, for two reasons:

Simple software programming preferences in my simplicity toolbox. Part 2.

The Patterns of Scalable, Reliable, and Performant Large-Scale Systems - binhnguyennus/awesome-scalability

TL;DR Command-Query Separation Extract Use Cases (Clean/Hexagonal Architecture) Domain Events (with Eventhandlers and Composite Pattern) Cross-Cutting Concerns (with Decorator Pattern) Many backend applications end up as a big ball of mud where small changes ripple through the whole codebase. The root causes are high coupling and low cohesion. The best remedies against those are Domain Driven Design (DDD) and the SOLID principles which are well-known, but often wrongly applied.

A comprehensive guide on implementing JWT authentication with refresh tokens in ASP.NET Core Web API using Entity Framework Core and Identity.

In this post, we'll look at how to apply the principles of The Clean Architecture to build a Xamarin.Forms Android app. This app will be based on a robust architecture that is loosely coupled and cleanly separates the important business or domain logic from other details and infrastructure like databases, UI frameworks, and network communications.

How I lost control of my AI-coded app in just one day — lessons from my first vibe-coding experiment

Sharing my Clean Architecture boilerplate for 2026 (TS). Benefit from years of architectural learning, works great with AI coding agents - Claude.md included!

How Netflix uses the hexagonal architecture to meet their business objectives

There’s an apocryphal story from the development of a game called Battle Chess. A Product Manager was well-known to always have to make a comment or propose a change on anything, no matter how minor - so, an engineer intentionally added an incongruous companion duck in a piece’s animation. The PM could say “looks good - but lose the duck”, and feel that they’d had a meaningful impact, when in fact the end result after removing the “sacrificial duck” was exactly as the engineer had originally intended.

After last year’s pandemic shock, this year has brought more hope and motivation to people. I’ve felt motivated to learn new things, deep-dive into unknown areas and finally change some things in my life. In this post I’ll share with you my most valued (software) tools, productivity tips, some books worth reading and finally some failure and success with regards to my habits. Health # Wim Hof Method # Last year just before the (pandemic) winter blues was about to begin I’ve had enough of that feeling something you cannot control was already part of my daily life.

If you’re here for the first time, this post is part of our Business Applications in Go series. Previously, we introduced Wild Workouts, our example application built with modern tools but containing some subtle anti-patterns. We added them on purpose to show common pitfalls and how to avoid them. In this post, we begin refactoring Wild Workouts. Previous articles will give you more context, but reading them isn’t necessary to understand this one.

In this guide, we share our pragmatic approach to Clean Architecture in Go, refined through years of real-world experimentation. We demonstrate refactoring techniques on a live project, showing how to extract application logic, define interfaces, and improve testability. You'll learn how to apply Clean Architecture principles in an idiomatic Go way, balancing theory with practical implementation. Our battle-tested methods help you create loosely coupled, highly cohesive code that's easier to maintain and extend over time.

A common critique of Rails is that it encourages a poor separation of concerns. That when things get serious, you need an alternative that brings the missing pieces. We disagree.

Not very long ago I gave a talk about the clean architecture on frontend. In this post I'm outlining...

How to build production-grade code with LLMs using spec-driven development. Specifications as contracts that ensure both humans and AI produce exactly what you need.

Full Modular Monolith application with Domain-Driven Design approach. - kgrzybek/modular-monolith-with-ddd

I’ve recently gone into doing CQRS with event sourcing along with DDD (Domain Driven Design) principles. I’ve been doing it in Go and want to share how I do it. To begin with, I’ve researched this topic thoroughly; I’ve probably watched and re-watched hundreds of videos and read many posts, articles, and books on it. I am by no means a cqrs/es expert, but I have gained some insight into how to do it. The first thing I want to put out there is that you don’t need a framework to do this. Ddd and cqrs/es are best done without a framework getting in the way and instead you should create a Clean Architecture where the framework you choose later on becomes a sort of plugin into your application.

Stop using frameworks for everything. Just stop. You don’t need a framework to write good code and deliver products. Don’t get me wrong, frameworks are useful, but they are all-consuming and hide the application. So if you shouldn’t depend on frameworks what should you do instead? Clean architecture. More specifically, there are some patterns you can follow to better architect your application and think about the structure of your application and remove the need for frameworks to express your application. The patterns I suggest you use are Clean Architecture, Domain Driven Design, and the SOLID principles. Having a maintainable application is a matter of applying certain design principles and professionalism. In particular, applying TDD or BDD and Domain Driven Design principles. Think about your application before you write a single line of code, design it, and test before you implement it.

Architectural design patterns like VIPER might seem radically different from common ones like MVVM. However, upon deeper inspection, it turns out that these patterns share the same constitutive components. In this article, we will compare the MVVM and VIPER design patterns in SwiftUI and show how they follow the same principles. Table of contents Architectural ... Read more

My name is Luciano Nooijen, freelance software engineer and lifelong learner

These books “are basically cheat codes” for leveling up your skills and knowledge as a developer.

Dmitri's blog about programming, Clojure, and software development

TL;DR Architecting an application with a pure function at its core can be a first step towards the “functional-core imperative shell” ideal, which can simplify testing and lower an applications complexity bar.

1. Intro tl;dr Instead of forcing your application into a prescriptive template like Clean or Hexagonal Architectures, get back to basics and use patterns from Modular Software Design. Divide the application into independent modules, each containing business logic representing a specific process. For modules with complex business logic, extract the infrastructure-related code into separate Infrastructure-Modules. This will enable you to build an application characterized by low cognitive load, high maintainability, and high extensibility.

This post is a continuation of Small and simple business applications using SQL.

This post is a continuation of Unclean architecture.

High level image of the clean architecture from Uncle Bobs blog post:

Bloco.io Android App Starter Template, the starting point of our newest projects. Take a deep look behind the scenes of our revised version.

The best things and stuff of 2018

Clean Architecture is a way of structuring a solution such that dependencies and infrastructure concerns are kept separate from business logic and the domain model. It's frequently used with Domain-Driven Design and can easily be built with ASP.NET Core using a solution template described in this article.

This is the second part of a 3 or 4 part series where I’m formulating my thoughts about an ongoing initiative at MedeAnalytics. I started yesterday with a related post called On Giving Techni…

The “D” in the SOLID principles stands for “Dependency Inversion”, stating that classes should "depend upon abstractions, not concretions".

Integrating previous designs

Behind every technology, there should be a guide for its use. While JavaScript modules make it easier to write “big” programs, if there are no principles or systems for using them, things could easily become difficult to maintain.

T.J. Maher, a QA Engineer since 1996, blogs about his transition from a manual tester to an automation developer to a software engineer in test.