Фундамент архітектури

Передмова: Чому ця книга існує і як її читати

1. Біль №1: знання у вакуумі
2. Біль №2: застаріле лайно мамонта
3. Біль №3: сліпа віра в ШІ
4. Для кого ця книга
5. Як ми будемо вчитися: Problem-First
6. Структура: куди ми йдемо
7. Подяки
8. 🔑 Висновки розділу

Частина I. Фундамент та Філософія

Розділ 1. Еволюція болю: від GOTO до ООП

1. Ера хаосу: Spaghetti Code та GOTO (1960-ті)
2. Ера структурного програмування та його «спадщина» (1970-ті)
3. Ера процедурного пекла: глобальні дані (1980-ті)
4. Народження ООП: клітини й повідомлення
5. Від цегли до байтів: історія патернів (1977-1994)
6. Протверезіння: GRASP і SOLID
7. The Big Picture (Велика картина)
8. А як щодо функціонального програмування?
9. Сучасність: як виглядають патерни зараз?
10. 🔑 Висновки розділу

Розділ 2. За що вам платять гроші? Архітектурні драйвери та мистецтво Trade-offs

1. ЩО проти ЯК: функціональні та нефункціональні вимоги
2. Сучасна шістка драйверів
3. Три вершники складності
4. Мистецтво компромісу (Trade-offs)
5. 🔑 Висновки розділу

Розділ 3. Парадокс ООП: ви думаєте, що знаєте, — але ні

1. Що таке парадигма?
2. Швидкий огляд «сусідів» ООП
3. Біологічна метафора та її наслідки
4. Messaging: прохання замість наказу
5. Стан + Поведінка = Нероздільна Єдність
6. Велика картина: де ми?
7. 🔑 Висновки розділу

Розділ 4. Інкапсуляція: два виміри «чорної скриньки»

1. Велика ілюзія безпеки
2. Два трактування: від Simula до наших днів
3. Інкапсуляція як архітектурний принцип
4. Навіщо взагалі все це потрібно: race conditions та ефект «відваленого заду»
5. Рішення: справжній ООП-об’єкт
6. 🔑 Висновки розділу

Розділ 5. Наслідування: як мислити ієрархіями та не отримати ляпаса від реального світу

1. Чому наслідування взагалі існує?
2. Базовий детектор: IS-A
3. Реальний кейс: медогляд і корпоративний мерч
4. Множинне наслідування та Diamond Problem
5. Правила виживання: скільки рівнів — норма?
6. 🔑 Висновки розділу

Розділ 6. Поліморфізм: вбивця if-else та справжнє серце ООП

1. Три механізми поліморфізму: від синтаксичного цукру до підтипів та дженериків
2. Еволюція болю: від «Бібліотеки» 96-го року до «Дерева смерті»
3. Рішення: Плагінна архітектура та «Бритва Поліморфізму»
4. Duck Typing: поліморфізм без явних контрактів
5. Параметричний поліморфізм: Дженерики проти копіпасту та «кастингової рулетки»
6. Пастка оверінжинірингу: Soft-coding та YAGNI
7. Антипатерн: об’єкт без поведінки вбиває поліморфізм
8. 🔑 Висновки розділу

Розділ 7. Абстракція: мистецтво ігнорувати деталі

1. Що таке аналіз насправді?
2. Абстракція є у всіх парадигмах
3. Три принципи — один результат
4. Антипатерн: занадто абстрактно
5. Реальна історія: коли дизайн занадто точний
6. Золоте правило: інтерфейс — завжди, балаган — ніколи
7. 🔑 Висновки розділу та підсумок блоку про ООП

Розділ 8. UML: Навіщо малювати, якщо можна кодити?

1. Як ми домовилися про мову
2. Міф про «Магічну кнопку» та Rational Rose
3. «Як роблять джуни», або Кнопка Зла
4. Суть підходу: UML як детектор лайнокоду
5. Тонкощі й trade-offs: інструменти й пастка коду
6. Чому ми беремо тільки дві діаграми з усіх можливих
7. 🔑 Висновки розділу

Розділ 9. Анатомія класу та битва стрілок: Class Diagram

