Читать книгу Полезные конспекты книг и авторские заметки по информационным технологиям. Без формул - - Страница 5

В разделе приведены цитаты из [3].

Единственный способ выдержать график – постоянно поддерживать чистоту в коде.

Поэтому нужно развивать «чувство кода».

Чистый код:

– элегантный и эффективный;

– логика прямолинейна;

– зависимости – минимальные;

– обработка ошибок – полная;

– производительность – близкая к оптимальной;

– решает одну задачу;

– поддерживается в чистоте с течением времени.

Следующая книга – «Agile software development; Principles, patterns, and practices», 2002.

Содержательные имена:

– имена всех объектов должны отвечать на все главные вопросы: почему существует, что делает и как используется, не требуют дополнительных комментариев, содержательные, передают намерения программиста;

– код очевиден, контекст следует из самого кода;

– не содержат ложных ассоциаций, затемняющих смысл кода;

– не используются слова со скрытыми значениями, отличными от предполагаемого;

– лучше обойтись без кодирования типа контейнера в имени.

Имена не содержат малозаметных различий, непохожи друг на друга излишне.

Имена не дезинформируют.

0 не равен O, 1 не равна l.

Используется правильный шрифт.

Используются осмысленные различия.

Имена не дублируют зарезервированные слова с незначительными изменениями.

Если имена различаются, они должны обозначать разные понятия.

Различия имен содержательны.

Префиксы используются, если создают осмысленные различия.

Не содержат неинформативных, избыточных слов.

Имена не отличаются только суффиксами.

Читателю кода понятен смысл различающихся имен – нет соблазна использовать 2 похожих имени по одному назначению.

Имена удобопроизносимы.

Программирование – социальная деятельность.

Не должны состоять из одних сокращений.

Состоят преимущественно из слов разговорной речи.

Удобны для поиска.

Легко находимы в большом объеме кода.

Относительно редкие.

Длинные имена лучше коротких.

Однобуквенные используются только для локальных переменных в коротких методах.

Длина имени соответствует размеру его области видимости.

Имя не содержит информации о типе или области видимости.

Не создает хлопот при расшифровке.

Неразумно заставлять каждого нового работника изучать очередной «язык» кодирования.

Имя остается понятным даже в случае опечатки.

Имя не усложняет изменение типа переменной.

Типы в именах не кодируются.

Переменные классов без префиксов.

Классы и функции компактны – можно обойтись без префиксов.

Имя не содержит балласта.

Имена интерфейсов без префиксов.

Имена не содержат лишней информации.

Не заставляют мысленно преобразовывать имена в другие.

Используются имена из пространств задачи и решения.

Счетчик цикла с малой областью видимости можно назвать 1 буквой – это традиция.

Ясность превыше всего.

Код понятен для других людей.

Имена классов и объектов – существительные и их комбинации без глаголов, не содержат обобщенных понятий – Manager, Processor, Data, Info.

Имена методов – глаголы или глагольные словосочетания.

Методы чтения или записи и предикаты образуются из значения и префикса get, set и is.

При перегрузке конструкторов использовать статические методы-фабрики с именами, описывающими аргументы (принудительное инспользование таких методов).

Нет остроумных шуток.

Ясность предпочтительнее развлекательной ценности.

Нет просторечий и сленга.

Нет шуток.

Одно слово для каждой концепции.

Имена функций законченные и логичные.

Нет эквивалентных методов с именами fetch, retrieve, get в разных классах.

Нет controller, manager, driver в одной кодовой базе.

Имена различны принципиально.

Единый согласованный лексикон.

Не используется одно слово в двух смыслах.

Две разные идеи не обозначены одним термином.

Нет каламбура.

Мысли в коде выражаются доступно.

Используются имена из пространства решения: термины из области информатики, названия алгоритмов, паттернов, математические термины, технические имена.

Используются имена из пространства задачи (клиентские): если нет подходящего программиста, узнаются у специалиста в предметной области.

