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

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

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

Как я пришел к такому выводу? Вот несколько аргументов:

Обратная связь

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

Без обратной связи трудно распознать и исправить ошибки.

Как только вы пишете код, вы получаете много отзывов, например:

• Ошибки и предупреждения от компилятора
• Результаты статического анализа кода
• Модульные тесты

Ошибки могут быть быстро распознаны и исправлены.

консистенция

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

Рефакторинг

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

Есть одно предварительное условие, чтобы эта работа работала: код должен быть достаточно легким для чтения и понимания. Это, вероятно, не может быть достигнуто с помощью Ассемблера, Базового или Фортрана, но современные языки (и библиотеки) гораздо более выразительны.

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

Я ставлю под сомнение предпосылку, что языки становятся все более выразительными. С сегодняшним ASP.NET-кодом на c # я пишу примерно на том же уровне, что и при написании ASP-кода в Visual Basic. Мы все еще используем c ++. Javascript добавил функции, но в целом язык не изменился. То же самое с SQL.

Я думаю, что эти другие изменения более значительны:

1. Принятие автоматизированных модульных тестов. Кто-то скажет, что тесты - это спецификация. Таким образом, мы не устранили необходимость в написании спецификаций; скорее мы пишем их в коде, а не в документах Word.

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

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

4. SOA-данные контракты. В наши дни почти все является SOA. Все, что вам нужно, это WSDL. Дни определения и документирования форматов передачи данных прошли. Нынешний шаг в сторону большего количества RESTful и микро-услуг продолжает эту тенденцию.

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

6. Гораздо больше пользы от установленных библиотек. .NET CLR предлагает множество функциональных возможностей, поэтому нет необходимости разрабатывать, скажем, схему для кэширования данных сеанса. Сторонние библиотеки, такие как jQuery UI или Bootstrap, устанавливают стандарты написания кода для работы определенным образом. Вам не нужно документировать это; команды должны иметь возможность просто использовать их.

7. Отраслевая зрелость. Специалисты SWE узнали, что не существует такого проекта как «Battlestar Galactica», в котором вы годами годами пытаетесь достичь определенной цели; к тому времени, когда эти годы пройдут, цель изменится. Сегодня мы знаем, что время выхода на рынок гораздо важнее, чем получить все именно так, как мы этого хотим в дизайне.

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

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

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

Я бы поспорил за нет .

По простой причине, что

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

Никогда не считался «идеальным», так как экстремальное программирование существует с 1990-х годов . И как вы говорите:

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

Был спор давным-давно. Например, эта легендарная статья 1992 года: что такое дизайн программного обеспечения .

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

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

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

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

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

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

Я думаю, что вы забыли цель иметь проектные документы в первую очередь!

Проектная документация (требования, варианты использования, макеты и т. Д.) Позволяет нам описать, понять и обсудить систему на высоком уровне. Количество оставленных деталей в таких документах, делает их полезными.

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

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

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

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

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

Модульные тесты

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

Более того, написание хороших тестов (которые не нужно будет редактировать с каждым рефакторингом, но все равно будет отлавливать достаточно ошибок) довольно сложно.

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

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

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

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

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