 Okay, next up in our list of patterns are the structural patterns. So they deal with adapting, changing the structure of your system for specific needs. And first up we do the so-called adapter pattern. And the name comes just from, for example, the electricity plugs where you adapt it to something else. For example, you're in the U.S. and you need a different plug than in Europe. So you just put something on top, put it into the outlet. It's exactly the same here. You are implementing some kind of service. So you have a class or an interface that has certain methods that you have defined that take some kind of parameters, certain kind of data. And then you are in a situation where, for example, your client comes and says, well, we have a different interface. Instead of my method and other data, we would like to have method and data. And then instead of going in here and changing this or trying to convince the client to change it, you can introduce an adapter. That's the idea here, because in many cases it might not be possible to change either of them. For example, imagine the case where these are standards that have to be followed and you have, for example, multiple clients. So you cannot just change your code or you don't want to change your code and send different versions to different clients, but you just add different adapters. The idea is done actually quite simple. You have an adapter that implements this interface where it realizes it. So it means it has this kind of method. The client can call it. But it also has a connection to an adaptee to your service. So it has some kind of connection there. It has this service. And then what happens in the concrete implementation of this method is that you simply convert the data and the overall method format. So inside of this method, you will probably change data to other data somehow. So you do data, modify, for example, if it needs to be a list instead of an array, you do that. Other data equals modified, so you somehow convert the data and then you will actually call this method with the other data. So the adaption process is basically in the concrete implementation of this method. And this is, again, as always, open-closed. So we are not modifying our service. We're simply extending it by additional functionality, in this case, just by a conversion, basically, by an additional interface. And the other thing we have here is the single responsibility idea. So we don't want to adapt this service inside the class itself. We don't want to modify it, but basically the way it looks like to the outside should be taken over by a special adapter that just does this one thing and nothing else. The only responsibility of this adapter is to provide a specific client interface, provide compatibility, basically. So as the first structural pattern, the other ones we'll go into are actually quite similar, but we'll go to the next. So the next one is the facade pattern.