Как вы погружаетесь в большие базы кода?

Какие инструменты и методы вы используете для изучения и изучения неизвестной кодовой базы?

Я имею в виду такие инструменты , как grep, ctags, блок-тестов, функциональный тест, класс-схема генераторов, называющие графики, метрики кода , такие как sloccount, и так далее. Мне было бы интересно узнать о вашем опыте, о тех помощниках, которых вы использовали или написали сами, а также о размере базы кода, с которой вы работали.

Я понимаю, что знакомство с базой кода - это процесс, который происходит со временем, и знакомство может означать что угодно, от «я могу суммировать код» до «я могу реорганизовать и уменьшить его до 30% от размера». Но как вообще начать?

я всегда делал следующее:

Откройте несколько копий моего редактора (Visual Studio / Eclipse / Wh независимо), а затем отладьте и сделайте разрывы строк, шагая по коду. Узнайте поток кода, проследите за стеком, чтобы увидеть, где находятся ключевые точки, и перейдите оттуда.

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

Как вы едите слона?

Один укус за раз :)

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

Должен ли я взломать, пока я не сделаю работу

Во многом да (извините).

Подходы, которые вы могли бы рассмотреть:

1. Попытайтесь выяснить, что код должен делать, с точки зрения бизнеса.
2. Прочитайте всю существующую документацию, независимо от того, насколько она плоха.
3. Поговорите со всеми, кто может что- то знать о коде.
4. Шаг через код в отладчике.
5. Внесите небольшие изменения и посмотрите, что ломается.
6. Внесите небольшие изменения в код, чтобы сделать его более понятным.

Некоторые вещи, которые я делаю, чтобы уточнить код:

1. Запустите кодировщик кода, чтобы красиво отформатировать код.
2. Добавить комментарии, чтобы объяснить, что я думаю, что это может сделать
3. Измените имена переменных, чтобы сделать их более понятными (с помощью инструмента рефакторинга)
4. Использование инструмента, который выделяет все виды использования конкретного символа
5. Сокращение беспорядка в коде - закомментированный код, бессмысленные комментарии, бессмысленные инициализации переменных и так далее.
6. Измените код, чтобы использовать текущие соглашения о коде (снова с помощью инструментов рефакторинга)
7. Начните извлекать функциональность в значимые подпрограммы
8. Начните добавлять тесты, где это возможно (не часто возможно)
9. Избавьтесь от магических чисел
10. Сокращение дублирования, где это возможно

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

Постепенно смысл всего этого должен стать более понятным.

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

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

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

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

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

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

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

Мне нравится делать следующее, когда у меня действительно большой исходный файл:

• Скопируйте весь беспорядок в буфер обмена
• Вставить в Word / TextMate любой
• Уменьшите размер шрифта до минимума.
• Прокрутите вниз, глядя на шаблоны в коде

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

Это требует времени

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

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

«Почему ты сделал эту часть таким образом»

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

"Что заставило вас всех выбрать технологию X вместо технологии Y?"

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

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

cscope может делать все, что ctags может сделать для C, плюс он также может перечислять, где вызывается вся текущая функция. Плюс это очень быстро. Легко масштабируется до миллионов LOC. Интегрируется аккуратно в emacs и vim.

Счетчик кода C и C ++ - cccc может генерировать метрики кода в формате html. Я использовал wc также для получения LOC.

doxygen может генерировать выделенный синтаксис и код с перекрестными ссылками в html. Полезно при просмотре большой базы кода.

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

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

Однажды у меня был довольно фантастический инженер-программист, который сказал мне, что самой дорогой формой анализа и сопровождения кода является построчное прохождение кода; конечно, мы программисты, и это во многом связано с работой. Я думаю, что счастливой средой является (в таком порядке): 1. Получить блокнот для создания заметок о том, как вы понимаете, как работает код, и добавить его со временем 2. Обратитесь к документации по коду 3. Поговорите с авторами или другими людьми, которые поддержали кодовую базу. Попросите у них «мозговой дамп». 4. Если вы дошли до того, что поняли некоторые отношения класса уровня детализации, сделайте некоторую пошаговую отладку кода, чтобы сделать некоторый синтез между тем, как, по вашему мнению, работает код, и как код на самом деле работает.

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

Затем нажмите Run и начните обходить код для того, что кажется ключевым функцией.

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

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

1. Запустите все тесты, если они у вас есть, и посмотрите, какой код покрыт, а какой нет.
2. Если код, который нужно изменить, не описан, попробуйте написать тесты, чтобы его охватить.
3. Измените код. Не нарушайте тесты.

Посмотрите, как Майкл Фезерс эффективно работает с устаревшим кодом

Вот мой короткий список:

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

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

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

4. Насколько хорошо я знаю языки и рамки, используемые в этом проекте? Здесь важна разница между тем, чтобы смотреть на некоторые вещи и говорить: «Да, видел это десятки раз и хорошо это знаю» и «Что здесь делают в мире? Кто думал, что это хорошая идея?» вопросы, которые, хотя я бы не сказал их вслух, я бы подумал, особенно если я смотрю на устаревший код, который может быть довольно хрупким, и люди, которые его написали, либо недоступны, либо просто не помнят, почему все было сделано так, как они были. Для новых областей, возможно, стоит потратить дополнительное время, чтобы узнать, какова структура и какие шаблоны я могу найти в этом коде.

