Design Patterns

Reading technical books on the field in which I have concluded my formal education for more than 15 years ago has turned out to be a super interesting exercise. It brings the possibility of learning new things, while allowing me to reflect on my own professional experience on real-life projects. The most recent of those readings is the book Design Patterns (Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides, 416 pages).

What’s so interesting about this book is that it is a classic, and to some extent its content is almost commonplace between experienced programmers. I found myself before using multiple times many of the design patterns described in the book. However, the experience of reading the book from cover to cover is still extremely useful, I would say even for experienced engineers.

The idea of documenting design patterns, as the authors say, was inspired by something done on the Architectural field of knowledge, which saw similar descriptions for the design of doors, windows, buildings, etc. As much of innovation otherwise, the idea of applying the same approach to object oriented design turned out to be extremely well succeeded.

There is in general a great benefit in, first of all, learning from some of the best design approaches, which more often than not are result of multiple attempts and refactoring rounds. This is the type of distilled knowledge that can lift younger engineers to the a level of understanding that could otherwise require years of experience to achieve.

In addition, the vocabulary and concepts introduced and popularized by this seminal book brought up a common language that allows engineers to discuss design approaches on a dimension that can go on in parallel with the application domain of knowledge. That is a powerful way of designing better applications, across the board.

Despite having being originally published almost 30 years ago, it is easy to spot how important the concepts introduced by this the book still are for today’s software development practices. An evidence of its relevance is the fact that several of the patterns have made their way into modern programming languages and some of their basic data types. For example, events (Observer), enumerators (Iterator), and command interfaces (Command) are at the fingertips of those using a modern language like C#, in the .NET world, which was first launched in the beginning of the 2000’s, and therefore many years after the first release of the book that came out in 1994.

To conclude, reading and re-reading this book is highly recommendable to anyone interested in refreshing or deepening his or her skills on and possibilities as a object-oriented systems designer.