Uso responsável de sugestões integradas do GitHub Copilot

Sobre as sugestões em linha do GitHub Copilot}

As sugestões em linha do Copilot} são sugestões de estilo de preenchimento automático geradas em linha pelo GitHub Copilot}. As sugestões em linha do Copilot} criam a experiência de trabalhar com um programador de pares alimentado por IA, oferecendo automaticamente sugestões para concluir seu código. Além disso, ele pode sugerir comentários de código, testes e muito mais. Ele faz essas sugestões diretamente em editores com suporte enquanto você escreve seu código, e pode funcionar com uma ampla gama de linguagens de programação e estruturas. Para saber mais, confira O que é o GitHub Copilot?.

As sugestões do Copilot} podem ser a conclusão da linha atual, mas às vezes será um novo bloco de código. Você pode aceitar toda ou parte de uma sugestão, ignorar a sugestão ou continuar digitando e ignorando as sugestões.

As sugestões em linha do Copilot} funcionam usando uma combinação de processamento de linguagem natural e aprendizado de máquina para entender o código ao redor (em relação à posição do cursor) e fornecer sugestões. Esse processo pode ser dividido em várias etapas.

Processamento de entrada

O código ao redor do cursor do usuário é pré-processado pelo sistema de sugestões em linha do Copilot}, combinado com informações contextuais (como trechos de código de guias abertas no editor) e enviados para um modelo de linguagem grande na forma de uma solicitação. Para obter informações sobre retenção de dados, consulte a Central de Confiabilidade do GitHub Copilot}.

Em seguida, o modelo de linguagem grande usa a solicitação e fornece uma resposta com base na solicitação. O sistema só se destina a ajudar na codificação.

Análise de modelo de linguagem

O modelo de linguagem grande que processa a solicitação de entrada é um modelo de linguagem ajustado para sugestões em linha, que é uma rede neural que foi treinada em um grande corpo de dados de código especializado para fornecer sugestões em linha.

Você pode alterar o modelo usado para sugestões em linha. Confira Alterando o modelo de IA para sugestões embutidas do GitHub Copilot.

Geração de resposta

O modelo de linguagem gera uma resposta com base na análise do prompt de entrada e no contexto fornecido. Essa resposta assume a forma de código gerado e comentários de texto sem formatação, desde o preenchimento da linha atual até um novo bloco de código.

Formatação de saída

A resposta gerada pelo Copilot} é formatada como um "texto fantasma", que é visualmente distinto do código ao redor e apresentada ao usuário como uma sugestão. Ele só será adicionado ao arquivo/base de código se o usuário aceitar explicitamente a sugestão. Os usuários podem aceitar toda ou parte de uma sugestão, ignorar a sugestão ou continuar digitando e ignorar as sugestões, caso em que a sugestão é descartada.

GitHub Copilot as sugestões embutidas destinam-se a fornecer as sugestões de código mais relevantes e úteis para aperfeiçoar o código existente. Mas, nem sempre ele consegue fornecer as respostas que você está procurando. Os usuários do Copilot} são responsáveis por revisar e validar as respostas geradas pelo sistema para garantir que elas sejam precisas e apropriadas antes de aceitá-las. Além disso, como parte do nosso processo de desenvolvimento de produtos, realizamos o agrupamento vermelho para entender e melhorar a segurança das sugestões em linha do Copilot}. As sugestões geradas também são executadas por meio de filtros de conteúdo. O sistema de filtragem de conteúdo detecta e impede o Copilot} de gerar qualquer conteúdo prejudicial ou ofensivo ou código inseguro. Além disso, dependendo das configurações do GitHub do usuário, o filtro também bloqueia ou anota sugestões que contêm correspondências ao código público.

Casos de uso para sugestões em linha do GitHub Copilot}

As sugestões em linha do GitHub Copilot} podem oferecer ajuda com código em uma variedade de cenários.

