Rethinking GRASP, SOLID, and GoF for JavaScript and Node.js
Practical training for rethinking and applying GRASP, SOLID, GoF patterns in asynchronous programming and JavaScript for application and system developers, backend and frontend, Node.js and browser applications.
🗓️ Next onboarding will start 1 October 2024
Understanding these concepts can't just be extracted from a box (or book) and placed into your maind. It varies greatly for different languages and platforms. Blindly transferring knowledge and practices from C++ or Java to JavaScript and C# results in dead ceremonies. However, they can be revived through practice, tied to realities, and rethought to avoid becoming monstrous and horrors.
From the author of the first course on asynchronous programming in JavaScript (17 years ago, KPI University), many conference talks and lectures on Node.js. Over the years, a lot of experience, code reviews, and practices have been collected and analized to rework the course almost every year, absorbing the best practices. Timur Shemsedinov is also a contributor to many platforms and libraries in open source, including Node.js, Metarhia, geoip-lite, MDN, HowProgrammingWorks, metasync... Timur is one of the first who began to port parallel programming abstractions from C++, C#, Java, Go and other languages to JavaScript.
Here's what I suggest learning and practicing:
- 📂 Module Systems, Dependency Injection, and Inversion of Control
- 📦 Decomposition of Abstractions and GRASP Principles
- 🧩 Gang of Four patterns rethinked for JavaScript realities
- 🔮 Principles of Isolation and SoC (Separation of Concerns)
- 👷🏻♂️ Separation of Applied and System Code
- 🧩 SOLID principles: Single Responsibility, OCP, ISP, DIP, LSP
- 🌟 Multi-Paradigm Programming and Domain-Specific Languages
- 🧩 Contract Programming and Modeling with Schemas
- 🏛️ Clean Architecture and Layered Architecture
- Minimal: learning in a common group without a mentor but with interactive calls
- Standard: training with mentor in small groups (up to 10 people)
- Professional: training with mentor, 1-on-1, groups, and additional materials
- Exclusive: personalized training track with a couse author
- 🗓️ 12 weeks (3 months) + onboarding (1 week) + secret module
- 👍 You will get access to course materials forever
- 🕑 Every week (mandatory): 1 hour of lectures + 2 hours of calls + 2 hours of independent work
- 🥋 Training and group work with mentors, not just watching videos and reading
- 🙋♂️ Optional: for deep dive +3 hours of additional materials on senior plans
- 🏅 You receive a certificate upon completion of the course
- 💬 Languages: RU for lectures; UA, TR, EN, RU for seminars, mentorship and Q&A sessions
⚠️ Requirements: basic JavaScript + practical programming experience is recommended- 🙅 Not for: beginners, look for free materials for beginners at Timur's Youtube and Github
- 💳 Payment plan: full payment or monthly payment for all plans except minimum
- 🗺️ After the course, participation in the community (thousands of people around the world)
👉 Buy: https://nodeua.com/Patterns-2024-buy.html
Why do we need rethinking and adapting GoF, SOLID, and GRASP for JavaScript/TypeScript realities. How to do it?
🗓️ Week 1: Code Characteristics and Optimization Strategies
There is a path that leads to radical improvement of the structure and characteristics of your code. GoF, SOLID, GRASP principles and patterns, how to apply them and what do we get. Code characteristics: readability (understanding), reliability, testability, maintainability, reusability, flexibility, security. Optimal use of computing resources: processor, memory, input-output and cognitive resources of developers.
🗓️ Week 2: Native features in language and platforms
JavaScript has built-in contracts: Thenable, Iterable, AsyncIterator, Callback-last, Callable, Cancelable, Observable, but the culture of developing through contracts and interfaces is not popular enough in the community. How can we improve development performance with Knowledge-driven approach. How patterns may help us in this direction: to delivery quick and effective, to be performant, to make everydays work interesting, to be motivated and never burnout.
🗓️ Week 3: Instantiation: Creational Patterns and Techniques
Creational patterns: Constructor, Singleton, Factory, Pool, Builder, Prototype, Flyweight, other patterns and techniques. Let’s find related principles and rethink applied importance of GRASP: Creator; GRASP: Polymorphism, SOLID: ISP; Aggregation and Composition. How to Save memory and other resources; how to use optimizations and caching. How to develop extremely quick and low-latency code for any devices we need to support and make this code clear for colleagues.
🗓️ Week 4: Isolation and Separation of Concerns
SoC is a general engineering principle to build flexible, reliable, and easy-modifying systems. We may use GoF patterns: Mediator, Bridge, Abstract factory, Strategy (JavaScript-specific implementation: Map<PropertyKey, Implementation>); Modularity; GRASP: Information Expert, Indirection, and Protected variations principles; SOLID: SRP; This will improve code testability and reduce integration expenses.
Working with application modules/components integration we need contract programming; it allows us to develop parts independently; scale the team; improve project manageability and make a development plan much predictable.
🗓️ Week 5: Contracts: Interfaces for Component Interaction
Patterns: Adapter (Wrapper), Facade, Bridge, Composite, Proxy, Promisify; Front controller; GRASP: Low Coupling and High Cohesion; SOLID: LSP (Liskov); and SOLID: OCP (Open-Closed); It opens the possibility of step-by-step refactoring, overcoming technical debt and increasing subsystem stability; reducing influence (coupling) between layers and modules. At the top level this makes possible to scale the team, manage priorities, and make architectural decisions.
🗓️ Week 6: Decoupling with Events and Messaging
Next great approach is event-based programming. This is useful in UIs, distributed systems, shared resources cooperative access. Async and event-driven programming made Node.js the ultimate solution for non-blocking I/O. We will consider GRASP: Pure Fabrication and Low Coupling; AsyncQueue and queueing systems, Async collections, etc.
🗓️ Week 7: Streams: Data Flows and Transformations
Reactive programming has become a separate paradigm; Streams and Signals are based on GRASP: Pure Fabrication and Event-driven approach with data transformation operators it is widely used in network protocols, file system and data access, game dev and financial and analytical systems, embedded devices control and telemetry; other subject areas. It gives expressive syntax, higher level of abstraction, flexibility and performance for better user experience.
🗓️ Week 8: Handling Errors: Exceptions and Soft Failures
We will explore error-handling best practices using both exceptions and domain-specific (soft errors). Gracefully recover and soft failures will increase whole system performance. We will use Chain of Responsibility, SOLID, Promises, fallback mechanisms to handle non-critical errors; GRASP: Protected Variations and Custom JavaScript-specific AggregateError and Error.prototype.cause and error serialization for network transmission.
Bringing everything together under real-world conditions. In this unit, we'll explore how the foundational concepts of structure, contracts, and patterns translate into running, scalable applications. This part will focus on how runtime considerations shape architectural decisions.
🗓️ Week 9: Semantics: Expressive DSLs
To improve code expressiveness and clearer semantics; any complex software needs to invent DSL (domain-specific language). For DSL we can use well-known syntax, JSON, JSON5, Markdown, and even JavaScript itself. We will consider patterns: Command, Interpreter, State, Strategy, Visitor. DSLs makes code readable for domain experts, analytics and even experienced users. It enhances communication and understanding, speeds up development, adapt easily to new requirements, simplify onboarding and knowledge transfer, hides technical complexity, allows specialists to focus on certain field, improving project predictability.
🗓️ Week 10: All-agnostic as a Default Strategy
Developing frameworks-agnostic, platform-agnostic, protocol-agnostic, database-agnostic, cloud-agnostic systems as a default approach to ensure flexibility and free architectural solutions; removes vendor lock, etc. We certainly don't need to implement all aspects of agnostic approach, but some of them will bring valuable benefits in system scaling and during system operation. We will use isolation, GRASP: Controller; SOLID: DIP; using IoC and DI; using interfaces and Strategy pattern to decouple from implementations.
🗓️ Week 11: Scaling Applications and Architectural Styles
This week we'll explore how to design systems that can scale and evolve efficiently by leveraging different architectural styles: such as DDD, Layered Architecture, SOA, Microservices, Event-Driven, Monolithic, Ports and Adapters, Clean Architecture, Event-Sourcing, CQRS, Pipeline, Peer-to-Peer, Client-Server Architecture and how SOLID, GRASP and GoF can help us in implementing architecture.
🗓️ Week 12: Methodology: How to Start Applying Concepts
The final part of the program focuses on practical application. We will go over how to start implementing the concepts and patterns covered in the course in real-world projects. This session provides actionable strategies to build a roadmap for adoption. How to identify the need for patterns and principles. Refactoring legacy Systems, Introduction of new development techniques and activities; How to building a Roadmap: Planning your own learning and team development using the course principles.
- Minimal: learning in a common group without a mentor but with interactive calls
- Standard: training with mentor in small groups (up to 10 people)
- Professional: training with mentor, 1-on-1, groups, and additional materials
- Exclusive: personalized training track with a couse author