 So next up in our module, we will discuss in-depth, so-called design patterns. So similar to the architectural patterns, design patterns are essentially good solutions to how to design your system. In this case, on a class and relationship level, on an implementation level. Now, originally, the term patterns comes from a guy called Christopher Alexander, and he published in 1977 a book which is called A Pattern Language, and that's an architecture book. So this was originally the idea for architecture that a pattern is some kind of timeless entity called a pattern. So Alexander had this idea, and there are over 200 in his book, that there exist these descriptions of a part of a town, of a city, that are sort of proven solutions that work well for whatever way you want to look at it, and that can be reused in different contexts. And just to give you an example, it would be, for example, I have that on the slides, there is an example of where you should place a café. You should place it next to a busy street and kind of offer different corners so that people can kind of just hide in the corners and let the life go past, and I don't know, do people watching and so on. But it's on this kind of level, so it's kind of descriptions on how do you design a courtyard or a street, a house. And this is timeless. It doesn't depend on the location. You have these kind of cafes in very warm countries and very cold countries in very different cultures. It's somehow timeless and, in a way, placeless. So the software community has taken up this quite a lot, so the pattern term became quite popular and they've decided, well, for architecture we have architectural patterns, proven solution, design patterns for classes and relationships. There are things, we won't cover them much here, but there's something that's called an anti-pattern. So things, solutions that are proven to not work very well. I gave an example there already, for example, the God class I mentioned in the previous video is an anti-pattern for design. So this is very influential. And among all of these, among the design patterns, there are the so-called gang of four patterns, which are probably the most well-known ones. This was a group of four authors that published a book about design patterns in object-oriented systems. So it's purely object-oriented. And it's a list of 23 patterns that became extremely influential. It's important to say that, well, they are not quite timeless. There has been a lot of debate around how useful they are. And that's something that is normal, software evolves. And, for example, the execution might change, the way of compiling and running software changes. So not all of these patterns will endure over time. But we will, in the following videos in the remainder of this module, actually look at some of these patterns. And just to give you an introduction of how they are mainly structured, they are structured into three groups. And that is creation patterns, structural patterns, and behavioral patterns. So essentially solutions for the creation of classes and objects and so on. Creation or structuring your system. What kind of blocks should you have? And how to design it that the behavior is good or well-working. And we will go into a couple of each of these patterns in more depth. And as I said, you will probably recognize them, some of them at least. You might have seen them. You might have always wondered why exactly they look like they do. We'll discuss it in depth.