Уровень 0 · материалов: 19
В кластер входят документы, посвященные высокоуровневым стратегиям организации структуры кода, архитектурным паттернам и принципам разделения логики, но не входят документы, сфокусированные исключительно на синтаксисе языка, изучении конкретных инструментов или обзоре функций отдельных фреймворков.
Общие признаки: разделение ответственности (separation of concerns), декомпозиция и модульность, паттерны проектирования (MVC, SAM, DDD, Clean Architecture), создание масштабируемых и поддерживаемых систем, событийно-ориентированная архитектура
Группа выше: Проектирование архитектуры ПО: основы и подходы
Смысл: The main idea is that frontend development should adopt decoupled, event-driven communication patterns (Pub/Sub) to avoid the fragility and complexity of traditional component hierarchies and mediator services.
Frontend architecture is lagging behind the backend; adopting a typed Pub/Sub event-driven approach can decouple components and eliminate the 'prop-drilling' nightmare.
Смысл: The main idea is that successful frontend development relies on strict decomposition and the separation of concerns (HTML/CSS/JS and Backend/Frontend). By treating UI as a set of independent, reusable components and avoiding the mixing of logic and presentation, developers create code that is maintainable, readable, and scalable for the long term.
A guide to frontend project decomposition emphasizing the strict separation of data (JS), structure (HTML), and style (CSS) through a modular, component-based architecture.
Смысл: The text aims to teach Unity3D developers how to move from tightly coupled script dependencies to a decoupled, event-driven architecture to improve project scalability and maintainability.
The article compares direct editor assignments, Singletons, and the Event Aggregator pattern for script communication in Unity3D, recommending the latter for maximum decoupling.
Смысл: The main idea is that while MVC is excellent for backend development, it fails on the frontend because it doesn't account for the unique requirements of UI state management and event handling, leading to the rise of component-based and unidirectional architectures.
MVC failed on the frontend due to improper separation of concerns, leading to the modern era of component-based architectures and unidirectional data flow.
Смысл: The main idea is that enterprise-level Node.js applications require a strict architectural separation between business logic and infrastructure to remain maintainable. The author promotes the BFF pattern for data orchestration and advocates for Clean/Hexagonal Architecture to prevent frameworks from polluting the core domain logic.
The article argues for using Node.js as a Backend For Frontend (BFF) and implementing Clean Architecture principles to decouple business logic from frameworks and infrastructure.
Смысл: The main idea is that modern web development has become dogmatic about statelessness (REST) and structural patterns (MVC), often using them incorrectly. The author advocates for a return to stateful, memory-efficient architectures enabled by modern asynchronous runtimes to achieve better performance and clearer system modeling.
The author argues that dogmatic adherence to REST and MVC is misguided and suggests leveraging modern event-loop technologies to return to high-performance stateful architectures.
Смысл: The main idea is to present Flight as a flexible, event-driven JavaScript framework that prioritizes component isolation and DOM integration over rigid architectural patterns.
Twitter released Flight, a lightweight, event-driven JS framework that uses isolated components and mixins to build web applications without enforcing a strict rendering architecture.
Смысл: The author aims to provide a blueprint for a scalable mobile architecture that avoids 'spaghetti code' and allows for parallel development of the core and the UI.
A comprehensive guide on decoupling mobile app cores from GUIs, featuring a 10-layer architectural model and a critical comparison between file-system and CoreData storage.
Смысл: The main idea is that highly reusable UI components should be designed as small, immutable atomic units following SOLID principles to prevent regressions, while business-specific components should remain cohesive to ensure maintainability.
Avoid bloated generic components by building a library of small, SOLID-compliant atomic pieces and composing them into cohesive application-level components.
Смысл: The main idea is to provide a pragmatic, interface-driven alternative to FSD for React projects that prioritizes ease of onboarding, clear component hierarchy, and strict separation of concerns to maintain code quality in a professional agency setting.
Doubletapp proposes a structured React architecture based on interface-driven component layers and shared models as a simpler, more scalable alternative to Feature-Sliced Design.
Смысл: The main idea is that the separation of concerns should be viewed through the lens of components rather than file types, making JSX a practical tool rather than an anti-pattern for modern client-side rendering.
The author argues that mixing HTML and JavaScript via JSX is not an anti-pattern but a logical evolution of component-based development for client-side applications.
Смысл: The text argues that the traditional MVC pattern is obsolete for modern web development and proposes the SAM (State-Action-Model) pattern as a functional, reactive alternative that decouples the UI from the underlying data model to prevent API bloat.
The author critiques MVC frameworks and proposes the SAM (State-Action-Model) pattern, using functional programming and TLA+ logic to decouple the View from the Model.
Смысл: The text proposes a 'modular' architectural approach as a viable alternative to microservices for projects that don't require extreme scalability. It suggests implementing the strict isolation and API principles of microservices within a single application to avoid network-related complexities while retaining the ability to split into true microservices later.
The author proposes a 'modular' architecture that combines microservice-style isolation with monolithic deployment to eliminate network complexity while preserving future scalability.
Смысл: The main idea is that synchronous interaction in distributed systems is fundamentally flawed due to resource blocking and fragility; therefore, developers should prefer asynchronous and reactive patterns combined with idempotency and rigorous failure-scenario planning to ensure scalability and data consistency.
Avoid synchronous service interaction to prevent resource blocking and scalability issues, instead utilizing asynchronous or reactive patterns with idempotent operations and detailed logging for robust distributed systems.
Смысл: The main idea is to move away from page-based web design toward a system-based approach using a chemistry-inspired hierarchy (Atomic Design) to create scalable, consistent, and maintainable user interfaces.
Atomic Web Design is a methodology that builds interfaces by assembling small, basic components (atoms) into increasingly complex structures (molecules, organisms, templates) until a final page is created.
Смысл: The text advocates for a simplified implementation of Domain-Driven Design (DDD) where microservices are mapped 1:1 to business entities. By doing so, organizations can eliminate 'monolithic' complexities, clarify system boundaries, and allow any developer to work on any part of the system through a unified internal architecture.
The author proposes solving monolithic complexity and team conflicts by mapping microservices directly to business entities using a simplified DDD approach and Onion Architecture.
Смысл: The main idea is to demonstrate a systematic approach to refactoring a complex, legacy mobile application core by transitioning from a monolithic, tightly coupled architecture to a modular, command-driven system that ensures sequential consistency and improves stability.
Yandex Music refactored its 10-year-old legacy playback core into a modular, command-based architecture over three months, resolving critical stability bugs and enabling SDK reuse.
Смысл: The main idea is to demonstrate how to build a robust, decoupled game logic engine using C# that can be independently tested and later integrated into Unity, focusing on architecture, the command pattern, and data-driven design.
A technical tutorial on creating a decoupled, testable game logic engine for a strategy game using C# and the Command and Factory patterns.
Смысл: The main idea is to teach Unity developers how to use Scriptable Objects to separate data from logic and implement a decoupled event system for better performance and maintainability.
A comprehensive guide on using Unity Scriptable Objects to store shared data and create a decoupled, event-driven architecture for a game's UI.