"Идеальный программист" Роберта Мартина давно стал руководством по профессионализму в сфере IT и одним из основополагающих трудов в современной разработке, наравне с "Чистым кодом", "Чистой архитектурой" и "Чистым эджайлом".

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

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

Иллюстрации к посту любезно предоставила нейросеть Kandinsky 2.2.

О профессионализме

Ты профессионал?
Ты профессионал?

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

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

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

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

О тестировании

QA тестирует твой код
QA тестирует твой код

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

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

Об автоматизации тестирования

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

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

О TDD

Три закона TDD:

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

  2. Вы пишете ровно такой объем кода модульного теста, какой необходим для того, чтобы этот тест не проходил (если код теста не компилируется, считается, что он не проходит).

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

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

TDD — не религия и не панацея. Выполнение трех законов не гарантирует ни одного из перечисленных преимуществ. Плохой код можно написать даже при предварительном написании тестов.

О чистоте кода и архитектуры

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

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

О чистой архитектуре

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

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

О доверии к своим рабочим методам

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

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

О саморазвитии

Читаем "Идеального программиста" Роберта Мартина
Читаем "Идеального программиста" Роберта Мартина

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

Читайте книги, статьи, блоги, твиты. Посещайте конференции и собрания пользовательских групп. Участвуйте в работе исследовательских групп. Изучайте то, что лежит за пределами вашей привычной зоны. Если вы программист .NET — изучайте Java. Если вы программируете на Java — изучайте Ruby. Если вы программируете на C — изучайте Lisp. А если вам захочется серьезно поработать мозгами, изучайте Prolog и Forth!

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

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

О передаче опыта

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

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

Об ответственности

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

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

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

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

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

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

Об обещаниях

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

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

Когда говорить "да" и "нет"

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

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

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

О выполнении своей работы

Поработай на совесть!
Поработай на совесть!

У профессиональных разработчиков есть только одно определение: выполнено — значит выполнено. Сделано — значит, что весь код написан, все тесты пройдены, служба контроля качества и ключевые участники приняли результат. Сделано.

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

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

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

Об авралах

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

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

На сверхурочную работу можно соглашаться только при выполнении некоторых условий: 1 — лично вы можете ее себе позволить; 2 — аврал будет продолжаться недолго, не более двух недель, и 3 — у руководства имеется резервный план на случай, если ваши усилия завершатся неудачей.

О концентрации

Концентрируйся!
Концентрируйся!

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

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

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

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

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

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

О взаимодействии внутри команды

Дейли, на который почти никто не пришёл
Дейли, на который почти никто не пришёл

О встречах

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

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

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

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

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

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

О работе в группах

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

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

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

О "притёртых" группах

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

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

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

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

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

