Course of Design Patterns: Creational

💸 First lesson available without registration 💸

What will you learn in this Creational Design Patterns course?

What is a design pattern? When is it worth applying it? What implications does it have to use them?

This is the first course in the Design Patterns series, where we focus on those of the Creational type, that is, those patterns aimed at achieving greater flexibility when creating objects.

Starting from an example applying the pattern, we look at the implications they have at the SOLID level and maintainability, and analyze their advantages and disadvantages, as well as alternatives and similarities with other patterns.

As it is the first course in the series, we also take the opportunity to lay the foundations and clarify some confusions that exist around patterns.

Learn to know when to apply Creational Design Patterns and understand the advantages and trade-offs that come with using them! 💪

Course content

1. 👞 What are Design Patterns? What does it imply that they are creational?
   • ✂️ What are design patterns?
   • 🤔 Design Pattern, Architecture Pattern, Architecture Style, is it all the same?
2. 😕 Singleton Pattern or Anti-Pattern?
   • 📬 Singleton, SOLID and Testability: DomainEventPublisher
   • 🌍 Problems with global state: Activating and deactivating Feature Flags
   • 🔥 Managing global state in an immutable way
   • 👀 Real World™️ examples of Singletons
3. 🪄 From Singleton to Dependency Injection
   • 🪅 From Singleton to Dependency Injection: Breaking the dependency with MySql
   • 💉 Ensuring a unique instance without Singletons: DomainEventPublisher
4. 🏭 Factories: types, alternatives, and implications at the SOLID level
   • 🤷 Factory, Factory Method, Template Method, and Named Constructor, how do they differ?
   • 👊 SOLID impact of the Factory Method
   • 📩 Alternative to the Factory Method: Sharing behavior through composition
5. 🤯 Factories: when things get complicated
   • 🏭 Create the instance at Runtime with a parameterized Factory Method
   • 🪄 Exhaustiveness in instantiation: The magic of typing
6. ☁️ Abstract Factory: Creating families of objects
   • 💸 Applying Abstract Factory to payment gateways
   • 🤕 Premature abstraction: Problems when adding Stripe and Bank Transfer
7. 🏗 Builder: Facilitating object construction
   • 🏗 Building complex objects with the Builder pattern
   • 👀 Real World™️ examples of Builders
   • 🔄 Alternatives to the Builder pattern
8. 🤖 Cloning objects using Prototype
   • 👯 Cloning objects in JavaScript and TypeScript: Shallow vs Deep copy
   • 👻 Decoupling from the constructor with Prototype: Adding enemies to a game
   • 🛒 Cloning objects with identity: Repeat last purchase
9. 🔄 Object Pool
   • 🔍 Detecting the need for an Object Pool: Performance issues in E2E tests
   • ✅ Solving performance issues with a pool of browsers
10. 🥱 Lazy initialization

• 🧐 Detecting the need to apply Lazy initialization: Basic implementation
• 🤝 Lazy initialization and Proxy join forces: Separating responsibilities
• 💥 The danger of using Lazy loading: Course steps

11. 🔜 Conclusions and next steps

• 🙅 Reasons to avoid design patterns
• ✅ 🤟 Conclusions and next steps

Free content

In the "Preview" section above, you can access the course index and watch the first 2 videos completely free and without the need to register.

We have worked hard to prepare this course, so you can check for yourself the quality of the videos and topics we will cover 😊