Поиск по сайту:
Человек живет как сор и умрет как сор (В.В. Розанов).

Повышение качества кода и сокращение технической задолженности с помощью ChatGPT

FavoriteLoadingДобавить в избранное
12.06.2024
Повышение качества кода и сокращение технической задолженности с помощью ChatGPT

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

Кент Бек, пионер шаблонов проектирования программного обеспечения и один из 17 первых подписантов манифеста Agile, и Мартин Фаулер, инженер-программист и специалист по объектно-ориентированному проектированию и анализу, ввели термин “запах кода” для шаблонов, которые могут указывать на дефекты дизайна. Эти дефекты не являются ошибками, скорее, это вещи, которые могут вызывать их или препятствовать разработке — то, что бросало вызов практике экстремального программирования Бека и Фаулера. Запахи кода порождают техническую задолженность — скрытые затраты на выбор быстрых и простых решений, требующих доработки в будущем, вместо того, чтобы тратить усилия сейчас на более эффективное решение.

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

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

 

Определение запахов кода с помощью ChatGPT

ChatGPT поможет вам определить запахи кода в кодовой базе .NET. Хотя вы можете использовать любой язык, в этой статье используется C #.

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

Затем отправьте четкое и лаконичное приглашение. Например, вы можете попросить ChatGPT определить запахи кода во фрагменте или проверить, соответствует ли ваш код определенному принципу SOLID object-oriented design. SOLID – это аббревиатура, обозначающая пять ключевых принципов объектно-ориентированного проектирования: единая ответственность, открытый-закрытый дизайн, замена Лискова, разделение интерфейса и инверсия зависимостей.

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

Пример

Запрос ChatGPT: Пожалуйста, проанализируйте следующий фрагмент кода и определите любые потенциальные запахи кода, присутствующие в нем.

private void ComputeGloom(WordDictionary wordDictionary, 
                           List<string> gloom) 
{ 
    wordDictionary._gloomScore = 0; 
    for (int i = 0; i < gloom.Count; i++) 
    { 
        if (wordDictionary.GloomWordsContain(gloom[i])) 
        { 
            int val; 
            wordDictionary.GloomWords.TryGetValue(gloom[i], out val); 
            wordDictionary._gloomScore += val; 
        } 
    } 
}
  • Функция Envy: Этот метод, похоже, больше интересуется WordDictionary классом, часто используя его данные и операции. Это говорит о том, что метод может быть лучше приспособлен для WordDictionary самого по себе.
  • Неуместная интимность/нарушение инкапсуляции: метод напрямую манипулирует wordDictionary._gloomScore полем, которое кажется закрытым. Метод должен учитывать инкапсуляцию объекта и не должен напрямую обращаться к его полям. Вместо этого используйте методы для манипулирования ими.
  • Избыточный код: операция GloomWordsContain проверки и TryGetValue является избыточной. Сам TryGetValue метод можно использовать для проверки наличия ключа и получения значения. Использование gloom[i] также может быть заменено на foreach.
  • Плохой API: метод изменяет состояние объекта, передаваемого в качестве параметра (wordDictionary), чего могут не ожидать пользователи этого метода. Как правило, изменять состояние объекта, передаваемого методу, – плохая идея.

 

Ответ ChatGPT эффективно выявляет feature envy, отмечая, что функция ComputeGloom, похоже, больше взаимодействует с классом WordDictionary, чем со своим собственным классом. Зависть к функциям возникает, когда метод проявляет больший интерес к классу, отличному от его собственного. Часто это указывает на то, что вы должны возложить обязанности метода на класс, которому он “завидует”. ChatGPT также обнаруживает ненадлежащую близость или нарушение инкапсуляции, избыточный код и, возможно, неадекватный API.

Конечный результат с запахом кода может быть ложноположительным. Предположение о плохом API может быть ошибочным, поскольку пользователь метода ожидает, что приложение каким-то образом вернет вычисленное значение gloom. Тип метода void указывает на это ожидание.

Читать  8 крупнейших тенденций веб-разработки на данный момент

 