Разделение концепций из пространств задачи и решения.

Несодержательные сами по себе имена помещаются в определенный контекст для читателя кода – классы, функции и пространства имен с правильно выбранными названиями.

В крайнем случае контекст уточняется префиксом.

Контекст не должен вычисляться.

Функции разделяются на меньшие смысловые фрагменты.

Нет избыточности контекста.

Нет работы против собственного инструментария.

Короткие имена лучше длинных, если только их смысл понятен читателю кода.

Имена экземпляров более точные.

Развивать описательные навыки и единый культурный фон.

Не должно быть опасения возражений при переименовании.

Функции:

Первый уровень структуризации.

Длина не избыточна.

Не содержит повторяющихся фрагментов кода.

Один уровень абстракции.

Функции компактны.

Функции еще компактнее.

Функции желательно не более 20 строк.

Все функции предельно очевидны.

Блоки в командах if, else, while и так далее должны состоять из 1 строки, в которой обычно – вызов функции.

Функции не содержат вложенных структур.

Не более 1—2 отступов.

Функция должна выполнять только одну операцию. Она должна выполнять ее хорошо. И ничего другого она делать не должна.

Если функция выполняет только те действия, которые находятся на одом уровне под объявленным именем функции, то эта функция выполняет одну операцию.

Функции пишутся прежде всего для разложения более крупной концепции (иначе говоря, имени функции) на последовательность действий в следующем уровне абстракции.

Чтобы определить, что функция выполняет более 1 операции, надо попробовать извлечь из нее другую функцию, которая бы не являлась простой переформулировкой реализации.

Функцию, выполняющую только одну операцию, невозможно осмысленно разделить на секции.

Все команды функции находятся на одном уровне абстракции.

За каждой функцией должны следовать функции следующего уровня абстракции.

Switch, длинные цепочки if-else скрывать в низкоуровневом классе и не дублировать в коде (использовать полиморфизм).

Принцип единой ответственности (single responsibility principle).

Принцип открытости-закрытости (open-closed principle).

Программа не содержит неограниченного количества других функций с аналогичной структурой (можно использовать абстрактную фабрику).

Имя точно описывает, что делает функция.

Длинное имя функции лучше короткого невразумительного.

Не бойтесь расходовать время на выбор имени функции.

В именах функций использовать те же словосочетания, глаголы и существительные, что и в модулях.

В идеальном случае количество аргументов функции равно нулю.

Использовать функции 1 аргумента:

– для проверки некоторого условия, связанного с аргументом;

– для обработки аргумента, его преобразования и возвращения;

– для события (вход есть, выхода нет);

– должно быть предельно ясно, что перед читателем событие;

– остальных форм функций с 1 аргументом лучше избегать;

– не использовать аргументы-флаги.

Бинарные функции оправданны, если оба аргумента – упорядоченные компоненты одного значения.

Использовать все доступные способы для сведения функций к унарной форме.

Аргументы должны иметь естественную связь и естественный порядок.

Хорошо подумать перед созданием тернарной функции.

Упаковывать аргументы в объекты.

Если переменное количество равноправных аргументов – упаковать в List.

Хорошее имя функции способно объяснить смысл функции, порядок и смысл ее аргументов.

В унарных функциях функция и аргумент должны образовывать естественную пару «глагол – существительное».

Функция не делает чего-то скрытно от пользователя.

Нет побочных временных привязок функции.

Нет побочных эффектов.

Нет причин лишний раз обращаться к сигнатуре функции (нет повторных заходов).

Выходных аргументов следует избегать.

Функция может изменять состояние только владельца.

Функция либо что-то делает (команда), либо отвечает на какой-либо вопрос (запрос).

Функция либо изменяет состояние объекта, либо возвращает информацию об этом объекте.

Исключена неоднозначность имен функций.

Функции-команды не возвращают коды ошибок.

Вместо возвращения кодов ошибок используются исключения.