Комментарии (30)


  1. shark14
    17.08.2023 06:36

    Как вот это пояснить?

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

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


    1. xpendence Автор
      17.08.2023 06:36

      Конечно, можно. Ведь код не компилируется.


      1. shark14
        17.08.2023 06:36

        Так чтобы тесту пройти (или не пройти), ему нужно запуститься сначала. А так у нас просто нет информации, проходит он или нет.


        1. avost
          17.08.2023 06:36

          (если код теста не компилируется, считается, что он не проходит).


          1. shark14
            17.08.2023 06:36

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


            1. avost
              17.08.2023 06:36

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


              1. shark14
                17.08.2023 06:36

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


                1. avost
                  17.08.2023 06:36
                  +1

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


                  1. Deirel
                    17.08.2023 06:36

                    Я согласен с shark14, что этот пункт стоило немного детализировать. А то, действительно, возникает ощущение, будто нормальная ситуация - не когда тест не компилится из-за отсутствия реализации тестируемой логики, а когда тест не компилится из-за криво написанного теста)


                    1. avost
                      17.08.2023 06:36

                      Да нет же! С точки зрения тдд тут нет разницы. Постулируется, что ошибки - это нормально. То, что вы слелали ошибку в тесте - это нормальная ситуация. Ничем не отличающаяся от того, что у вас нет реализации. Просто у вас будет на одну итерацию больше - ну, и что? Ошибки ведь всё равно нужно исправлять. В тдд они исправляются тем же алгоритмом, что пишется новая функциональность. Можно усложнить алгоритм и сделать развилку, но какое дополнительное преимущество это даст?
                      Тдд используют для того, чтобы упорядочить собственную работу и получить определённые преимущества от методологии. Если исходить из этого станет понятно, что выделять ошибки тестов отдельно не имеет смысла. Вот если использовать тдд доя того, чтобы пустить пыль в глаза начальству, тогда, да. Такие ошибки "удобны". Ну, рассматривайте это как дополнительное преимущество метода :)


    1. apevzner
      17.08.2023 06:36
      +1

      Да. Но чинить придется Васю тест, а не код


    1. sepetov
      17.08.2023 06:36

      Конечно же, речь идёт не о синтаксических ошибках в самих тестах. Здесь лучше пример. Допустим, у нас есть объект Customer, где уже реализована вся логика работы с клиентами. Разработчику дали заявку: доработать объект так, чтобы было ясно, что клиент - должник.

      Разработчик решил, что для этого он добавит в Customer новый метод isDebtor(), возвращающий true для клиентов-должников. Соответственно, перед тем, как добавлять метод, пишется примерно такой тест:

      public function testCustomerIsDebtor()
      {
        $customer = new Customer;
        $customer->isDebtor();
      }

      Тест при запуске выдаст ошибку в стиле: "Вызов неизвестного метода isDebtor()". После этого разработчик его когда-нибудь реализует и тест перестанет сообщать об ошибке.

      P. S. Пример, конечно, на грани искусственного :-)


      1. shark14
        17.08.2023 06:36

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

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


        1. sepetov
          17.08.2023 06:36

          Да, правильно - пример на интерпретируемом языке (PHP).

          А с компилируемым языком разве будет другая история? Возьмём - абстрактно - старичка паскаля. Есть модуль Customer.pas, куда планируем добавить функцию isDebtor(). Пишем отдельный тест, где будет такая функция (за точность синтаксиса не ручаюсь, конечно, не мой стек):

          unit Customer;
          
          function testIsDebtor()
          var customer: Customer;
          begin
            customer := new Customer;
            customer.isDebtor();
          end;

          Сохраняем файл с тестом, пробуем его - а он не компилируется. И с той же ошибкой: несуществующий метод isDebtor(). А как только функцию isDebtor() реализуем, то тест будет нормально компилироваться и запускаться. Или я тут ошибаюсь?


          1. shark14
            17.08.2023 06:36
            +1

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


            1. sepetov
              17.08.2023 06:36

              Спасибо, интересно.

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

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


            1. avost
              17.08.2023 06:36
              +1

              Почему бессмысленно-то? Да, не скомпилится проект, а что это меняет? Ошибка будет та же самая. Ну, и современные компиляторы инкрементальны, так что в этом смысле "нескомпилится" именно файл. Про вкоммитить речь вообще не идёт. Хотя, никто не мешает, конечно, коммитить в локальную ветку и сломаные тесты. Тест, падающий из-за отсутствия функции - это в данной парадигме нормально. Написание заглушки - это уже следующий шаг итерации. Да, с современными иде этот шаг может быть неявным - несуществующие методы будут подсвечены, но это просто потому, что иде проделала часть работы по компиляции в фоне, а на самом деле он формально никуда не делся.


              1. shark14
                17.08.2023 06:36

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

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


                1. avost
                  17.08.2023 06:36

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

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

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

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

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

                  А зачем этому другому что-то реализовывать, если и так всё хорошо - всё компилится, тесты зелёные - делать ничего не надо. :)

                  Ps конечно, так тоже можно и большинство делают именно так, но тогда вы не получите плюшек ТДД. А они есть. И книжка именно про тдд, а не про то, как просто писать тесты. Про это есть другие книжки.

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


  1. LyuMih
    17.08.2023 06:36
    +2

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

    Конечно, если в команде 1 или 2 человека, то лучше, чтобы они были идеальными)


    1. xpendence Автор
      17.08.2023 06:36
      +1

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

      Постоянное сопротивление непрофессиональных коллег держит профессионала в тонусе.


    1. apevzner
      17.08.2023 06:36
      +1

      У меня есть гипотеза, что если собрать в одну команду достаточное количество идеальных, то они либо сами расслоятся на идеальных/не идеальных, либо команда сломается каким-то другим образом (например, все передерутся, или все перестанут работать)

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


  1. apevzner
    17.08.2023 06:36

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

    Я не уверен.

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

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

    Поэтому нет, я не уверен в универсальной справедливости процитированного правила (хотя писать лишнее, конечно, тоже не стоит)


    1. Deirel
      17.08.2023 06:36

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


  1. sepulkary
    17.08.2023 06:36
    +10

    К Роберту Мартину отношусь с уважением, но конкретно эта книга - типичный корпоративный скам, предназначенный для бесплатной раскладки на рабочих местах, вроде "Семи навыков высокоэффективных людей" Кови; по моему, сейчас на серьезных щах эту философию "работник должен .<длинный список долгов>" не продать даже первокурснику.

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

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


    1. Deirel
      17.08.2023 06:36

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


  1. terrier
    17.08.2023 06:36
    +7

    Книжка - артефакт давно погибшей вселенной, где "идеальный" программист после работы в личное время лихорадочно шел изучать больше и больше технологий, читать IT-twitter , коммитить в опен-сорс, мечтая взять на себя больше Ответственности с большой буквы О. Потому что вдруг какой-нибудь дядя из интернета не назовет его Профессионалом. Как это можно пережить?

    В той странной вселенной "покрытие тестирования" в строчках считалось разумной метрикой качества кода, за ним следила Служба Контроля Качества и если оно падало ниже 100%, то программиста наказывали. Программист должен был постоянно спрашивать себя "А искренне ли я верю в TDD или готов его предать в первом же аврале?". Вопросы типа "А какие есть аргументы и исследования, которые подтверждают или опровергают тезисы Пророка" считались еретическими. Хуже была только просьба показать успешный проект, созданный Пророком в соответствии с его проповедуемыми принципами. За такое сразу четвертование.

    А может этой вселенной никогда и не существовало кроме как в воображении дяди Боба. В любом случае я рад, что не живу в такой вселенной.


    1. victor_1212
      17.08.2023 06:36
      +2

      > А может этой вселенной никогда и не существовало кроме как в воображении дяди Боба. В любом случае я рад, что не живу в такой вселенной.

      насколько знаю он достаточно долго в 70-80х работал в Teradyne, большая компания хорошего уровня и закрытой тематики, вероятно работа была организована на уровне, многому научился, человек умный, дальше решил делать самостоятельную карьеру, типа писать книги и консультировать, все интересней чем на работу каждый день, но это давно уже было, C++, agile, и пр., последние лет 20 типа пропагандист для начинающих, чем и кормится, для общего знакомства по диагонали его книги прочитать не вредно, но это не человек уровня Dijkstra


  1. Karopka
    17.08.2023 06:36
    +6

    Обожаю такие книжки.

    Прочел - и уже можешь рассуждать как профессионал, не то что разбирать оптимальную реализацию красно-черных деревьев или томики Кнута долбить.


  1. BugM
    17.08.2023 06:36
    -2

    А можно тоже самое без пафоса и без слишком широких и слишком радикальных заявлений?

    Вот про это 100% покрытие всего кода тестами, например. Оно не имеет смысла и существует только в голове автора. Ну и может в каких-то помойках где точно не следует работать.