Рефакторинг кода с помощью ChatGPT

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

Пример

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

private void ComputeGloom(WordDictionary wordDictionary, 
                           List<string> gloom) 
{ 
    wordDictionary._gloomScore = 0; 
    for (int i = 0; i < gloom.Count; i++) 
    { 
        if (wordDictionary.GloomWordsContain(gloom[i])) 
        { 
            int val; 
            wordDictionary.GloomWords.TryGetValue(gloom[i], out val); 
            wordDictionary._gloomScore += val; 
        } 
    } 
}  

public class WordDictionary 
{ 
  public Dictionary<string, int> GloomWords { get; private set; } 
  public int GloomScore { get; private set; } 

  public WordDictionary (Dictionary<string, int> gloomWords) 
  { 

    GloomWords gloomWords ?? new Dictionary<string, int>(); 
    GloomScore = 0; 
  } 

  public void ComputeGloom(List<string> gloom) 
  { 
    GloomScore = 0; 

    foreach (var word in gloom) 
    { 
      if (GloomWords.TryGetValue(word, out int val)) 
      { 
        GloomScore += val; 
      } 
    } 
  } 
}

 

Вот краткое изложение изменений и причин, стоящих за ними:

  1. Сделайте WordDictionary._gloomScore общедоступным свойством с частным настройщиком:
    Это упрощает чтение GloomScore извне класса, в то же время не позволяя внешнему коду изменять его напрямую. Это обеспечивает целостность данных.
  2. Устранена необходимость прямого доступа к экземпляру wordDictionary:
    метод ComputeGloom теперь является методом экземпляра внутри WordDictionary класса. Концептуально это имеет больше смысла, поскольку это операция, выполняемая над WordDictionary экземпляром.
  3. Объединить слова GloomWords Contain и Gloom Words.TryGetValue:
    TryGetValue Метод словаря одновременно проверяет наличие ключа и извлекает значение. Это устраняет необходимость в двух обращениях к словарю, тем самым повышая эффективность.
  4. Используйте ‘foreach’ вместо ‘for’:
    это делает код более чистым и читабельным. В этом случае нет необходимости вручную управлять индексной переменной, поскольку мы не используем ее ни для чего, кроме доступа к элементам.
  5. Перенести начальную настройку GloomScore в конструктор:
    Это гарантирует, что каждый экземпляр WordDictionary имеет инициализацию GloomScore O, не требуя явного вызова ComputeGloom.

 

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

Просьба к ChatGPT объяснить суть рефакторинга помогает углубить ваше понимание того, как реструктурировать код. Затем вы сможете применять те же методы в будущем, сводя к минимуму необходимость устранения недостатков кода.

 

Внедрение лучших практик использования ChatGPT на

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

ChatGPT может проанализировать ваш код, определить области, где он отличается от лучших практик, и предложить улучшения. В этом разделе рассматривается, как ChatGPT может помочь вам реализовать принципы SOLID объектно-ориентированного проектирования в вашей кодовой базе C #, включая принцип разделения интерфейсов (ISP). Провайдер заявляет, что клиенты не должны быть вынуждены зависеть от интерфейсов, которые они не используют.

Пример

Запрос ChatGPT: Не могли бы вы проанализировать этот код и указать области, где его потенциально можно улучшить? Существуют ли какие-либо рекомендации, принципы проектирования или соглашения, которые, по-видимому, отсутствуют или не были реализованы надлежащим образом?

public interface IDictionaryOperations 
{ 
    void ComputeGloom(List<string> gloom); 
    int GetGloomScore(); 
    void AddWord(string word, int score); 
    void RemoveWord(string word); 
} 

public class WordDictionary : IDictionaryOperations 
{ 
    private int _gloomScore; 
    private Dictionary<string, int> _gloomWords; 

    public WordDictionary(Dictionary<string, int> gloomWords) 
    { 
        _gloomWords = gloomWords; 
        _gloomScore = 0; 
    } 