Тела блоков try/catch выделены в отдельные функции.

Функции выполняют 1 операцию.

Обработка ошибок – одна операция.

Нет магнитов зависимостей – классов или перечислений, импортируемых и используемых многими другими классами.

Нет дублирования алгоритмов.

Уменьшена вероятность ошибки.

Goto не используется.

Много return, break, continue допускается в компантных функциях.

В коде сначала излагаются мысли, а затем «причесываются».

Система рассматривается как история, которую нужно рассказать.

Комментарии – неизбежное зло.

Только код может правдиво сообщить, что он делает.

Свести использование комментариев к минимуму.

Комментирование – причина повысить качество кода.

Вместо юридических комментариев – ссылки на них.

Информацию лучше передавать в имени функции.

Использовать комментарии для информации о намерении.

Комментарии – в случае неудобочитаемых форм данных.

Комментарии для предупреждения о последствиях.

Комментарии TODO на будущее.

Комментарии для подчеркивания важности обстоятельства.

Не делать комментарии на скорую руку.

Комментирий не приводит к поиску расшифровки в других модулях.

Использовать аналог Javadoc.

Не комментировать бормотанием.

Не комментировать избыточно.

Комментарии точнее кода.

Комментарии точные и соответствуют коду.

Комментарий не вводит в заблуждение и не дезинформирует.

Бессмысленные или обязательные комментарии исключены.

Комментарий не повышает риск обмана и недоразумений.

Длинные журналы комментариев исключены.

Комментарии не загромождают и не усложняют код.

Комментарии-шумы исключены.

Комментарии не утверждают очевидное, не предоставляя новой информации.

Комментарии не бесполезны.

Комментарии не вызывают желания игнорировать их.

Комментарии не содержат эмоций.

Комментарии делают работу приятной и эффективной.

Комментарии не используются там, где можно использовать функцию или переменную.

Заголовки в комментариях применяются, когда приносят ощутимую пользу.

Закрывающие скобки не комментируются.

Ссылки на авторов в комментариях заменяются использованием системы контроля версий.

Нет закомментированного кода.

Нет HTML-комментариев.

Комментарии описывают код, к которому отнесены.

Комментарии не содержат дискуссий, исторических подробностей, не относящихся к делу.

Связь между комментарием и его кодом очевидна.

Цель комментария – объяснить код, который не объясняет сам себя.

Комментарий не нуждается в объяснении.

Комментарии для API общего пользования не помещаются в коде, не предназначенном для общего потребления.

Комментарий упрощает понимание алгоритма пользователем.

Код должен быть хорошо отформатирован.

Форматирование облегчает передачу информации.

Маленькие файлы понятнее больших.

Типичная длина файла 200 строк, предел – 500.

Исходный файл выглядит как статья.

Имя файла простое, но содержательное.

Имени файла достаточно, чтобы определить. этот модуль нужен или нет.

Начальные блоки файла описывают высокоуровневые концепции и алгоритмы.

Степень детализации увеличивается к концу файла.

В конце файла собираются все функции и подробности низшего уровня.

Код читается слева направо и сверху вниз.

Законченные мысли отделяются пустыми строками.

Строки кода с тесной связью должны быть сжаты по вертикали.

Тесно связанные концепции не находятся в разных файлах.

Следует избегать запущенных переменных.

Читателю не нужно прыгать туда-сюда по исходным файлам и классам.

Переменные объявляются максимально близко к месту использования.

Переменные перечисляются в начале каждой функции.

Управляющие переменные циклов объявляются внутри конструкции циrла.

Переменные экземпляров объявляются в начале класса.

Если одна функция вызывает другую, то они располагаются вблизи друг друга по вертикали.

Вызывающая функция располагается над вызываемой.

Концептуально родственные фрагменты кода располагаются близко друг к другу по вертикали.

Важные концепции излагаются сначала с минимальным количеством второстепенных деталей.

