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

четверг, 30 апреля 2009 г.

Скобочки для if в одну строчку

(DRAFT)

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

if(condition)
{
        return 0;
}


вместо
if(condition)
        return 0;


Мифическая причина идущая от Стива Макконнела (Code Complete). К ней все обращаются, когда начинают мне её называть. Такое ощущение, что это единственная книга, которую горячие стороники скобочек читали :) Кстати, советую тогда заглянуть на http://agileconsulting.ru/wiki/Books - тут множество книг о качестве кода.
1. Защита от дурака, что кто-то в будущем добавит строчку и сделает баг в программе.

А теперь демистификация скобок. Итак, почему скобки это пережиток:
1. Отступы явно указывают на логический блок из одной строки.
2. Отступы проставляются автоматически средой разработки.
3. Тесты не дадут написать код неправильно. У вас нету тестов? Тогда улучшать качество кода начали не от туда :)
4. Скобки кушают 2 линии
5. Мы бизнес-разработчики, и должны свести к минимум все инженерные ухищрения. Ведь в любом языке фраза: "если наступит утро, то я проснусь" не содержит скобок.

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

Если вы используете современную IDE и TDD и утверждаете, что скобки полезны по названой мифической причине - просьба дайте конкретный пример. Иначе рассуждаем о коне в ваккууме.

вторник, 21 апреля 2009 г.

Строки-ресурсы или магические строки (draft)

В продолжение предыдущего поста возникли логичные вопросы. А что делать с
String.Format(StringResourse.TotalString, total)? Кстати, вам легко понять это? А я ещё не начал перечислять минусы :)

Итак, начну с переносом строк в ресурсы. Начнём сначала. Какой смысл был у строки? Если смысл кокатация строчек. То первичный вопрос - накой козе баян? Зачем делать форматирование строке "Всего: " + total + " штук"? А потом повышаем косвенность, закидывая строку "Всего: {0} штук" в ресурсы?

В отличии от string, StringBuilder, String.Format назначение ресурсов в предоставление вариационности. Вариационности в способе отображения, а для строк это либо другой язык, либо другая система отображения значений (пример: дата, дроби и т.п.). Вы часто имеете дело с мультикультурными приложениями? :) Да и там чуток по другому делают. Причем не на стадии программирования, а это свойство относится к всем процессу разработки. Другой нюанс - некоторое множество сообщений, которое на каждом углу программы используется. Некое постоянное магическое множество. Типа "Всего: {0} руб.". Тут ещё можно подумать. Но вредно. Для этого есть специальные классы. Которые должны сразу выплёвывать такие строчки и мы не должны волноваться как это получилось.

Другой сногсшибательный аргумент - если у вас есть технический редактор, и ему удобно работать с одним списком сообщений. Представляю я работу этого редактора. Вместо того, чтобы заранее написать текст, который он ожидает. Или с программистом договориться во время непосредственного написания кода. Он будет открывать файл ресурсов и не соображая, что за туча сообщений, править. Полностью оторвав от контекста применения. Кто нибудь так делает? Ух ты! Ну и как часто так делаете? Чаще чем пишете код? :)

А теперь какие бонусы мы получаем от такой системы (не для варианта мультикультурной платформы, а для нашей простой разработки)
Бонус 1. Попробуйте посчитать количество ваших действий, чтобы внести изменение в вашу строчку. Ужас на крыльях ночи. И это только ради того, чтобы внести маленькое исправление в строчку. Боюсь если вы уделяете столько внимания строчкам, то время на полезный код у вас не остаётся вообще :) Мне намного легче править то, что я вижу непосредственно.
Бонус 2. Даже если не менять. Чтобы читатель мог понял, что тут написано и что ожидается, вам прийдётся скакать как минимум по двум файлам. Кстати, поиск таких вещей и мест их потребления - это другая тема. А разговор идёт не об одной сущности, а просто об одной строчке кода. Да к тому же ещё среди кучи строчек вам нужно ещё вашу. Упасть не встать.
Бонус 3. Я молчу, насколько это эффективно программируется по сравнению с простой строчкой кода :)
Бонус 4. Нарушение ценностей и принципов Implementation Patterns и Simple Design.
Бонус 5. Программирование ради неопределенного будущего. Какой то технический

