Стиль оформления кода

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

К примеру, когда разговор заходит о стиле оформления кода, обычно вы встречаете обсуждение нескольких стилей, какой из них удобнее, нагляднее и вообще "лучше" и "круче" в сферическом вакууме. Иногда можно встретить заметки в личных блогах, которые описывают стиль автора и чем он ему приглянулся. Другие читают это, вдохновляются и разрабатывают свой стиль: "я прочитал XYZ и выработал свой стиль: смесь этого с тем, добавив то, но вот здесь я делаю ABC, потому что DEF". "Нет такой вещи как 'правильный' стиль оформления - у каждого свои подходы". "Если так делает Embarcadero - это не значит, что это правильно: оформлять можно по-разному".

Звучит знакомо?

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

Если вы немного подумаете, то отсюда следует такой вывод: в Delphi есть единственный правильный стандарт оформления кода, а все остальные - неверны.

Единственный верный стандарт

Этот стандарт - стандарт оформления кода от Borland/CodeGear/Embarcadero. То, в чём написаны исходники самой Delphi.

Позвольте мне пояснить, что в этом случае означает слово "правильный":

- Он не идеален.
- Вы можете предложить более читабельный вариант.
- Но это - единственный стиль оформления, который может претендовать на звание "стандарт".

Почему это так

Вы можете сказать: "но как же, вот я использую такое оформление - смотри, насколько оно лучше! Как этот ваш стиль может быть правильным, а мой - нет? Похожее оформление использует даже <человек-с-большим-именем>!".

Дело в том, что этот ваш стиль оформления не соблюдается никем, кроме вас (окей: и ещё пяти человек, которых вы вдохновили на него). Со стандартом оформления кода Delphi же знакомы все. Чувствуете разницу?

Посмотрите на это с другой стороны. Вот есть ANSI/ISO стандарт языка C++. Почему никому не приходит в голову его улучшить? Расширить - возможно, но не изменить/улучшить (похоже, расширение стандарта языка не имеет аналогии для стиля оформления кода). Почему? Потому что этим вы убиваете весь смысл стандарта! Его цель - быть единым и правильным. Вводя свой стандарт вы ничего не улучшаете. Вы просто вносите хаос, создавая ещё один стандарт (как стандартов может быть два?!). Джоэль Спольски хорошо сказал на эту тему.

Но это ещё не самое главное. Вот вы оформляете свой код так. Вася - сяк. А Петя - ещё как-то. И тут вам пришлось работать в одной команде, причём так, что каждый работает над всем кодом сразу, а не так, что каждый взял себе по куску и корпит над ним. Чтобы как-то скоординироваться, вы взяли стиль Васи, добавив к нему элементы от Пети и сказали: "так, народ, вот стандарт, которого вы все должны придерживаться" (иногда так делают в софтверных конторах: каждому приходящему работнику даётся описание стандарта оформления, которого придерживаются в фирме, и обязуют его следовать этим правилам; иногда так делают даже в университетах при сдаче работ).

Отлично, какое-то время вы работаете. Более или менее успешно, хотя Петя постоянно норовит скатится к своему оформлению (привычка-с!), и ему приходится срочно перелопачивать код перед commit-ом, чтобы не получить по шапке.

А потом за ваш проект берётся другая команда/контора, в которой принят другой стандарт оформления кода.

Опс.

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

Другой пример: как насчёт автогенерируемого Delphi кода? Ведь он использует оформление, которое отличается от вашего. Будете тратить своё время на переписывание автосгенерированного кода или же оставите всё как есть, сохраняя смешение двух стилей (Delphi и вашего) в одном модуле? Как ни посмотри, и так и сяк - недостатки.

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

С другой стороны, исходники Delphi читают все. Более того, у всех перед глазами фрагменты автосгенерированного кода. Поэтому ни у кого не возникнет особых затруднений с чтением кода, оформленного "как в Delphi". Разве это не здорово? Если вы пишете так, вы можете дать это любому человеку - и у него не будет проблем с восприятием этого кода. И он даже сможет писать так же. Новому работнику не надо будет учить новый для него стандарт: ведь со стилем Delphi он уже знаком.

Посмотрите на известные библиотеки и компоненты на Delphi. Откройте их код. Что вы увидите? Домашний стиль оформления автора кода? Или же стиль оформления кода Delphi?

(хинт для организаций: если вы хотите форсировать стиль оформления кода в своей конторе - не изобретайте "удобный" стандарт оформления: возьмите стандарт оформления кода Delphi!)

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

Стандарт и привычка

"Но у меня привычка писать так! С чего бы я стал ломать свои привычки?!"

Знаете, я когда-то писал по-другому, ещё со времён Turbo Pascal. Begin я сдвигал в блок, а отступ у меня был в один пробел, а не в два, вот так:

procedure Proc;
begin
DoSomething;
DoSomethingElse;
if Condition then
 begin
 DoAnotherThing;
 DoAnotherThingMore;
 end;
DoSomethingMore;
end;

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

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

procedure Proc;
begin
  DoSomething;
  DoSomethingElse;
  if Condition then
  begin
    DoAnotherThing;
    DoAnotherThingMore;
  end;
  DoSomethingMore;
end;

А потом это вошло в привычку.

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

Но что же это за стандарт оформления кода Delphi?

Ну, вы все его видели - достаточно открыть любой стандартный модуль Delphi. Если вы хотите начать ему следовать, вы можете или изучать скучное формальное описание (на момент написания заметки, сайт немного в дауне) или же вы можете открыть модуль Delphi и писать "по аналогии". К сожалению, никакого официального Delphi Programming Code Style Guidelines я не нашёл.

Здесь надо понимать, что оформление кода в Delphi не является строго формализованным. Оно иногда меняется со временем, но очень незначительно. Поэтому мелкие детали могут оставаться на ваш выбор, но основные вещи - фиксированы.

Автоматическое форматирование

Ну, с появлением Code Formatter в Delphi 2010, стиль кода Delphi получает ещё бонусных очков.

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

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

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

Но тут, в общем-то, ваш выбор. Лично я - за смену привычек.

Хорошим компромиссом видится автоматическое форматирование базовых вещей, а затем доводка тонких моментов вручную.

А бывают ли ситуации, когда можно/нужно нарушать стандарт?

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

Я дам только один пример. Это субъективно, поэтому можете не начинать "это не стоит того!". Просто лучшего мне в голову сейчас не приходит.

В Delphi все модули в uses пишутся так:

uses
  Windows, SysUtils, Classes, Controls;

Возможно, вы захотите нарушить это правило и писать так:

uses
  Windows,
  SysUtils,
  Classes,
  Controls;

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

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

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