Строки делать по возможности короткими.

Пробелы для визуального обозначения приоритета операторов.

Длинные списки – причина для разделения на классы.

Горизонтальное выравнивание не применяется.

Отступы выделяют области видимости.

Не применяются вырожденные области видимости.

Группа разработчиков согласует единый стиль форматирования.

Код продукта оформлен в едином стиле.

Внешний пользователь не в курсе деталей реализации.

Методы интерфейса устанавливают политику доступа к данным.

Классами предоставлены абстрактные интерфейсы, посредством которых пользователь оперирует с сущностью данных.

Пользователь не имеет представления о фактическом формате данных.

Объекты скрывают свои данные за абстракциями и предоставвляют функции, работающие с этими данными.

Структуры данных раскрывают свои данные и не имеют осмысленных функций.

Процедурный код (код, использующий структуры данных) позволяет легко добавлять новые функции без изменения существующих структур данных.

ООП-код упрощает добавление новых классов без изменения существующих функций.

Процедурный код усложняет добавление новых структур данных, так как требуется изменение всех функций.

ООП-код усложняет добавление новых функций, так как требуется изменение всех классов.

Данные необязательно представляются в виде объектов.

Закон Деметры – модуль не должен знать внутреннее устройство объектов, с которыми работает.

Метод f класса С должен ограничиваться вызовом методов следующих объектов: С; объекты, созданные f; объекты, переданные f в качестве аргумента; объекты, хранящиеся в переменной экземпляра С.

Метод не должен вызывать методы объектов, возвращаемых любыми из разрешенных функций.

Не использовать цепочки вызовов (разделять).

Не используются гибриды объектов и структур данных.

Разные уровни детализации не смешиваются.

Объекты передачи данных – Data transfer object – классы с открытыми переменными без функций используются для преобразования низкоуровневых данных, получаемых из базы, в объекты кода приложения.

Bean – компоненты из приватных переменных, операции с которыми осуществляются при помощи методов чтения и записи, преимуществ не имеют.

Активные записи – active records – структуры данных с открытыми переменными, а также с навигационными методами – это структуры данных и бизнес-логику не содержат.

Обработка ошибок не заслоняет логику программы.

Ошибки обрабатываются стильно и элегантно.

Используются исключения вместо кодов ошибок.

Начинать с написания команды try-catch-finally для кода, способного вызывать исключение.

Тип исключения сужается до реально инициируемого.

Блоки try должны напоминать транзакции.

Использовать непроверямые исключения.

С исключениями передавать содержательные сообщения об ошибках.

Из сведений об исключении должно быть понятно, с какой целью выполнялась операция.

Классы исключений определены в контексте потребностей вызывающей стороны.

Инкапсулированы вызовы сторонних API.

Для обработки особых случаев использовать паттерн особый случай.

Вместо null выдается исключение или особый случай.

Для API, возвращающего null, – делать обертки.

Не возвращать null из методов.

Не передавать null при вызове методов.

Запрещать передачу null по умолчанию.

Чистый код должен быть надежным.

Вместо приведения типа контейнера лучше использовать параметризованные контейнеры.

Ограничить передачу граничных интерфейсов по платформе (можно инкапсулировать).

Для стороннего кода писать тесты.

Сторонний код тестировать в рамках понимания его работы.

Конструкторы по умолчанию должны иметь конфигурацию.

Писать учебные тесты, граничные тесты.

Можно заранее определять интерфейсы, затем писать паттерн-адаптер к готовым.

Для граничного кода необходимо четкое разделение сторон и тесты, определяющие ожидания пользователя.

Количество обращений к границам стороннего кода сводится к минимуму.

Законы TDD:

– не пишите код продукта, пока не напишете отказной модульный тест;

– не пишите модульный тест в объеме большем, чем необходимо для отказа (невозможность компиляции является отказом);

– не пишите код продукта в объеме большем, чем необходимо для прохождения текущего отказного теста.

