Combinada com metodologias como o Test-Driven Development (TDD), a engenharia de prompt potencializa muito o trabalho de quem desenvolve, proporcionando uma experiência de desenvolvimento mais ágil e eficiente.
Ao dominar a engenharia de prompt, profissionais de tecnologia exploram todo o potencial de ferramentas como a StackSpot AI, que compreendem comandos e se adaptam ao estilo de cada pessoa. Comandos claros e precisos garantem resultados ainda melhores.
Neste artigo, exploraremos a cooperação entre a inteligência artificial generativa e o desenvolvimento de software, com foco na utilização de testes unitários como prompts para a geração de código. Através de um exemplo prático, demonstraremos como a StackSpot AI pode otimizar o processo de desenvolvimento e garantir a qualidade do software, com metodologias como o Test-Driven Development (TDD).
O que é Test Driven Development (TDD)?
Projetos de software de grande porte exigem rigor e precisão. O Test-Driven Development (TDD) é uma metodologia que eleva a qualidade do código e promove a excelência técnica.
No Test-Driven Development, os testes são escritos antes da implementação, orientando o desenvolvimento e garantindo que o código sempre atenda aos requisitos. Essa abordagem fortalece a confiança da equipe, acelera o desenvolvimento e facilita a colaboração.
Ao adotar o Test-Driven Development, as equipes garantem que o software seja mais robusto, mais fácil de manter e altamente confiável. Ao garantir um código de alta qualidade, o TDD contribui para uma experiência das pessoas usuárias mais satisfatória e estável.
Benefícios do Test-Driven Development (TDD)
Os benefícios de adotar o Test-Driven Development (TDD) no desenvolvimento de software são muitos. A seguir, destacamos os principais:
- Código de alta qualidade: Ao escrever os testes antes, a pessoa desenvolvedora se concentra em criar código que atenda aos requisitos específicos dos testes, resultando em um código mais limpo;
- Melhoria da arquitetura: O Test-Driven Development (TDD) incentiva a criação de um design modular e testável, tornando a manutenção e a refatoração do código mais simples e seguras;
- Documentação viva: Os testes servem como uma documentação executável do comportamento esperado do código, tornando mais fácil entender e modificar o sistema no futuro;
- Aumento da confiança: Ao ter um conjunto de testes abrangente, as pessoas desenvolvedoras podem fazer alterações no código com mais confiança, sabendo que os testes irão identificar qualquer regressão;
- Código sempre funcionando: O ciclo de fail-pass-refactoring garante que o código está quase sempre funcionando, e é mais fácil debugar.
Testes como prompt
A StackSpot AI se destaca por permitir que testes unitários substituam a necessidade de traduzir ideias complexas para uma linguagem natural, que pode ser ambígua. Ao fornecer um teste, quem desenvolve mostra à IA exatamente o comportamento esperado de uma função ou classe.
Essa abordagem se assemelha a dar um desenho técnico para um profissional da arquitetura: o desenho detalha exatamente como a construção deve ser.
Com a StackSpot AI, a comunicação entre pessoa desenvolvedora e máquina se torna mais direta e eficiente, através da engenharia de prompt, resultando em um processo de desenvolvimento mais ágil e preciso.
Um exemplo prático
Agora que já conhecemos as vantagens do Test-Driven Development (TDD) é hora de ver na prática como a StackSpot AI pode ajudar neste processo.
O problema
Para essa demonstração, vamos criar um arquivo de testes unitários em Python e esse arquivo será o input que a StackSpot AI usará para gerar o código.
Problema: gostaria de ter uma classe que encapsula um número e faça a conversão bidirecional entre as representações em números arábicos e caracteres romanos.
Esse é o código de teste:
import unittest
class RomanNumeralTest(unittest.TestCase):
def test_should_create_roman_numeral_object_from_int(self):
actual_numerals = [RomanNumeral(i).as_roman() for i in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100,200, 300, 400,500, 600, 700, 800, 900, 1000]]
expected_numerals = ["I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX", "X", "XX","XXX", "XL", "L", "LX", "LXX", "LXXX", "XC", "C", "CC", "CCC", "CD", "D","DC", "DCC", "DCCC", "DCCCC", "M"]
self.assertListEqual(expected_numerals, actual_numerals)
def test_should_create_roman_numeral_object_from_string(self):
actual_numerals = [RomanNumeral(s).as_arabic() for s in ["I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC", "C", "CC", "CCC", "CD", "D","DC", "DCC", "DCCC", "DCCC", "M"]]
expected_numerals = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 200, 300, 400, 500, 600, 700, 800, 900, 1000]
self.assertListEqual(expected_numerals, actual_numerals)
if __name__ == '__main__':
unittest.main()
Aprimorando o teste
Vamos solicitar uma análise de code smells. Para isso, clique com o botão direito do mouse dentro da área de edição de código. Um menu vai aparecer; é o menu de contexto. Nesse menu, vou até StackSpot AI. Um submenu vai aparecer, com a opção “Is there any code smell in this code?“. Basta selecionar essa opção.
Essa é a resposta:
Com base no trecho de código fornecido, não é possível dizer com certeza se há bugs ou code smells porque a implementação da classe RomanNumeral não é fornecida. No entanto, existem algumas observações e possíveis problemas que podem ser apontados:
1. A classe RomanNumeral não é importada ou definida no trecho de código, o que resultaria em um NameError ao tentar instanciar RomanNumeral(i) ou RomanNumeral(s).
2. Há um possível erro de digitação na lista de números esperados para a representação em algarismo romano de 900. Ele está listado como “DCCCC”, mas o algarismo romano correto para 900 é “CM”.
3. O código não segue o guia de estilo PEP 8 para código Python, que recomenda duas linhas em branco antes das definições de classe.
StackSpot AI sugere o seguinte código, corrigindo os pontos levantados:
import unittest
# Assuming the RomanNumeral class is defined in roman_numeral.py
from roman_numeral import RomanNumeral
class RomanNumeralTest(unittest.TestCase):
def test_should_create_roman_numeral_object_from_int(self):
actual_numerals = [RomanNumeral(i).as_roman() for i in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 200, 300, 400, 500, 600, 700, 800, 900, 1000]]
expected_numerals = ["I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM", "M"] # Corrected "DCCCC" to "CM"
self.assertListEqual(expected_numerals, actual_numerals)
def test_should_create_roman_numeral_object_from_string(self):
actual_numerals = [RomanNumeral(s).as_arabic() for s in ["I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM", "M" # Assuming "CM" is the correct representation for 900]]
expected_numerals = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 200, 300, 400, 500, 600, 700, 800, 900, 1000]
self.assertListEqual(expected_numerals, actual_numerals)
if __name__ == '__main__':
unittest.main()Vamos aceitar as correções e prosseguir.
É interessante que a StackSpot AI tem conhecimento de temas que extrapolam o escopo do desenvolvimento de software, como numeração romana.
Gerando o código
Entro com o seguinte prompt:
“Forneça uma implementação da classe RomanNumeral que faça os testes passarem.”
A StackSpot AI trouxe de resposta:
class RomanNumeral:
def __init__(self, value):
if isinstance(value, int):
self.value = value
elif isinstance(value, str):
self.value = self._from_roman(value)
else:
raise TypeError("Value must be an integer or a string representing a Roman numeral.")
def as_roman(self):
return self._to_roman(self.value)
def as_arabic(self):
return self.value
@staticmethod
def _to_roman(number):
roman_numerals = {1000: 'M', 900: 'CM', 500: 'D', 400: 'CD', 100: 'C', 90: 'XC', 50: 'L', 40: 'XL', 10: 'X', 9: 'IX', 5: 'V', 4: 'IV', 1: 'I'}
result = ""
for value, numeral in sorted(roman_numerals.items(), reverse=True):
while number >= value:
result += numeral
number -= value
return result
@staticmethod
def _from_roman(roman):
roman_numerals = {'M': 1000, 'CM': 900, 'D': 500, 'CD': 400, 'C': 100, 'XC': 90, 'L': 50, 'XL': 40, 'X': 10, 'IX': 9, 'V': 5, 'IV': 4, 'I': 1}
index = 0
number = 0
while index < len(roman):
if (index + 1 < len(roman)) and (roman[index:index+2] in roman_numerals):
number += roman_numerals[roman[index:index+2]]
index += 2
else:
number += roman_numerals[roman[index]]
index += 1
return number
A StackSpot fornece ainda a orientação de colocar o código no arquivo roman_numeral.py. Ao executar os testes, temos resultado positivo em ambos.
Conclusão
No exemplo prático da conversão de números romanos, StackSpot AI demonstrou ser uma colaboradora valiosa ao identificar e corrigir os problemas no código de testes, além de gerar o código de produção esperado.
Essa colaboração entre pessoa e máquina acelerou o processo de desenvolvimento e resultou em um código mais limpo, eficiente e confiável.
A capacidade da StackSpot AI em gerar código de alta qualidade com base em testes unitários abre novas possibilidades para o futuro do desenvolvimento de software.
Confira a documentação da StackSpot AI aqui.
Ficou com alguma dúvida ou tem sugestões? Então deixe um comentário.
