Пять строк кода. Роберт Мартин рекомендует

Предисловие
Введение
Цель: избранные правила и шаблоны рефакторинга
Аудитория и план изложения
О преподавании
О коде
Дополнительный проект
Благодарности
Об авторе
Иллюстрация на обложке
От издательства
Глава 1. Рефакторинг рефакторинга
1.1. Что такое рефакторинг
1.2. Навыки: что требует рефакторинга
1.2.1. Пример запаха кода
1.2.2. Пример правила
1.3. Культура: когда проводить рефакторинг
1.3.1. Рефакторинг старых унаследованных систем
1.3.2. Когда рефакторинг делать не нужно
1.4. Инструменты: как проводить рефакторинг (безопасно)
1.5. Инструменты, необходимые для начала
1.5.1. Язык программирования: TypeScript
1.5.2. Редактор: Visual Studio Code
1.5.3. Контроль версий: Git
1.6. Общий пример: 2D-головоломка
1.6.1. Практика ведет к совершенству: вторая база кода
1.7. Примечание по реальным программам
Резюме
Глава 2. Суть рефакторинга
2.1. Улучшение читаемости и обслуживаемости
2.1.1. Улучшение кода
2.1.2. Обслуживание кода ... без изменения его функциональности
2.2. Выработка скорости, гибкости и стабильности
2.2.1. Выбирайте композицию вместо наследования
2.2.2. Изменение кода путем добавления, а не изменения
2.3. Рефакторинг и повседневная работа
2.3.1. Рефакторинг как метод для освоения
2.4. Определение «области» в контексте ПО
Резюме
Часть I. Учимся на рефакторинге компьютерной игры
Глава 3. Разбивка длинных функций
3.1. Определяем первое правило: почему пять строк?
3.1.1. Правило «Пять строк»
3.2. Шаблон проектирования для разбивки функций
3.2.1. Шаблон рефакторинга «Извлечение метода»
3.3. Разбивка функций для уравновешивания абстракций
3.3.1. Правило «Вызов или передача»
3.3.2. Применение правила
3.4. Свойства хорошего имени функции
3.5. Разбивка функций, делающих слишком много
3.5.1. Правило «If только в начале»
3.5.2. Применение правила
Резюме
Глава 4. Пусть код типов работает
4.1. Рефакторинг простой инструкции if
4.1.1. Правило «Никогда не использовать if с else»
4.1.2. Применение правила
4.1.3. Шаблон рефакторинга «Замена кода типов классами»
4.1.4. Перемещение кода в классы
4.1.5. Шаблон рефакторинга «Перемещение кода в классы»
4.1.6. Встраивание избыточного метода
4.1.7. Шаблон рефакторинга «Встраивание метода»
4.2. Рефакторинг большой инструкции if
4.2.1 Устранение обобщенности
4.2.2. Шаблон рефакторинга «Специализация метода»
4.2.3. Допускается только одна switch
4.2.4. Правило «Никогда не использовать switch»
4.2.5. Удаление if
4.3. Разбираемся с повторением кода
4.3.1 Разве нельзя было использовать вместо интерфейсов абстрактные классы?
4.3.2. Правило «Наследовать только от интерфейсов»
4.3.3. Зачем все это повторение кода?
4.4. Рефакторинг двух сложных выражений if
4.5. Удаление мертвого кода
4.5.1. Шаблон рефакторинга «Пробное удаление с последующей компиляцией»
Резюме
Глава 5. Совмещение схожего кода
5.1. Объединение схожих классов
5.1.1. Шаблон рефакторинга «Объединение схожих классов»
5.2. Объединение простых условий
5.2.1. Шаблон рефакторинга «Совмещение if»
5.3. Объединение сложных условий
5.3.1 Использование правил арифметики для условий
5.3.2. Правило «Использовать чистые условия»
5.3.3. Применение условной арифметики
5.4. Объединение кода среди классов
5.4.1. Введение диаграмм классов UML для отражения связи классов
5.4.2. Шаблон рефакторинга «Введение паттерна «Стратегия»»
5.4.3. Правило «Избегать интерфейсов с единственной реализацией»
5.4.4. Шаблон рефакторинга «Извлечение интерфейса из реализации»
5.5. Объединение похожих функций
5.6. Объединение схожего кода
Резюме
Глава 6. Защита данных
6.1. Инкапсуляция с помощью геттеров
6.1.1. Правило «Не использовать геттеры или сеттеры»
6.1.2. Применение правила
6.1.3. Шаблон рефакторинга «Удаление геттера или сеттера»
6.1.4. Удаление последнего геттера
6.2. Инкапсулирование простых данных
6.2.1. Правило «Всегда избегать общих аффиксов»
6.2.2. Применение правила
6.2.3. Паттерн рефакторинга «Инкапсулирование данных»
6.3. Инкапсулирование сложных данных
6.4. Устранение инварианта последовательности
6.4.1. Шаблон рефакторинга «Обеспечение последовательности»
6.5. Устранение перечислений иным способом
6.5.1. Перечисление с помощью закрытых конструкторов
6.5.2. Переотображение чисел в классы
Резюме
Часть II. Применение полученных знаний в реальной жизни
Глава 7. Сотрудничество с компилятором
7.1. Близкое знакомство с компилятором
7.1.1. Слабость: проблема останова имеет ограниченную информативность во время компиляции
7.1.2. Сильная сторона: достижимость гарантирует возвращение из методов
7.1.3. Сильная сторона: явное присваивание предотвращает обращение к неинициализированным переменным
7.1.4. Сильная сторона: контроль доступа помогает инкапсулировать данные
7.1.5. Сильная сторона: проверка типов подтверждает свойства
7.1.6. Слабость: разыменовывание null рушит приложение
7.1.7. Слабость: арифметические ошибки вызывают переполнение или сбои
7.1.8. Слабость: Ошибки выхода за допустимый диапазон вызывают сбой приложения
7.1.9. Слабость: бесконечные циклы стопорят приложение
7.1.10. Слабость: взаимные блокировки и состояния гонки вызывают нежелательное поведение
7.2. Использование компилятора
7.2.1. Подключаем компилятор к работе
7.2.2. Не перечьте компилятору
7.3. Доверие к компилятору
7.3.1. Учим компилятор инвариантам
7.3.2. Обращайте внимание на предупреждения
7.4. Исключительное доверие к компилятору
Резюме
Глава 8. Избегайте комментариев
8.1. Удаление устаревших комментариев
8.2. Удаление закомментированного кода
8.3. Удаление бессмысленных комментариев
8.4. Преобразование комментариев в имена методов
8.4.1. Использование комментариев для планирования
8.5. Сохранение комментариев к инвариантам
8.5.1. Инварианты в процессе
Резюме
Глава 9. Страсть к удалению кода
9.1. Удаление кода может стать очередной вехой
9.2. Удаление кода для устранения ненужной сложности
9.2.1. Техническое неведение ввиду неопытности
9.2.2. Технические потери из-за нехватки времени
9.2.3. Технический долг под давлением обстоятельств
9.2.4. Техническая задержка из-за роста
9.3. Категоризация кода по степени его близости
9.4. Удаление кода в старых унаследованных системах
9.4.1. Прояснение кода с помощью шаблона «фикус-удавка»
9.4.2. Использование «фикуса-душителя» для улучшения кода
9.5. Удаление кода из замороженного проекта
9.5.1. Получение желаемого результата по умолчанию
9.5.2. Минимизация затрат с помощью отрыва и стабилизации
9.6. Удаление веток в системе контроля версий
9.6.1. Минимизация затрат за счет ограничения количества веток
9.7. Удаление документации кода
9.7.1. Алгоритм для определения необходимости документирования
9.8. Удаление тестирующего кода
9.8.1. Удаление оптимистичных тестов
9.8.2. Удаление пессимистичных тестов
9.8.3. Исправление или удаление ненадежных тестов
9.8.4. Рефакторинг кода для избавления от плохих тестов
9.8.5. Специализация тестов для их ускорения
9.9. Удаление кода дополнительной конфигурации
9.9.1. Ограничение конфигурации настраиваемости во времени
9.10. Удаление кода для сокращения числа библиотек
9.10.1. Ограничение использования внешних библиотек
9.11. Удаление кода из работающего функционала
Резюме
Глава 10. Никогда не бойтесь добавлять код
10.1. Принятие неуверенности: встретить опасность лицом к лицу
10.2. Использование отрыва для преодоления страха создать что-то неправильно
10.3. Преодоление страха перед лишними затратами или риском установки фиксированного соотношения
10.4. Преодоление страха перед неудачей за счет постепенной разработки
10.5. Как копипаст влияет на скорость
10.6. Изменение путем добавления через расширяемость
10.7. Изменение путем добавления поддерживает обратную совместимость
10.8. Изменение путем добавления с помощью переключателей функционала
10.9. Изменение путем добавления с помощью ветвления через абстрагирование
Резюме
Глава 11. Соблюдение
структуры в коде
11.1. Категоризация структуры на основе области и источника
11.2. Три способа, которыми код отражает поведение
11.2.1. Выражение поведения в потоке управления
11.2.2. Выражение поведения в структуре данных
11.2.3. Выражение поведения в данных
11.3. Добавление кода для раскрытия структуры
11.4. Наблюдение вместо прогнозирования и использование эмпирических техник
11.5. Обеспечение безопасности без понимания кода
11.5.1. Обеспечение безопасности через тестирование
11.5.2. Обеспечение безопасности за счет мастерства
11.5.3. Обеспечение безопасности с помощью инструментов
11.5.4. Обеспечение безопасности через формальную верификацию
11.5.5. Обеспечение безопасности через толерантность к ошибкам
11.6. Определение неэксплуатируемых структур
11.6.1. Эксплуатация пустого пространства с помощью извлечения и инкапсуляции
11.6.2. Эксплуатация дублирования с помощью объединения
11.6.3. Эксплуатация общих аффиксов с помощью инкапсуляции
11.6.4. Эксплуатация типа среды выполнения с помощью динамической диспетчеризации
Резюме
Глава 12. Избегайте оптимизаций и обобщенности
12.1. Стремление к простоте
12.2. Когда и как вносить обобщенность
12.2.1. Создание минимальной функциональности
12.2.2. Объединение компонентов с похожим уровнем стабильности
12.2.3. Устранение ненужной обобщенности
12.3. Когда и как оптимизировать
12.3.1. Рефакторинг перед оптимизацией
12.3.2. Оптимизация согласно теории ограничений
12.3.3. Координирование оптимизации с помощью метрик
12.3.4. Выбор удачных алгоритмов и структур данных
12.3.5. Использование кэширования
12.3.6. Изоляция оптимизированного кода
Резюме
Глава 13. Пусть плохой код выглядит плохо
13.1. Проблемы привлечения внимания к плохому коду
13.2. Разделение на безупречный и legacy-код
13.2.1. Теория разбитого окна
13.3. Подходы к определению плохого кода
13.3.1. Правила в этой книге: простые и конкретные
13.3.2. Запахи кода: полноценные и абстрактные
13.3.3. Цикломатическая сложность: алгоритмическая (объективная)
13.3.4. Когнитивная сложность: алгоритмическая (субъективная)
13.4. Правила безопасного ухудшения кода
13.5. Методы безопасного ухудшения кода
13.5.1. Использование перечислений
13.5.2. Использование целых чисел и строк в качестве кода типов
13.5.3. Добавление в код магических чисел
13.5.4. Добавление в код комментариев
13.5.5. Добавление в код пробелов
13.5.6. Группировка элементов на основе имен
13.5.7. Добавление контекста в имена
13.5.8. Создание длинных методов
13.5.9. Добавление в методы большого числа параметров
13.5.10. Использование геттеров и сеттеров
Резюме
Глава 14. Подведение итогов
14.1. Краткий обзор пройденного
14.1.1. Введение: мотивация
14.1.2. Часть I: конкретизирование
14.1.3. Часть II: расширение горизонтов
14.2. Раскрытие внутренней философии
14.2.1. Поиск все меньших шагов
14.2.2. Поиск внутренней структуры
14.2.3. Использование правил для совместной работы
14.2.4. Интересы команды важнее личных интересов
14.2.5. Простота важнее универсальности
14.2.6. Использование объектов или функций высшего порядка
14.3. Куда двигаться дальше
14.3.1. Микроархитектура
14.3.2. Макро-архитектура
14.3.3. Качество программного обеспечения
Резюме
Приложение. Установка инструментов для части I
Node.js
TypeScript
Visual Studio Code
Git
Настройка проекта TypeScript
Создание проекта TypeScript
Как настроить уровень