Тесты не уступают в качестве коду продукта.

Тесты развиваются вместе с продуктом.

Модульные тесты обеспечивают гибкость, удобство сопровождения и возможность повторного использования кода.

Без тестов любое изменение становится потенциальной ошибкой.

Некачественные тесты приводят к некачественному коду продукта.

Чистый тест характеризуется удобочитаемостью: ясностью, простотой и выразительностью.

В тестах использовать паттерн «построение – операции – проверка».

Тесты не делают ничего лишнего, в них используются только действительно необходимые типы и функции.

Использовать наборы функций и служебных программ, использующих API.

Код тестов не такой эффективный, как код продукта.

Чтобы избежать дублирования, можно воспользоваться паттерном шаблонный метод.

Не более 1 assert в функции теста.

Одна концепция в тесте (1 тест – 1 проверка).

Характеристики чистых тестов:

– тесты должны выполняться быстро;

– тесты не зависят друг от друга;

– тесты дают повторяемые результаты в любой среде.

Результатом выполнения теста должен быть логический признак (результат очевиден).

Тесты создаются своевременно непосредственно перед кодом продукта.

Класс должен начинаться со списка переменных.

Сначала перечисляются открытые статические константы.

Далее следуют приватные статические переменные.

За ними идут приватные переменные экземпляров.

Затем открытые функции.

Приватные вспомогательные функции, вызываемые открытыми функциями, непосредственно за самой открытой функцией (газетная статья).

Открытые переменные обычно не используют.

Предпочтительно объявлять переменные и вспомогательные функции приватными.

Иногда переменную или вспомогательную функцию приходится объявлять защищенной, чтобы иметь возможность обратиться к ней из класса.

Ослабление инкапсуляции должно быть последней мерой.

Классы должны быть максимально компактными.

Компактность класса определяется его ответственностью.

По имени класса можно определить его размер.

Краткое описание класса должно укладываться в 25 слов, без выражений «если», «и», «или», «но».

Принцип единой ответственности: SRP – класс или модуль должен иметь одну и только одну причину для изменения (одну ответственность).

Система должна состоять из множества мелких классов со сформированной структурой.

Класс взаимодействует с другими классами для реализации желаемого поведения системы.

Классы должны иметь небольшое количество переменных экземпляров.

Чем с большим числом переменных работает метод, тем выше связность этого метода со своим классом. Создавать классы с высокой связностью не рекомендуется.

Высокая связность означает, что методы и переменные класса взаимозависимы.

Рост числа переменных экземпляров свидетельствует о необходимости выделения класса.

Рефакторинг может удлинить программу.

Приватные методы, действие которых распространяется на небольшое подмножество класса, – признак возможности усовершенствований.

Структурирование проводится с учетом изменений.

Время, необходимое для понимания класса, падает почти до нуля.

Вероятность того, что одна из функций нарушит работу другой, ничтожно мала.

Принцип открытости-закрытости: классы должны быть открыты для расширений, но закрыты для модификации.

Структура системы должна быть такой, чтобы обновление системы создавало как можно меньше проблем.

В идеале новая функциональность должна реализовываться расширением системы, а не внесением изменений в существующий код.

С помощью интерфейсов и абстрактных классов класс изолируется от конкретных подробностей.

Принцип обращения зависимостей: классы системы должны зависеть от абстракций, а не от конкретных подробностей.

В программных системах фаза инициализации, в которой конструируются объекты приложения и «склеиваются» основные зависимости, должна отделяться от логики времени выполнения, получающей управление после ее завершения.

Инициализация – область ответственности.

Код инициализации пишется системно и отделен от логики времени выполнения.

Удобные идиомы не ведут к нарушению модульности.

Приложение ничего не знает о main или о процессе конструирования.

Все аспекты конструирования помещаются в main или в модули, вызываемые из main.

Если момент создания объекта должен определяться приложением, то использовать паттерн «Фабрика».

