Software design is a vast and arduous subject. From the high-level specification of an information system to the good pratices and small refactorings in the code of a single component, from the design of public APIs to the unit testing of a piece of software, there are many things to know. Too many things for a single person.
Design anti-patterns, traps disguised as good practices, forgotten or misinterpreted principles of very old paradigms, all of these examples exist. And however good you think you are, there are probably something you could improve in the software you produce.
Fortunately, the internet is filled with articles from great people sharing their knowledge and their opinions about their domain of predilection. Nowadays, the most important thing to do to ensure software quality is to keep an open mind. To read and discuss the opinion of talented people, and to develop your own.
This article is a selection of articles I have found when reading about this complicated topic. Each of this articles develop an idea that any software developer should, in my opinion, at least know about. By reading those articles and many more, you will be able to expand your thinking, and detect the practices that I wrote about before, the practices you could improve.
Being a software programmer mostly using Java, some of these articles might be based on the Java language and its ecosystem. But these are software design articles: most of the time, their principles and recomandations can be applied to any language. It may be harder to grasp the underlying concept in some cases, but that shouldn't stop you from reading them!
Software development articles
General software design stuff
- The Dark Side of Best Practices: This articles talks about best practices, and why we shouldn't follow them blindly. I think it applies to everything we do in software design and development. Always ask "why". Always question your assumptions. Computer science evolves too fast to allow ourselves to keep doing the same thing more than a few months without at least cheking that it's not obsolete or just plain wrong.
- The Law Of Leaky Abstractions or why it's important to understand how the tool you're using works. Some beginner programmers today don't find it interesting to learn what's hidden behind a C string. They think assembly, pointers and CPU architecture are artifacts from another age, hidden by ever increasingly complex and high level abstractions. Unfortunately, they will never be completely gone.
Domain Driven Development
- The Anemic Domain Model : This is what of those hidden anti-patterns that I was talking about. Do you think the business logic of you application should be in the service layer (sometimes called the "Application Layer")? I did too. I encourage you to read this article and remember what you were taught about Object Oriented Programming. It will seem obvious that you can do better.
- The Biggest Flaw of Spring Web Applications : Don't stop on the title if you don't use Spring. This article covers an important flaw that can be found in any application, not just those that use Spring or are written in Java. It explains why the classical and widespread separation of an application in three layers (Controllers, Services, Domain) can be misinterpreted and lead to unmaintainable software.
- DDD: Application File Structure : A very interesting blog post about the anatomy of a DDD java application. DDD is associated with all sorts of questions and myths when it comes to implementation. What does an aggregate look like in java? Where should I put my factories and repositories? What's the actual implementation difference between an entity and a value object? This article talks about all of them.
- Steve Fenton's Unit Testing Epiphany : I'm putting this article in the unit testing category, but it could easily be in the software-design one. Read this and you will finally stop thinking of TDD as a additional burden on the already tedious task of writing unit tests. You will realise that the original motto of TDD, if correctly applied, will help you write unit tests for the correct classes and method, and only those.
- Writing Clean Tests – Small Is Beautiful : Ever wrote unit tests using rspec or jasmine? Wouldn't it be great if we could do something similar in Java? It turns out that we can. Using Junit's NestedRunner, we are encouraged to write small and clean tests with minimal code duplication. A must-read!
- Three Steps to Code Quality via TDD : I'm not going to speak too much about this one, because the introduction is already very clear. This article highlights three common problems and obstacles with Test Driven Development, and how to solve them so that you don't find yourself breaking all your tests each time you refactor a small method.