Задайте себе вопрос - что вы чаще меняете: кучу сообщений без привязки к месту использования или конкретное сообщение в конкретном коде. И из этого делайте вывод. Если вы днями программируете текст в ресурсном файле. То ресурс это ваше все. А если вы пишите код программы и добавляете в него сообщения - то вывод очевиден. Что данные (а строка это данные) должны быть в непосредственной близости от места потребления.

Следующий вопрос - Magic String. Звучит очень странно. Но давайте вернёмся к аналогии. У нас есть Magic Number. Пример: 12. Конечно, любой скажет, что нужно напрячься, причем очень сильно, чтобы найти СМЫСЛ этого. Поэтому СМЫСЛ мы заключаем в название переменной int interest = 12. Ещё раз подчеркиваю, чтобы не искать смысл числу 12 по крупицам в коде окружающем это значение мы вводим переменную, в название которой перенесли смысл числа. В нашем примере 12 означает interest (процент). Теперь взглянем на наши Magic String:

string errorMessage = "Произошла ошибка. Повторите операцию";

Вот скажите, а чего вам не понятно в исходном сообщение? Смысл? Там же по-русски написано :) Я понимаю, что фраза "@#$#@$^%$" может запутать и нужно ввести поясняющую переменную. Но в примере то чего сложного?

Теперь пошли нюансы Magic String:
Бонус 1. Переменная, у которой область видимости максимум круглые скобочки в качестве параметра вызова в MessageBox, почему то становиться видна всей нашей функции. Как будто без этого мало строчек кода.
Бонус 2. При чтение кода нам нужно прыгать сначала к тексту применения, а потом к определению. Хотите скачи - идите на ипподром.
Бонус 3. Некоторые умельцы ещё и форматирование туда запихивают. Мозг выносится напрочь, когда обнаруживается код типа:
string totalString = "Всего: {0} штук";
....
String.Format(totalString , total);

Итог, использование Magic String и ресурсов в большенстве своём плохой и неоправданный стиль программирования. Но когда же их исползовать? Ресурсы - когда вариационность текстовой составляющей (языки, отображение и т.п.), Magic String - ну когда одно и тоже в многих местах или ну совсем длинная или непонятная строчка :)

понедельник, 20 апреля 2009 г.

String vs StringBuilder

Сегодня в microsoft study-group обсуждали стринг. Собственно эта тема всех интервью - что нужно использовать для "оптимального" хранения строчек? И все хором говорят - используем StringBuilder. А на вопрос, что использовать для кокатации строк - String.Format. И все напрочь забывают, что мы программируем не для оптимизации, а для того, чтобы поддерживать код и развивать. То есть делать код понятным даже первокласснику, что не скажешь про "профессионально" оптимизированные без надобности куски творчества.

Так вот про вопросы интервью. Я с ними полностью не согласен. Люди! Не то чтобы на пороге 21 век, он уже дома! Преждевременная оптимизация - зло и порождает ДОРОГОСТОЯЩИЙ код! Качественный код приравнивается к самодокументируемому коду. Оптимизация здесь не рассматривается - она здесь не обсуждается. Так как мы бизнес-разработчики, а не любители оптимизнуть что под руку попадёт. Бизнес-разработчик пишет код, где каждая строчка отражает НАМЕРЕНИЕ, а не хитро-вычитанные фичи платформы :)

Начну развеивать заблуждение с конкатацией через String.Format. Цель функции String.Format форматирование строки, а не конкатация. То есть привращать 1 в 001,00 например. С точки зрения качественного программирования запись с целью конкатации String.Format("Total: {0} dollars", total); выглядит настолько неэкономично, что ужас. Конечно микроскопом можно гвозди забивать :) У некоторых это даже получается. Во-первых, чтобы понять это, нужно чтение слева-направа заменить на скачкообразное чтение с актвацией ячейки памяти в моём мозгу. Во-вторых, добавление новых переменных вызывает дополнительное напряжение - теряем время, за которое нам платят деньги. В-третьих, чтобы добавить новую переменную - мне нужно делать 2 (!!!!) изменения.

