 Okay, we have now covered a bunch of object-oriented design patterns and I just quickly wanted to recap of, discuss what the value is with these and important points are really that first of all the application of these patterns might change over time. As for example you see with the singleton debate that originally this was maybe used more than it is now and there is much more criticism regarding for example the testability of singleton. These things might change over time. Then they very much depend on the design of the language you're using, the programming language. So in some languages some patterns might not be possible, in some languages you might not need certain patterns and the concrete implementation might look different. So in the slides to this module I have also provided a reference for Python in particular where you see a discussion of the patterns and you also see implementation examples because of course the patterns I've shown you, I've shown you on the UML level and how to implement them that is really, really language specific and whether you need them is language specific as well. So that's definitely a key point here as well that it depends as always. And finally you should be aware if you're new to patterns that there is this typical situations of having patterns everywhere and that's the classic saying of if everything you have is a hammer everything looks like a nail. So if you're new to this and you think this is a great idea novices typically start just applying patterns wherever they can and that might just be not required. So you should really think about is it needed that I have a pattern? Does it really provide a benefit? Think for example of the observer and decorator patterns. They are very useful if you write an application that is really built to intended to be built on top extended. So you want to have like I mentioned eclipse a lot, you want to have a platform where people can build new functionality in new code editors, new kind of plug-ins then this might be very useful but if you really already know that this will not be the case then it may not make sense to add decorators and observers everywhere. Really try to limit the use of patterns to when it's necessary. So that's the idea of design patterns and that concludes our overall design and implementation module. Just to recap we discussed these different aspects of for example having configuration management, having host target development, doing reuse, these kind of aspects that you might not be as familiar with yet. Then we went into the solid principles so how what are kind of guidelines to design object oriented programs and then we finished up with the design patterns with some of them at least and the main intention here was to get you familiar with them so that you can write better programs but also whenever you look at code of other people that you actually recognize these things because often when you're new to this you really ask yourself why is the code so complicated we could just make this much simpler but very often there is an underlying idea here that helps you for example to make your application very extensible. Okay thank you for watching design and implementation and for this module we are done.