Design Patterns In Python OOP/UML for Projects/Architecture

English is very poor, lectures are very boring and theoretical. No real life examples.

Cannot understand the trainer very well.

PRO] The quiz sections gave a way to review the intent of the design patterns and when it was used. Code sections provided some examples on how the design pattern flows, see it in action and play with how the pattern worked to learn. I learned a lot but had to go outside the course A LOT to fill in details, etc. [CON] Instructor’s English is really hard to understand. I had to enable the closed caption feature. At first, I was disappointed that it was not available for the code sections. However, I found it was not an issue on the most part since he just read the code line by line. As mentioned, I found that I had to go outside the course a lot. To explain, the sections just needed more info: 1) details/reasons for his class interaction 2) analogies to reinforce the intent of the design pattern (the Factory Method Analogy was confusing, site listed below, has a better example) 3) Explain how to implement the design pattern in practice. For instance, the Command pattern left out details on implementation. The reason I feel this way I had to use other resources to explain the pattern implementation. Luckily, I stumbled onto the below site, it that gave a great analogy, waitress took an and then the chef cooked the food. The site pointed out that two clients should be used to implement the Command pattern. It explained how, client one was the act of: 1) waitress concreteCommand class 2) taking the food order Receiver class , i.e. saving the food order. Then the second client was the act of: 1) putting the order into the short order chef Invoker class . 2) Then him cooking the food, executing the command Invoker.ExecuteCmd(). This class was missing this. Also, it mostly seemed like the instructor was reading the material from a book via memorization rather than explaining from understanding. The reason I felt this way is because: 1) he just reads the code or straight from the slides without explaining reasons behind the design pattern and 2) how the classes worked together, etc as explained above. 3) Further, I had to use github code and other web pages for 16 of 23 design patterns covered in this class to address said issues. The reason, I did this is to 1) understand how to use/implement them in practice because he does not explain them well at times, 2) understand why the classes are structured in the pattern to solve the problem or 3) the code was not written clear in some sense. Look at the Memento code example: 1) The Execute method actual changes the state from zero to one in the originator. In practice, you would not do that when implementing the Memento pattern. 2) Also, method names are poorly chosen. I’d call the Execute method Save or SaveState. Likewise, I’d call the Unexecute method Undo or Restore. As a second example, the Factory method only had code for one product. I went out to github to understand where/how the code would controls how product one vs. product two is chosen/created/initialized in practice… The site I used to supplement this course was https://sourcemaking.com/design patterns. If the course could be updated with 1) the analogies and explanations in the spirit of sourcemaking.com or github examples. 2) rethink class/variable names to fit the pattern and analogy examples 3) explain from understanding not memorizing or repeating a book. 4) Rather, explain how to implement the patterns realistically in practice (not like Execute() in Momento Code). Then future students could learn a lot quicker and efficiently, making this a 5 out of 5 star class.

Solid exposition of design patterns.

Really hard to understand. From what I did hear, slides were basically just read back and I didn’t understand how I was going to learn about design patterns and how that also related to Python.