Исходя из этих соображений. А мои соображения основываются на принципах Implementation Patterns & Refactoring и трёх простых ценностях (коммуникация, простота и гибкость). В данном случае используем самую первую и самую важную ценность - коммуникация. Напомню: Коммуникация (communication) - разрабатываемый код должен явно отражать намерение создателя. Этот принцип подчёркивается и в рефакторинге. Так вот начиная читать строку String.Format - я чётко фиксирую себя на мысле "форматируем"!, а когда плюсиками - то конкатируем. Просто и разумно.

Ужасная конкатация через форматирование: String.Format("Total: {0} dollars", total);
Поэтому намного лучше и приятней: "Total: " + total + " dollars";
Хотя, перед PHP код снимаю шляпу: echo "Total: $total dollars";

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

К вопросу о StringBuilder - это ещё та тема. Все вертится вокруг сборки результата, результирующего значения. Объект выполняет роль сборщика. В одном месте мы собираем данные, а в другом потребляем. Это не форматирование и не простая конкатация. А целый алгоритм конкатации. Поэтому использование предыдущих методов, когда нужен StringBuilder, обречёт наследников вашего кода вспоминать вас недобрым словом :)

Итак с точки зрения качественного кода (а это код, которых легко читать):
StringBuilder - вещь хорошая, но его стоит применять, когда мы подходим к объекту как механизму с накапливанием значения, а результат будет снят как сливки намного дальше от кода наполнения. То есть в одном месте явно накапливаем (сложный код... преимущественно бывает в циклах), а в другом вы забираете результат (особенно часто встречается со словом return ;).
String.Format - для форматирования кода, но не конкатации. Причем в отличие от String.Builder результат забирается в месте форматирования.
+ (любимый плюсик для строк) - приятный и дешевый способ конкатации

PS. "Экономично", "дорогостоящий" и "дешевый" читать с точки зрения разработки и поддержки. Меньше тратим время, чтобы "врубиться", значить дешевле. Время - деньги.
PS2. А оптимизация делается на заключительной стадии. Ключевое слово: профайлер.

воскресенье, 3 февраля 2008 г.

Соглашаемся на некачественный код

В предверьях семинара http://profyclub.ru/projects/seminars/2588/ я изложил свои мысли в виде статьи. Предлагаю ознакомиться и покомментировать :)

Соглашаемся на некачественный код
Денис Миллер


Что скрывается за качеством кода? Минимально количество ошибок? Правильно оформленные названия полей и методов? Жесткое распределение файлов проекта по папочкам? С точки зрения Стива Макконнела [2] качество системы снижает расходы на её разработку. Чем меньше мы усилий тратим на понимание своего же кода, тем легче мы добавляем новый функционал. Продолжая эту мысль – чем меньше мы допускаем запутанности кода, тем лучше качество. Часто разработчики говорят, чтобы в будущем было легче разобраться в коде, нужно выработать «Соглашение о наименовании». Ниже я покажу , что такое соглашение имеет смысл, но с качеством кода связанно косвенно.

В начале разработки сложных приложений ведущие разработчики и менеджеры проектов ставят перед командой вопрос о принятии «Соглашения о наименовании» (Coding & Naming Convention, сокращённо CNC). Фактически дав разрешение на религиозную войну. Соглашение есть способ документирования опыта, предпочтений и привычек одного из разработчиков. Преимущественно документируется (навязывается) опыт ведущего разработчика. Если бы было не так, то в команде в 7 человек, должно появиться как минимум 7 соглашений. Многие команды, чтобы избежать разногласий выбирают соглашение рекомендуемое авторитетным источником (Java [5], .Net [6]). Другой вариант, когда команда принимает соглашения уровня корпоративного стандарта.

Если посмотреть со стороны на процесс принятия соглашения. То можно заметить, что происходит парадоксальная ситуация. Команда забывает, что суть соглашения не в наименовании, не в авторитете, а в том, чтобы поддержка разработанного кода была легче и самое главное будет легко передан смысл кода. Когда любой разработчик сможет обратиться к написанному мною участку кода и этот участок будет понятен. Проведём аналогию с русским языком. Грамматика и орфография является неким соглашением. Но если так, ТО Сей4ас Я наPушИЛ соГлашеНИЕ По НАИМеноВанИЮ. Но смысл понятен и я легко могу внести изменения.

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

