Design Patterns in Go (Udemy.com)

I found the course very useful with focus on practical, hands-on examples. Each pattern was explained with concrete Go code, which made it easier to see how to apply them in real projects. Sometimes I had to rewind and play parts back to fully comprehend everything, but that was perfectly fine and actually helped the material sink in.

This isn't a course focused on someone who doesn't know a single thing in Golang, so, if you're just starting, learn the basics first, because, after you've learned the basics, there's ton of knowledge waiting for you, to improve a lot your Go knowledge. I really recommend this course for everyone with the basics topics already covered.

The course is good, it covers a nice range of patterns and I like the way the instructor explains using simple examples to make it clear and easy to understand. My only feedback here is about exercises, it would be better if you provide at least one exercise to put into practice the concepts learned of a particular section. I know we can find them online but it would be easier to have everything here at one place. Good work!

Good top level explanation of design patterns and implementation in Go. Could've done with some additional ideas on how or when to use them in some real world development application, especially in more complex systems, but otherwise a decent course.

Got exactly what I was looking for. Thanks for having this course in Golang. Would be exciting to see in Rust as well. Some suggestions: 1. Some lectures don't have caption support in English. Would be great if you could add. 2. I struggled to figure out how I am going to use these design patterns in my project, I mean what is the thought process like if I am working on some project then while writing code how the thought process should work like, which pattern to use where and exactly at what point of the project phase. Thank you again for having this course.

The author has done exceptional task of translating the oops concept with tools found in GoLang, This was an exceptional effort on his part. As a student of this course I found this course as a reinforcer to best practices in low level design. As a suggestion I would like the author to include class diagrams( some equivalent for GoLang) where he can demonstrate issues, challenges, and solution, before jumping to coding. Although he does explain all these but they are generally verbal communication without support of diagrams.

The instructor is the best teacher in the advance subject of programming online courses. Speak clearly, direct to point, and coding example are also simple to understand and follow. Thank you so much, I have been struggling with advance code for sometime and after learning a few sections in the course I have already starting to see more clear some of the code that I have trouble understanding before. Best and highly recommended!

Above and over the fact that the instructor has taken a stab at almost all practical design patterns, it's the examples that sets this course apart. There's no "hello world" kind of examples that are typically ubiquitous in blog posts across the internet. These are fairly apt examples that demonstrate the best usage of the patterns. I also liked the fact that the instructor goes through the trade offs for each pattern and does not label any single pattern as a "god" pattern. I'm fairly confident in my abilities to use these patterns at work. Glad I bought this.

This was very good course. one suggestion is before jumping directly into the go programming and explaining the patterns it would be helpful if there was a real world example touching upon what is the problem, how this patterns solves it. Might help us to remember the application of the patterns

I’ve been using design patterns using several languages during my career, C,C++,Java,C#,SmallTalk, but I was really curios to see them in action with a language lacking of concept like classes or heritance. That course is proving that Ken Thomson is always right: you can write efficient and elegant code even without Generics or Super-Multi-Heritance, the contrary is true and this is also my opinion. This course is really good for refreshing your understanding on Patterns and also on how to apply them to modern problems and with a relatively new language as Go. Some feedback to Dimtri:  Not having Class or Heritance is not a “problem” and was design decision for Go: below the Go team explaining in depth their design decisions: o https://www.youtube.com/watch?v=sln-gJaURzk&feature=youtu.be  Think you should also treat the design pattern’s counterpart: Antipatterns. Could be an idea for a future version of the course  It would be great if you could also code the examples using TDD or a least adding tests, I’ve done them by myself and you can find them on my GitHub repository here: https://github.com/Gammaglobulino/designpatterns_go In general I truly appreciated the deepest on how you treated every single pattern, looking forward to apply those to my coding style on GO.