И последнее, но не менее важное: знайте, что ожидают те, кто управляет проектом, с точки зрения того, что вы должны делать в каждый момент времени, учитывая следующие несколько идей о том, чего можно ожидать:

• Вы вводите новые функции?
• Вы исправляете ошибки?
• Вы рефакторинг кода? Новые стандарты для вас или они очень знакомы?
• Предполагается, что вы просто знакомитесь с базой кода?

Я всегда пытаюсь начать с точки входа в программу, поскольку все программы имеют такую ​​точку (например, метод main, main class, init и т. Д.). Это тогда укажет мне на то, что начинается и иногда, как вещи связаны.

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

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

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

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

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

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

Я так много сделал ...

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

1. Получить цели, которые система должна решить (если они не написаны) - напишите это. Спросите менеджера, других сотрудников, даже бывших, если они доступны. Спросите клиента или найдите любую часть документации.
2. Получить спецификацию. Если этого не существует - напишите это. Не стоит просить кого-то об этом, так как если этого не существует, то вы находитесь в ситуации, когда другим не все равно. Так что единственный способ написать собственный (позже будет гораздо проще обратиться к нему).
3. Получить дизайн. Не существует - напиши это. Старайтесь ссылаться на любые документы и исходный код как можно больше.
4. Напишите подробный дизайн части, которую нужно изменить.
5. Определите, как вы это тестируете. Таким образом, вы можете быть уверены, что старый и новый код работают одинаково.
6. сделать систему способной быть собранной за один шаг. И проверить со старым кодом. Поместите это в SVC, если это еще не так.
7. Внедрить изменения. Не ранее.
8. Через месяц или около того убедитесь, что ничего не сломано.

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

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

PS: я помню один код, который использовался для 5 клиентов с разными настройками. И каждое изменение (новая функция) требовало размышлений о том, «какие части используются» и «какие конфигурации есть у клиентов», чтобы ничего не тормозить и не копировать код. Помещение их настроек в cvs проекта и написание спецификаций сокращает это время обдумывания почти до 0.

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

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

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

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

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

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

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

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

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

Делайте небольшие шаги, даже самое маленькое изменение кода может оказать большое влияние.

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

Если только 1 метод / функция вызывает C, то это довольно безопасное изменение. Если сотни методов / функций вызывают C, то это будет иметь большее влияние.

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

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

Некоторые вещи, которые я делаю ...

1) Используйте инструмент анализа источника, такой как Source Monitor, чтобы определить различные размеры модулей, метрики сложности и т. Д., Чтобы получить представление о проекте и помочь определить области, которые нетривиальны.

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

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

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

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

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

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

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

• выберите стандартный префикс комментария для дубликатов (мы используем [dupe]сразу после маркера комментария;
• написать спецификации с вашими командами об именах для использования в дубликате процедуры;
• первый раунд: каждый берет несколько файлов и добавляет их [dupe][procedure_arbitrary_name]перед дублирующейся процедурой;
• второй раунд: каждый берет процедуру или подмножество процедуры и присваивает значение, указывающее порядок вероятности различных реализаций одного и того же назначения (тогда строка будет:) [dupe][procedure_arbitrary_name][n];
• третий раунд: ответственный за каждую процедуру переписывает ее в соответствующий класс;
• четвертый раунд: grepсчастлив!

Я думаю, что одна из самых важных вещей - взять простую функцию, выбрать простейшую из возможных и реализовать ее. Если есть поддерживаемый список пожеланий, используйте его или поговорите с кем-нибудь, знакомым с базой кода, и попросите его предложить функцию. Обычно я ожидаю, что это будет изменение с 5 ~ 20 LOC. Важный момент заключается не в том, что вы добавляете очень необычную функцию, а в том, что вы работаете (или, скорее, боретесь с :)) с базой кода и проходите весь рабочий процесс. Вы должны были бы

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

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

Маленькая вещь, которую я хотел добавить:

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

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

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

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

Создать / обновить документ по созданию программной среды. Все инструменты, причуды, варианты установки и т. Д. Идут сюда.

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

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

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

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

Я написал довольно длинный пост на эту тему. Вот выдержка

Я долго думал об этой проблеме. Я решил написать свое личное решение как общий процесс. Шаги, которые я задокументировал, следующие:

1. Создать словарный запас
2. Изучите приложение
3. Просмотр доступной документации
4. Делать предположения
5. Найдите сторонние библиотеки
6. Анализировать код

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

взяты из: процесс для изучения новой кодовой базы

Есть несколько небольших советов, которыми я могу поделиться.

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

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

• Следующим шагом будет создание простой диаграммы классов с ее обязанностями (например, карты CRC).

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

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

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

И метод, который мы успешно использовали, и я бы сказал, является наиболее эффективным способом, без вопросов ИМХО, это парное программирование.

За последние 12 месяцев у нас в команде было 4 новых члена, и каждый раз новый участник связывался с другим участником, хорошо знакомым с базой кода. В начале, старший член команды будет иметь клавиатуру. Примерно через 30 минут мы передавали клавиатуру новому члену, который работал бы под руководством старшего члена команды.

Этот процесс оказался весьма успешным.