Latest / M365.FM – Podcast de Microsoft 365, Copilot e IA em português / Corrija rápido a validação de formulários do Power Pages com GitHub Copilot e @powerpages no VS Code (Dublagem IA)

Transcript

Corrija rápido a validação de formulários do Power Pages com GitHub Copilot e @powerpages no VS Code (Dublagem IA) · M365.FM – Podcast de Microsoft 365, Copilot e IA em português

0:00
Você conhece aquela sensação ruim quando o seu formulário do PowerPages não valida
0:03
e as mensagens de erro são tão úteis quanto um erro 404 de cérebro não encontrado?
0:07
Esse problema é exatamente o que vamos ver hoje.
0:09
Vamos cobrir cinco passos.
0:11
Otimizar modelos Liquid, acelerar JavaScript e validação de formulários,
0:14
obter explicações de código em linguagem simples,
0:16
integrar HTML com Bootstrap para layouts responsivos
0:19
e simplificar chamadas de API Web.
0:22
Um aviso rápido, você precisará do VS Code com extensão Power Platform Tools,
0:26
o GitHub Copilot Chat e o conteúdo do seu site extraído via Power Platform CLI com autenticação DataVersity.
0:32
Essa configuração torna o Copilot contexto.
0:34
Com isso, o Copilot espera de sugerir trechos de código aleatórios.
0:37
Ele fornece código iterativo e contextual que reduz a tentativa E.
0:40
Vou mostrar os prompts exatos para que você mesmo possa replicar os resultados.
0:43
E como a maioria das dores começa com JavaScript,
0:45
vamos entrar no que acontece quando seus erros de formulário parecem uma falha crítica.
0:49
Quando o JavaScript parece uma falha crítica,
0:51
ele pode transformar o que deveria ser uma verificação simples de formulário em um desastre rapidamente.
0:55
Uma tecla digitada no lugar errado e, em vez de impedir uma entrada inválida,
0:58
todo o fluxo entra em colapso.
1:00
É geralmente quando você fica sentado encarando a tela
1:02
imaginando como o banana conseguiu passar pela sua lógica de validação cuidadosamente escrita.
1:06
Você conhece o processo, um formulário que parece inofensivo,
1:09
um validador feito para filtrar absurdos e um usuário esperto digitando a única coisa que você não previu.
1:13
De repente, seus logs do console explodem com reclamações
1:16
e cada aba do VS Code parece um beco sem saída.
1:18
Os erros pequenos são os que mais doem.
1:20
Um ponto e vírgula faltando,
1:22
ou um erro de escopo que faz sentido na sua cabeça,
1:23
mas que age como dano venenoso quando o código é executado.
1:26
Essas pequenas falhas aparecem em implantações reais o tempo todo
1:29
e explicam por que uma validação quebrada é um chamado tão comum no desenvolvimento web.
1:34
Normalmente, sua abordagem é força bruta.
1:36
Você ajusta uma linha, atualiza,
1:37
barrado por outro erro,
1:38
então repete o ciclo até que algo finalmente funcione.
1:42
Uma noite inteira se esvai,
1:43
e o resultado final é muitas vezes apenas um escrito improvisado que funciona.
1:46
Sem elegância, sem aprendizado.
1:48
Por isso que depurar a validação parece aquela falha crítica clássica.
1:50
Você tá tentando, mas o resultado joga contra você.
1:54
É que o Copilot entra.
1:56
Sugestões genéricas do Copilot às vezes ajudam,
1:58
mas na maior parte do tempo parecem fragmentos aleatórios
2:00
tirados de um registro de missão esquecido.
2:02
O texto na intenção é errados nos detalhes.
2:04
Isso acontece porque o Copilot comum não conhece as peculiaridades do PowerPage.
2:07
Mas adicione ao participante,
2:08
arroba PowerPages,
2:09
e de repente ele para de cuspir código padrão
2:11
e passa a oferecer código contextual moldado pro seu ambiente.
2:14
A Microsoft a criou pra lidar com as especificidades do PowerPages,
2:17
incluindo modelos líquidos de vínculos com Dataverse,
2:19
o que significa que as sugestões levam em conta os recursos que geralmente causam problemas.
2:23
E não se trata apenas de gerar trechos de código.
2:25
A integração arroba PowerPages também pode explicar construções específicas do PowerPages,
2:29
para que você não apenas colhe e torça pelo melhor,
2:31
mas realmente entenda por que um script faz o que faz.
2:33
Isso torna a depuração menos como caminhar de olhos vendados,
2:36
e mais como trabalhar ao lado de alguém que já superou o mesmo desafio.
2:40
Por exemplo, você pode literalmente digitar este prompt no chat do Copilot.
2:43
Arroba PowerPages.
2:43
Arroba PowerPages escreva um código JavaScript para validação de campo de formulário,
2:46
para verificar se o valor do campo de telefone está no formato válido.
2:49
Isso não é apenas teoria,
2:50
é uma entrada pronta para demonstração que você verá mais adiante neste passo a passo.
2:54
Código retornado não é um trecho genérico da web,
2:56
ele é diretamente aplicável e projetado para compilar no seu contexto do PowerPages.
3:00
Essa previsibilidade é a verdadeira mudança.
3:02
Com o Copilot genérico,
3:04
parece que você trouxe um bardo que pode tocar o acorde certo,
3:06
mas metade das vezes a melodia não tem nada a ver com a sua batalha atual.
3:09
Com o arroba PowerPages é como viajar com um explorador
3:11
que já sabe onde as armadilhas estão escondidas.
3:14
A missão deixa de ser sobre sobreviver a armadilhas
3:16
e passa a ser sobre projetar experiências de usuário claras.
3:19
A ferramenta não substitui seu julgamento ao Aprimor.
3:21
Você ainda decide o que conta com a entrada válida
3:23
e como os erros devem orientar o usuário.
3:25
Mas, em vez de gastar tempo com erros de sintaxe e erros de digitação booleanos,
3:28
você dedica seu esforço para tornar o fluxo de trabalho intuitivo.
3:31
Quando tratadas corretamente,
3:32
essas etapas de validação deixam de ser obstáculos
3:34
e passam a fazer parte de uma narrativa fluida para quem estiver usando o formulário.
3:37
Pode não parecer uma grande vitória,
3:39
mas impedir as falhas básicas é o que evita uma enxurrada de chamados simples
3:42
mais à frente.
3:44
Uma vez que o Copilot assume o trabalho pesado
3:46
de gerar código de validação preciso,
3:47
seu tempo muda do modo sobrevivência
3:49
para o aprimoramento real do comportamento do aplicativo.
3:52
Essa diferença importa,
3:53
porque quando você vê como comandos bem direcionados
3:54
mudam o fluxo da geração de código,
3:56
você começa a se perguntar o que mais esses comandos podem desbloquear.
3:59
E é aí que a verdadeira vantagem de usar o Copilot com Power Pages se torna clara.
4:03
Obtendo vantagem em comandos do Copilot.
4:05
Obter vantagem aqui significa saber os comandos certos
4:07
para usar no Copilot em vez de esperar que a sorte esteja ao seu lado.
4:10
Essa é a verdadeira força de usar o participante em arroba Power Pages.
4:14
Ele transforma o chat do Copilot de um ajudante genérico
4:16
em um parceiro com contexto,
4:18
criado por seu ambiente Power Pages.
4:20
Veja como invocá-lo.
4:22
Dentro do VS Code,
4:23
abra o painel de chat do Copilot
4:24
e digite seu prompt começando com arroba Power Pages.
4:27
Essa tag é o que sinaliza o Copilot
4:29
para carregar o cérebro do Power Pages em vez do modo padrão.
4:32
Você pode pedir validadores,
4:34
snippets de Liquid
4:34
ou até chamadas vinculadas ao Data Virus
4:36
e o Copilot moldará suas respostas
4:38
para se adequar ao sistema em que você está programando.
4:41
Agora, antes que isso funcione,
4:42
você precisa da configuração certa.
4:44
Visual Studio Code instalado,
4:45
a extensão Power Platform Tools,
4:47
a extensão GitHub Copilot Chat
4:49
e o Power Platform CLI
4:50
autenticado no seu ambiente Dataverse.
4:53
A etapa de autenticação é a mais importante,
4:55
pois o Copilot só entende seu ambiente
4:57
depois que você baixa o conteúdo do site
4:58
no VS Code estando logado.
5:01
Sim, isso ele está apenas adivinhando.
5:02
E um aviso sobre governança.
5:03
Alguns recursos do Copilot para Power Pages
5:05
ainda estão em versão prévia
5:06
e os administradores do TN controlam
5:08
se estão habilitados via Copilot Hub
5:09
nas configurações de governança.
5:11
Não se surpreenda se os recursos demonstrados
5:12
aqui estiverem desativados, não só.
5:14
Isso é uma configuração de administrador, não.
5:15
Veja a diferença depois que seja configurado.
5:17
Copilot comum é como pedir conselhos de batalha a um bardo.
5:20
Você receberá uma melodia agradável,
5:22
talvez um comentário genérico,
5:23
mas nada dos detalhes necessários
5:25
ao lidar com modelos líquidos
5:26
ou campos de entidades do Dataverse.
5:28
Participante arroba Power Pages
5:29
é mais como um batedor que já mapeou o terreno.
5:31
Não é apenas código que compila
5:33
é código que referencia os vínculos corretos
5:35
encaixa em validadores de formulário
5:36
e se alinha ao funcionamento do Power Pages.
5:40
Uma metáfora, um contraste, um resultado.
5:42
Saída utilizável e consciente do contexto
5:44
em vez de snippets genéricos frágeis.
5:46
Vamos falar de resultados.
5:47
Se você pedir uma rotina de validação
5:48
ao Copilot simples,
5:50
provavelmente receberá um script
5:51
que funcione em um formulário HTML básico.
5:52
Mas ao colocá-lo no Power Pages
5:54
você encontrará falhas.
5:55
Sem reconhecimento do esquema de entidade,
5:57
sem noção do que as tags Liquid fazem
5:58
e definitivamente sem consciência das regras do Dataverse.
6:01
Funciona como fita adesiva.
6:02
Gruda, mas não é confiável.
6:04
Faça o mesmo pedido com arroba Power Pages na frente
6:06
e, de repente, você tem validadores
6:07
que não apenas funcionam,
6:08
mas se vinculam às referências de campo de entidade
6:10
de que você realmente precisa.
6:11
Mesmo pedido, saída ajustada ao contexto
6:13
sem necessidade de sessões de correção na madrugada.
6:15
E isso não se trata apenas de gerar scripts.
6:17
Comandos como arroba Power Pages
6:19
explicam o código a seguir,
6:20
percent include page copy percent,
6:22
oferece explicações em linguagens simples
6:23
sobre constructs específicos de Liquid ou Power Pages.
6:25
Você não está copiando e colando as cegas,
6:27
você está realmente construindo conhecimento.
6:29
Isso é um tipo diferente de poder
6:31
porque você aprende as escritas enquanto as utiliza.
6:34
Quanto mais você trabalha com esses comandos,
6:35
mais seu fluxo de trabalho muda.
6:37
Em vez de corrigir erros sozinho às duas da manhã,
6:39
você trata o Copilot como um segundo par de olhos
6:41
que já conhece o que quebrou em 90% de construções similares.
6:45
Os comandos não lhe dão códigos de trapaça,
6:47
eles lhe dão insights e exemplos funcionais
6:49
que respeitam as peculiaridades do ambiente.
6:51
Eles poupam você de ciclas em neves de retramar.
6:53
Em uma função comum do Copilot,
6:54
você ficará em um meio termo.
6:56
Script decente, retrabalho extra,
6:58
algumas tentativas e erros até encaixar.
7:00
Em uma função no arroba Power Pages,
7:02
parece um acerto crítico.
7:04
Scripts de validação se encaixam perfeitamente
7:06
no seu formulário Power Pages,
7:07
include de Liquid, funcionam,
7:08
e as vinculações do Dataverse não geram erros.
7:10
Não é sorte, é o que acontece
7:12
quando o Copilot conhece o terreno que você está programando.
7:15
Essa vantagem, porém, só lhe dá o primeiro rascunho.
7:17
Um trecho de código funcional
7:18
não significa uma experiência finalizada.
7:20
Usuários digitam entradas estranhas,
7:22
mensagens de erro precisam de detalhes,
7:23
e scripts precisam evoluir além do rascunho básico
7:25
que o Copilot tem.
7:26
E é aí que o próximo desafio começa.
7:28
De scripts básicos para um código totalmente blindado,
7:31
tudo começa onde a maioria das validações começa,
7:33
na estrutura simples.
7:34
Na estrutura simples.
7:35
Você recebe um primeiro rascunho,
7:36
um script simples,
7:37
que tecnicamente funciona,
7:38
mas bloqueia apenas o absurdo mais ou menos.
7:40
Pense nisso como um lutador de nível 1
7:42
segurando um escudo de papelão.
7:43
Funciona para um ou dois golpes fracos,
7:45
mas no momento em que um usuário real
7:46
começa a atacar, a coisa se estiressa.
7:48
Qualquer um que já tenha lançado um formulário
7:49
sabe que o script nunca dura muito em seu estado inicial.
7:52
Você se protege contra erros fáceis,
7:54
mas então o usuário cola um emoji em um campo de telefone
7:56
ou digita uma data de nascimento no futuro.
7:59
De repente, sua defesa entra em colapso,
8:00
o ticket chega na sua caixa de entrada
8:01
e você fica com uma validação frágil
8:02
que não faz nada além de agitar os braços.
8:05
O problema central não é apenas a cobertura da validação,
8:07
é o feedback.
8:08
Uma mensagem como entrada inválida
8:09
é o equivalente de software a uma porta trancada sem aviso.
8:13
Ela não diz nada aos usuários,
8:14
então eles tentam adivinhar falham de novo
8:15
e eventualmente jogam o problema para você.
8:16
É aí que seus tickets de suporte
8:18
se multiplicam pelos mesmos motivos previsíveis.
8:20
Aqui está mudando.
8:21
Esses ecript papelão não precisam continuar frágeis.
8:24
Com o Copilot, você não aceita apenas o esqueleto,
8:26
você o transforma em armadura.
8:28
E o fluxo de trabalho é simples o suficiente
8:29
para lembrar como um ciclo de quatro etapas
8:31
gere o esqueleto,
8:32
peça ao Copilot para melhorar as mensagens de erro,
8:34
adicione o tratamento de casos extremos
8:36
e finalmente implemente.
8:37
Cada etapa transforma a lâmina fina
8:39
em uma arma real em que você confia em campo.
8:41
O Copilot trabalha em sessão,
8:42
o que torna tudo rápido.
8:43
Como você está dentro do mesmo chat de onde veio o esqueleto,
8:46
basta digitar, atualize o código
8:47
e escreva mensagens de erro detalhadas.
8:50
O Copilot não começa do zero,
8:51
ele literalmente atualiza o código
8:53
que você já tinha no seu editor.
8:55
Sem alternar entre abas e navegador
8:57
ou reconstruir prompts do zero.
8:59
É interativo, não é copia e colar.
9:00
E você pode ver o impacto imediatamente.
9:02
Imagine o antes e o depois.
9:04
Seu primeiro rascunho retorna a entrada inválida.
9:07
Após um refinamento, ele diz,
9:08
o número de telefone deve conter apenas dígitos
9:10
e pelo menos 10 caracteres.
9:12
Essa clareza transforma a experiência do usuário.
9:14
Em vez de um muro, você constrói um guia.
9:16
Eles sabem o que deu errado e como corrigir sozinhos.
9:19
Sem tickets, sem reclamações,
9:20
menos tempo perdido para você.
9:22
Peça mais para casos extremos
9:23
e o Copilot amplia a blindagem.
9:25
Precisa verificar se caracteres especiais
9:27
estão entrando em campos numéricos?
9:29
Peça ao Copilot no mesmo chat.
9:30
Quer respostas mais detalhadas
9:31
para diferentes tipos de falha?
9:33
Veja um fluxo de trabalho.
9:34
A cada vez, o script se fortalece um pouco mais
9:37
com o contexto ligado ao seu ambiente Power Pages,
9:39
não apenas código web genérico.
9:41
Realmente acontece uma mudança
9:42
na forma como você depura.
9:43
Você para de apagar incêndios
9:45
em linhas de sintaxe quebrada
9:46
e começa a escober rascunhos funcionais.
9:48
O Copilot l entrega uma base funcional,
9:50
então sua energia vai para o polimento.
9:52
Em vez de tentativa e erro
9:53
com peculiaridades de sintaxe,
9:54
você molda deliberadamente
9:55
como o código responde ao usuário.
9:57
Isso reduz horas de retrabalho
9:58
e diminui a sobrecarga de suporte.
10:00
Quando você olha através desse ciclo de estrutura,
10:02
refinar mensagens,
10:04
fortalecer contra casos extremos
10:05
e implantar,
10:05
percebe que não está apenas
10:06
evitando o caos de dados,
10:07
mas reduzindo ativamente
10:08
a carga de suporte futura.
10:10
Cada mensagem de erro bem elaborada
10:12
é um porquê isso não funciona.
10:13
Vino.
10:14
Antiquete a menos na sua filha.
10:15
Cada caso extremo tratado
10:16
é um campo frágil a menos
10:17
esperando para estourar na produção.
10:19
Quando os refinamentos do Copilot
10:21
são adicionados,
10:22
o esqueleto ainda existe sob a armadura,
10:23
mas está completamente transformado.
10:25
O que começou como um paliativo
10:27
torna-se algo resiliente
10:28
para dados de produção,
10:29
com um feedback que educa o usuário
10:31
em vez de bloqueá-lo.
10:33
Com um escudo de papel
10:34
reforjado em chapa de metal,
10:35
isso muda como a batalha é sentida
10:36
em ambos os lados da tela.
10:37
Embora a validação via script
10:39
seja uma peça do quebra-cabeça,
10:40
há um campo de batalha maior ao redor.
10:42
O código pode ser blindado,
10:44
mas a questão passa a ser
10:44
como você gerencia
10:45
toda a estrutura onde ele vive
10:46
sem perder velocidade.
10:48
É aí que surge o próximo desafio,
10:50
não no script em si,
10:50
mas na forma como você lida
10:51
com o mapa do seu site.
10:54
Editando o mapa da masmorra
10:55
com CLI e VS Code.
10:57
Quando você quer ir além de scripts isolados
10:58
e começar a gerenciar todo o seu site,
11:00
precisa de algo,
11:01
além de edições manuais.
11:02
Você precisa de um mapa adequado.
11:04
Editar o mapa da masmorra
11:05
com CLI e VS Code
11:06
é como você para devagar
11:07
por corredores cegos
11:08
e passa a manter cada corredor à vista.
11:11
O jeito bagunçado
11:11
é alternar abas no design studio
11:13
do navegador,
11:13
pular para um terminal
11:14
e ficar movendo arquivos
11:15
de um lado para o outro
11:15
só para fazer uma pequena alteração.
11:17
Funciona,
11:18
mas parece desajeitado.
11:19
O jeito integrado
11:20
é baixar todo o conteúdo
11:21
do seu site localmente
11:22
com a CLI do Power Platform,
11:23
depois editar e implantar
11:24
através da extensão
11:25
Power Platform Tools
11:25
no VS Code
11:26
um fluxo de trabalho
11:27
sem passos intermediários
11:28
desnecessários.
11:29
Veja como funciona.
11:30
Antes de qualquer coisa,
11:31
você se autentica
11:32
no seu ambiente Dataverse.
11:34
Pense nisso
11:35
como destrancar a porta da frente
11:36
para que a CLI
11:37
possa acessar o seu site.
11:39
Uma vez autenticado,
11:40
você executa
11:40
um único comando
11:41
para baixar o conteúdo do site
11:42
para seu espaço
11:43
de trabalho local.
11:45
Esse download
11:45
traz os modelos,
11:46
scripts,
11:46
CSS e recursos.
11:49
Uma cópia completa
11:50
dos insights
11:50
do seu site
11:51
na sua máquina.
11:52
O Copilot
11:53
também se beneficia,
11:54
pois com arquivos locais
11:55
ele pode referenciar
11:56
entidades específicas
11:57
do ambiente
11:57
em vez de fazer
11:58
suposições genéricas.
12:00
A partir daí,
12:00
você permanece
12:01
no VS Code.
12:02
Quer ajustar
12:02
um modelo Liquid?
12:03
O arquivo está logo ali.
12:04
Corrigi a lógica de validação.
12:06
Abra o arquivo JavaScript
12:07
ao lado dele.
12:08
Como tudo está centralizado,
12:09
você vê em tempo real
12:10
como as peças se conectam
12:11
em vez de alternar
12:12
entre ferramentas
12:12
sem contexto
12:13
do panorama geral.
12:15
A extensão Power Platform Tools
12:16
torna os comandos
12:17
da CLI digeríveis.
12:26
Isso significa
12:27
não precisar
12:27
memorizar sequências longas
12:28
toda vez que executar
12:29
os mesmos comandos
12:29
curtos repetidamente.
12:31
Achar e editar a implanta.
12:32
Siga o suave,
12:33
sem fragmentos restantes
12:34
ficando fora de sincronismo.
12:36
A implantação em si
12:36
também é simplificada.
12:38
Após fazer as edições,
12:39
você usa o mesmo fluxo
12:40
baseado em CLI
12:41
para enviar as alterações
12:42
de volta ao seu ambiente
12:43
Power Pages.
12:44
Isso fecha o ciclo
12:45
sem o trabalho dobrado
12:46
de costume
12:46
ou problema de versão.
12:48
Você não está copiando
12:48
pastas manualmente
12:49
ou torcendo para que
12:50
sua sessão no navegador
12:51
não expire.
12:53
Você mantém tudo
12:53
em um ambiente
12:54
que realmente controla.
12:56
E o ganho
12:56
de produtividade
12:57
aparece de verdade
12:58
ao adicionar
12:58
o Copilot nesse ciclo.
13:00
Em vez de manipular
13:00
trechos desconectados,
13:02
agora seus prompts
13:02
do arroba Power Pages
13:03
acontecem no mesmo espaço
13:04
de trabalho do conteúdo
13:05
do seu site.
13:06
Você pode ajustar
13:06
um script de validação
13:07
e testar imediatamente
13:08
como ele interage
13:09
com modelos líquidos
13:10
a duas abas de distância.
13:11
É um ambiente,
13:11
um contexto,
13:12
um passo da pergunta
13:13
à resposta.
13:14
Para tornar concreto,
13:15
mostrei uma pequena demonstração.
13:17
Execute um comando CLI
13:18
para baixar seu site,
13:19
abra o arquivo líquido
13:20
de uma página
13:20
e seu script de validação
13:22
no VS Code
13:22
e depois peça
13:23
ao arroba Power Pages
13:24
para melhorar
13:25
as mensagens de erro.
13:26
Esse é o ciclo completo.
13:28
Mapa à sua frente,
13:28
arquivos ao alcance,
13:29
assistente de IA em espera.
13:33
A verdadeira vitória
13:33
não é adicionar
13:34
mais ferramentas,
13:35
é consolidá-las.
13:36
Você elimina
13:37
alternâncias de contexto,
13:38
mantém o foco
13:39
e trabalha
13:39
em um ambiente estável
13:40
onde codificação,
13:41
conteúdo e assistência
13:42
se alinham.
13:44
Isso economiza tempo,
13:44
mas mais importante,
13:45
evita que você gaste energia
13:46
com distrações
13:47
em vez de focar
13:47
na construção real.
13:49
Com o mapa
13:49
finalmente em mãos,
13:50
você não fica mais tropeçando
13:51
sem saber
13:52
onde está o próximo obstáculo.
13:54
Mas mesmo com o layout
13:55
da masmorra claro,
13:56
algumas lutas permanecem,
13:58
pois quando o chefão
13:58
aparece disfarçado
13:59
de erros de depuração,
14:00
o teste real
14:00
é se você consegue
14:01
ler seu padrão de ataque.
14:03
E essa é uma batalha
14:04
para a qual muitos desenvolvedores
14:05
ainda vão às cegas,
14:07
depurando batalhas
14:07
contra chefões com copilot.
14:09
Às vezes o verdadeiro teste
14:10
não é escrever código novo,
14:11
mas entender
14:12
porque algo que você achava
14:13
que estava bom
14:13
de repente se torna um problema.
14:16
É aí que a depuração
14:16
de batalhas contra chefões
14:17
com copilot
14:18
entra em jogo.
14:20
Depurar Power Pages
14:21
pode parecer trocar golpes
14:22
com um monstro chefão
14:23
que esconde seu padrão de ataque,
14:24
os erros parecem aleatórios,
14:26
os logs gritam sem contexto.
14:28
Você vai escolher scripts longos
14:29
sem saber se o problema
14:30
é sintaxe,
14:31
uma falha na tag Liquid
14:32
ou vinculações do Dataverse
14:33
que se recusam a cooperar.
14:35
O que deveria ser
14:35
um conserto rápido
14:36
consome uma sessão inteira
14:37
porque você está traduzindo
14:38
coisas sem sentido linha por linha.
14:39
O Liquid torna isso mais difícil.
14:41
Uma pequena tag
14:42
pode mudar a página.
14:43
Às vezes de forma organizada,
14:44
às vezes de forma espetacularmente errada.
14:46
1% include percent
14:47
insere conteúdo sem problemas.
14:50
Outro em um contexto
14:51
ligeiramente diferente
14:52
arruina todo o seu layout.
14:53
As vinculações do Dataverse
14:54
adicionam mais a trilha.
14:55
Elas podem ser resolvidas
14:56
corretamente em um formulário
14:57
e falhar silenciosamente em um.
14:59
A própria orientação da Microsoft
15:00
reconhece essa peculiaridade.
15:01
Liquid e Dataverse
15:02
se comportam de maneira diferente
15:04
dependendo da posição,
15:05
o que significa que
15:05
mover o código até funcionar
15:07
se torna seu fluxo
15:07
de trabalho não oficial.
15:09
É precisamente aí
15:09
que o participante
15:10
arroba a PowerPage
15:11
do Copilot
15:11
muda suas chances.
15:13
Em vez de perder uma tarde
15:14
fazendo experimentos a cegas,
15:15
você pode colocar o código
15:16
sob um holofote.
15:17
Você literalmente digita
15:19
arroba a PowerPage
15:20
e explica o seguinte código.
15:21
Percent Include Page Copy
15:22
Percent
15:23
no chat do Copilot.
15:25
Sem rodeios,
15:26
sem conselhos genéricos.
15:28
O resultado é uma explicação
15:29
clara detalhando
15:30
o que aquela tag faz,
15:31
o que ela puxa
15:31
e por que sua posição
15:32
na página afeta
15:33
o comportamento.
15:35
Na prática,
15:35
você para de adivinhar
15:36
e finalmente tem
15:37
um script legível
15:38
dos movimentos do chefão.
15:39
Para aproveitar ao máximo,
15:40
estruture a sua depuração
15:41
como uma demonstração rápida.
15:43
Primeiro,
15:43
identifique o trecho com erro.
15:45
Um formulário que explode
15:45
após uma tag include.
15:46
Segundo,
15:47
coloque o código exato
15:48
no Copilot
15:49
com o comando explicação.
15:50
Terceiro,
15:51
aplique a explicação do Copilot
15:52
em uma pequena reescrita
15:53
ou ajuste layout.
15:55
No teste,
15:56
os passos são compactos
15:56
de explicar e aplicar a testa.
15:58
Teve resultados
15:58
sem ficar preso
15:59
em um ciclo infinito
16:00
de tentar te ver.
16:01
E o Copilot
16:01
vai muito além da tradução.
16:03
No mesmo chat,
16:03
você pode pedir uma correção.
16:05
Por exemplo,
16:05
o Copilot pode sugerir
16:06
ajustar como include
16:07
alinhado para funcionar
16:08
bem com o seu layout
16:09
ou pode ajustar o JavaScript
16:10
para que o manipulador
16:11
de eventos
16:11
seja disparado
16:12
sem travar o console.
16:13
Sem travar o console.
16:14
Como ele funciona
16:15
com reconhecimento de contexto
16:16
no seu espaço de trabalho
16:17
do Power Pages,
16:18
as sugestões se conectam
16:19
diretamente ao seu ambiente
16:20
em vez de ficarem perdidas
16:20
informações genéricas da web.
16:22
Essa é a diferença
16:22
entre um vendedor de poções aleatório
16:24
e alguém que realmente conhece
16:25
o chefe que você está enfrentando.
16:26
Benefício imediato.
16:28
Em vez de passar metade do dia
16:29
isolando uma vinculação quebrada,
16:30
você vai direto ao ponto
16:31
para entender por que ela falha.
16:32
Isso transforma a depuração
16:33
de algo aleatório e cansativo
16:34
em algo tático.
16:36
Você viu o que que quebrou,
16:36
aplica uma correção focada
16:37
e confirma se o comportamento estabiliza.
16:39
Parece menos como tirar dados
16:40
de uma bolsa amaldiçoada
16:41
e mais como reagir
16:42
a padrões visíveis.
16:44
Aqui está o contraste na prática.
16:45
Antes, uma mensagem de erro como
16:47
algo deu errado
16:48
deixava você circulando
16:49
o problema sem parar.
16:51
Com a explicação do Copilot,
16:52
você aprende que a tag include
16:53
carrega um fragmento específico
16:54
da página e,
16:55
na sua posição,
16:56
ela sobrescreveu
16:56
um container necessário.
16:58
Você reescreve a posição
16:59
como o Copilot sugere
17:00
e testa novamente o formário.
17:02
Em três etapas,
17:03
você vai dar confusão
17:04
à resolução.
17:05
Claro, uma regra
17:06
que vale a pena repetir.
17:07
Copilot faz ótimas sugestões,
17:09
mas não é uma garantia.
17:11
Sempre revise e teste
17:11
antes de implantar em produção.
17:13
Trate os resultados
17:14
como um guia de estratégia,
17:15
não como um item lendário
17:16
que você pode equipar
17:16
de olhos fechados.
17:17
Eles economizam tempo,
17:18
mas é o seu julgamento
17:19
que mantém o sistema está.
17:20
Ao construir esse ciclo
17:21
de feedback,
17:22
explicar, ajustar, confirmar,
17:23
você elimina o fator
17:24
intimidador da depuração.
17:25
O Liquid não parece
17:26
mais um brincalhão caótico,
17:28
as peculiaridades do Dataverse
17:29
deixam de ser mistérios totais
17:30
e até as surpresas do JavaScript
17:31
se tornam contra-ataques
17:32
gerenciáveis.
17:34
Uma batalha contra um chefe
17:35
é ainda um desafio,
17:36
mas você luta com visão
17:37
em vez de levar golpes
17:37
de ângulos aleatórios.
17:39
E essa mudança de perspectiva
17:40
é a verdadeira vitória.
17:41
Depurar com Copilot
17:42
não apaga o encontro.
17:44
Você ainda codifica,
17:45
ainda testa
17:46
e ainda soluciona problemas,
17:47
mas para de desperdiçar energia
17:48
tentando decifrar
17:49
resultados misteriosos
17:50
e começa a jogar
17:50
com uma vantagem confiável,
17:52
o que prepara o cenário
17:52
para a parte final,
17:54
o que todas essas mudanças
17:55
representam quando você se afasta
17:56
e olha para a missão maior.
17:58
A conclusão se resume a isto.
18:00
Copilot não está pulando lutas,
18:01
ele está mudando a forma
18:02
como você desencarna.
18:03
Você sai da frágil tentativa
18:05
e erro para um código assistido
18:06
por IA que se explica,
18:07
refina sob comando
18:08
e cria fluxos
18:08
que os usuários realmente
18:09
conseguem navegar
18:10
sem desistir de frustração.
18:12
Aqui estão suas cinco vitórias.
18:14
Simplificar modelos líquidos
18:15
e acelerar JavaScript
18:16
e validação de formulários.
18:17
Obter explicações simples
18:18
para textos complexos,
18:19
inserir HTML e Bootstrap
18:21
para layouts responsivos
18:22
e simplificar chamadas
18:23
de API web sem suposições.
18:25
Alguns recursos
18:26
ainda estão em versão premium.
18:27
Os administradores do Locatários
18:28
ativam pelo hub do Copilot
18:30
no centro de administração
18:30
do Power Platform,
18:31
então verifique com seu
18:32
se algo parecia ausente.
18:34
Chefe derrotado,
18:34
spoiler garantido.
18:35
Equipe o bônus de inscrição,
18:37
ative o sino
18:37
para futuras demonstrações
18:38
e deixe um comentário
18:39
com um problema de validação
18:40
ou de líquido
18:40
que você gostaria
18:41
que o Copilot resolvesse seguir.
18:42
Vamos aprimorar
18:43
nossos próximos tutoriais
18:44
com base nos seus difíceis.