{"id":6391,"date":"2022-06-30T21:10:08","date_gmt":"2022-06-30T21:10:08","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/an-introduction-into-design-patterns\/"},"modified":"2022-06-30T21:10:08","modified_gmt":"2022-06-30T21:10:08","slug":"an-introduction-into-design-patterns","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/an-introduction-into-design-patterns\/","title":{"rendered":"The Advantages of Patterns"},"content":{"rendered":"

Before I write about patterns in my upcoming posts, I have to answer one question first. What are the advantages of patterns? As you may assume, I see many advantages, but I boil them down to three points: well-defined terminology, improved documentation, and learning from the best.<\/p>\n

<\/p>\n

\"patterns\"<\/p>\n

I gave my first talks about design patterns. This was around 2002 – 2008. Why? Patterns are probably the most valuable and impactful abstraction in modern software development.<\/strong><\/p>\n

Now, let me write about the important stuff.<\/p>\n

Advantages of Patterns<\/h2>\n

My argumentation is based on three facts: well-defined terminology, improved documentation and learning from the best.<\/p>\n

Well-defined terminology<\/h3>\n

\"15DesignPattern\"<\/p>\n

Patterns establish a well-defined terminology. Imagine, I go for a run and I explain to you that I saw an asthoning animal. I explain it to you in my bad English. The animal had kind of the size of a cat and had fur and long ears. Its hind legs were extremely long. It could, therefore, jump three meters far and two meters high. While running, it could its direction quickly. You may guess which animal I saw: a European hare<\/a>. Using the exact term helps a lot. Now you have the term and you can look it up on Wikipedia. This is for me the main benefit of patterns. We have well defined-terminology. We know, what we are talking about.<\/p>\n

Let’s make it more concrete. You want to implement a newsreader and ask me for my advice. The customer of your newsreaders should be automatically informed if some news happens. My answer can very verbose and explain that your newsreader should have a register and unregister functionality. Additionally, the newsreader stores all the customers and each customer should support a notify member function. When the newsreader publishes something, it goes through its list of customers and calls and notifies all of them. There is more to it. The newsreader could send the news, or only send that there is news in which the customer could be interested. I’m not done with my advice, but I stop here. In contrast, my answer could be one term: the observer pattern<\/a>. You can read the details in the literature.<\/p>\n<\/p>\n

Improved documentation<\/h3>\n

\"Observer\"<\/p>\n

Let me distinguish between fine-grained and high-level documentation of software.<\/p>\n

Fine-grained documentation<\/h4>\n

Honestly, I’m no fan of fine-grained source code documentation like the following:<\/p>\n

<\/p>\n

\n
\/\/ initialize a vector of strings<\/span>\r\nstd::<\/span>vector<<\/span>std::<\/span>string><\/span> myStrVec =<\/span> {\"12345\"<\/span>, \"123456\"<\/span>, \"1234\"<\/span>, \"1\"<\/span>, \"12\"<\/span>, \"123\"<\/span>, \"12345\"<\/span>};\r\n\r\n\/\/ sort the vector of strings based on their length ascending<\/span>\r\nstd::<\/span>sort(myStrVec.begin(), myStrVec.end(), lessLength);\r\n<\/pre>\n<\/div>\n
 <\/p>\n
On the contrary, your code should be expressive and read like prose:<\/p>\n
<\/p>\n
\n
std::<\/span>vector<<\/span>std::<\/span>string><\/span> myStrVec =<\/span> {\"12345\"<\/span>, \"123456\"<\/span>, \"1234\"<\/span>, \"1\"<\/span>, \"12\"<\/span>, \"123\"<\/span>, \"12345\"<\/span>};\r\n\r\nstd::<\/span>sort(myStrVec.begin(), myStrVec.end(), [](const<\/span> std::<\/span>string&<\/span> f, const<\/span> std::<\/span>string&<\/span> s){return<\/span> f.length() <<\/span> s.length();});\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The code tells the truth and is by definition always up to date.<\/p>\n
It happened so often in my career as a software developer that I should maintain legacy software and improve it. Typically, this software was very complex, and it took me a considerable amount of brain power to understand it. Sometimes I couldn’t even understand the software. You may guess, how happy I was that I found documentation in the source code that helped me to put the puzzle pieces together. Sadly, I recognized later, that the documentation was out of date and I invested my brain power in the wrong direction. I went back to square one. Fine-grained source code documentation becomes easily out of date. Out-of-date documentation is awful. Your code should be self-explanatory.<\/p>\n
High-level documentation<\/h4>\n
Honestly, I’m a big fan of high-level documentation of software.<\/p>\n
For example, you provide a graphic in UML <\/a>or SysML <\/a>describing the architecture of the software and say, that you apply the reactor pattern in your software. The reactor pattern is an architectural pattern. It describes a proven solution to build event-driven applications that can accept multiple client requests simultaneously and distribute them to different service providers. Now, that I get the big picture, I can dive more into the details:<\/p>\n