1. Анатомія «Квадратика»
2. Залежності: хто кого смикає
3. Битва Ромбиків: Агрегація vs Композиція
4. Мультиплікатори: скільки вішати в грамах?
5. Генералізація і Чупа-чупси
6. Нотатки (стікери) та Dependency Injection
7. 🔑 Висновки розділу

Розділ 10. Життя об’єктів у рантаймі: Sequence Diagram

1. Коли статика вводить в оману
2. Анатомія Sequence Diagram
3. «Як роблять джуни»: антипатерни зайвої деталізації
4. Рішення: хірургічний інструмент, а не малярний валик
5. Гранд-фінал: навіщо взагалі вчити UML?
6. 🔑 Висновки розділу

Частина II. GRASP: Мистецтво розподілу відповідальності

Розділ 11. Вступ до GRASP та патерн Information Expert

1. Що таке GRASP загалом?
2. Анатомія об’єкта: стан та поведінка
3. Шлях Information Expert на прикладі чека
4. Коли Information Expert стає монстром: Анемічна модель і кейс DirecTV
5. Модерн-процедуралізм та Smart Data
6. 🔑 Висновки розділу

Розділ 12. Creator: хто дає життя об’єктам?

1. Процедурна помилка початківців
2. Правила Лармана: хто має «ліцензію» на new?
3. Велика битва: Creator проти Dependency Injection
4. Конфлікт GRASP та SOLID: сувора реальність
5. Еволюція складності: «гітарний ефект»
6. 🔑 Висновки розділу

Розділ 13. Controller: перша лінія оборони

1. Що таке System Event, або системна подія?
2. Ізоляція багатопоточності: «хвилеріз»
3. Антипатерн: Bloated Controller, або роздутий контролер
4. Два різновиди контролерів: Facade vs Use-Case
5. 🔑 Висновки розділу

Розділ 14. Low Coupling і High Cohesion: інь та ян архітектури

1. Low Coupling: ефект метелика та «монолітність»
2. High Cohesion: смітник чи інструмент?
3. Доводимо ідеал до абсурду
4. Кейс YouTube: коли реальність перемагає теорію
5. Місток до майбутнього: GRASP проти SOLID
6. 🔑 Висновки розділу

Розділ 15. Polymorphism: вбивця IF/ELSE

1. Вступна проблема: життя на сходинках
2. «Як роблять джуни»: жах видалення
3. Рішення: поліморфізм як архітектурний патерн
4. Коли «паттернізм головного мозку» вбиває проєкти
5. 🔑 Висновки розділу

Розділ 16. Pure Fabrication: Чиста вигадка, або чому в реальному світі немає менеджерів і хелперів

1. Конфлікт ООП та реальності
2. Компроміс заради метрик: суть патерну
3. «Як роблять джуни»: темний бік вигадок — Utils та Helpers
4. Лікування хелперів
5. Резюме
6. 🔑 Висновки розділу

Розділ 17. Indirection: посередник, що розв’язує руки, або чому один інтерфейс зводить копіпаст до нуля

1. Вступна проблема: два розробники і вічний баг
2. Рішення: посередник між двома класами
3. Термінологічне пекло: Indirection, DIP, IoC та DI
4. Суперсила: Interception
5. Тонкощі й trade-offs: коли застосовувати інтерфейси?
6. Резюме
7. 🔑 Висновки розділу

Розділ 18. Protected Variations: як локалізувати вибух, або стратегія виживання у світі, де ТЗ змінюється щодня

1. Неминучість змін та одна неприємна правда
2. Механіка: два кроки до виживання
3. Axis of Change — поняття, яке буде переслідувати вас до кінця книги
4. Protected Variations і OCP — батько і син
5. Антипатерн: не будьте Вангою
6. Резюме та прощання з GRASP
7. 🔑 Висновки розділу

Частина III. SOLID: Принципи гнучкості

Розділ 19. Вступ до SOLID та принцип SRP, або Чому програми «гниють» і як знайти вісь змін

1. «Як роблять джуни»: міф про «одну дію»
2. Рішення: осі змін та актори
3. Прагматизм: коли ми свідомо порушуємо SRP
4. 🔑 Висновки розділу