Важнее определить не соглашение. А принципы, из которых должны исходить разработчики, чтобы код был легок в поддержке, сопровождении и дальнейшем развитии. А таких принципов три[3]:
1. Коммуникация
2. Простота
3. Гибкость

Код пишется не для компьютера, а для человека. Первый принцип говорит, что разрабатывая код подумайте: сможет ли его прочитать другой человек? сможет понять его смысл? Второй принцип подсказывает, что требуется выбирать наиболее простое решение. А любую сложную функциональность (например, метод больше 10 строк [1]) декомпозировать на несколько простых. Гибкость – самый сложный принцип, за его реализаций предлагаю обратиться к шаблонам проектирования (design patterns)[7].

Исходя из указанных принципов можно строить уже не стилистическое соглашение CNC, а смысловое. Косвенно о таком соглашении идёт речь в книге «Совершенный код» Стива Макконнела[2] и ещё больше рассказывает о реализации трёх принципов Кент Бек [3].
В семинаре выбран другой, но не менее важный подход. Подход известный в математике «от обратного». Определив соглашение в виде положительных утверждений, мы не определяем случаи злоупотребления теми или иными конструкциями. Которые не несут ярко выраженного отрицательного эффекта для разработчика и даже соответствуют «соглашениям». Такие случаи только потенциально могут привести к сложности кода. Их называют - smells. Так если каждый программист будет допускать их появление, то они будут накапливаться словно снежный ком. И через буквально 1-2 месяца разработки корректный с точки зрения «соглашений» код будет совершенно нечитаемый с точки зрения смысла.

Семинар предлагает командам принять новое соглашение, которые должно сформироваться на основе каталога smells. "Code smells" сигнализирует о потенциальных сложностях кода. Правильная интерпретация этих сигналов позволит вам выявлять некачественный код, затрудняющий разработку и приводящий к удорожанию решений, а также трудности модификации существующего кода. Предлагаемая практика полезна как малым командам, так и крупным предприятиям, вовлеченным в промышленную разработку. На семинаре мы рассмотрим общий каталог Smells, включающий различные уровни: кодирование, базы данных и архитектуру. Особое внимание мы уделим каталогу некачественного кода и способа устранения smell’ов – рефакторинг. Один из первых авторов, кто поднял тему рефакторинга и работы со smell’ами является Мартин Фаулер [1].

Внедрение нового подхода в кодировании требует определённые усилия. Во-первых, нужно изменить порядок принятия соглашения. Заменить принятие правил как цельного документа на постепенное (итерационное освоение, см. принцип итерационного подхода в Agile-методологиях). Так предлагается построить приоритетный список некачественных решений по степени появления. После одобрения всей командой в течении одной итерации осмысленно и целенаправленно избегать пять самых приоритетных smell’ов и проводить рефакторинг над ними. Здесь можно использовать техники парного программирования, code review различного уровня. В завершение итерации добавить встречу для обсуждения (Smell Meeting). Во-вторых , требуется изменения режима разработки. Заменить устоявшуюся цепочку задача-модификация-тестирование на задача-рефакторинг-модификация-рефакторинг-тестирование. А в дальнейшем посмотреть на популярный на западе подход к самоорганизующимся и самообучаемым командам на основе Agile-подхода[7, 8] в разработке.

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

Дополнительно:
1. Мартин Фаулер. Рефакторинг. Улучшение существующего кода
2. Стив Макконнелл. Совершенный код. Практическое руководство по разработке программного обеспечения
3. Kent Beck. Implementation Patterns
4. Э.Гамма «Приемы объектно-ориентированного проектирования. Паттерны проектирования».
5. Code Conventions for the JavaTM Programming Language. http://java.sun.com/docs/codeconv/html/CodeConvTOC.doc.html
6. .NET Framework Developer's Guide Guidelines for Names.
http://msdn2.microsoft.com/en-us/library/ms229002.aspx
7. Российское Agile сообщество.
http://agilerussia.ru
8. Рассылка «Инженерные практики Agile».
http://subscribe.ru/catalog/comp.soft.prog.agile

пятница, 14 декабря 2007 г.

Определите национальность

Определите национальность автора кода

//--------
boolean b;

if(b.toString().length() >4){...}
//-------