Должны ли мы высматривать ложный код?

9

Это относится к обсуждению в ответе и комментариям к этому вопросу: что происходит с отвращением к документации в отрасли? , В ответе утверждалось, что «код не может лгать» и, следовательно, должен быть местом для перехода, а не документацией. В нескольких комментариях указывалось, что «код может лгать». С обеих сторон есть истина, по крайней мере отчасти из-за того, как плохо и ненадлежащим образом обрабатывается документация.

Должны ли мы искать ложный код, сравнивая его с какой-либо существующей документацией? Или это обычно лучший источник того, что нужно делать? Если это гибкий код, менее ли он лжив, или этот код вообще не лжет?

thursdaysgeek
источник
1
Не могли бы вы уточнить, что вы подразумеваете под "ложью"? Нам не нужно ссылаться на комментарии в другом вопросе, чтобы получить ваш контекст.
user16764
@ user16764 Не обращая внимания на другую ветку, первое, что приходит на ум, - Конкурс
Изката,
Если в документации сказано, что код должен выполнять foo, а код выполняет bar, значит ли это, что код должен делать код? Или мы предполагаем, что bar является правильным действием, потому что мы никогда не читаем документацию, потому что код всегда корректен?
thursdaysgeek
Если код был принят как бар, то документация неверна и устарела. Но если foo и bar тесно связаны, и пользователи не заметили, что это не совсем решает их проблемы, как они ожидали, то, возможно, документация по foo не является неправильной? Другими словами, действительно ли код является основным и конечным из того, что код должен делать?
thursdaysgeek

Ответы:

9

По словам непрофессионала:

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

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

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

Чем короче, тем меньше врет. Это самоочевидно.

Чем менее сложен код, тем он прозрачнее. Так что вранье меньше.

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

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

Также хороший автоматический тестовый аккумулятор заставляет код говорить правду.

Тулаинс Кордова
источник
4
The shorter and terser the code is, the less it lies. It's self evident. Я вряд ли скажу это. По моему опыту, чем короче и короче код, тем больше возможностей он может охватить, как правило, скрывая их в обманчивых вызовах функций.
Мейсон Уилер
@MasonWheeler Вы правы. Я отредактировал "краткую" часть.
Тулаинс Кордова
Меня не убеждает «Код без ложных соглашений об именах». Это конечно плохо, но как это может быть ложью, если она тебе ничего не говорит? "Я не скажу тебе!" упрямо обструктивный и неинформативный, но не обманчивый. Конечно, «ложь» - это когда соглашение об именах существует, но оно используется таким образом, который не соответствует тому, что на самом деле делает код - например, если вы используете венгерский (чёрт!), Но иногда есть префикс pдля переменной, которая не указатель
Steve314
2
На самом деле, то, что вы предлагаете, может быть лучше описано как «софистика», чем просто как «ложь». Софистика, как правило, многословна и сложна именно для того, чтобы трудно было увидеть логические недостатки, и внешне умна и уверена, так что люди боятся подвергать ее сомнению в случае, если они выглядят глупо.
Steve314
Другой пример: код, который изменяет базовый язык или свойства среды выполнения, например, переопределение или маскирование примитивного поведения.
JustinC
6

Код не может лгать.

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

Код, безусловно, может быть неверным . Это, безусловно, может вводить в заблуждение в названии или организации. Это, безусловно, может быть нечитаемым.

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

Telastyn
источник
Существует школа мысли, что если вы намеренно обманчивы, но педантично верны, то вы не лжете. Это не единственная школа мысли. Например, у меня есть старое издание « Обнаружение лжи и обмана» от Aldert Vrij . Одна из первых вещей, которые это делает, это рассматривает различные определения лжи и обмана, выбирая включение педантически правильных, но намеренно вводящих в заблуждение утверждений, отчасти потому, что в любом случае это общее понимание.
Steve314
Извините, но говорить «но это было педантически правильно» не означает, что вас нельзя назвать лжецом - даже если люди не спорят, они все равно это знают.
Steve314
@ steve314 - шт. Первоначальный вопрос был вокруг комментариев. Создание соломенного человека для этих редких сценариев, в которых код вводится в заблуждение с целью аргументирования в пользу комментариев (и игнорирования распространенного сценария устаревания комментариев), является абсурдом.
Теластин
1
Я согласен с этим - я не спорю с тем, что вы делаете, а только с очевидным определением «лжи», которое вы используете при этом. Код может лгать - не компилятору, а определенно читателям. В некоторых случаях это даже преднамеренная цель - такие вещи, как запутанный конкурс на С, были бы относительно мягким примером. Софистика, как я предлагаю в своем комментарии к пользователю 61852. То, что компилятор видит ложь, не означает, что это не ложь.
Steve314
@Telastyn Я предполагаю, что у вас никогда не было фильтра, который делал бы перенаправление, в результате чего в пробелах действительно происходил пошаговый переход, а затем переходил к коду, не вызываемому из этого метода, и никогда не возвращался, а? Боже, я ненавижу! @ # $ Java-разработчики делают с Java.
Эрик Реппен
0

Вы задаете несколько вопросов.

Должны ли мы быть в поисках лживого кода?

Конечно!

Должны ли мы сравнивать [код] с какой-либо существующей документацией?

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

Или [код] обычно лучший источник того, что он должен делать?

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

  • Сам код;
  • Вызывающий код;
  • Комментарии в этом коде;
  • Документация;
  • Юнит-тесты;
  • Интеграционные и регрессионные тесты;
  • Программист;
  • Конечный пользователь;

Какой «лучший» источник (или их комбинация) зависит от вашей ситуации.

Если это гибкий код, менее ли он лжив, или этот код вообще не лжет?

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


Сноска
Все вышесказанное предполагает, что код может лгать, и что это простой (хотя и немного надуманный) пример:

public int DivideByTwo(int input) 
{
    return input / 3;
}

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

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

Йерун
источник
0
if (x > 5) {
  doSomething();
} else {
  doADifferentThing();
}

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

Более того, компилятор, возможно, заметил это и заменил этот блок кода просто

doSomething()

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

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

MatrixFrog
источник