    public void ComputeGloom(List<string> gloom) 
    { 
        _gloomScore = 0; 
        foreach (var word in gloom) 
        { 
            if (_gloomWords.TryGetValue(word, out int val)) 
            { 
                _gloomScore += val; 
            } 
        } 
 
    public int GetGloomScore() 
    { 
        return _gloomScore; 
    } 

    public void AddWord(string word, int score) 
    { 
        // Not needed for this class but necessary because of the interface 
        throw new NotImplementedException(); 
    } 

    public void RemoveWord(string word) 
    { 
        // Not needed for this class but necessary because of the interface 
        throw new NotImplementedException(); 
    } 
}

 

Вот ответ:

В этом коде есть несколько моментов для обсуждения:

  • Принцип разделения интерфейсов (ISP): Это один из принципов SOLID. Он гласит, что ни один клиент не должен быть вынужден зависеть от интерфейсов, которые он не использует. Здесь WordDictionary реализованы IDictionaryOperations, но не нужны методы AddWord и RemoveWord, как показано в комментариях. Следовательно, этот код нарушает права провайдера. Если эти методы применимы не ко всем реализующим классам IDictionaryOperations, возможно, было бы лучше разделить этот интерфейс на два: один для вычисления и получения показателя мрачности, а другой для манипулирования словарем.
  • Использование NotImplementedException: Плохая практика – реализовывать интерфейс, а затем выдавать NotImplementedException для методов, которые вы не хотите использовать. Если вы обнаружите, что некоторые методы неприменимы к вашему классу, вместо того, чтобы создавать исключение, вы можете пересмотреть дизайн своего класса и интерфейса (см. Пункт об ISP выше).
  • Модификаторы доступа и инкапсуляция: класс WordDictionary зависит от Dictionary<строка, int>. Эта зависимость передается через ее конструктор, и к ней можно получить доступ извне класса. Возможно, вы захотите пересмотреть это, чтобы полностью инкапсулировать данные внутри вашего класса. Если абсолютно необходимо, чтобы он предоставлялся извне, рассмотрите возможность создания глубокой копии, чтобы избежать потенциальных проблем с изменяемыми данными.
  • Соглашение об именовании: ComputeGloom и GetGloomScore могли бы иметь лучшие имена для обозначения того, что они делают. Методы должны быть глаголами или глагольными фразами, и они должны четко передавать свои эффекты. Например, ComputeGloomScore было бы лучше, чем ComputeGloom, и GetGloomScore could быть RetrieveGloomScore.
  • Потенциальная несогласованность: метод ComputeGloom сбрасывается, а затем пересчитывается _gloomScore при каждом вызове. Если существует вероятность _gloomWords изменения базового кода между вызовами ComputeGloom и GetGloomScore, это может привести к неожиданному поведению. Чтобы избежать этого, рассмотрите возможность пересчета оценки в пределах GetGloomScore или в момент изменения gloomWords.
  • Неизменяемость: поле _gloomScore может изменяться. Вы могли бы рассмотреть возможность создания вычисляемого свойства на основе _gloomWords, что сделало бы ваш класс более устойчивым к манипулированию состоянием и потенциальным ошибкам.
  • Тестирование и ремонтопригодность: При текущем дизайне модульное тестирование класса может быть затруднено из-за изменений внутреннего состояния. Разработка с учетом возможности тестирования может привести к созданию более понятного и сопровождаемого кода.
Читать  Теорема CAP в системном проектировании

 

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

 

Интеграция ChatGPT в процесс разработки

Интеграция ChatGPT в ваш процесс разработки на C # / .NET может повысить производительность и качество кода. Чтобы ускорить процесс разработки, вы можете использовать мощные инструменты, такие как Copilot от GitHub и CodeGPT, для решения следующих задач:

  • Генерация кода — Используя эти расширения, разработчики могут без особых усилий генерировать шаблонный код на C # / .NET. Простым описанием высокоуровневой функциональности расширения создают классы, интерфейсы и методы, тем самым экономя время разработки и поддерживая согласованность всей кодовой базы.
  • Предложения по коду — Такие инструменты, как GitHub Copilot и CodeGPT, могут предложить улучшенные методы программирования. Вы можете напрямую попросить эти расширения сгенерировать оптимизированные и эффективные предложения по коду, выделив ваш код.
  • Помощь с документацией — Эти расширения на базе искусственного интеллекта могут помочь в написании XML-комментариев для методов, свойств и классов C #, обеспечивая хорошо документированную кодовую базу.
  • Обзоры кода — Вы можете использовать эти расширения для проверки соответствия кода установленным соглашениям о кодировании, таким как именование и отступы. Инструменты обеспечивают соответствие лучшим практикам и гарантируют, что вы правильно используете функции C #, такие как сопоставление шаблонов async / await.
  • Парное программирование — GitHub Copilot и CodeGPT также предлагают предложения по коду в режиме реального времени и примеры фрагментов кода, что упрощает парное программирование. Эти инструменты даже помогают отлаживать код, выявляя потенциальные проблемы.
  • Тестирование и отладка — Использование этих инструментов может помочь в написании модульных тестов с использованием популярных фреймворков тестирования, таких как NUnit или xUnit, и они могут предложить потенциальные крайние случаи или сценарии тестирования.

 

API ChatGPT Whisper позволяет программно использовать искусственный интеллект в ваших процессах разработки на /.NET, повышая производительность и качество кода.

Примените эти рекомендации, чтобы успешно интегрировать ChatGPT в ваш процесс разработки на /.NET:

  • Определите области использования — Выберите части процесса разработки, где ChatGPT может принести пользу.
  • Интеграция инструментов — Включите ChatGPT в повседневные инструменты с помощью плагинов и расширений IDE.
  • Настройте его в соответствии с вашими конкретными потребностями — Точно настройте ChatGPT для отдельных кодовых баз в соответствии с уникальными стилями кодирования вашей организации и бизнес-логикой.
  • Обучайте команду — Проводите тренинги, чтобы убедиться, что ваша команда разработчиков эффективно использует ChatGPT.
  • Постоянная оценка и корректировка — Регулярно оценивайте влияние интеграции ChatGPT и вносите коррективы на основе отзывов.
  • Постепенное масштабирование — После успешного первоначального внедрения расширьте использование ChatGPT в процессе разработки.
Читать  Meta стремится создать конкурента ChatGPT с открытым исходным кодом

 

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

 

Ограничения и рекомендации

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

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

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

  • Используйте ChatGPT для создания шаблонного кода — Быстро создавайте стандартные части вашего приложения, уменьшая количество человеческих ошибок и повторяющихся задач, значительно экономя время разработки.
  • Используйте ChatGPT для создания структур кода, которые вам придется заполнить позже — Сделайте вашу разработку более организованной и уменьшите когнитивную нагрузку, связанную с созданием архитектуры с нуля, улучшая общее качество кода.
  • Используйте ChatGPT для объяснения кода, сгенерированного с помощью зависимостей с открытым исходным кодом или сторонних производителей – Упрощайте понимание сложных структур кода, упрощая интеграцию, настройку или отладку внешних библиотек и зависимостей в вашем проекте.
  • Используйте ChatGPT для создания документации и примеров модульного тестирования на основе устаревшего кода — Вы можете обеспечить надлежащий охват тестирования и улучшить ремонтопригодность с помощью точной и актуальной документации.
  • Используйте ChatGPT для генерации понятного кода, а затем напишите его самостоятельно — это не только помогает новичкам освоить лучшие практики кодирования, но и помогает опытным разработчикам в изучении альтернативных стратегий кодирования.

 

Заключение

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

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

Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.

1 Звезда2 Звезды3 Звезды4 Звезды5 Звезд (2 оценок, среднее: 5,00 из 5)
Загрузка...
Поделиться в соц. сетях:



Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

пятнадцать − 7 =

**ссылки nofollow

Это может быть вам интересно


Рекомендуемое
С каждым днем ​​мы приближаемся к миру видеокарт RDNA 4.…

Сообщить об опечатке

Текст, который будет отправлен нашим редакторам: