Design Patterns in JavaScript (Udemy.com)

Discover the modern implementation of design patterns in JavaScript

( 41 Reviews )

Created by: Dmitri Nesteruk

Produced in 2019

What you will learn

Recognize and apply design patterns
Refactor existing designs to use design patterns
Reason about applicability and usability of design patterns

Quality Score

Content Quality

Video Quality

Qualified Instructor

Course Pace

Course Depth & Coverage

Overall Score : 74 / 100

Course Description

Course OverviewThis course provides a comprehensive overview ofDesign Patterns in JavaScriptfrom a practical perspective. This course in particular covers patterns with the use of:
The latest versions of the JavaScript programming languageUse of modern programming libraries and frameworksUse of modern developer tools such as JetBrainsWebStormDiscussions of pattern variations and alternative approachesThis course provides an overview of all the Gang of Four (GoF)design patterns as outlined in their seminal book, together with modern-day variations, adjustments, discussions of intrinsic use of patterns in the language.
What are Design Patterns?
Design Patterns are reusable solutions to common programming problems. They were popularized with the 1994 bookDesignPatterns:
Elements of Reusable Object-Oriented SoftwarebyErich Gamma,John Vlissides, Ralph Johnson and Richard Helm(who are commonly known as a Gang of Four, hence the GoF acronym).
The original book GoF book used C++and Smalltalk for its examples, but, since then, design patterns have been adapted to every programming language imaginable:
C#, Java, Swift, Python and now JavaScript!
The appeal of design patterns is immortal:
we see them in libraries, some of them are intrinsic in programming languages, and you probably use them on a daily basis even if you don't realize they are there.
What Patterns Does This CourseCover?
This course coversallthe GoF design patterns. In fact, here's the full list of what is covered:
SOLIDDesign Principles: Single Responsibility Principle, Open-Closed Principle, Liskov Substitution Principle, Interface Segregation Principle andDependency Inversion PrincipleCreational Design Patterns:
Builder, Factories (Factory Method and AbstractFactory), Prototype andSingletonStructrural Design Patterns: Adapter, Bridge,Composite, Decorator, Faade,Flyweight andProxyBehavioral Design Patterns: Chain of Responsibility,Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, TemplateMethod and VisitorWho Is the Course For?
This course is for JavaScript developers who want to see not just textbook examples of design patterns, but also the different variations and tricks that can be applied to implement design patterns in a modern way. For example, the use ofSymbol.
iterator allows objects (including iterator objects) to be iterable and lets scalar objects masquerade as if they were collections.
Presentation StyleThis course is presented as a (very large)series of live demonstrations being done in JetBrainsWebStorm and presented using theKinetica rendering engine.
Kinetica removes the visual clutter of theIDE, making you focus on code, which is rendered perfectly, whether you are watching the course on a big screen or a mobile phone.
Most demos are single-file, so you can download the file attached to the lesson and run it in WebStorm, Atom or anotherIDEof your choice(or just run them from the command-line). This course does not use UMLclass diagrams; all of demos are done via live coding.
Who this course is for:
Software engineersWeb developersDesignersArchitects

Time: 10h

Instructor Details

Dmitri Nesteruk

3.7 Rating
41 Reviews

Dmitri is a quant, developer, book author and course author. His interests lie in software development and integration practices in the areas of computation, quantitative finance and algorithmic trading. His technological interests include C# and C++ programming as well high-performance computing using technologies such as CUDA and FPGAs. He has been a C# MVP since 2009.

Reviews

3.7

41 total reviews

5 star 4 star 3 star 2 star 1 star

Write a Review

By Anton Kolomiiets on 11/14/2020

The author doesn't have time to check the Question.

By Jaime Suncin on 11/7/2020

Is a deep dive into design patterns with Javascript, although is very easy to follow

By Vu Minh Tu on 9/8/2020

Good practice for Javascript developer

By Rohit Rane on 8/18/2020

Kudos! The Tutor has great language agnostic knowledge of Design Patterns but a few of challenges I am facing in learning here are :
1. Visual learning could have been made better with Diagrams instead of diving directly into code.
2. The Tutor seems to be from non Javascript Background. So the examples are esoteric and not associable for everyday React Developer or Angular developer. They look like Python Example painfully transposed to Javascript world.
3. Particularly when it came to Prototype Design Pattern, the example & Syntax was painful to bear. Could have instead been implemented using :
https://developer.mozilla.org/en-US/docs/Learn/JavaScript/Objects/Object_prototypes
https://scotch.io/tutorials/demystifying-es6-classes-and-prototypal-inheritance

By Ivan Grimes on 7/22/2020

This course definitely should use Typescript.

By Anca Nagy on 7/10/2020

So far design patterns are explained ok even if he's using the esoteric teacher-type class and instance names that you'll never use in real life coding.
However, there are no clear examples of where you would use one design pattern over another or what are the pros and cons to each one.

By Selino on 7/7/2020

The video seems to be running at 1.5x speed. It's difficult for me to follow as it seems to wander into the weeds with the examples. It would help me to explain the concept and then have another video exemplify that concept to reinforce the understanding. Each video seems to try to explain the concept as he's coding the example. So I'm not sure if I'm supposed to be learning his approach to building out software or the design pattern. I'm forced to try and learn both at breakneck speeds.
It's not a "class" where a teacher is guiding a student toward an understanding. It's more of a shotgun of information that expects you to know most of what the instructor knows in order to decipher the lesson.

By Philippe Van Caloen on 6/18/2020

I don't know it's a little bit long or not using enough pedagogy a

By Luis Carlos Barahona Rodrguez on 6/13/2020

It was great, maybe examples are too related to expertise field of the author and could be more generic. Thanks a lot.

By Nikita Kot on 5/26/2020

Great course, great examples, great patterns explanations, I learned a lot during the course. What is missing in my opinion are class diagrams before doing the actual code. Also some exercises are not very well explained.

By Sergio Javier Garca Snchez on 5/25/2020

So far it has provided simple and good explanations of every concept. It is a bit unfortunate to have this in Javascript, given that some principles cannot be applied in the same way as with Java, C#, etc.
This could probably be improved by using something like Typescript instead.

By Sopra Sur on 5/16/2020