Вся информация о конструировании хранится на стороне main.

Приложение изолировано от подробностей построения.

Использовать внедрение зависимостей Dependency Injection или обращение контроля Inversion of Control для отделения конструирования от использования.

Итеративная разработка – сегодня реализуем текущие потребности, а завтра перерабатываем и расширяем систему для реализации новых потребностей.

Архитектура программных систем может развиваться последовательно, если обеспечить правильное разделение ответственности.

Компонент-сущность (entity bean) – представление реляционных данных в памяти.

Применять АОП – модульные конструкции, называемые аспектами, определяют, в каких точках системы поведение должно меняться некоторым последовательным образом в соответствии с потребностями определенной области ответственности (изменения вносит инфраструктура без необходимости вмешательства в целевой код).

Посредники (proxies) хорошо подходят для простых ситуаций – вызова методов отдельных объектов или классов.

Использовать POJO-объекты.

DAO – Data accessor object – объект доступа к данным.

Использовать aspectJ.

Не полагаться на BDUF.

На каждом уровне абстракции архитектура должна оставаться простой и обладать минимальными привязками.

Хороший API должен исчезать из вида большую часть времени.

Один человек не может принять все необходимые решения.

Принятие решений лучше всего откладывать до последнего момента.

Стандарты применяются разумно, когда они приносят очевидную пользу.

Главная задача – реализовать интересы клиента.

Использовать DSL (их код читается как структурированная форма текста, написанного экспертом в данной предметной области).

Используйте самое простое решение из всех возможных.

Четыре правила простой архитектуры:

– архитектура обеспечивает прохождение всех тестов;

– не содержит дублирующегося кода;

– выражает намерения программиста;

– использует минимальное количество классов и методов.

Система должна делать то, что задумано ее проектировщиком.

Существует простой способ убедиться в том, что система действительно решает свои задачи.

Система, тщательно протестированная и прошедшая все тесты, контролируема.

Обеспечение полной контролируемости системы повышает качество проектирования.

Для системы необходимо написать тесты и постоянно выполнять их.

Рефакторинг – последовательная переработка кода.

Рефакторинг проводится при наличии полного набора тестов.

В системе не дублируется реализация.

Применять повторное использованием даже в мелочах.

Дублирование – главный враг системы.

Код системы возможно понять без глубокого понимания решаемой проблемы.

Постараться сделать код выразительным.

Неравнодушие – драгоценный ресурс.

Использовать прагматичный подход взамен бессмысленного догматизма.

Применять нагрузочное тестирование.

Многопоточность – стратегия устранения привязок.

Многопоточность – аналогия работы нескольких компьютеров.

Многопоточность повышает быстродействие не всегда.

Многопоточность может изменить архитектуру.

При многопоточности нужно предусмотреть проблемы многопоточной взаимной блокировки, одновременное обновление.

Многопоточность требует больше производительности и кода.

Правильная реализация многопоточности сложна.

Ошибки в многопоточности обычно не воспроизводятся.

Многопоточность обычно требует фундаментальных изменений в стратегии проектирования.

Предусмотреть перебивание потоками друг друга (требуется знание обработки байт-кода и атомарных операций модели памяти).

Многопоточные архитектуры должны отделяться от основного кода.

Код реализации многопоточности имеет собственный цикл разработки, модификации и настройки.

При написании кода многопоточности возникают специфические сложности.

Предусмотреть обработку обращений к общему объекту.

Инкапсулировать данные: жестко ограничить доступ и область видимости общих данных.

Вместо использования общего объекта каждому потоку можно предоставить копию.

Использовать синхронизацию.

Потоки должны быть как можно более независимы.

Постараться разбить данные на независимые подмножества, с которыми могут работать независимые потоки (возможно, на разных процессорах).

Использовать потоково-безопасные коллекции.

Использовать неблокирующие решения.

Изучать доступные классы на предмет потоково-безопасности.

Модели логического разбиения поведения программы при многопоточности:

