Latest / M365.FM – Microsoft 365, Copilot & AI podcast in het Nederlands / Power Pages-formuliervalidatie snel repareren met GitHub Copilot en @powerpages in VS Code (AI-nasynchronisatie)

Transcript

Power Pages-formuliervalidatie snel repareren met GitHub Copilot en @powerpages in VS Code (AI-nasynchronisatie) · M365.FM – Microsoft 365, Copilot & AI podcast in het Nederlands

0:00
Ken je dat wegzakkende gevoel wanneer je Power Pages formulier niet valideert en de foutmeldingen ongeveer net zo nuttig zijn als een 404 Brain Not Found?
0:07
Dat pijnpunt gaan we vandaag precies oplossen.
0:09
We behandelen vijf stappen, Liquid Template stroomlijnen, JavaScript en formuliervalidatie versnellen,
0:15
begrijpelijke uitleg van code krijgen, HTML integreren met Bootstrap voor responsive layouts en web API aanroepen vereenvoudigen.
0:22
Een snelle waarschuwing, je hebt VS-code nodig met de Power Platform Tools Extensie, GitHub Copilot Chat en je siteinhoud binnengehaald via de Power Platform CLI met dataverse authenticatie.
0:32
Die opzet maakt Copilot context bewust.
0:34
Met die basis stopt Copilot met het lukraak werpen van codefragmenten.
0:37
Het geeft contextuele, iteratieve code die vallen en opstaan vermindert.
0:40
Ik laat je de exacte prompts zien, zodat je de resultaten zelf kunt repliceren.
0:43
En aangezien de meeste frustratie begint bij JavaScript, laten we kijken wat er gebeurt als je formulierfouten aanvoelen als een natuurlijke misstap.
0:49
Wanneer JavaScript aanvoelt als een natuurlijke misstap, kan het een eenvoudige formuliercontrole snel in een ramp veranderen.
0:55
Een verkeerde toetsaanslag en in plaats van slechte invoer te stoppen, stoort de hele flow in.
1:00
Dat is meestal het moment waarop je naar het scherm staart en je afvraagt hoe, banaan, ooit voorbij je zorgvuldig geschreven validatielogica is gekomen.
1:06
Je kent het wel, een formulier dat onschuldig lijkt, een validator bedoelt om onzin te filteren en een slimme gebruiker die net dat ene intypt waar je geen rekening mee hield.
1:13
Ineens exploderen je console laks met klachten en voelt elk tabblad in VS-code als een doodlopende weg.
1:18
De kleine fouten komen het hardst aan.
1:20
Een ontbrekende puntkomma of een scoopfout die in je hoofd logisch lijkt, maar als gif werkt zodra de code draait.
1:26
Deze kleine slippertjes duiken constant op in echte implementaties en verklaren waarom kapotte validatie zo'n bekend ticket is bij webontwikkeling.
1:33
Normaal gesproken is je aanpak brood kracht.
1:36
Je past een regel aan, ververst, wordt teruggefloten door een nieuwe fout en herhaalt de cyclus totdat er eindelijk iets blijft werken.
1:42
Een avond verdampt en het eindresultaat is vaak slechts een met daktape aan elkaar hangend script dat net draait.
1:46
Geen elegantie, geen leermoment.
1:48
Daarom voelt het debuggen van validatie als die klassieke natuurlijke misstap.
1:51
Je doet je best, maar de kansen zijn tegen je gekeerd.
1:54
Dit is waar Copilot om de hoek komt kijken.
1:56
Algemene Copilot suggesties helpen soms, maar vaak lijken ze op willekeurige fragmenten uit een halfvergeten logboek.
2:02
Nuttig in de kern, fout in de details.
2:04
Dat komt omdat de standaard Copilot de eigenaardigheden van Powerpages niet kent.
2:07
Maar voeg de ad Powerpages-streepje deelnemer toe en plotseling spuugt het geen standaardteksten meer,
2:11
maar biedt het context bewuste code die precies in jouw omgeving past.
2:14
Microsoft heeft het gebouwd om Powerpages-specifieke zaken aan te pakken,
2:17
waaronder liquid schablonen en dataverse koppelingen,
2:19
wat betekent dat de suggesties rekening houden met de functies waar je normaal gesproken over struikelt.
2:23
En het gaat niet alleen om het genereren van codefragmenten.
2:25
De ad Powerpages-streepje integratie kan ook Powerpages-specifieke constructies uitleggen,
2:29
zodat je niet zomaar iets plakt en hoopt op het beste,
2:31
maar daadwerkelijk begrijpt waarom een script doet wat het doet.
2:34
Dat maakt debuggen minder als geblinddoekt rondwalen
2:36
en meer als werken naast iemand die dezelfde kerk er al heeft verkend.
2:39
Je kunt bijvoorbeeld letterlijk deze prompt typen in de Copilot-chat.
2:43
Ad Powerpages schrijft JavaScript-code voor formulierveldvalidatie
2:46
om te controleren of de waarde van het telefoonveld het juiste formaat heeft.
2:49
Dat is geen theorie, dat is een reproduceerbare, demoklare invoer die je later in deze walkthrough zult zien.
2:54
De code die je terugkrijgt is geen vaagwebfragment,
2:56
maar direct toepasbaar en ontworpen om te compileren binnen je Powerpages-context.
3:00
Die voorspelbaarheid is de echte verandering.
3:02
Met de algemene Copilot voelt het alsof je een barthab ingehuurd die misschien het juiste akkoord aanslaat,
3:06
maar de helft van de tijd heeft de melodie niets te maken met je huidige strijd.
3:09
Met Ad Powerpages is het meer alsof je reist met een ranger die al weet waar de valkuilen zich verschuilen.
3:14
De zoektocht draait minder om het overleven van valstrikken
3:16
en meer om het ontwerpen van heldere gebruikerservaringen.
3:18
De tool vervangt je beoordelingsvermogen niet, maar scherpt het aan.
3:21
Jij bepaalt nog steeds wat geld als geldige invoer en hoe foutmeldingen de gebruiker moeten begeleiden.
3:25
Maar in plaats van tijd te verspillen aan syntaxfouten en typfouten in booleans,
3:29
besteken je energie aan het intuïtief maken van de workflow.
3:31
Indien correct afgehandeld, stoppen die validatiestappen als wegversperringen
3:34
en worden ze onderdeel van een soepel verloop voor iedereen die het formulier gebruikt.
3:37
Het voelt misschien niet als een flitsende overwinning,
3:39
maar het voorkomen van basisfouten bespaart je later een vloedgolf aan eenvoudige supporttickets.
3:44
Zodra Copilot het zware werk van het genereren van nauwkeurige validatiecode op zich neemt,
3:48
verschuift je tijd van overlevingsmodus naar het daadwerkelijk verfijnen van het appgedrag.
3:52
Dat verschil is belangrijk, want wanneer je ziet hoe goed gerichte opdrachten de stroom van codegeneratie veranderen,
3:56
begin je je af te vragen wat die opdrachten nog meer kunnen ontgrendelen.
3:59
En dat is wanneer het echte voordeel van het gebruik van Copilot met powerpages duidelijk wordt.
4:03
Het krijgen van een voorsprong met Copilot-commando's.
4:05
Een voorsprong krijgen betekent hier de juiste opdrachten kennen om in Copilot in te voeren,
4:09
in plaats van te hopen dat de dobbelstenen in jouw voordeel vallen.
4:11
Dat is de werkelijke kracht van het gebruik van de ad powerpages-deelnemer.
4:14
Het transformeert Copilot-chat van een algemene helper naar een contextbewuste partner
4:18
die is gebouwd voor jouw powerpages-omgeving.
4:20
Hier is hoe je het aanroept.
4:22
Open in VS-code het Copilot-chat-venster en type vervolgens je prompt met ad powerpages aan het begin.
4:27
Die tag is wat Copilot signaleert om het powerpages-brein te laden in plaats van de standaardmodus.
4:32
Je kunt vragen om validators, liquid snippets en zelfs dataverse gebonden aanroepen
4:37
en Copilot stemt de antwoorden af op het systeem waar je daadwerkelijk voor programmeert.
4:41
Voordat dat werkt heb je de juiste configuratie nodig.
4:44
Visual Studio code geïnstalleerd, de Power Platform Tools extensie, de GitHub Copilot chat extensie
4:49
en de Power Platform CLI geauthenticeerd met je dataverse omgeving.
4:53
De authenticatiestap is het belangrijkst omdat Copilot je omgeving pas begrijpt
4:56
zodra je de site inhoud in VS-code hebt binnengehaald terwijl je bent ingelogd.
5:00
Zonder dat is het puur GIS-werk.
5:02
En nog een kanttekening wat betreft governance.
5:04
Sommige copilot-functies voor powerpages zijn nog in preview
5:06
en tenantbeheerders bepalen via de Copilot-hub in de governance instellingen of deze zijn ingeschakeld.
5:10
Wees niet verrast als functies die hier gedemonstreerd worden in jouw organisatie uitgeschakeld zijn.
5:13
Dat is een beheerdersinstelling, geen bak.
5:15
Dit is het verschil zodra alles is ingesteld.
5:18
De gewone copilot is als een bart om advies op het slagveld vragen.
5:21
Je krijgt een prettig deuntje, misschien wat algemeen commentaar,
5:24
maar niet de details die je nodig hebt voor liquid templates of dataverse entiteitsvelden.
5:27
De add powerpages-streepje deelnemer lijkt meer op een ranger die het terrein al in kaart heeft gebracht.
5:32
Het is niet alleen code die compileert, het is code die verwijst naar de juiste bindingen,
5:36
past in formulier validators en aansluit bij hoe powerpages echt werkt.
5:39
Eén metafoor, één contrast, één resultaat.
5:42
Bruikbare, contextbewuste output in plaats van fragiele, generieke snippets.
5:46
Laten we het over resultaten hebben.
5:47
Als je de standaard copilot om een validatieroutine vraagt,
5:50
krijg je waarschijnlijk een script dat werkt in een basis HTML formulier.
5:53
Zet het echter in powerpages en je loopt tegen blinde vlekken aan.
5:55
Geen herkenning van entiteitsschema's, geen idee wat liquid text doen
5:58
en absoluut geen besef van dataverse regels.
6:01
Het werkt als duct tape, plakkerig, maar onbetrouwbaar.
6:04
Doe hetzelfde verzoek met add powerpages aan het begin
6:06
en plotseling heb je validators die niet alleen werken, maar ook binden aan de juiste veldverwijzingen die je echt nodig hebt.
6:11
Zelfde verzoek, context aangepaste output, geen nachtelijke fix is meer nodig.
6:15
En dit gaat niet alleen over het genereren van scripts.
6:18
Commando's zoals add powerpages explain the following code,
6:21
percent include page copy percent,
6:22
geven je begrijpelijke uitleg over liquid of powerpages specifieke constructies.
6:26
Je kopieert en plakt niet blind, je bouwt daadwerkelijk begrip op.
6:29
Dat is een ander soort kracht, omdat je de spreuken leert terwijl je ze uitspreekt.
6:33
Hoe langer je met deze commando's werkt, hoe meer je workflow verandert.
6:37
In plaats van om twee uur s'nachts alleen fouten te herstellen,
6:40
behandel je copilot als een tweede paar ogen dat al weet wat er in 90% van vergelijkbare beelds misgaat.
6:45
De commando's geven je geen cheat codes.
6:47
Ze geven je inzicht en werkende voorbeelden die rekening houden met de eigenaardigheden van de omgeving.
6:51
Ze besparen je eindeloze revisierondes.
6:53
In een reguliere copilot rol kom je ergens in het midden uit.
6:56
Redelijk script, extra werk, wat vallen en opstaan voordat het past.
7:00
In een add powerpages-streepje rol voelt het als een natuurlijke 20.
7:04
Validatiescripts passen naadloos in je powerpages-formulier.
7:07
Liquid includes werken echt.
7:08
Dataverse bindings geven geen fouten.
7:10
Dat is geen geluk, dat gebeurt wanneer copilot het terrein kent waarvoor je programmeert.
7:15
Dat voordeel brengt je echter alleen bij het eerste concept.
7:17
Een werkend fragment betekent nog geen voltooide ervaring.
7:20
Gebruikers voeren vreemde dingen in.
7:22
Foutmeldingen hebben details nodig en scripts moeten verder evolueren dan het basisontwerp van Copilot.
7:26
En daar begint de volgende uitdaging.
7:28
Van scriptskeletten naar volledig bepanceerde code begint waar de meeste validatie begint, bij de basis.
7:35
Je krijgt een eerste versie, een simpel script dat technisch werkt, maar alleen de meest voor de hand liggende onzin blokkeert.
7:40
Zie het als een level 1 vechter met een kartonnen schild.
7:43
Het werkt tegen een paar zwakke slagen, maar zodra een echte gebruiker begint te rammen, versplintert het.
7:48
Iedereen die wel eens een formulier heeft opgeleverd, weet dat het script niet lang in zijn beginstatus blijft.
7:52
Je beveiligt tegen simpele fouten, maar dan plakt een gebruiker een emoji in een telefoonveld of typt morgen als geboortedatum.
7:59
Plotseling stort je verdediging in, stromen de tickets binnen en blijft er breekbare validatie over die nauwelijks iets doet.
8:04
Het fundamentele probleem is niet alleen de validatiedekking, maar de feedback.
8:08
Een melding als ongeldige invoer is softwarematig de tegenhanger van een gesloten deur zonder bordje.
8:12
Het vertelt gebruikers niets, dus ze gokken, falen opnieuw en gooien het probleem uiteindelijk bij jou over de schutting.
8:17
Dat is wanneer je helpdesktickets zich vermenigvuldigen om dezelfde voorspelbare redenen.
8:20
Hier is de omslag. Die kartonnen scripts hoeven niet fragiel te blijven.
8:24
Met Copilot accepteer je niet alleen het skelet, je bouwt het uit tot een harnas.
8:28
En de workflow is eenvoudig genoeg om als een vierstapslust te onthouden.
8:31
Genereer het skelet, vraag Copilot om foutmeldingen te verbeteren, voeg randgevallen toe en implementeer.
8:37
Elke stap upgrade het dunne heft tot een echt wapen waar je in het veld op vertrouwt.
8:41
Copilot werkt in een sessie, wat het snel maakt.
8:44
Omdat je in dezelfde chat zit waar het skelet vandaan kwam, typ je gewoon updatecode en schrijf gedetailleerde foutmeldingen.
8:50
Copilot begint niet vanaf nul, het werkt letterlijk de code bij die je al in je editor had.
8:55
Geen gedoe tussen browser-tabladen of prompts vanaf nul opnieuw opbouwen.
8:58
Het is iteratief, niet knippen en plakken.
9:00
En je ziet de impact onmiddellijk.
9:02
Stel je het verschil voor.
9:03
Je eerste versie geeft de melding ongeldige invoer.
9:06
Na één verfijning staat er, telefoonnummer moet alleen cijfers bevatten en minimaal 10 tekens lang zijn.
9:11
Die duidelijkheid transformeert de gebruikerservaring.
9:14
In plaats van een muur, bouw je een leuning.
9:16
Ze weten wat er misging en hoe ze het zelf kunnen herstellen.
9:19
Geen ticket, geen gemopper, minder verloren tijd aan jouw kant.
9:22
Vraag opnieuw om randgevallen en Copilot breidt de beveiliging uit.
9:25
Moet je controleren op speciale tekens in nummerieke velden?
9:28
Vraag het aan Copilot in dezelfde thread.
9:30
Wil je meer gelaagde antwoorden voor verschillende soorten fouten?
9:33
Hetzelfde proces. Elke keer wordt het script iets sterker, met context die is gekoppeld aan je powerpages-omgeving, niet zomaar generieke webcode.
9:41
Wat er echt gebeurt, is een verandering in hoe je debat.
9:43
Je stopt met het blussen van brandjes bij foutieve syntax en begint met het boetseren van werkende ontwerpen.
9:48
Copilot geeft je al een functionele basis, dus je energie gaat naar het verfijnen.
9:52
In plaats van vallen en opstaan met syntax-eigenaardigheden, vorm je bewust hoe de code communiceert met de gebruiker.
9:57
Dat bespaart uren aan herstelwerk en vermindert de druk op support.
10:00
Wanneer je het doordielus bekijkt skelet, berichten verfijnen, beveiligen tegen randgevallen, implementeren besef je dat je niet alleen data chaos voorkomt, maar actief de toekomstige supportlast verlaagt.
10:10
Elk zorgvuldig opgesteld foutbericht is één waarom werkt dit niet, tik het minder in je wachtrij.
10:15
Elk afgehandeld randgeval is één kwetsbaar veld minder dat in productie kan exploderen.
10:19
Tegen de tijd dat de verfijningen van copilot zijn toegevoegd, bestaat het skelet nog steeds onder het panser, maar is het volledig getransformeerd.
10:25
Wat begon als een noodoplossing wordt iets dat robuust genoeg is voor productiedata, met feedback die de gebruiker onderwijst in plaats van blokkeert.
10:32
Als een papieren schild dat is omgesmeed tot een harnas, verandert het hoe de strijd aan beide kanten van het scherm aanvoelt.
10:38
En hoewel gescripte validatie een stukje van de puzzel is, ligt er een groter strijdtoneel omheen.
10:42
De code kan worden bepanserd, maar de vraag wordt, hoe beheer je de volledige structuur waar binnen het leeft zonder te vertragen?
10:48
Dat is waar de volgende uitdaging zich voordoet, niet in het script zelf, maar in de manier waarop je de kaart van je site beheert.
10:54
De dungeonkaart bewerken met CLI en VS code
10:56
Wanneer je verder wilt kijken dan individuele scripts en je hele site wilt gaan beheren, heb je meer nodig dan brute force aanpassingen.
11:02
Je hebt een goede kaart nodig.
11:04
De dungeonkaart bewerken met CLI en VS code is de manier om te stoppen met blind rondwalen en in plaats daarvan elke gang in het zicht te houden.
11:10
De rommelige manier is jongleren met tabbladen in de browser design studio, overschakelen naar een terminal en dan bestanden heen en weer schuiven voor een kleine wijziging.
11:17
Het werkt, maar het voelt onhandig aan.
11:19
De geïntegreerde manier is al je siteinhoud lokaal downloaden met de Power Platform CLI en vervolgens bewerken en implementeren via de Power Platform Tools extensie in VS code.
11:27
Eén workflow zonder tussenstappen.
11:29
Zo werkt het.
11:30
Voordat je iets doet, verifieer je jezelf bij je dataverse omgeving.
11:34
Zie het als het openen van de voordeur zodat de CLI je site kan bereiken.
11:38
Eenmaal geverifieerd voer je één commando uit om de websiteinhoud naar je lokale werkruimte te downloaden.
11:45
Die pool haalt de templates, scripts, CSS en assets binnen.
11:49
Een volledige kopie van de inzichten van je site op je machine.
11:52
Copilot profiteert hier ook van, want met lokale bestanden kan het verwijzen naar omgevingsspecifieke entiteiten in plaats van algemene gissingen te doen.
11:59
Vanaf dat punt blijf je altijd in VS code.
12:01
Wil je een Liquid Template aanpassen? Het bestand staat daar gewoon.
12:05
Validatielogica herstellen? Open het JavaScript bestand dat ernaast staat.
12:08
En omdat alles gecentraliseerd is, zie je in realtime hoe onderdelen samenhangen, in plaats van te wisselen tussen tools zonder context van het grotere geheel.
12:15
De Power Platform Tools extensie maakt de CLI-commando's begrijpelijk.
12:18
Je hebt nog steeds de ruwe opdrachtregel tot je beschikking, maar die bevindt zich nu in de geïntegreerde terminal van VS code, gekoppeld aan de werkruimte waarin je werkt.
12:25
Dat betekent dat je geen lange reeksen hoeft te onthouden als je telkens dezelfde korte commando's uitvoert.
12:30
Downloaden, bewerken, implementeren. Een soepele cyclus.
12:34
Geen achtergebleven fragmenten die uit de pas lopen. De implementatie zelf wordt ook eenvoudiger.
12:38
Na het aanbrengen van wijzigingen gebruik je dezelfde CLI-workflow om ze terug te pushen naar je Power Pages-omgeving.
12:44
Dat sluit de cirkel zonder het gebruikelijke dubbele werk of versieproblemen.
12:48
Je kopieert geen mappen handmatig en hoeft niet te hopen dat je browsersessie niet is verlopen.
12:52
Je houdt alles in één omgeving die je daadwerkelijk beheert.
12:56
En de productiviteitswinst is pas echt zichtbaar als je Copilot aan die cyclus toevoegt.
13:00
In plaats van met losse fragmenten te jong leren, vinden je at Power Pages-streepje prompts nu plaats in dezelfde werkruimte als je site inhoudt.
13:06
Je kunt een validatiescript aanpassen en direct testen hoe het interacteert met Liquid templates die twee tabbladen verderop staan.
13:11
Het is één omgeving, één context, één stap van vraag naar antwoord.
13:14
Om het concreet te maken, laat ik het je zien in een korte demo.
13:17
Voer 1 CLI-commando uit om je site op te halen, open zowel het Liquid-bestand als het validatiescript van een pagina in VS-code en vraag at Power Pages om de foutmeldingen te verbeteren.
13:26
Dat is de hele cyclus.
13:27
Kaart voor je neus, bestanden binnen handbereik, AI-assistent stand-by.
13:32
De echte winst is niet dat je meer tools toevoegt, maar dat je ze consolideert.
13:36
Je elimineert contextwisselingen, blijft gefocust en werkt binnen één stabiel kader waar codering, content en ondersteuning samenkomen.
13:43
Het bespaart tijd, maar belangrijker nog, het voorkomt dat je energie verspilt aan afleidingen in plaats van aan het eigenlijke bouwen.
13:49
Met de kaart eindelijk in handen, struikel je niet langer rond in de vraag waar het volgende knelpunt zit.
13:54
Maar zelfs met een duidelijke indeling van de dungeon blijven sommige gevechten over, want als de eindbaas verschijnt als een stapel foutmeldingen, is de echte test of je het aanvalspatroon kunt lezen.
14:03
En dat is een strijd waar veel ontwikkelaars nog steeds blind in gaan.
14:06
Eindbaas-gevechten debuggen met co-pilot aan boord.
14:09
Soms is de echte test niet het schrijven van nieuwe code, maar uitzoeken waarom iets dat prima leek plotseling vijandig wordt.
14:15
Dat is waar het debuggen van eindbaas-gevechten met co-pilot aan boord van pas komt.
14:20
Het debuggen van power pages kan aanvoelen als een gevecht met een eindbaas die zijn aanvalspatroon verbergt.
14:25
Fouten lijken willekeurig.
14:26
De lags schreeuwen zonder context.
14:28
Je spit door lange scripts, onzeker of het probleem syntax is, een haperende liquid tech of dataverse koppelingen die niet meewerken.
14:34
Wat een snelle oplossing had moeten zijn, vreet een hele sessie op omdat je regel voor regelwartaal moet vertalen.
14:39
Liquid maakt dit lastiger.
14:41
Een kleine tech kan de hele pagina veranderen.
14:43
Soms netjes, soms spectaculair fout.
14:46
De ene, percent include percent, plaatst moeiteloos content.
14:49
De andere, in een net iets andere context, brengt je hele layout ten val.
14:53
Dataverse koppelingen voegen meer wrijving toe.
14:55
Ze werken correct op het ene formulier en falen stilzwijgend op het andere.
14:59
De eigen richtlijnen van Microsoft erkennen deze eigenaardigheid.
15:02
Liquid en dataverse gedragen zich verschillend afhankelijk van de plaatsing, wat betekent dat gewoon verschuiven tot het werkt, je onofficiële workflow wordt.
15:09
Dat is precies waar Copilot in Power Pages je kansen vergroot.
15:12
In plaats van een middag te verspillen aan blinde experimenten, kun je de code onder een vergrootglas leggen.
15:18
Je typt letterlijk, at Power Pages legt de volgende code uit, percent include page copy, percent in de Copilot chat.
15:25
Geen vage praat, geen algemeen advies.
15:27
De output is een heldere uitleg die vertelt wat die tag doet, wat deze ophaalt en waarom de positie op de pagina het gedrag beïnvloedt.
15:35
Kortom, je stopt met gokken en hebt eindelijk een leesbaar script van de zetten van de eindpaas.
15:39
Om er het maximale uit te halen, structureer je het debuggen als een korte demo.
15:43
Identificeer eerst het foutieve fragment.
15:45
Een formulier implodeert na een include tag.
15:47
Plaats ten tweede de exacte code in Copilot met het uitleg, commando.
15:50
Gebruik ten derde de uitleg van Copilot voor een kleine herschrijving of layout aanpassing.
15:55
Testen daarna.
15:55
De stappen zijn compact, uitleggen, toepassen, testen.
15:58
Je ziet resultaat zonder vast te lopen in eindeloos vallen en opstaan.
16:01
En Copilot gaat verder dan alleen vertalen.
16:03
In dezelfde chat kun je vragen om een oplossing.
16:05
Copilot kan bijvoorbeeld voorstellen de nesting van een include aan te passen voor een betere layout.
16:10
Of de javascript bijsturen zodat een event-handler niet de console laat crashen.
16:14
Omdat het contextbewust werkt in je powerpages-omgeving, sluit het advies direct aan bij jouw situatie in plaats van algemene webkennis te spuien.
16:21
Dat is het verschil tussen een willekeurige drankjesverkoper en iemand die de eindbaas kent die je aan het bevechten bent.
16:26
Het voordeel is direct merkbaar.
16:28
In plaats van een halve dag kwijt te zijn aan het isoleren van één kapotte binding, begrijp je direct waarom het misgaat.
16:32
Dat maakt debuggen van een moeizame gokspel tot iets tactisch.
16:35
Je ziet wat er kapot is, past een gerichte patch toe en controleert of het gedrag stabiliseert.
16:39
Het voelt minder als gokken met een vervloekte dobbelsteen en meer als reageren op zichtbare patronen.
16:43
Hier is het contrast in de praktijk.
16:45
Vroeger liet een foutmelding als er is iets misgegaan, je eindeloos rondjes draaien om het probleem.
16:51
Met de uitleg van Copilot leer je dat er een clue-tekken specifiek pagina-fragment laat en dat het in jouw opzet een vereiste container overschreef.
16:58
Je herschrijft de plaatsing zoals Copilot voorstelt, test opnieuw en het formulier blijft heel.
17:02
In drie stappen ga je van verwarring naar resolutie.
17:05
Natuurlijk is er een regel die het herhalen waard is.
17:07
Copilot doet sterke suggesties, maar het is geen garantie.
17:10
Controleer en test altijd voordat je iets naar productie verplaatst.
17:13
Zie de output als een strategiegids, niet als instant buiten je blind kunt uitrusten.
17:17
Het bespaart tijd, maar jouw oordeel houdt het systeem stabiel.
17:20
Zodra je die feedbackloop van uitleggen, aanpassen en bevestigen opbouwt, neemt de drempelfrees voor debuggen af.
17:26
Liquid voelt niet langer als een chaotische trickster.
17:28
Dataverse eigenaardigheden zijn geen mysteries meer en zelfs JavaScript verrassingen worden beheersbaar tegen aanvallen.
17:34
Een baasgevecht blijft een uitdaging, maar je vecht met inzicht in plaats van willekeurige klappen te incasseren.
17:39
En die verandering in perspectief is de echte winst.
17:41
Debuggen met Copilot wist het gevecht niet uit.
17:44
Je codeert, test en lost problemen op, maar je verspilt geen energie meer aan mysterieuze outputs en begint met een betrouwbaar voordeel, wat de weg vrijmaakt voor het laatste stuk.
17:54
Waar al deze veranderingen toe leiden zodra je een stap terug doet en kijkt naar de grotere missie.
17:58
De conclusie komt hierop neer.
18:00
Copilot slaat gevechten niet over, het verandert de manier waarop je ze voert.
18:03
Je stapt af van fragiel, vallen en opstaan en gaat naar AI ondersteun de code die zichzelf uitlegt, verfijnt op commando en flows bout die gebruikers echt kunnen gebruiken zonder gefrustreerd af te haken.
18:12
Dit zijn je vijf winstpunten, stroomlijn Liquid schablonen, versnel JavaScript en formuliervalidatie, krijg begrijpelijke uitleg voor lastige codefragmenten, voeg HTML en Bootstrap toe voor responsieve layouts en vereenvoudig web API aanroepen zonder GISwerk.
18:25
Sommige functies zijn nog in preview.
18:27
Tenantbeheerders schakelen deze in via de Copilot-hap in het Power Platform Beheer Centrum, dus overleg met hen als er onderdelen lijken te ontbreken.
18:34
Baas verslagen, buit binnen.
18:35
Activeer de abonneren baf, klik op het belletje voor toekomstige demo's en laat een reactie achter met het validatie- of liquidprobleem dat Copilot als volgende moet aanpakken.
18:42
We zullen toekomstige walkthroughs toespitsen op jouw lastigste tickets.