Latest / M365.FM – Podcast su Microsoft 365, Copilot e IA in italiano / Correggere subito la convalida dei moduli Power Pages con GitHub Copilot e @powerpages in VS Code (Doppiaggio IA)

Transcript

Correggere subito la convalida dei moduli Power Pages con GitHub Copilot e @powerpages in VS Code (Doppiaggio IA) · M365.FM – Podcast su Microsoft 365, Copilot e IA in italiano

0:00
Conosci quella sensazione di sprofondare quando il tuo modulo Power Pages non si convalida
0:03
e i messaggi di errore sono utili quanto un 404 brain not found?
0:07
E' proprio questo il problema che risolveremo oggi.
0:09
Vedremo 5 mosse, ottimizzare i modelli Liquid, velocizzare JavaScript e la convalida dei moduli,
0:15
ottenere spiegazioni del codice in linguaggio semplice,
0:17
integrare HTML con Bootstrap per layout responsive e semplificare le chiamate API Web.
0:22
Una rapida precisazione, avrai bisogno di VS Code con l'estensione Power Platform Tools,
0:26
GitHub Copilot Chat e i contenuti del tuo sito scaricati tramite la CLI di Power Platform con autenticazione Dataverse.
0:32
Questa configurazione rende Copilot consapevole di quello.
0:34
Una volta fatto, Copilot smetterà di lanciare frammenti di codice casuali.
0:37
Ti fornirà codice iterativo contestualizzato che riduce i tentativi errori.
0:40
Ti mostrerà i prompt esatti così da poter replicare i risultati da solo.
0:43
E dato che la maggior parte dei problemi nasce con JavaScript,
0:45
vediamo cosa succede quando gli errori dei tuoi moduli sembrano un fallimento critico.
0:49
Quando JavaScript ti mette il bastone tra le ruote,
0:51
può trasformare rapidamente quello che dovrebbe essere un semplice controllo del modulo in un disastro.
0:55
Un tasto premuto male e, invece di bloccare un input errato, l'intero flusso collassa.
1:00
Di solito è il momento in cui rimani a fissare lo schermo chiedendoti come abbia fatto quella banana
1:03
a superare la tua logica di convalida scritta con cura.
1:06
Conosci la storia, un modulo che sembra innocuo,
1:08
un validatore fatto per filtrare le assordità
1:10
e un utente furbo che scrive l'unica cosa che non avevi previsto.
1:13
All'improvviso i log della console esplodono di lamentele
1:15
e ogni scheda di VS Code sembra un piccolo check.
1:18
Gli errori più piccoli sono i più duri da digerire.
1:20
Un punto e virgola mancante
1:21
o un bug di scope che ha senso nella tua testa ma che agisce come un veleno quando il codice viene eseguito.
1:26
Questi minuscoli errori appaiono continuamente nelle distribuzioni reali
1:29
e spiegano perché una convalida rotta sia un ticket così comune nello sviluppo web.
1:32
Solitamente il tuo approccio è la forza bruna.
1:36
Modifichi una riga, aggiorni, venire spinto da un altro errore
1:38
e poi ripeti il ciclo finché qualcosa finalmente funziona.
1:41
Una serata evapora e il risultato finale è spesso solo uno script rattoppato alla bella e meglio.
1:46
Nessuna eleganza, nessun insegnamento.
1:48
Ecco perché il debug della convalida sembra il classico fallimento critico.
1:52
Stai tirando i dadi ma l'esito è contro di te.
1:54
Ed è qui che entra in gioco Copilot.
1:55
I suggerimenti generici di Copilot a volte aiutano ma spesso sembrano frammenti casuali
2:00
presi da un registro delle missioni dimenticato a metà.
2:02
Utili nello spirit sbagliati nei dettagli.
2:04
Questo perché il Copilot standard non conosce le stranezze di PowerPages.
2:07
Ma aggiungi il partecipante e ciò da PowerPages
2:09
e improvvisamente non sputa più codice standard
2:11
ma offre codice consapevole del contesto modellato sul tuo ambiente.
2:14
Microsoft l'ha creata per gestire le specificità di PowerPages
2:17
inclusi i template liquid e i binding di Dataverse.
2:19
Questo significa che i suggerimenti tengono conto delle funzioni che di solito che hanno un problema.
2:23
E non si tratta solo di generare snippet.
2:25
L'integrazione Accio la PowerPages
2:26
può anche spiegare i costrutti specifici di PowerPages
2:29
così non dovrai solo incollare e sperare
2:30
ma capirai davvero perché uno script fa quello che fa.
2:33
Questo rende il debugging meno simile a vagare a bendati
2:36
e più simile a lavorare accanto a qualcuno che ha già superato lo stesso dungeon.
2:40
Ad esempio puoi letteralmente digitare questo prompt nella chat di Copilot.
2:43
Accio la PowerPages scrivi del codice JavaScript
2:45
per la convalida dei campi del modulo
2:46
per verificare che il valore del campo telefono sia in formato valido.
2:49
Non è solo teorie
2:50
è un input riproducibile pronto per la demo
2:52
che vedrai più avanti in questo walkthrough.
2:53
Il codice che ricevi non è un vago snippet web
2:56
ma è direttamente applicabile e progettato
2:58
per essere compilato nel tuo contesto PowerPages.
3:00
Questa prevedibilità rappresenta il vero camione.
3:02
Con un Copilot generico
3:03
è come avere un bardo che potrebbe
3:05
suonare l'accordo giusto
3:06
ma spesso la melodia non ha nulla a che fare con la tua battaglia attuale.
3:09
Con Accio la PowerPages
3:10
è più simile a viaggiare con un ranger
3:12
che sa già dove si nascondono i signi.
3:14
La missione diventa meno incentrata
3:15
sul sopravvivere alle trappole
3:16
e più sulla progettazione di esperienze utente chiare.
3:18
Lo strumento non sostituisce il tuo giudizio, lo affina.
3:21
Sei sempre tu a decidere cosa costituisce un input valido
3:23
e come gli errori debbano guidare l'utente.
3:25
Ma invece di sprecare tempo su bug di sintassi
3:27
ed errori di battitura booleani
3:28
dedichi i tuoi sforzi a rendere intuitivo il flusso di lavoro.
3:31
Se gestiti correttamente
3:32
quei passaggi di convalida smettono di essere ostacoli
3:34
e diventano parte di un percorso fluido
3:36
per chiunque utilizzi il modulo.
3:37
Potrebbe non sembrare una vittoria eclatante
3:39
ma prevenire i guasti di base
3:40
ti salva da una marea di ticket di basso livello in futuro.
3:43
Una volta che Copilot si occupa del lavoro sporco
3:46
di generare codice di convalida accurato
3:47
il tuo tempo passa dalla modalità sopravvivenza
3:49
al perfezionamento del comportamento dell'app.
3:52
Questa differenza è importante
3:53
perché quando vedi come comandi ben mirati
3:55
cambiano il flusso di generazione del codice
3:56
inizia a chiederti cos'altro possano sbloccare.
3:59
Ed è allora che diventa chiaro il vero vantaggio
4:01
di usare Copilot con PowerPages.
4:03
Ottenere un vantaggio con i comandi di Copilot.
4:05
Ottenere un vantaggio qui significa
4:07
conoscere i comandi giusti da dare a Copilot
4:08
invece di sperare che i dati girino a tuo favore.
4:11
Questa è la vera forza dell'utilizzo del partecipante
4:13
H-PowerPages.
4:14
Trasforma la chat di Copilot da un assistente generico
4:16
a un partner consapevole del contesto
4:18
creato per il tuo ambiente PowerPages.
4:20
Ecco come richiamarlo.
4:22
In VS Code apri il riquadro della chat di Copilot
4:24
e poi digita il tuo prompt iniziando con H-PowerPages.
4:27
Quel tag è ciò che segnala a Copilot
4:29
di caricare il cervello di PowerPages
4:30
invece della modalità standard.
4:33
Puoi chiedere validatori, snippet liquid
4:34
e persino chiamate associate a Dataverse e Copilot
4:37
modellerai le risposte in base al sistema
4:39
su cui stai realmente lavorando.
4:41
Ora, prima che funzioni,
4:42
ti serve la configurazione giusta.
4:44
Visual Studio Code installato,
4:45
l'estensione Power Platform Tools,
4:47
l'estensione GitHub Copilot Chat
4:49
e la CLI di Power Platform
4:50
autenticata nel tuo ambiente Dataverse.
4:53
Il passaggio dell'autenticazione è fondamentale
4:55
perché Copilot comprende il tuo ambiente
4:56
solo dopo aver effettivamente estratto
4:58
i contenuti del sito in VS Code
4:59
mentre sei connesso.
5:00
Senza questo sto solo tirando indovini.
5:02
Un avviso sulla Gover.
5:03
Alcune funzionalità di Copilot per PowerPages
5:05
sono ancora in anteprima
5:06
e gli amministratori tenant controllano
5:08
se siano abilitate tramite il Copilot Hub
5:09
nelle impostazioni di Gover.
5:11
Non sorprenderti se le funzionalità mostrate qui
5:12
risultano disazionati in Dataverse.
5:14
È un'impostazione dell'amministratore,
5:15
non va.
5:15
Ecco la differenza una volta che hai completato la configurazione.
5:17
Il Copilot standard è come chiedere
5:19
un barido consigli per una battaglia.
5:21
Avrei una melodia piacevole,
5:22
forse qualche commento generico,
5:23
ma nessuno ha dei dettagli necessari
5:24
quando tratti template liquid
5:25
o campi di entità Dataverse.
5:27
Il partecipante di Action PowerPages
5:29
è più simile a un ranger
5:30
che ha già mappato il terreno.
5:32
Non è solo codice che viene compilato,
5:33
è codice che fa riferimento ai binding corretti.
5:35
Si adatta ai validatori dei moduli
5:36
e si allinea come PowerPages funziona realmente.
5:40
Una metafora, un contrasto, un vantaggio.
5:42
Output utilizzabile e consapevole del contesto
5:44
invece di frammenti generici e fragili.
5:46
Parliamo dei risultati.
5:47
Se chiedi a Copilot standard
5:48
una routine di validazione,
5:49
probabilmente otterrai uno script
5:51
che funziona in un modulo HTML basilare.
5:53
Inseriscilo però in PowerPages
5:54
e incontrerai dei punti C.
5:55
Nessun riconoscimento
5:56
dello schema dell'entità
5:57
nessuna idea di cosa facciano i tag liquid
5:58
e decisamente nessuna consapevolezza
6:00
delle regole di data.
6:01
Funziona come del nastro adesivo,
6:02
appiccicoso ma è inaffidabile.
6:04
Inoltre la stessa richiesta
6:05
con H o la PowerPages all'inizio
6:06
e improvvisamente avrai validatori
6:07
che non solo funzionano
6:08
ma si collegano ai riferimenti
6:09
dei campi entità che ti servono davvero.
6:11
Stessa richiesta, output adattato al contesto
6:13
a nessuna sessione di correzione notturna necessaria.
6:15
E non si tratta solo di generare script.
6:17
Comandi come H o la PowerPages
6:19
spiega il seguente codice
6:20
percent include page copy percent
6:22
ti offrono spiegazioni in linguaggio semplice
6:26
non stai facendo copia e incolla alla cieca
6:27
stai costruendo una vera comprensione.
6:29
È un tipo di potere diverso
6:30
per chi impari le formule magiche
6:31
mentre le stai lanciando.
6:34
Più lavori con questi comandi
6:35
più il tuo flusso di lavoro cambia.
6:37
Invece di correggere errori
6:38
da solo alle 2 del mattino
6:39
tratti Copilot come un secondo paio di occhi
6:41
che sa già cosa si è rotto
6:42
nel 90% i build simili.
6:45
I comandi non ti danno trucchi
6:47
ti offrono intuizioni
6:48
ed esempi funzionanti
6:49
che rispettano le peculiarità dell'ambiente.
6:51
Ti salvano da infiniti cicli di rifacimento.
6:53
Con un ruolo Copilot standard
6:54
ti troverai in una via di mezzo.
6:56
un script decente
6:57
lavoro extra
6:58
qualche tentativo prima che vada bene.
7:00
Con un ruolo actual a Power Pages
7:01
sembra di fare un 20 naturale.
7:04
Gli script di Convalida
7:05
si inseriscono bene
7:06
nei moduli Power Pages
7:07
include Liquid
7:07
funzionano
7:08
e i binding dataverse
7:09
non danno errori.
7:10
Non è fortuna
7:11
è quello che succede
7:12
quando Copilot conosce
7:13
il terreno su cui stai programmando.
7:15
Tuttavia quel vantaggio
7:16
ti fornisce solo una prima bozza.
7:17
Uno snippet funzionante
7:18
non significa un'esperienza completa.
7:20
Gli utenti inseriscono dati strani
7:22
i messaggi di errore necessitano di dettagli
7:23
e gli script devono evolversi
7:24
oltre la bozza scheletrica
7:25
che Copilot tiò.
7:26
Ed è qui che inizia la sfida successiva.
7:28
Passare da scheletri di script
7:30
a codice corazzato
7:31
inizia dove parte
7:32
la maggior parte delle convalide
7:33
dalle basi.
7:35
Ottieni una prima bozza.
7:36
Uno script se semplice
7:37
che tecnicamente funziona
7:38
ma blocca solo le assurdità più evidenti.
7:40
Immaginalo come un combattente
7:41
di livello 1
7:42
con uno scudo di cartone.
7:44
Funziona per uno o due colpi deboli
7:45
ma quando un utente vero
7:46
inizia a colpirsi
7:47
frantuma.
7:48
Chiunque abbia pubblicato un modulo
7:49
sa che lo script
7:50
non dura a lungo
7:50
nel suo stato iniziale.
7:52
Ti proteggi dagli errori semplici
7:54
ma poi un utente
7:54
incolla un emoji
7:55
in un campo telefonico
7:56
scrive una data
7:57
di nascita futura.
7:59
Improvvisamente
7:59
la difesa crolla
8:00
e i ticket arrivano
8:00
nella tua casella di posta
8:01
e ti ritrovi con una convalida
8:03
fragile che non serve a nulla.
8:05
Il problema principale
8:05
non è solo la copertura
8:06
della convalida
8:07
ma il feedback.
8:08
Un messaggio come
8:08
input non valido
8:09
è l'equivalente software
8:11
di una porta chiusa
8:11
senza cartello.
8:13
Non dice nulla
8:13
agli utenti
8:14
quindi tentano
8:14
falliscono di nuovo
8:15
alla fine
8:15
scaricano il problema su di te.
8:17
È allora che i ticket
8:18
dell'assistenza
8:18
si moltiplicano
8:19
per le stesse prevedibili ragioni.
8:21
Ecco la svolta.
8:21
Quegli script di cartone
8:22
non devono restare fragili.
8:24
Con Copilot
8:25
non accetti solo lo scheletro
8:26
lo trasformi in un'armatura.
8:28
Il flusso di lavoro
8:28
è semplice da ricordare
8:29
un ciclo in quattro fasi
8:31
generare lo scheletro
8:32
chiederà a Copilot
8:32
di migliorare i messaggi di errore
8:34
aggiungere la gestione
8:35
dei casi limite
8:35
e infine distribuire.
8:37
Ogni passaggio
8:38
trasforma la sottile guardia
8:39
in un'arma reale
8:39
di cui ti puoi fidare sul campo.
8:41
Copilot lavora in sessione
8:42
il che rende tutto veloce.
8:43
Poiché sei nella stessa chat
8:45
da cui proviene lo scheletro
8:46
scrivi solo
8:47
aggiorna il codice
8:47
e scrivi messaggi di errore
8:48
dettagliati.
8:50
Copilot non parte da zero
8:52
e aggiorna letteralmente
8:52
il codice che avevi già
8:53
nel tuo editor.
8:55
Nessun passaggio continuo
8:56
tra le schede del browser
8:57
o ricostruzione dei prompt
8:58
è da zero.
8:59
È iterativo
8:59
non taglia in call
9:00
e puoi vedere l'impatto
9:01
immediatamente.
9:02
Immagina il prima e il dopo.
9:03
La tua prima bozza
9:04
restituisce input non valido.
9:07
Dopo un perfezionamento
9:08
dice
9:08
il numero di telefono
9:09
deve contenere solo cifre
9:10
e almeno 10 caratteri.
9:12
Quella chiarezza
9:12
trasforma l'esperienza utente.
9:14
Invece di un muro
9:14
costruisci una guida.
9:16
Sano cosa andato storto
9:17
e come correggerlo da soli.
9:19
Niente ticket
9:19
niente lamentele
9:20
meno tempo sprecato per te.
9:22
Spingi ancora
9:22
sui casi limite
9:23
e Copilot espande la protezione.
9:25
Devi controllare
9:26
se dei caratteri speciali
9:27
si intrufolano
9:27
nei campi numerici.
9:28
Chiedi l'Ocopilot
9:29
nella stessa conversazione.
9:30
Vuoi risposte più articolate
9:31
per diversi tipi di errore?
9:33
Stesso flusso di lavoro.
9:34
Ogni volta
9:35
lo script si rafforza
9:36
con un contesto legato
9:37
al tuo ambiente
9:37
Power Pages
9:38
non solo codice web
9:39
enerico.
9:40
Ciò che sta realmente accadendo
9:42
è un cambiamento
9:42
nel modo in cui effetti il debatto.
9:43
Smetti di correggere
9:44
singole righe di sintassi errate
9:45
e inizia a scolpire
9:46
bozze funzionanti.
9:48
Copilot ti fornisce
9:49
già una base operativa
9:49
così le tue energie
9:50
vanno nella rifinitura.
9:52
Invece di tentativi
9:53
ed errori sulla sintassi
9:54
dai deliberatamente forma
9:55
al modo in cui
9:55
il codice comunica con l'utente.
9:57
Questo riduce
9:58
le ore di lavoro extra
9:59
e il carico di supporto.
10:01
Guardandola attraverso
10:01
questo ciclo struttura
10:02
perfezionamento messaggi
10:04
protezione dai casi limite
10:05
distribuzione
10:05
capisci che non stai
10:06
solo evitando il caos
10:10
ogni messaggio di errore
10:11
ben fatto è un
10:12
perché non funziona
10:13
un ticket in meno
10:14
tue coda
10:14
ogni caso il limite gestito
10:16
è un campo fragile in meno
10:17
che potrebbe esplodere
10:18
in produzione.
10:20
Quando i perfezionamenti
10:20
di copilot sono stratificati
10:22
la struttura di base
10:23
c'è ancora
10:23
ma è completamente trasformata.
10:25
Ciò che era iniziato
10:26
come una soluzione temporanea
10:27
diventa qualcosa di resiliente
10:28
per i dati di produzione
10:29
con un feedback
10:30
che educa l'utente
10:31
anziché bloccarlo
10:32
come uno scudo di carta
10:33
riforgiato in piazza d'acciaio
10:35
cambia la percezione
10:35
dello scontro
10:36
da entrambi i lati dello schermo
10:37
e mentre la convalida
10:40
c'è un campo di battaglia
10:41
più grande intorno
10:42
il codice può essere protetto
10:44
ma la domanda diventa
10:44
come gestisci l'intera struttura
10:46
in cui vive senza rallentare
10:47
è qui che si presenta
10:49
la prossima sfida
10:49
non nello script stesso
10:51
ma nel modo in cui
10:51
gestisci la mappa del tuo sito
10:52
modificare la mappa del dungeon
10:55
con CLI e VS Code
10:56
quando vuoi andare
10:57
oltre i singoli script
10:58
e iniziare a gestire
10:59
l'intero sito
10:59
ti serve più che semplici modifiche
11:01
forzate
11:01
ti serve una mappa adeguata
11:03
modificare la mappa del dungeon
11:05
con CLI e VS Code
11:06
è il modo per smettere
11:07
di vagare in corridoi cecchi
11:08
e tenere invece
11:09
ogni percorso ben visibile
11:10
il modo disordinato
11:11
consiste nel destreggiarsi
11:12
tra le schede
11:13
nel browser design studio
11:14
passare a un terminale
11:14
e poi spostare
11:15
e fare avanti e indietro
11:16
solo per fare una piccola modifica
11:17
funziona ma sembra macchinoso
11:18
il metodo integrato
11:19
consiste nello scaricare localmente
11:21
tutto il contenuto del sito
11:22
con la power platform CLI
11:23
per poi modificare e distribuire
11:24
tramite l'estensione
11:25
power platform tools
11:26
in VS Code
11:26
un unico flusso di lavoro
11:28
senza passaggi intermedi
11:28
ecco come funziona
11:30
prima di fare qualsiasi cosa
11:31
devi autenticarti
11:32
nel tuo ambiente dataverse
11:33
pensalo come aprire
11:35
la porta d'ingresso
11:36
affinché la CLI
11:36
possa effettivamente
11:37
raggiungere il tuo sito
11:39
una volta autenticato
11:40
esegui un singolo comando
11:41
per scaricare il contenuto
11:42
del sito web
11:42
nel tuo spazio di lavoro locale
11:43
quel comando scarica
11:45
modelli, script, css
11:47
e risorse
11:48
un'intera copia
11:49
dei dati del tuo sito
11:50
direttamente sul tuo computer
11:51
anche Copilot
11:53
ne trae vantaggio
11:54
perché con i file locali disponibili
11:55
può fare riferimento
11:56
a entità specifiche
11:57
dell'ambiente
11:58
invece di tirare a indovinare
11:59
da quel momento
12:00
rimani sempre in VS Code
12:01
vuoi modificare un modello liquid?
12:03
il file è proprio lì
12:04
correggere la logica di combattere
12:05
apri il file javascript
12:06
che si trova accanto
12:07
e poiché è tutto centralizzato
12:09
vedi in tempo reale
12:10
come si collegano le parti
12:11
invece di passare
12:11
da uno strumento all'altro
12:12
senza una visione di insieme
12:13
l'estensione Power Platform Tools
12:16
rende i comandi CLI
12:17
facili da gestire
12:18
hai ancora la riga di comando
12:19
a disposizione
12:20
ma ora vive nel terminale
12:21
integrato di VS Code
12:22
collegato allo spazio di lavoro
12:24
in cui stai già programmando
12:25
ciò significa
12:26
non dover memorizzare
12:27
lunghe stringhe
12:28
ogni volta che esegui
12:29
costantemente
12:29
gli stessi brevi comandi
12:30
scarica, modifica, distribuisce
12:32
un ciclo fluid
12:33
nessun frammento residuo
12:34
che sfugge alla sincronizzazione
12:35
anche la distribuzione in sé
12:37
si semplica
12:37
dopo aver apportato le modifiche
12:39
utilizzi lo stesso flusso di lavoro
12:40
basato su CLI
12:41
per inviare le modifiche
12:42
al tuo ambiente Power Pages
12:43
questo chiude il cerchio
12:45
senza i soliti doppi passaggi
12:46
o errori di versione
12:48
non devi copiare cartelle manualmente
12:49
o sperare che la sessione del browser
12:51
non scada
12:51
o non scada
12:52
mantieni tutto
12:53
in un unico ambiente
12:54
che controlli realmente
12:55
e il guadagno
12:56
in termini di produttività
12:57
è evidente una volta aggiunto
12:58
Copilot a quel ciclo
12:59
invece di gestire frammenti scollegati
13:01
ora i tuoi prompt
13:02
e che la Power Pages
13:03
avvengono nello stesso spazio di lavoro
13:04
del contenuto del tuo sito
13:05
puoi modificare uno script di convalida
13:07
e testare immediatamente
13:08
come interagisce con i modelli liquid
13:09
a due schede di distanza
13:10
è un unico ambiente
13:11
un unico contesto
13:12
un solo passaggio
13:13
dalla domanda a risposta
13:14
per renderlo concreto
13:15
te lo mostrerò in una breve demo
13:16
esegui un comando CLI
13:18
per scaricare il sito
13:19
aprisi il file liquid
13:20
di una pagina
13:20
che è relativo script di convalida
13:22
in VS Code
13:22
quindi chiedi di aggiornare
13:24
i messaggi di errore
13:25
di aggiornare i messaggi di errore
13:26
questo è l'intero ciclo
13:27
mappa davanti a te
13:28
fai la portata in mano
13:29
assistente hai in attesa
13:30
vero vantaggio
13:33
non è aggiungere più strumenti
13:34
ma consolidarli
13:36
elimini i cambi di contesto
13:38
rimani concentrato
13:39
e lavori in un ambiente stabile
13:40
dove codice, contenuti e assistenza
13:42
sono allineati
13:43
ti fa risparmiare tempo
13:44
ma soprattutto
13:45
evita di sprecare energie
13:46
in distrazione
13:47
invece che nella costruzione
13:48
vera e propria
13:48
con la mappa finalmente in mano
13:50
non vaghi più cercando di capire
13:52
dove sia il prossimo ostacolo
13:53
ma anche con il layout
13:55
del dungeon chiaro
13:56
restano alcune battaglie
13:57
perché quando il boss
13:58
appare sotto forma di errore
13:59
di debug
13:59
la vera sfida è riuscire a leggerne
14:01
lo schema d'attacco
14:02
ed è una battaglia
14:04
in cui molti sviluppatori
14:05
si addentrano ancora alla C
14:06
affrontare i boss
14:07
del debugging con Copilot
14:08
a volte la vera prova
14:10
non è scrivere un nuovo codice
14:11
ma capire perché
14:12
qualcosa che sembrava a posto
14:13
diventi improvvisamente ostile
14:14
è qui che entrano in gioco
14:16
le battaglie contro i boss
14:17
del debugging con Copilot
14:19
debugging di Power Pages
14:21
può sembrare un scontro
14:22
con un boss
14:23
che nasconde il suo schema d'attacco
14:24
gli errori sembrano casuali
14:26
i log urlano senza fornire contesto
14:28
scavi tra lunghi script
14:29
senza sapere se il problema
14:30
sia la sintassi
14:31
un tag liquiderato
14:32
o i binding di Dataverse
14:34
che non collaborano
14:34
ciò che doveva essere
14:35
una correzione rapida
14:36
divora un'intera sessione
14:37
perché devi tradurre
14:38
geroglifici riga per riga
14:39
liquida rende tutto più complicato
14:40
un piccolo tag
14:42
può stravolgere la pagina
14:42
a volte in modo preciso
14:44
altre volte in modo disastroso
14:46
un tag include
14:47
e inserisce il contenuto
14:48
senza problemi
14:49
un altro in un contesto
14:51
leggermente diverso
14:52
distrugge l'intero layout
14:53
binding di Dataverse
14:54
aggiungono ulteriori attriti
14:55
possono risolversi
14:56
correttamente su un modulo
14:57
e fallire silenziosamente
14:58
su un altro
14:58
la stessa guida di Microsoft
15:00
riconosce questa peculiarità
15:01
liquid e Dataverse
15:02
comportano diversamente
15:03
in base alla posizione
15:04
il che significa
15:05
che il tuo flusso di lavoro
15:06
diventa
15:06
spostalo
15:07
finché non funziona
15:08
è proprio qui
15:09
che l'intervento di Copilot
15:10
in Power Pages
15:11
cambia le probabilità
15:12
a tuo favore
15:12
invece di spercare
15:13
un pomeriggio
15:14
in esperimenti alla cieca
15:15
puoi mettere il codice
15:16
sotto i riflettori
15:17
scrivi letteralmente
15:18
accio la Power Pages
15:19
spiega il seguente codice
15:21
include page
15:22
underscore copy
15:22
nella chat
15:23
di Copilot
15:24
nessuna risposta vaga
15:26
nessun consiglio generico
15:27
l'output
15:28
è una spiegazione
15:29
in linguaggio semplice
15:30
che chiarisce
15:30
cosa fa quel tag
15:31
cosa richiama
15:32
e perché la sua posizione
15:33
sulla pagina
15:33
influisce sul comportamento
15:34
in pratica
15:35
smetti di tirare
15:36
e indovinare
15:36
e ottieni finalmente
15:37
uno script elegibile
15:38
delle mosse del boss
15:39
per sfruttarlo al meglio
15:40
struttura il tuo debugging
15:41
come una breve demo
15:42
prima identifica
15:44
lo snippet con bug
15:44
un modulo implode
15:45
dopo un tag include
15:46
secondo
15:47
incolla il codice esatto
15:48
in Copilot
15:49
con il comando di spiegazione
15:50
terzo
15:51
usa la spiegazione di Copilot
15:52
per una piccola riscrittura
15:53
o un aggiustamento
15:54
del layout
15:54
vai testa
15:55
i passaggi sono compatti
15:56
spiega applica testa
15:58
vedi i risultati
15:58
senza rimanere intrappolato
15:59
in infiniti tentativi
16:00
e Copilot
16:01
volta la semplice traduzione
16:02
nella stessa chat
16:03
puoi chiedere una correzione
16:04
ad esempio
16:05
Copilot può suggerire
16:06
come amidare l'include
16:07
affinché si integri bene
16:08
con il tuo layout
16:09
o può modificare
16:10
javascript affinché
16:10
un event ender
16:11
venga attivato
16:12
senza bloccare la console
16:13
poiché opera
16:15
con consapevolezza
16:16
del contesto
16:16
nel tuo spazio di lavoro
16:17
power page
16:18
i suggerimenti
16:18
si collegano direttamente
16:19
al tuo ambiente
16:20
invece di fluttuare
16:21
nel web generico
16:21
questa è la differenza
16:22
tra un venditore di pozioni casuale
16:24
e qualcuno che conosce
16:24
davvero il boss
16:25
che stai affrontando
16:26
vantaggio immediato
16:27
invece di passare
16:28
mezza giornata
16:29
e isolare un binding rotto
16:30
vai dritto al punto
16:30
per capire perché fallisce
16:32
ciò trasforma il debug
16:33
da un processo casuale
16:34
ripetitivo
16:34
in qualcosa di tattico
16:35
vedi cosa si è rotto
16:36
applici una patch mirata
16:37
e confermi se il comportamento
16:38
si stabilizza
16:39
sembra meno come estrarre dadi
16:40
da un sacchetto maledetto
16:41
più come reagire
16:42
a schemi visibili
16:43
ecco il contrasto
16:44
nella pratica
16:45
prima un messaggio di errore
16:46
come qualcosa
16:47
è andato storto
16:48
ti lasciava girare a vuoto
16:49
attorno al problema
16:50
con la spiegazione di copilot
16:52
scopri che il tag include
16:53
carica un frammento
16:53
di pagina specifico
16:54
e nella tua posizione
16:55
sovrascriveva
16:56
un contenitore necessario
16:57
riscrivi la posizione
16:59
come suggerito da copilot
17:00
testi di nuovo
17:01
in tre passaggi
17:03
passi dalla confusione
17:04
alla risoluzione
17:05
naturalmente
17:06
c'è una regola
17:06
che vale la pena ripete
17:07
copilot fa ottimi suggerimenti
17:09
ma non sono una garanzia
17:10
controlla e testa
17:11
sempre prima
17:12
di distribuire in produzione
17:13
considera gli output
17:14
come una guida strategica
17:15
non come un bottino
17:16
istantaneo
17:16
ad equipaggiare la c
17:17
ti fanno risparmiare tempo
17:18
ma il tuo giudizio
17:19
mantiene il sistema stabile
17:20
una volta creato
17:21
questo ciclo di feedback
17:22
spiega, correggi, conferma
17:23
riduci il fattore intimidatorio
17:24
del debug
17:25
liquid non sembra più
17:26
un improgione caotico
17:27
le stranezze
17:28
i dataverse smettono
17:29
di essere misteri totali
17:30
e persino le sorprese
17:31
di javascript
17:32
diventano contro attacchi
17:33
gestibili
17:33
una battaglia contro un boss
17:35
è ancora una sfida
17:36
ma combatti con visione
17:37
invece di subire colpi
17:38
d'angolazioni casuali
17:39
e quel cambio di prospettiva
17:40
è la vera vittoria
17:40
il debug con copilot
17:42
all'interno
17:42
non elimina lo sconto
17:43
continui a programmare
17:45
testare e risolvere problemi
17:47
ma smechi di sprecare energia
17:48
a scrutare output misteriosi
17:49
e inizi ad agire
17:50
con un vantaggio affidabile
17:51
il che prepara il terreno
17:52
per la parte finale
17:53
a cosa portano
17:54
tutti questi cambiamenti
17:55
una volta che fai un passo indietro
17:56
riguardo la missione più grande
17:57
la conclusione si riduce a questo
17:59
copilot non salta i combattimenti
18:01
cambia il modo in cui li affronta
18:03
passi da fragili tentativi ed errori
18:05
a un codice assistito dall'IA
18:06
che si spiega da solo
18:07
si perfeziona su comando
18:08
e crea flussi
18:08
in cui gli utenti
18:09
possono effettivamente navigare
18:10
senza abbandonare per frustrazione
18:12
ecco le tue 5 vittorie
18:13
ottimizzare i modelli liquid
18:15
velocizzare javascript
18:16
la convalida dei moduli
18:17
ottenere spiegazioni semplici
18:18
per snippet complessi
18:19
inserire html
18:20
bootstrap per layout reattivi
18:22
e semplificare le chiamate app web
18:23
senza tirare e indovinare
18:24
alcune funzionalità sono ancora in ante
18:27
gli amministratori del tenant
18:28
le attivano tramite l'hub copilot
18:29
nell'interfaccia di amministrazione
18:31
di power platform
18:31
quindi verifica con loro
18:32
se sembra mancare qualcosa
18:33
boss sconfitto
18:34
bottino assicurato
18:35
equipaggio del potenziamento
18:36
iscriviti
18:37
attiva la campanella
18:38
per le prossime demo
18:38
e lascia un commento
18:39
con il problematico invalido
18:40
o liquid che vorresti
18:41
che copilot affrontasse per prima
18:42
fineremo le prossime guide
18:43
basandoci sui tuoi ticket
18:44
più difficili
18:45
grazie
18:47
grazie