– производители-потребители: потоки-производители создают задания и помещают в буфер или очередь. Потоки-потребители извлекают задания из очереди и выполняют их. Производители перед записью дожидаются появления свободного места в очереди, а потребители дожидаются появления заданий в очереди. Производитель записывает задание и сигнализирует о том, что очередь непуста. Потребитель читает задание и сигнализирует о том, что очередь не заполнена. Обе стороны готовы ждать оповещения о возможности продолжения работы;

– модель читатели-писатели: писатели пишут в общий ресурс, который считывают читатели. Писатель может блокировать читателей. Нужно найти баланс между потребностями читателей и писателей, чтобы обеспечить правильный режим работы, нормальную производительность и избежать зависания;

– модель обедающих философов: за круглым столом сидят философы-потоки и думают, в центре – тарелка еды. Каждому философу для еды доступно 2 вилки-ресурсы – по 1 от соседей. Когда философ проголодается – берет вилки, поел – кладет обратно. Сложности проектирования – взаимные блокировки, обратные блокировки, падение производительности и эффективность работы.

Изучать базовые алгоритмы, разбираться в решениях.

Избегать использования нескольких методов одного совместно используемого объекта.

Избегать зависимостей между синхронизированными методами.

Или использовать 3 стандартных решения:

– блокировка на стороне клиента;

– блокировка на стороне сервера;

– адаптирующий сервер.

Код не должен перегружаться лишними синхронизированными объектами, так как блокировки создают задержки и увеличивают затраты ресурсов.

Синхронизированные секции должны иметь минимальные размеры.

Корректное завершение не может быть бесконечным ожиданием потока.

Реализовать логическую изоляцию конфигураций многопоточного кода.

Протестировать программу с количеством потоков, превышающим число процессоров.

Применять инструментовку кода для повышения вероятности сбоев.

Сначала отлаживать основной код.

Не игнорировать системные ошибки, считая их случайными разовыми сбоями.

Убедиться, что сам код работает вне многопоточного контекста, созданием POJO-объектов, вызываемых из потоков.

Реализовать многопоточный код так, чтобы он мог выполняться в различных конфигурациях: с разным числом потоков, тестовых заменителей, времени работы тестов, количеством повторов тестов.

Найти средства измерения производительсноти системы в разных конфигурациях.

Реализовать систему так, чтобы количество программных потоков могло легко изменяться, в том числе во время работы системы, в том числе с автоматическим регулированием количества потоков.

JVM не гарантирует вытесняющей многопоточности.

Протестировать систему во всех средах, которые могут использоваться для ее развертывания, начиная с ранней стадии.

Заставить поток исполняться по разным путям в тесте методами object. wait (), object.sleep (), object. yield (), object.priority () – инструментовка кода.

Автоматическая инструментовка с использованием Aspect-Oriented Framework, CGLIB, ASM, ConTest.

Суть тестирования – сломать предсказуемость пути выполнения.

Использовать стратегию случайного выбора пути выполнения для выявления ошибок.

Типичные источники многопоточных ошибок: работа с общими данными из нескольких потоков, использование пула общих ресурсов.

Использовать длительное тестирование многопоточного кода перед включением в систему.

Программирование ближе к ремеслу, чем к науке.

Спасать положение нужно именно сейчас.

Во время переработки кода не добавлять в программу новые возможности.

Предусмотреть, в каких местах будет появляться новый код.

Множество разных типов со сходными методами – причина выделить класс.

TDD: не вносить в систему изменения, нарушающие работоспособность системы.

Добавление теста или класса ничего не нарушит.

Удалять бесполезные функциии.

Тесты всегда должны хотя бы запускаться.

Прочитать последовательное очищение.

Переработка кода напоминает кубик Рубика.

Важный аспект хорошей архитектуры – логическое разбиение кода.

Плохой код тянет группу ко дну.

Открытый код требует смелости и доброй воли.