Gerar código com base em suas instruções

Além de depender do Copilot} para dar sugestões, você pode usar comentários de código para informar o Copilot} sobre o código que você espera que siga o comentário. Por exemplo, você pode usar comentários como "usar recursão" ou "usar um padrão singleton" para especificar um tipo de algoritmo que o Copilot} deve sugerir. Ou você pode usar comentários para informar ao Copilot} quais métodos e propriedades adicionar a uma classe.

Gerar casos de teste de unidade

As sugestões em linha do Copilot} podem ajudar você a escrever casos de teste de unidade gerando trechos de código com base no código ao redor digitado no editor. Isso pode ajudar você a gastar menos tempo em tarefas repetitivas escrevendo casos de teste. Por exemplo, se estiver escrevendo um caso de teste para uma função específica, você poderá usar o Copilot} para sugerir possíveis parâmetros de entrada e valores de saída esperados com base na assinatura e no corpo da função. Sugestões embutidas também podem sugerir asserções que garantem que a função esteja funcionando corretamente, com base no contexto e na semântica do código.

As sugestões em linha Copilot} também podem ajudar a gerar casos de teste para casos extremos e condições de fronteira que podem ser difíceis de identificar manualmente. Por exemplo, o Copilot} pode sugerir casos de teste para o tratamento de erro, os valores nulos ou os tipos de entrada inesperados, ajudando a garantir que o código fique robusto e resiliente. No entanto, é importante observar que os casos de teste gerados podem não abranger todos os cenários possíveis. Testes manuais e revisões de código ainda serão necessários para garantir a qualidade do código.

Isso pode ser uma ferramenta útil para programadores, pois pode fornecer diretrizes e suporte para tarefas e desafios comuns de codificação.

Melhorando o desempenho das sugestões em linha do GitHub Copilot}

As sugestões em linha do Copilot} podem gerar sugestões de código em diferentes contextos, com métricas variadas de desempenho e qualidade. Para aprimorar o desempenho e resolver algumas das limitações das sugestões em linha Copilot}, há várias medidas que você pode adotar. Para obter mais informações sobre as limitações das sugestões automáticas Copilot, consulte Limitações das sugestões automáticas GitHub Copilot.

Mantenha as solicitações no tópico

O Copilot} se destina exclusivamente a gerar conclusões que sejam relacionadas ao código ou o próprio código. Portanto, limitar o contexto do conteúdo no editor ao código ou às informações relacionadas à codificação pode melhorar a qualidade de saída do modelo.

Use as sugestões em linha do Copilot} como uma ferramenta, e não uma substituição

Embora o Copilot} seja ferramenta poderosa para gerar código, é importante usá-lo como ferramenta em vez de substituir a programação humana. Você sempre deverá examinar o código gerado pelo Copilot} antes de aceitar uma sugestão e validá-la posteriormente para garantir que atenda aos seus requisitos e esteja livre de erros ou problemas de segurança.

Use práticas seguras de codificação e revisão de código

Embora as sugestões em linha do Copilot} possam gerar código sintaticamente correto, esse código pode nem sempre ser seguro. Você sempre deve seguir as práticas recomendadas para codificação segura, como evitar senhas embutidas diretamente no código ou vulnerabilidades de injeção de SQL. Além disso, siga as práticas recomendadas de revisão de código para resolver as limitações de Copilot.

Fique atualizado

Copilot as sugestões embutidas ainda são uma tecnologia bastante nova e provavelmente evoluirão ao longo do tempo. Esteja sempre em dia com as atualizações ou alterações na ferramenta, bem como novos riscos de segurança ou práticas recomendadas que possam surgir. As atualizações automatizadas de extensão são habilitadas por padrão no Visual Studio Code, no Visual Studio e no pacote JetBrains de IDEs. Se as atualizações automáticas estiverem habilitadas, o Copilot} será atualizado automaticamente para a última versão quando você abrir o IDE. Para obter mais informações sobre atualizações automáticas em seu IDE, consulte a documentação do seu IDE ou editor de código preferido.