Розділ 20. OCP: Відкриті для розширення, закриті для змін (або як додавати фічі, не ламаючи старий код)

1. «Як роблять джуни»: Антипатерн Хардкодингу
2. Рішення: Два шляхи OCP
3. Тонкощі та Trade-offs: Пастка Soft-coding
4. Прагматизм: Коли правила ламаються
5. 🔑 Висновки розділу

Розділ 21. LSP: Принцип підстановки Лісков (або чому компілятор вас не врятує)

1. Синдром Миколи: Коли формальність вбиває логіку
2. Design by Contract (Проєктування за контрактом)
3. Математика проти ООП: Проблема Квадрата і Прямокутника
4. Як виявити архітектурний «бруд» (порушення LSP)
5. LSP і Duck Typing: «Якщо це качка — то і плавати теж зобов’язана»
6. 🔑 Висновки розділу

Розділ 22. ISP: Інтерфейс належить клієнту (або чому оператору не можна давати «червону кнопку»)

1. Чому нас вчили зводити все в один «універсальний» інтерфейс
2. «Дедлайн на вчора» і кнопка Extract Interface
3. Різати, не чекаючи перитоніту: рольові інтерфейси
4. Коли ISP виходить за межі коду: REST і мобільна розробка
5. ISP і качина типізація: навіть качці не завжди потрібні всі її функції
6. ISP головного мозку (коли доводять до абсурду)
7. ISP і SRP: два брати-акробати
8. Місток до DIP
9. 🔑 Висновки розділу

Розділ 23. DIP: Бізнес не повинен знати про MySQL

1. Коли бізнес-логіка напряму залежить від MySQL
2. Що реально означає Dependency Inversion Principle
3. Бізнес визначає контракт, а не інфраструктура
4. Адаптери інфраструктури: деталі, які можна міняти
5. Чому з DIP тести стають коротшими і дешевшими
6. Де не треба вигадувати зайві інтерфейси
7. Коротко про шари, щоб ми говорили однією мовою
8. Як DIP зв’язується з GRASP-принципами
9. 🔑 Висновки розділу

Частина IV. Патерни GoF (Банда Чотирьох) у сучасному світі

Розділ 24. Вступ до GoF: Патерни як інструменти, а не релігія

1. Чому ми прийшли до GoF лише тепер
2. Патерни 1994 року у реаліях 2026
3. Як пройти всі 23 патерни без втрати практичності
4. Де DI-контейнер закриває питання, а де — ні
5. Rule of Three: коли патерн справді потрібен
6. Класифікація GoF без фанатизму
7. Що далі: Singleton
8. 🔑 Висновки розділу

Розділ 25. Singleton (Одинак): Чому глобальний стан вбиває ваші тести

1. Класична реалізація та багатопотоковий жах
2. Ілюзія безпеки: пастка Double-Checked Locking
3. Чому класичний Singleton — це Антипатерн?
4. Сучасне рішення: DI-контейнер як «Великий Сінглтон»
5. Специфіка PHP: Сінглтон живе одне життя (запит)
6. Специфіка Node.js та Python: безкоштовні сінглтони
7. Мовні «чіт-коди»: Kotlin, Go, Ruby та Rust
8. Патерн Monostate (коли об’єктів багато, а стан один)
9. Патерн Multiton (коли одного об’єкта замало)
10. Singleton і Функціональне програмування (FP)
11. А якщо у мене немає DI-контейнера? (Pure DI)
12. Що далі: перехід до фабрик
13. 🔑 Висновки розділу

Розділ 26. Factory Method та Abstract Factory: Як створювати об’єкти без архітектурного самогубства

1. Проблема, яку вирішують фабрики
2. Класичний GoF Factory Method: учбова схема, яку в продакшені фактично не пишуть
3. Робочий варіант №1: Simple Factory
4. Робочий варіант №2: Static Factory Method у самому класі
5. 2026 рік: DI-контейнери вже працюють фабрикою для Injectables
6. Лямбди як фабрики: менше бойлерплейту
7. Коли який варіант брати
8. Качина типізація: фабрики без класів
9. Як не влетіти в overengineering
10. Музейна хвилинка: Abstract Factory
11. Що далі: Prototype та Object Pool
12. 🔑 Висновки розділу

Розділ 27. Prototype та Object Pool: Клони атакують і коробка з інструментами

1. Як роблять джуни: Антипатерн “Кілометри сеттерів”
2. Патерн Prototype: Клонування замість конструювання
3. Диявол у деталях: Поверхневе vs Глибоке копіювання
4. Патерн Object Pool: Коробка з інструментами
5. 🔑 Висновки розділу

Розділ 28. Builder: Порятунок від конструкторів-монстрів

1. Як це описано в GoF (і чому це мертво)
2. Як це роблять нормальні люди (Fluent Builder)
3. Мовні реалії 2026 року
4. Коли все ж виносити Builder в окремий клас?
5. Builder + Factory Method: Ідеальний симбіоз
6. 🔑 Висновки розділу

Розділ 29. Структурні патерни-посередники: Adapter, Proxy, Decorator, Facade

1. Adapter (Не можеш змінити — адаптуй)
2. Proxy (Контроль доступу та ліниве завантаження)
3. Decorator (Магія в рантаймі та матрьошки)
4. Facade (Спрощення макросвіту)
5. 🔑 Висновки розділу

Розділ 30. Bridge (Міст): Порятунок від комбінаторного вибуху

1. Байка про «Фінуправління» та суть проблеми
2. «Як роблять джуни»: Декартовий добуток класів
3. Як працює Bridge: дві ієрархії для двох осей змін
4. А як щодо мов із качиною типізацією?
5. Біль архітектора: нестабільність патерну
6. Резюме
7. 🔑 Висновки розділу

Розділ 31. Сила та слабкість: Composite та Flyweight

1. 1. Composite: Магічне знищення рекурсії
2. 2. Flyweight: Пожежне гасіння Out of Memory
3. 🔑 Висновки розділу

Розділ 32. Strategy (Король патернів): Заміна if/else на вибір в рантаймі

1. Біль: Тисячорядковий if-else та розрахунок ціни
2. Рішення: патерн Strategy
3. Хто вирішує, яку стратегію використовувати?
4. Тонкощі, сучасні реалії та Trade-offs
5. Важливий урок: Чистота Git та антипатерн «Човновий якір»
6. 🔑 Висновки розділу

Розділ 33. Mediator та Observer: Централізація проти реактивності

1. Біль: спагеті-залежності в GUI та біда чекбокса
2. Рішення 1: Mediator (Посередник) — Централізація влади
3. Рішення 2: Observer (Спостерігач) — Повна децентралізація
4. Темна сторона Observer
5. Еволюція Observer у сучасному світі
6. Duck Typing: як це працює в мовах із качиною типізацією
7. Битва концепцій: Mediator проти Observer
8. 🔑 Висновки розділу

Розділ 34. Chain of Responsibility: Конвеєри обробки та Middleware

1. Біль: стіна перевірок HTTP-запиту
2. Академічний тупик: GoF Chain of Responsibility
3. Сучасне рішення: FilterChain / Pipeline (ланцюжок фільтрів та конвеєр)
4. Тонкощі, підводні камені та архітектурні граблі
5. Duck Typing та першокласні функції: як це працює в динамічних мовах
6. 🔑 Висновки розділу

Розділ 35. Memento, Command та Interpreter: Тріада інтерактивних систем

1. Memento: Збережись перед босом
2. Command: Інкапсуляція дії
3. Interpreter: Створення власної мови для бізнесу
4. Як вони уживаються разом (і чи треба?)
5. 🔑 Висновки розділу

Розділ 36. Iterator: Ховаємо кишки колекцій

1. 🔑 Висновки розділу

Розділ 37. State: Кінець епохи нескінченних switch

1. State у фронтенді: не плутайте реактивність із патерном
2. 🔑 Висновки розділу

Розділ 38. Template Method: Скелет алгоритму та пастки наслідування

1. 🔑 Висновки розділу

Розділ 39. Visitor: Подвійна диспетчеризація та операції над закритими класами

1. 🔑 Висновки розділу

Розділ 40. Епілог: Design Patterns у сучасному світі. Як ШІ змінює розробку. Життя після GoF

1. 🔑 Висновки розділу