По каким признакам можно отличить код профессионала от кода новичка — отвечают эксперты

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

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

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

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

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

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

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

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

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

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

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

Почему код грамотного специалиста так точен? Потому что профессионалы последовательны, а новички не стремятся к систематизации и любят всё сваливать, что называется, в одну кучу. А ведь в программировании фраза «разделяй и властвуй» как нельзя более точна. «Каша» из кода может быть даже вполне работоспособной, но только до первой попытки внести изменения или первой нестандартной ситуации.
Ещё одно критическое отличие заключается в том, что код искусного программиста легко тестируется. Доступность для тестирования — это важнейший элемент обеспечения качества кода. К примеру, жёсткая связка компонент может отрицательно сказаться на стоимости тестирования. Если компонент отвечает за вычисление заработной платы и напрямую связан с конкретной базой данных, то для его тестирования придётся поднимать всю базу данных. Такое действие потребует большого объёма ресурсов, что может быть неудобно или даже невозможно.

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

Перед тем, как писать код, профессионал пишет, рисует на бумаге план (этапы) приложения (функционала). Затем этот план он переносит в редактор кода в виде комментариев. Это позволяет ему продумать структуру, к примеру, отдельного класса заранее, а также отчётливо видеть, какой этап реализуется в данный момент. При этом профессионал мыслит наперёд. Чтобы код можно было поддерживать, а не переписывать вновь при добавлении нового аргумента в функцию. Профессионал всегда думает о читабельности своего кода, иногда пренебрегая его краткостью. Профессионал придерживается одного стандарта написания кода. У профессионала код всегда идеально отформатирован, переменные имеют понятные именования. Документирование кода для профессионала является обязательным. Код профессионала читается легко и понятно, как книга ? Профессионал всегда следит за тем, что в его коде отсутствуют устаревшие функции или функции, которые не используются в приложении. Одинаковые блоки кода, выполняющие одно действие, вынесены в отдельные функции. При разработке использует паттерны, ведь они действительно помогают другим разработчикам лучше понимать, как работает приложение. Также профессионал знает, что такое обработка исключений и что данные на входе в приложение как минимум нужно проверить. Профессионал никогда не забывает про надёжность приложения.

P. S. Пишите так, чтобы через время вы сами смогли разобраться, в том, что вы написали месяц назад!

1) Внешне — лаконичностью. Профессионал заботится о тех, кто будет читать код. Поэтому классы не превращаются в портянки на 100500 строк, а методы по высоте помещаются на экран. Все именования, начиная с параметров, продолжая переменными и методами, заканчивая классами и пространствами имён, складываются в увлекательное чтение.

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

2) Код профессионала очень скучный, потому что очень предсказуемый. В нём нет внезапных и невероятных вещей. Например, если при сохранении чека покупки в БД отображаемый список товаров вдруг становится пустым — это весело… но не профессионально.

3) Код профессионала прост и не содержит в себе лишнего. Но не всегда, иногда у профессионала лапки.

4) Профессионал за время работы уже успел написать супер оптимизированный, но неподдерживаемый код, поэтому знает, что преждевременная оптимизация — это зло.

В первую очередь по его объёму, чем опытнее разработчик, тем изящнее решения. У нас в компании есть такое сравнение с искусством: если какую-то сложную задачу удаётся решить в 2–3 строчки, это можно сравнить с чёрным квадратом ?

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

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

Во-вторых, в профессиональном сообществе есть некие общепринятые рекомендации как писать хорошо, а как — плохо. Профессионал не позволяет себе опускаться до того, чтобы писать код, который считается плохим. Например, конструкция goto. Её использование в наше время — признак дурного тона! Такие вещи называются анти-паттернами. Существует много споров, что является анти-паттерном, а что нет, и в каких случаях. Но вот есть такие, которые однозначно всеми признаются «говнокодом».

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

Профессионал лучше продумывает защиту от дурака. Старается предусмотреть все варианты. Например, если в программе выполняется некая математическая операция с делением, то профессионал обязательно должен предусмотреть то, что пользователь может ввести 0. Как нам в школе говорили: на ноль делить нельзя! В таком случае программа вылетит с ошибкой.

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

Подытожу: код, написанный профессионалом, лучше структурирован, более читабелен и стабилен.

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

1. Код новичка часто излишне громоздкий и слабо структурирован: обычная история, когда исходный код представляет собой огромный файл с тысячами строк. Начинающий разработчик может злоупотреблять глобальными переменными и процедурным стилем программирования. Понимание оптимальных и «красивых» конструкций, технологий и применение типовых алгоритмов приходит, в основном, с опытом.
Отдельно стоит коснуться ООП (объектно-ориентированное программирование), с которым новички знакомы поверхностно. Неопытные разработчики зачастую создают связи между классами только в виде наследования, что приводит к появлению так называемых god object-классов, которые выполняют большую часть логики приложения и занимают тысячи строк кода.

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

3. Общие или малопонятные имена переменных и функций — ещё одна беда начинающего программиста. Сам новичок через пару месяцев уже не будет помнить, что делают переменные i и data, класс Manager и функция check.

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

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

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

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

Вы всегда сможете узнать начинающего разработчика, просматривая по:
1) «умным» конструкциям. На самом деле велосипедам, костылям и копипасте. Избегайте самописных реализаций типичных задач — берите лучшее из проверенных решений с открытым кодом;
2) сомнительным абстракциям. За каждую абстракцию нужно платить. Затраты не всегда можно оценить сразу;
3) плохой архитектуре. Правильная архитектура существенно упрощает долгосрочную поддержку;
4) злоупотреблению общим состоянием. Старайтесь сохранять состояния в маленьких областях видимости и не давать им вылезать наружу.

Код профессионала будет:
1) максимально линейным;
2) коротким;
3) производительным. Человек с опытом знает сложности алгоритмов по скорости и потребляемой памяти;
4) иметь не монолитную архитектуру приложения, а состоящую из набора небольших сервисов;
5) содержать в самых претенциозных местах хорошие комментарии, описывающие не действия кода, а причину этих действий;
6) будет написан на языке под конкретную задачу.

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

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

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

Если вы хотите стать профи и писать «тупой» код, начните с азов – YAGNI, принцип единственной ответственности, DRY, принцип единственного уровня абстракции, слабое зацепление и т. д. Кроме того, «тупой» код позволяет выделять микроблоки, из которых потом как из конструктора можно в 2-3 раза быстрее строить похожие по свойствам и назначению пользовательские истории.