Limitações das sugestões embutidas GitHub Copilot

Dependendo de fatores como sua base de código e dados de entrada, você poderá experimentar diferentes níveis de desempenho ao interagir com as sugestões em linha do Copilot}. As informações a seguir foram projetadas para ajudá-lo a entender as limitações do sistema e os principais conceitos sobre o desempenho à medida que se aplicam a sugestões em linha do Copilot}.

Escopo limitado

As sugestões em linha do Copilot} são treinadas em um grande corpo de código, mas ainda têm um escopo limitado e podem não ser capazes de lidar com estruturas de código mais complexas ou linguagens de programação obscuras. Para cada linguagem, a qualidade das sugestões recebidas pode depender do volume e da diversidade de dados de treinamento para essa linguagem. Por exemplo, o JavaScript é bem representado nos repositórios públicos e é uma das linguagens com melhor suporte do GitHub Copilot. No caso de linguagens com menos representação em repositórios públicos, pode ser mais difícil para o Copilot} ajudar. Além disso, as sugestões em linha do Copilot} só podem sugerir o código com base no contexto do código que está sendo escrito, e portanto, pode não conseguir identificar questões de design ou arquitetura mais amplos.

Por fim, as sugestões em linha do Copilot} destinam-se a gerar o código e a saída relacionada ao código. O uso de sugestões em linha do Copilot} não se destina a gerar saídas de linguagem natural.

Possíveis desvios

Os dados de treinamento do Copilot são extraídos de repositórios de código existentes, que podem conter desvios e erros que poderão ser perpetuados pela ferramenta. Além disso, as sugestões em linha do Copilot} podem ser tendenciosas em relação a determinadas linguagens de programação ou estilos de codificação, o que pode levar a sugestões de código abaixo do ideal ou incompletas.

Riscos de segurança

O Copilot} gera código com base no contexto do código que está sendo escrito, que poderá expor informações confidenciais ou vulnerabilidades se não for usado com cuidado. Tenha cuidado ao usar o Copilot} para gerar o código para aplicativos sensíveis à segurança e sempre revise e teste completamente o código gerado.

Correspondências com código público

Copilot sugestões embutidas são capazes de gerar novo código, o que fazem de forma probabilística. Embora a probabilidade seja baixa, o Copilot} pode gerar sugestões de código que correspondem ao código no conjunto de treinamento.

Código impreciso

Uma das limitações do Copilot} é que ele pode gerar um código que parece ser válido, mas pode não estar correto em termos semânticos ou sintáticos, ou não refletir com precisão a intenção do desenvolvedor. Para atenuar o risco de código impreciso, revise e teste cuidadosamente o código gerado, ainda mais ao lidar com aplicativos críticos ou confidenciais. Você também deve garantir que o código gerado siga práticas recomendadas e os padrões de design e se encaixe na arquitetura geral e no estilo da base de código.

Considerações legais e regulatórias

Os usuários precisam avaliar possíveis obrigações legais e regulatórias específicas ao usar serviços e soluções de IA, o que pode não ser apropriado para uso em todos os setores ou cenários. Além disso, os serviços ou soluções de IA não são projetados para serem usados de maneiras proibidas e não podem ser assim usados nos termos de serviço e códigos de conduta relevantes aplicáveis.

Próximas etapas

Para obter detalhes de como usar as sugestões em linha do Copilot}, consulte:

•         [AUTOTITLE](/copilot/using-github-copilot/getting-code-suggestions-in-your-ide-with-github-copilot)
  

Leitura adicional

•         [AUTOTITLE](/free-pro-team@latest/site-policy/github-terms/github-terms-for-additional-products-and-features#github-copilot)
  

•         [Central de Confiabilidade do GitHub Copilot](https://copilot.github.trust.page/)