Критерии хорошего кода в программировании. Правила программирования на PHP (14 правил) Правила программирования

15 правил написания качественного кода

Есть мириады способов написать плохой код. К счастью, чтобы подняться до уровня качественного кода, достаточно следовать 15 правилам. Их соблюдение не сделает из вас мастера, но позволит убедительно имитировать его.

Правило 1. Следуйте стандартам оформления кода.

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

Например, в этом куске кода в соответствии со стандартом есть 12 ошибок:

For(i=0 ;i

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

Многие организации подстраивают стандарты под свои специфические нужды. Например, Google разработал стандарты для более чем 12 языков программирования. Они хорошо продуманы, так что изучите их , если вам нужна помощь в программировании под Google. Стандарты даже включают в себя настройки редактора, которые помогут вам соблюдать стиль, и специальные инструменты, верифицирующие ваш код на соответствию этому стилю. Используйте их.

Правило 2. Давайте наглядные имена.

Ограниченные медленными, неуклюжими телетайпами, программисты в древности использовали контракты для имён переменных и процедур, чтобы сэкономить время, стуки по клавишам, чернила и бумагу. Эта культура присутствует в некоторых сообществах ради сохранения обратной совместимости. Возьмите, например, ломающую язык функцию C wcscspn (wide character string complement span). Но такой подход неприменим в современном коде.

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

Гораздо важнее, чтобы вы долго и хорошо думали перед тем, как что-то назвать. Является ли имя точным? Имели ли вы в виду highestPrice или bestPrice? Достаточно ли специфично имя, дабы избежать его использования в других контекстах для схожих по смыслу объектов? Не лучше ли назвать метод getBestPrice заместо getBest? Подходит ли оно лучше других схожих имён? Если у вас есть метод ReadEventLog, вам не стоит называть другой NetErrorLogRead. Если вы называете функцию, описывает ли её название возвращаемое значение?

В заключение, несколько простых правил именования. Имена классов и типов должны быть существительными. Название метода должно содержать глагол. Если метод определяет, является ли какая-то информация об объекте истинной или ложной, его имя должно начинаться с «is». Методы, которые возвращают свойства объектов, должны начинаться с «get», а устанавливающие значения свойств - «set».

Правило 3. Комментируйте и документируйте.

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

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

Правило 4. Не повторяйтесь.

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

• Создание справочников API из комментариев, используя Javadoc и Doxygen.
• Автоматическая генерация Unit-тестов на основе аннотаций или соглашений об именовании.
• Генерация PDF и HTML из одного размеченного источника.
• Получение структуры классов из базы данных (или наоборот).

Правило 5. Проверяйте на ошибки и реагируйте на них.

Методы могут возвращать признаки ошибки или генерировать исключения. Обрабатывайте их. Не полагайтесь на то, что диск никогда не заполнится, ваш конфигурационный файл всегда будет на месте, ваше приложение будет запущено со всеми нужными правами, запросы на выделение памяти всегда будут успешно исполнены, или что соединение никогда не оборвётся. Да, хорошую обработку ошибок тяжело написать, и она делает код длиннее и труднее для чтения. Но игнорирование ошибок просто заметает проблему под ковёр, где ничего не подозревающий пользователь однажды её обнаружит.

Правило 6. Разделяйте код на короткие, обособленные части.

Каждый метод, функция или блок кода должн умещаться в обычном экранном окне (25-50 строк). Если получилось длиннее, разделите на более короткие куски. Даже внутри метода разделяйте длинный код на блоки, суть которых вы можете описать в комментарии в начале каждого блока.

Более того, каждый класс, модуль, файл или процесс должен выполнять определённый род задач. Если часть кода выполняет совершенно разнородные задачи, то разделите его соответственно.

Правило 7. Используйте API фреймворков и сторонние библиотеки.

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

Правило 8. Не переусердствуйте с проектированием.

Проектируйте только то, что актуально сейчас. Ваш код можно делать довольно обобщённым, чтобы он поддерживал дальнейшее развитие, но только в том случае, если он не становится от этого слишком сложным. Не создавайте параметризованные классы, фабрики, глубокие иерархии и скрытые интерфейсы для решения проблем, которых даже не существует - вы не можете угадать, что случится завтра. С другой стороны, когда структура кода не подходит под задачу, не стесняйтесь рефакторить его.

Правило 9. Будьте последовательны.

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

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

Правило 10. Избегайте проблем с безопасностью.

Современный код редко работает изолированно. У него есть неизбежный риск стать мишенью атак. Они необязательно должны приходить из интернета; атака может происходить через входные данные вашего приложения. В зависимости от вашего языка программирования и предметной области, вам возможно стоит побеспокоиться о переполнении буфера, кросс-сайтовых сценариях, SQL-инъекциях и прочих подобных проблемах. Изучите эти проблемы, и избегайте их в коде. Это не сложно.

Правило 11. Используйте эффективные структуры данных и алгоритмы.

Простой код часто легче сопровождать, чем такой же, но изменённый ради эффективности. К счастью, вы можете совмещать сопровождаемость и эффективность, используя структуры данных и алгоритмы, которые даёт ваш фреймворк. Используйте map, set, vector и алгоритмы, которые работают с ними. Благодаря этому ваш код станет чище, быстрее, более масштабируемым и более экономным с памятью. Например, если вы сохраните тысячу значений в отсортированном множестве, то операция пересечения найдёт общие элементы с другим множеством за такое же число операций, а не за миллион сравнений.

Правило 12. Используйте Unit-тесты.

Сложность современного ПО делает его установку дороже, а тестирование труднее. Продуктивным подходом будет сопровождение каждого куска кода тестами, которые проверяют корректность его работы. Этот подход упрощает отладку, т.к. он позволяет обнаружить ошибки раньше. Unit-тестирование необходимо, когда вы программируете на языках с динамической типизацией, как Python и JavaScript, потому что они отлавливают любые ошибки только на этапе исполнения, в то время как языки со статической типизацией наподобие Java, C# и C++ могут поймать часть из них во время компиляции. Unit-тестирование также позволяет рефакторить код уверенно. Вы можете использовать XUnit для упрощения написания тестов и автоматизации их запуска.

Правило 13. Сохраняйте код портируемым.

Если у вас нет особой причины, не используйте функциональность, доступную только на определённой платформе. Не полагайтесь на то, что определённые типы данных (как integer, указатели и временные метки) будут иметь конкретную длину (например, 32 бита), потому что этот параметр отличается на разных платформах. Храните сообщения программы отдельно от кода и на зашивайте параметры, соответствующие определённой культуре (например, разделители дробной и целой части или формат даты). Соглашения нужны для того, чтобы код мог запускаться в разных странах, так что сделайте локализацию настолько безболезненной, насколько это возможно.

Правило 14. Делайте свой код собираемым.

Простая команда должна собирать ваш код в форму, готовую к распространению. Команда должна позволять вам быстро выполнять сборку и запускать необходимые тесты. Для достижения этой цели используйте средства автоматической сборки наподобие Make , Apache Maven , или Ant . В идеале, вы должны установить интеграционную систему, которая будет проверять, собирать и тестировать ваш код при любом изменении.

Правило 15. Размещайте всё в системе контроля версий.

Все ваши элементы - код, документация, исходники инструментов, сборочные скрипты, тестовые данные - должны быть в системе контроля версий. Git и GitHub делают эту задачу дешёвой и беспроблемной. Но вам также доступны и многие другие мощные инструменты и сервисы. Вы должны быть способны собрать и протестировать вашу программу на сконфигурированной системе, просто скачав её с репозитория.

Заключение.

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

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

Я раньше работал доцентом в институте (впрочем до преподавания был админом, разбирался с 1С, поработал немного во франче но зарабатывал не много). После 5 лет преподавания сейчас уже 6 лет профессиональный 1Сник. Спустя шесть лет данной публикацией навеяло кое-что добавить.

Видел я разных студентов и учителей, программистов и начальников. Сам я постигал азы программирования с детства на коленке, курсов не кончал, а преподавал так - компилировал учебники и статьи из интернета, смотрел, показывал и делал видеокурсы, практическими заданиями правда все больше готовыми пользовался. По роду деятельности программистом после института и в возрасте уже нет особой возможности много учиться, так что я - программист из окопа, занимался по началу все больше оперативной деятельностью, много был на поддержке пользователей в чем не особо пригодилось чему учили и чему учил, так как на первом месте даже не качество а объем и скорость разработки, ну и соответственно умение в 100 процентов случаев достигать положительного результата. Даже если в текучке ошибся - пользователь напишет или сам позвонит и покажет, все такое в рабочем режиме без проблем устраняется. Очень полезная штука в организации труда на поддержке Битрикс, документооборот с заявками на ИТ. Вот если неправильно разработать метождику проекта или не до конца продумать, вот тут уж проблема может быть гораздо серьезнее.

Как-то вышло маститые сертификаты с меня не спрашивали, но первый руководитель отдела 1Сник был у меня Разработчик с большой буквы, который отличался глубоким знанием предметной области и умением делать абсолютно всё необходимое в работе, даже по админской части, все его очень уважали. Не было ни одного вопроса, который он не мог бы решить на предприятии.

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

В проектной деятельности больше всего помогает знание основ моделирования IDEF и чтение SAP ARIS (но рисовать схемы ARIS трудоемко). Всяко и прежде всего надо обязательно начинать проекты с продуманного ТЗ потому что без него понимание и общение с заказчиком проекта очень непросто складывается.

А программирование, что уж тут, 7 операторов да объектная модель... Оно и к месту, что статья такая коротенькая. Больше всего оказалось нужно для использования меня по назначению как 1Сника - выучить используемые на предприятии конфигурации, научиться помогать сотрудникам, помогать бухгалтерам, разбираться в коде, искать ошибки в учете... Ну и конечно на производстве в области программирования даже в оперативной деятельности, особенно как правило систем несколько (учетные, складские, транспортные,...), сложные задачи.

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

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

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

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

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

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

Имя каждого компонента должно начинаться с префикса, состоящего из трех букв нижнего регистра и обозначающего тип компонента. Например, имя формы содержит префикс frm , поля ввода – edt , кнопки – btn и т.д. Буквы после префикса описывают назначение или содержание компонента. Например, поле ввода edtLastName содержит фамилию.

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

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

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

4.2. Правила разработки программ

У всех вещественных констант цифры должны быть как слева, так и справа от десятичной точки, например 0.15, а не.15.

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

Для преобразования вещественного значения в строку и обратно используйте процедуры Str () и Val (), а для целых значений в языке Object Pascal – функции StrToInt () и IntToStr () соответственно.

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

Удаляйте ненужный код. Особенно это относится к операторам внутри циклов, выполняющихся многократно. Например, нет необходимости присваивать значения переменным или элементам массива перед присвоением им значений другими операторами. Любой такой оператор присваивания уменьшает эффективность программы и делает код более громоздким.

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

Большинство статей, написанных на тему найма программистов, звучит более или менее одинаково. Как правило, такие статьи рекомендуют «нанимать только самых лучших». Признаюсь, я не в восторге от этого совета, потому что он звучит слишком неопределенно. Это все равно, что если бы вы пришли в автосалон и спросили бы у продавца какую бы он машину вам порекомендовал, а он вам бы ответил что «Лучшую» при этому не указан ни на какую находящуюся в автосалоне.

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

«Отвергнуть хорошего кандидата гораздо лучше, чем принять плохого… Если у вас возникнут хотя бы малейшие сомнения - Не нанимайте»

Но стандартный совет все равно меня раздражает. Дело даже не столько в самом совете, сколько в том, что люди склонны понимать его неверно. Если применять его без дополнительных поправок, эта практика в основном формирует чувство собственного превосходства. Этот эффект особенно часто распространен среди программистов, поскольку элитарность так или иначе присуща нам. Когда мы слышим, что нанимать нужно только «самых лучших», этот совет проходит подсознательное преобразование:

«Самых лучших?» Но это же я! Я «самый лучший». Разумеется, я должен нанимать людей, таких же одаренных, таких умных и симпатичных, как я сам. Да и зачем засорять мою прекрасную команду всяким сбродом?

Кто они, самые лучшие программисты?

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

«Я хочу сформировать как можно более эффективную команду. Нанимая дополнительного работника, я стремлюсь не только к численному расширению штата. Каждый нанимаемый человек должен улучшать мою команду в определенном отношении. Я вовсе не ищу такого же одаренного человека, как я сам. Скорее, мне нужен человек, одаренный более меня по крайней мере в одном важном направлении».

Начальник

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

Наверное, в крупной компании с таким подходом можно прожить. Я сильно подозреваю, что Лохматый Начальник в комиксах про Дилберта был срисован с натуры.

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

Кадры программистов

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

Ищите людей, склонных к самоанализу

«Самые лучшие» работники никогда не перестают учиться.

Одним из важнейших критериев при оценке кандидатов я считаю то, что я про себя называю «первой производной». Учится ли этот человек? Движется ли он вперед или стоит на месте? (Некоторые мои размышления на эту тему опубликованы в статье «Career Calculus» в моем блоге).

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

Это не означает, что нанимать нужно только тех людей, которые желают добиться успеха. Все люди хотят добиться успеха. Я советую нанимать людей, серьезно относящихся к постоянному обучению. Такие люди не тратят время на попытки убедить вас в том, как много они знают. Они сосредоточены не на прошлом, а не будущем. Пока вы проводите с ними собеседование, они проводят собеседование с вами, пытаясь узнать, чему они смогут у вас научиться.

Как найти такого человека?

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

На собеседованиях кандидату часто предлагается описать свою основную слабость. Хотя этот вопрос до ужаса традиционен, он мне нравится.

К сожалению, многие кандидаты пытаются уклониться от ответа. Они идут в книжный магазин и покупают книгу о прохождении собеседования. Книга предупреждает, что я задам им этот вопрос, и предлагает «творческие» способы уклониться от искреннего ответа:

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

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

Нанимайте разработчиков, а не программистов

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

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

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

Что же означает стандартное правило? Какой именно атрибут нужно измерить, чтобы определить, является ли кандидат «самым лучшим»?

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

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

1. Способен ли этот кандидат сделать для группы то, что не сможет никто другой?
2. Находится ли он в процессе постоянного обучения?
3. Знает ли этот кандидат о своих слабостях и может ли спокойно обсуждать их?
4. Насколько этот кандидат универсален и способен сделать «все, что потребуется», чтобы обеспечить коммерческий успех продукта?
5. Принадлежит ли кандидат к числу «десятикратных» программистов?
6. Обладает ли он степенью бакалавра, полученной в одном из уважаемых университетов?
7. Если кандидат обладает докторской степенью, имеются ли другие признаки, свидетельствующие о его способностях к разработке коммерческих продуктов?
8. Имеется ли у кандидата опыт работы в группах, занимавшихся разработкой коммерческих продуктов?
9. Может ли кандидат представить примеры хорошего кода?
10. Любит ли кандидат программирование настолько, чтобы писать код в свободное время?

Положительный ответ на все 10 вопросов не обязателен. Я даже не собираюсь указывать максимальное количество положительных ответов, необходимых для принятия кандидата. Наем - это лотерея, и каждый вопрос может послужить признаком для оценки пригодности кандидата.

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

Уроки, извлечённые из опыта разработки программного обеспечения. Хоть список правил больше касается разработки ПО, это будет полезно почитать каждому новичку.

Разработка

1. Начинайте с небольших вещей, затем расширяйте их.

Как при создании чего-то нового, так и при добавлении функциональности к готовым системам, я всегда начинаю с очень простой версии, которая не делает почти ничего из необходимых функций. Затем я расширяю это решение шаг за шагом, до тех пор пока оно не станет тем, что было заявлено изначально. У меня ещё никогда не получалось расписать в плане все детали уже на старте. Вместо этого, я всё лучше и лучше понимаю то, что нужно получить в процессе разработки и использую эти знания в проекте.

Мне нравятся эти слова Джона Галла: «Любая достаточно сложная система, которая работает, так или иначе в своё время эволюционировала из простой системы, которая работала».

2. Изменяйте что-то одно за один раз.

Если при разработке программа начинает проваливаться на каком-то тесте или некоторая функция перестаёт работать, то гораздо проще найти причину, если вы поменял код только в одном месте. Другими словами, лучше использовать небольшие итерации, чем пытаться сделать всё и сразу. Сделайте что-то одно, убедитесь, что это работает, повторите.

Это также применимо и на уровне коммитов в систему контроля версий. Если вам надо провести рефакторинг, то прежде чем добавить какую-то новую фичу, сначала зафиксируйте изменения для рефакторинга, а только потом (отдельным коммитом) добавьте эту фичу.

3. Добавляйте логирование и обработку ошибок на ранних стадиях.

Когда я принимаюсь за разработку новой системы, одна из первых вещей, которую я делаю — это добавление логирования и обработки ошибок. Обе эти вещи приносят пользу с самого начала работы над проектом. В любой программе, которая больше пары десятков строк кода, вам нужно знать, что происходит в процессе выполнения. И особенно эти данные важны тогда, когда что-то работает не так, как было запланировано.

Примерно то же самое и с обработкой ошибок — раз уж исключений всё равно не избежать, и они будут кидаться на протяжении всей жизни проекта, то почему бы не начать обрабатывать их систематически уже в самом начале?

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

Прежде чем закончить работу по какой-либо функциональной возможности, её нужно протестировать. Ведь иначе как вы поймете, что она делает именно то, что должна? Часто лучший вариант для этого — автоматические тесты, хотя бывают и другие варианты. В целом не важно как, но главное, что управление должна получить каждая написанная вами строчка кода.

Иногда может быть сложно воспроизвести нужные условия, чтобы зайти во все ветки кода. К счастью, у вас есть возможность немного смухлевать, не обязательно стараться воспроизводить полностью боевые условия. К примеру, отлов ошибок базы данных можно проверить специально допустив ошибку в написании названия колонки. Или можно временно инвертировать условие внутри if, тогда случай «ошибка произошла» поменяется местами со «всё прошло корректно». Это полезно для ошибок, которые в принципе происходят очень редко и их сложно сымитировать.

Иногда мне попадаются баги, которые показывают, что определённая строчка кода вообще никогда не должна работать. Она может выглядеть вполне нормально внешне, во время code-review, но всё равно не работать так, как должна. Вы избежите таких ситуаций, если примете за правило всегда выполнять хотя бы один раз каждую новую строку.

5. Тестируйте по частям прежде, чем проверять весь проект на работоспособность.

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

6. Абсолютно всё занимает больше времени, чем вы думаете.

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

Похоже старик Хофштадтер был прав, когда формулировал свой закон: «На любое дело требуется больше времени, чем казалось в начале, даже если вы учитывали при этом закон Хофштадтера».

7. Сначала поймите, что делает данный код.

В большинстве своем программирование подразумевает изменение существующего кода. Даже если вы включили в проект нечто совершенно новое, это новое должно стать частью написанного кода. Более того, необходимо понять найденное решение прежде, чем добавлять его. Иначе вы можете нарушить работоспособность чего-то, что уже было реализовано. Поэтому умение читать код так же важно, как умение его писать. И это еще одна причина, почему вроде бы простая задача по встраиванию кода может занять больше времени, чем кажется: нужно понимать контекст, в котором происходят изменения.

8. Читайте и запускайте код.

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

Отладка

9. Ошибки будут всегда.

Мне не очень нравится подход «Сделать всё с первого раза». Не имеет значения, сколько усилий вы потратите, ошибки будут всё равно («Мы об этом не подумали…»). Гораздо продуктивней запустить приложение и исправлять баги по мере поступления.

10. Реагируйте на отчеты об ошибках.

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

11. Воспроизводите проблему.

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

12. Исправьте известные ошибки и смотрите, что останется.

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

13. Совпадений не бывает.

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

14. Учитывайте временны́е метки.

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

Сотрудничество

Живой диалог не заменят видеоконференции, чат, звонок или электронная почта. Удивительно, насколько лучше становятся идеи и решения, если обсудить их с коллегами.

16. Резиновый утенок.

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

17. Спрашивайте.

Чтение и запуск кода — отличный способ понять, как он работает. Но если у вас есть возможность спросить кого-нибудь компетентного (автора программы, к примеру), используйте её. Возможность задать вопрос и получить на него ответ, а затем, исходя из ответа задать дополнительные вопросы, позволит вам получить информацию за несколько минут вместо нескольких дней.

18. Признавайте заслуги других.

Говорите, напимер: «Маркусу пришла в голову замечательная идея …», вместо: «мы попробовали …». Старайтесь упомянуть всех, кто вам помог.

Разное

19. Экспериментируйте.

Если вы не уверены, как работает та или иная особенность языка, вы можете просто написать маленькую программу, которая продемонстрирует это на примере. Тот же самый метод применим и когда вы тестируете сложную систему. Что случится, если я передам -1 в качестве аргумента? А не упадет ли сервис, когда я перезагружу машину? Исследуйте, как что работает — вы наверняка обнаружите какие-то ошибки, и кроме того, глубже поймете систему.

20. Поспите.

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

21. Меняйтесь.

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

22. Учитесь.

Самая лучшая особенность ИТ — всегда есть, куда расти, есть, чему учиться. Пробуйте разные языки и инструменты, читайте книги, проходите онлайн-курсы. Маленькие улучшения, накапливаясь, значительно укрепят ваши навыки.