Latest / M365.FM – Microsoft 365, Copilot & KI Podcast auf Deutsch / Power-Pages-Formularvalidierung schnell reparieren: GitHub Copilot mit @powerpages in VS Code (KI-Synchronfassung)

Transcript

Power-Pages-Formularvalidierung schnell reparieren: GitHub Copilot mit @powerpages in VS Code (KI-Synchronfassung) · M365.FM – Microsoft 365, Copilot & KI Podcast auf Deutsch

• 0:00
  Kennen Sie dieses ungute Gefühl, wenn sich Ihr Powerpages-Formular nicht validieren lässt
• 0:03
  und die Fehlermeldungen etwa so hilfreich sind wie ein 404-Fehler im Gehirn?
• 0:07
  Genau diesen Schwachpunkt werden wir heute beheben.
• 0:09
  Wir behandeln fünf Schritte.
• 0:11
  Optimierung von Liquid-Templates, Beschleunigung von JavaScript und Formularvalidierung,
• 0:14
  verständliche Code-Erklärungen, Integration von HTML mit Bootstrap für Responsive Layouts
• 0:19
  und Vereinfachung von Web-API-Aufrufen.
• 0:22
  Ein kurzer Hinweis vorab, Sie benötigen 4S Code mit der Power-Plattform-Tools-Erweiterung,
• 0:26
  GitHub-Copilot-Chat und Ihre Website-Inhalte, die über die Power-Plattform-CLI mit Dataverse-Authentifizierung heruntergeladen wurden.
• 0:32
  Dieses Setup macht Copilot-Kontext bewusst.
• 0:34
  Sobald das steht, hört Copilot auf, wahllos Codeschnipsel zu liefern.
• 0:37
  Er liefert kontextuellen, iterativen Code, der das Ausprobieren auf ein Minimum reduziert.
• 0:40
  Ich zeige Ihnen die exakten Prompts, damit Sie die Ergebnisse selbst nachvollziehen können.
• 0:43
  Und da der meiste Ärger bei JavaScript beginnt, schauen wir uns an, was passiert,
• 0:46
  wenn sich Ihre Formularfehler wie ein natürlicher 1er-Würfelwurf anfühlen.
• 0:49
  Wenn JavaScript sich wie ein natürlicher 1er anfühlt, kann es eine eigentlich einfache Formularprüfung schnell in ein Desaster verwandeln.
• 0:54
  Ein einziger falscher Tastenschlag reicht aus und anstatt fehlerhafte Eingaben zu stoppen, bricht der gesamte Ablauf zusammen.
• 1:00
  Meist sitzen Sie dann vor dem Bildschirm und fragen sich, wie Banane jemals an Ihrer sorgfältig geschriebenen Valigierungslogik vorbeikommen konnte.
• 1:06
  Sie kennen das Spiel, ein harmlos wirkendes Formular, ein Validator, der Unsinn filtern soll
• 1:09
  und ein schlauer Benutzer, der genau das eintippt, womit Sie nicht gerechnet haben.
• 1:13
  Plötzlich explodieren Ihre Konsolenprotokolle vor Beschwerden und jeder VS-Code-Tab fühlt sich wie eine Sackgasse.
• 1:18
  Die kleinen Fehler schmerzen am meisten.
• 1:20
  Ein fehlendes Semikolon oder ein Scope-Bug, der im Kopf sind, ergibt sich aber beim Ausführen des Codes,
• 1:24
  das wie Gift auswirkt.
• 1:26
  Diese winzigen Ausrutscher tauchen ständig in echten Deployments auf und erklären,
• 1:30
  warum fehlerhafte Validierung ein so vertrautes Ticket in der Web-Entwicklung ist.
• 1:34
  Normalerweise ist die Ansatzrohe gewalt.
• 1:36
  Sie ändern eine Zeile, aktualisieren, werden durch einen neuen Fehler zurückgeworfen
• 1:39
  und wiederholen den Zyklus, bis endlich etwas funktioniert.
• 1:42
  Ein ganzer Abend verfliegt und das Endergebnis ist oft nur ein notdürftig gepflegtes Skript, das gerade zuläuft.
• 1:46
  Keine Eleganz, kein Lerneffekt.
• 1:48
  Deshalb fühlt sich das Debugging der Validierung wie der klassische natürliche Eins an.
• 1:52
  Sie würfeln zwar, aber die Chancen stehen gegen Sie.
• 1:54
  Hier kommt Co-Pilot ins Spiel.
• 1:56
  Allgemeine Co-Pilot-Vorschläge helfen manchmal, aber oft sehen sie aus wie zufällige Fragmente aus einem halbvergessenen Questlog.
• 2:02
  Vom Ansatz her nützlich im Detail falsch.
• 2:04
  Das liegt daran, dass der einfache Co-Pilot die Eigenheiten von Powerpages nicht kennt.
• 2:06
  Aber fügen Sie den Add Powerpages Teilnehmer hinzu und plötzlich spuckt ihr kein Standardcode mehr aus,
• 2:11
  sondern bietet kontextbewussten Code, der perfekt auf ihre Umgebung zugeschnitten ist.
• 2:14
  Microsoft hat es für Powerpages Besonderheiten wie Liquid-Templates und Dataverse-Bindungen entwickelt,
• 2:18
  wodurch Vorschläge genau die Funktionen berücksichtigen, die sie oft vor Probleme stellen.
• 2:23
  Es geht nicht nur um das Erstellen von Snippets.
• 2:25
  Die Add Powerpages-Longeration kann auch spezifische Powerpages-Konstrukte erklären,
• 2:29
  damit sie nicht nur kopieren und hoffen, sondern wirklich verstehen, warum ein Skript tut, was es tut.
• 2:33
  Dadurch fühlt sich das Debugging weniger wie ein Herumirren mit verbundenen Augen an,
• 2:36
  sondern eher wie die Zusammenarbeit mit jemandem, der dasselbe Verlies bereits gemeistert hat.
• 2:40
  Sie können beispielsweise buchstäblich diesen Prompt in den Co-Pilot-Chat eingeben.
• 2:43
  Add Powerpages schreibe JavaScript-Code für die Formularfeld-Validierung,
• 2:46
  um zu prüfen, ob der Wert im Telefonfeld das richtige Format hat.
• 2:49
  Das ist keine bloße Theorie, sondern eine reproduzierbare, demobereite Eingabe,
• 2:52
  die Sie später in dieser Anleitung sehen werden.
• 2:54
  Der zurückgegebene Code ist kein vages Web-Snippet,
• 2:56
  sondern direkt anwendbar und darauf ausgelegt, in Ihrem Powerpages-Kontext zu kompilieren.
• 3:00
  Diese Vorhersehbarkeit ist die eigentliche Well-No.
• 3:02
  Beim generischen Co-Pilot fühlt es sich an, als hätten Sie einen Baden engagiert,
• 3:05
  der zwar den richtigen Akkord spielen könnte,
• 3:07
  aber meistens hat die Melodie nichts mit dem aktuellen Kampf zu tun.
• 3:09
  Mit Add Powerpages ist es eher so, als würden Sie mit einem Waldläufer reisen,
• 3:12
  der bereits weiß, wo sich die Fallstricke verbergt.
• 3:14
  Die Aufgabe besteht weniger darin, Fallen zu überleben,
• 3:16
  sondern mehr darin, klare Benutzererfahrungen zu gestalten.
• 3:19
  Das Tool ersetzt nicht Ihr Urteilsvermögen, es schärft es.
• 3:21
  Sie entscheiden weiterhin, was als gültige Eingabe gilt
• 3:23
  und wie Fehler den Benutzer leiten sollen.
• 3:25
  Doch anstatt Zeit mit Syntax-Fehlern und Tippfehlern bei bulischen Werten zu verschwenden,
• 3:28
  investieren Sie Ihre Energie darin, den Arbeitsablauf intuitiv zu gestalten.
• 3:31
  Richtig gehandhabt hören diese Validierungsschritte auf, Hindernisse zu sein
• 3:34
  und werden zu einem Teil eines reibungslosen Ablaufs für jeden, der das Formular nutzt.
• 3:37
  Das mag sich nicht nach einem spektakulären Sieg anfühlen,
• 3:39
  aber das Verhindern grundlegender Fehler
• 3:41
  bewahrt Sie später vor einer Flut an einfachen Support-Tickets.
• 3:44
  Sobald Co-Pilot die Fleißarbeit der Erstellung präziser Validierungscodes übernimmt,
• 3:47
  verschiebt sich Ihre Zeit vom Überlebensmodus hin zur gezielten Optimierung des App-Verhaltens.
• 3:52
  Dieser Unterschied ist wichtig, denn wenn Sie sehen,
• 3:53
  wie gut gezielte Befehle den Ablauf der Code-Generierung verändern,
• 3:56
  fangen Sie an, sich zu fragen, was diese Befehle noch freischalten können.
• 3:58
  Und genau dann wird der echte Vorteil der Nutzung von Co-Pilot mit Powerpages deutlich.
• 4:03
  Mit Co-Pilot-Befehlen den entscheidenden Vorteil erzielt.
• 4:05
  Ein Vorteil zu haben bedeutet hier, die richtigen Befehle für Co-Pilot zu kennen,
• 4:08
  anstatt darauf zu hoffen, dass das Glück auf Ihrer Seite ist.
• 4:11
  Das ist die wahre Stärke der Nutzung des App-Powerpages-Teilnehmers.
• 4:14
  Er verwandelt den Co-Pilot-Chat von einem generischen Helfer
• 4:16
  an einen kontextbezogenen Partner, der speziell für Ihre Powerpages-Umgebung entwickelt wurde.
• 4:20
  So rufen Sie ihn auf.
• 4:22
  Öffnen Sie in VS Code das Co-Pilot-Chat-Fenster
• 4:23
  und geben Sie Ihren Prompt mit den vorangestellten App-Powerpages ein.
• 4:26
  Dieses Tag signalisiert Co-Pilot, das Powerpages-Modul anstelle des Standardmodus zu laden.
• 4:32
  Sie können nach Validatoren, Liquid-Snippets oder sogar Dataverse-gebundenen Aufrufen fragen
• 4:36
  und Co-Pilot passt seine Antworten an das System an, für das Sie tatsächlich programmieren.
• 4:41
  Damit das funktioniert, benötigen Sie zunächst die richtige Ausstattung.
• 4:44
  Visual Studio Code muss installiert sein.
• 4:45
  Ebenso die Power-Plattform-Tools-Erweiterung, die GitHub-Copilot-Chat-Erweiterung
• 4:49
  und die Power-Plattform-CLI authentifiziert gegenüber Ihrer Dataverse-Umgebung.
• 4:52
  Der Authentifizierungsschritt ist am wichtigsten, da Co-Pilot Ihre Umgebung erst versteht,
• 4:57
  wenn Sie die Website-Inhalte bei angemeldetem Zustand im VS Code geladen haben.
• 5:00
  Ohne das ist alles nur Rat.
• 5:02
  Noch ein wichtiger Hinweis zu Governance.
• 5:03
  Einige Co-Pilot-Funktionen für Powerpages befinden sich noch in der Vorschau
• 5:06
  und Mandanten-Administratoren steuern deren Aktivierung über den Corporance-Einstellungen.
• 5:10
  Einstellung.
• 5:11
  Wundern Sie sich also nicht, wenn hier gezeigte Funktionen Ihnen im Unternehmen deaktivieren.
• 5:14
  Das ist eine Admin-Einstellung, kein Fehler.
• 5:15
  Hier ist der Unterschied, sobald Sie alles eingerichtet haben.
• 5:17
  Der normale Co-Pilot ist so, als würden Sie einen Baden um Rad auf dem Schlachtfeld bitten.
• 5:20
  Sie erhalten eine nette Melodie, vielleicht einen allgemeinen Kommentar,
• 5:23
  aber keinerlei Details, die Sie bei Liquid-Vorlagen oder Dataverse-Entitätsfeldern benötigen.
• 5:28
  Der Powerpages-Teilnehmer gleicht eher einem Waldläufer, der das Gelände bereits erkundet hat.
• 5:32
  Es ist nicht nur Code, der kompiliert, sondern Code, der die richtigen Bindungen davoranziert,
• 5:35
  in Formularvalidatoren passt und mit der Funktionsweise von Powerpages übereinstimmt.
• 5:40
  Eine Metapher, ein Kontrast, ein Ergebnis.
• 5:42
  Nutzbare, kontextbezogene Ergebnisse statt zerbrechlicher, generischer Snippet.
• 5:46
  Sprechen wir über Ergebnisse.
• 5:47
  Wenn Sie den normal Co-Pilot nach einer Validierungsroutine fragen,
• 5:49
  erhalten Sie wahrscheinlich ein Skript, das in einem einfachen HTML-Formular funktioniert.
• 5:52
  Wenn Sie es jedoch in Powerpages einfügen, stoßen Sie auf blinde Flecken.
• 5:55
  Keine Erkennung des Entitätsschemas, keine Ahnung, was Liquid-Tags bewirken
• 5:58
  und definitiv kein Bewusstsein für Dataverse-Regeln.
• 6:01
  Es läuft hier mit Klebeband, klebrig, aber unzuverlässig.
• 6:04
  Stellen Sie die gleiche Anfrage mit AddPowerpages voran
• 6:06
  und plötzlich erhalten Sie Validatoren, die nicht nur laufen,
• 6:08
  sondern die richtigen Entitätsfeldreferenzen ansprechen, die Sie wirklich brauchen.
• 6:11
  Gleiche Anfrage, kontextangepasste Ausgabe, keine nächtlichen Korrektursitzungen mehr nötigen.
• 6:15
  Und dabei geht es nicht nur um das Generieren von Skripten.
• 6:17
  Befehle wie AddPowerpages, ExplainTheFollowingCode oder PercentIncludePageCopyPercent
• 6:21
  bieten Ihnen leicht verständliche Erklärungen zu Liquid- oder Powerpages-spezifischen Konstrukten.
• 6:26
  Sie kopieren nicht blind, sondern bauen tatsächlich Verständnis auf.
• 6:29
  Das ist eine andere Art von Stärke, weil Sie die Ruhen lernen, während Sie sie gleichzeitig anwenden.
• 6:33
  Je länger Sie mit diesen Befehlen arbeiten, desto mehr verändert sich Ihr Workflow.
• 6:36
  Anstatt nachts um zwei Uhr alleine Fehler zu beheben, betrachten Sie Co-Pilot als ein zweites Paar Augen,
• 6:41
  das bereits weiß, was bei 90% ähnlicher Bild schiefgelaufen ist.
• 6:44
  Äh.
• 6:45
  Die Befehle liefern Ihnen keine Cheatcodes, sondern Einblicke und funktionierende Beispiele,
• 6:49
  die die Besonderheiten Ihrer Umgebung berücksichtigen.
• 6:51
  Sie bewahren Dich vor endlosen Überarbeitungsschleifen.
• 6:53
  In einer normalen Co-Pilot-Rolle landest Du irgendwo im Mittelfeld.
• 6:56
  Ein ordentliches Skript, etwas Nacharbeit, ein wenig ausprobieren, bis es passt.
• 7:00
  In einer AddPowerpages-Rolle fühlt es sich wie ein natürlicher 20er-Wurfer.
• 7:03
  Validierungsskripte fügen sich perfekt in Dein Powerpages-Formular ein,
• 7:07
  Liquid Includes funktionieren sofort und Dataverse-Bindungen werfen keine Fehler.
• 7:10
  Das ist kein Glück, sondern das Ergebnis, wenn Co-Pilot das Terrain kennt, für das Du programmierst.
• 7:15
  Dieser Vorteil bringt Dir jedoch nur den ersten Entwurf.
• 7:17
  Ein funktionierender Schnipsel bedeutet noch keine fertige Anwendung.
• 7:20
  Benutzer geben seltsame Dinge ein, Fehlermeldungen brauchen, Details und Skripte müssen über das Grundgerüst,
• 7:24
  das Dir der Co-Pilot liefert, hinauswachsen.
• 7:26
  Und genau hier beginnt die nächste Herausforderung.
• 7:29
  Vom Skript-Skelett zum vollwertigen Code-Weg.
• 7:31
  Dorthin beginnt, wie bei den meisten Validierungen, bei der Basis.
• 7:35
  Du erhältst einen ersten Entwurf.
• 7:36
  Ein einfaches Skript, das zwar technisch läuft, aber nur den offensichtlichsten Unsinn blockiert.
• 7:40
  Stell es Dir wie einen Kämpfer auf Stufe 1 mit einem Pappschild vor.
• 7:43
  Es hält ein oder zwei schwache Treffer aus, aber sobald ein echter Benutzer loslegt, zersplittert das Ding.
• 7:48
  Jeder, der schon einmal ein Formular bereitgestellt hat, weiß, dass das Skript in seinem Anfangszustand nie lange hält.
• 7:51
  Du sicherst Dich gegen einfache Fehler ab, aber dann fügt Dein Benutzer ein Emoji in ein Telefonfeld ein oder gibt ein morgiges Datum als Geburtsdatum an.
• 7:59
  Plötzlich bricht Deine Verteidigung zusammen, Tickets landen in Deinem Posteingang und Du bleibst auf einer brüchigen Validierung sitzen, die kaum mehr macht, als hilflos zu rinken.
• 8:04
  Das Kernproblem ist nicht nur die Abdeckung der Validierung, sondern das Feedback.
• 8:08
  Eine Nachricht wie ungültige Eingabe ist das Software-Äquivalent einer verschlossenen Tür ohne Hinweisschild.
• 8:12
  Sie sagt dem Benutzer nichts, also raten Sie, scheitern erneut und werfen das Problem schließlich bei Dir ab.
• 8:17
  Dann vervielfachen sich Deine Helpdesk-Tickets aus den immer gleichen vorhersehbaren Gründen.
• 8:20
  Das ist der Wendepunkt. Diese Pub-Skripte müssen nicht zerbrechlich bleiben.
• 8:24
  Mit Co-Pilot akzeptierst Du nicht einfach das Skelett, Du baust es zu einer Rüstung aus.
• 8:28
  Der Arbeitsablauf ist einfach als Vier-Schritte-Schleife zu merken.
• 8:31
  Skelett generieren, Co-Pilot um bessere Fehlermeldungen bitten, Grenzfälle behandeln und schließlich bereitstellen.
• 8:37
  Jeder Schritt wertet den dünnen Griff zu einer echten Waffe auf, der Du im Einsatz vertrauen kannst.
• 8:40
  Co-Pilot arbeitet in einer Sitzung, was das Ganze schnell macht.
• 8:44
  Da Du Dich im selben Chat befindest, aus dem das Skelett stammt, tippst Du einfach Code aktualisieren und detaillierte Fehlermeldungen schreiben unten.
• 8:50
  Co-Pilot fängt nicht bei Null an, sondern aktualisiert buchstäblich den Code, den Du direkt in Deinem Editor hast.
• 8:55
  Kein Hin- und Herwechseln zwischen Browser-Tabs oder das Neuerstellen von Prompts von Gründen.
• 8:58
  Es ist iterativ nicht bloß das Kopieren, nein. Und Du kannst die Auswirkungen sofort sehen.
• 9:02
  Stell den Vor- und Nachher-Effekt vor.
• 9:03
  Ihr erster Entwurf meldet ungültige Eingabe.
• 9:05
  Nach einer Verfeinerung heißt es, Telefonnummer darf nur Ziffern enthalten und muss mindestens 10 Zeichen lang sein.
• 9:12
  Diese Klarheit verbessert das Nutzererlebnisgrundlegen.
• 9:14
  Statt vor einer Wand stehen Sie nun an einem Leitfaden.
• 9:16
  Sie wissen, was schiefgelaufen ist und wie Sie es selbst beheben können.
• 9:19
  Kein Ticket, kein Ärger, weniger Zeitverlust für Sie.
• 9:22
  Fragen Sie bei Randfällen nach und Co-Pilot erweitert die Schutzschicht.
• 9:25
  Müssen Sie prüfen, ob sich Sonderzeichen in Zahlenfelder einschleichen?
• 9:28
  Fragen Sie Co-Pilot direkt im selben Thread.
• 9:30
  Wünschen Sie differenziertere Antworten für verschiedene Fehlertypen?
• 9:33
  Derselbe Arbeitsablauf.
• 9:34
  Mit jedem Mal wird das Skript robuster und, zwar mit Kontext zu Ihrer Powerpages-Umgebung,
• 9:38
  nicht nur mit generischem Webcode im Webcode.
• 9:41
  Was sich wirklich ändert, ist die Art und Weise, wie Sie Fehler beheben.
• 9:43
  Sie bekämpfen nicht mehr kaputte Syntaxzeilen, sondern formen funktionierende Entwürfe.
• 9:48
  Co-Pilot liefert Ihnen bereits eine funktionierende Basis, sodass Sie Ihre Energie in das Feintuning stecken können.
• 9:52
  Statt mit Syntax-Eigenheiten zu experimentieren, gestalten Sie gezielt, wie der Code mit dem Nutzer kommuniziert.
• 9:57
  Das reduziert Überarbeitungen und senkt das Support-Aufkommen.
• 10:00
  Wenn Sie diesen Prozess betrachten, Grundgerüst, Nachrichten verfeinern, gegen Randfälle absichern, bereitstellen,
• 10:05
  merken Sie, dass Sie nicht nur Datenchaos verhindern, sondern aktiv die künftige Support-Last senken.
• 10:09
  Sink.
• 10:10
  Jede sorgfältig formulierte Fehlermeldung bedeutet ein Warum. Funktioniert das nicht?
• 10:14
  Minus in einiger Warteschlag.
• 10:15
  Jede abgedeckte Randfall bedeutet ein instabiles Feld weniger, das in der Produktion Probleme verursacht.
• 10:19
  Wenn die Verfeinerungen von Co-Pilot integriert sind, existiert das Grundgerüst zwar noch unter der Rüstung, aber es ist völlig verändert.
• 10:24
  Was als Notlösung begann, wird zu etwas, das robust genug für Produktionsdaten ist, mit Feedback, das den Nutzer schult, statt ihn auszusperren, starren.
• 10:32
  Wie ein Papierschild, das zu einer Panzerplatte geschmiedet wurde, verändert es das Erlebnis auf beiden Seiten des Bildschirms.
• 10:37
  Und während skriptbasierte Validierung nur ein Teil des Puzzles ist, gibt es ein größeres Schlachtfeld drumherum.
• 10:42
  Der Code kann gepanzert sein, doch die Frage bleibt, wie verwalten Sie die gesamte Struktur, ohne an Geschwindigkeit zu verlieren.
• 10:48
  Hier zeigt sich die nächste Herausforderung.
• 10:50
  Nicht im Skript selbst, sondern in der Art, wie Sie die Landkarte Ihrer Website handhaben.
• 10:52
  Bearbeitung der Dungeon-Karte mit CLI und VS Code
• 10:56
  Wenn Sie über einzelne Skripte hinausgehen und Ihre gesamte Website verwalten wollen, reicht Ruhegewalt.
• 11:00
  Beim Bearbeiten nicht aus. Sie brauchen eine ordentliche Karte.
• 11:04
  Die Dungeon-Karte mit CLI und VS Code zu bearbeiten bedeutet, nicht mehr blind durch Gänge zu irren, sondern jeden Korridor klar im Blick zu haben.
• 11:10
  Die umständliche Methode ist das Jonglieren mit Browser-Tabs im Designstudio, das Hin- und Herspringen zum Terminal und das Verschieben von Dateien nur um eine kleine Änderung vorzunehmen.
• 11:17
  Es funktioniert zwar wirklich, aber schwerfällig.
• 11:19
  Der integrierte Weg besteht darin, alle Website-Inhalte lokal mit der Power-Plattform-CLI herunterzuladen
• 11:23
  und dann über die Power-Plattform-Tools-Erweiterung in VS Code zu bearbeiten und bereitzustellen.
• 11:27
  Ein Workflow, kein unnötiges Hin und Her. So funktioniert es.
• 11:30
  Bevor Sie irgendetwas tun, authentifizieren Sie sich gegenüber Ihrer Dataverse-Umgebung.
• 11:34
  Dennen Sie es sich so vor, als würden Sie die Haustür aufschließen, damit die CLI überhaupt auf Ihre Website zugreifen kann.
• 11:39
  Sobald Sie authentifiziert sind, führen Sie einen einzigen Befehl aus, um die Website-Inhalte in Ihren lokalen Arbeitsbereich herunterzuladen.
• 11:44
  Dieser Abruf lädt die Templates, Skripte, CSS-Dateien und Assets herunter.
• 11:49
  Eine vollständige Kopie der Erkenntnisse Ihrer Website auf Ihrem Computer.
• 11:52
  Auch Co-Pilot profitiert davon, denn mit den lokalen Dateien kann er sich auf umgebungsspezifische Entitäten beziehen,
• 11:57
  statt nur allgemeine Vermutungen anzustellen.
• 12:00
  Ab diesem Punkt bleiben Sie komplett in Vollscope.
• 12:02
  Möchten Sie ein Liquid-Template anpassen? Die Datei liegt direkt an.
• 12:04
  Die Validierungslogik? Öffnen Sie die JavaScript-Datei direkt daneben.
• 12:08
  Und da alles zentralisiert ist, sehen Sie in Echtzeit, wie die Teile zusammenhängen,
• 12:11
  statt ständig zwischen verschiedenen Tools ohne Gesamtkontext zu wechseln.
• 12:14
  Die Power-Plattform-Tools-Erweiterung macht die CLI-Befehle übersichtlich.
• 12:18
  Sie haben zwar immer noch die Rohrbefehlszelle zur Verfügung,
• 12:20
  aber sie befindet sich jetzt im integrierten Terminal von Voice Code,
• 12:23
  direkt verbunden mit dem Arbeitsbereich, in dem Sie programmieren.
• 12:26
  Das bedeutet, Sie müssen sich nicht jedes Mal lange Zeichenfolgen merken,
• 12:29
  wenn Sie dieselben Befehle ausführen.
• 12:31
  Herunterladen, Bereitstellen.
• 12:32
  Ein reibungsloser Kreislauf.
• 12:33
  Keine verbleibenden Fragmente, die aus dem Takt geraten.
• 12:35
  Auch die Bereitstellung selbst wird vereinfacht.
• 12:37
  Nach den Änderungen verwenden Sie denselben CLI-basierten Workflow,
• 12:41
  um die Änderungen zurück in Ihre Power-Pages-Umgebung zu pushen.
• 12:44
  Das schließt den Kreis ohne die üblichen doppelten Arbeitsschritte oder Versionskonflikte.
• 12:48
  Sie kopieren keine Ordner manuell und müssen nicht hoffen,
• 12:50
  dass Ihre Browser Sie zum Licht abgelaufen ist.
• 12:52
  Sie behalten alles in einer Umgebung, die Sie tatsächlich kontrollieren.
• 12:56
  Und der Produktivitätsgewinn zeigt sich besonders,
• 12:58
  wenn Sie Co-Pilot in diesen Kreislauf einbinden.
• 13:00
  Statt isolierte Schnipsel zu jonglieren,
• 13:01
  finden Ihre Ad-Power-Pages-Prompts nun im selben Arbeitsbereich statt wie Ihre Website-Inhalte.
• 13:06
  Sie können ein Validierungsskript anpassen und sofort testen,
• 13:08
  wie es mit den Liquid-Templates zweiter interagiert.
• 13:11
  Es ist eine Umgebung, ein Kontext, ein Schritt von der Frage zur Antwort.
• 13:14
  Um es konkret zu machen, zeige ich es Ihnen in einer kurzen Demo.
• 13:17
  Führen Sie einen CLI-Befehl aus, um Ihre Website abzurufen,
• 13:19
  öffnen Sie sowohl die Liquid-Datei einer Seite als auch deren Validierungsskript in 4SCode
• 13:23
  und bitten Sie dann Ad-Power-Pages, die Fehlermeldung zu verbessern.
• 13:26
  Das ist der gesamte Prozess.
• 13:27
  Den Plan vor Augen, die Dateien griffbereit, der KI-Assistent auf Abruf.
• 13:32
  Der wahre Gewinn liegt nicht darin, mehr Tools hinzuzufügen, sondern sie zu konsolidieren.
• 13:36
  Sie eliminieren Kontextwechsel, bleiben fokussiert und arbeiten in einem stabilen Rahmen,
• 13:40
  in dem Programmierung, Inhalte und Unterstützung aufeinander abgestimmt sind.
• 13:43
  Es spart Zeit, aber noch wichtiger ist, dass Sie keine Energie für Ablenkungen verschwenden,
• 13:47
  statt für den eigentlichen Aufbau.
• 13:48
  Stach!
• 13:49
  Mit der Karte endlich in Ihren Händen stolpern Sie nicht mehr herum und fragen sich, wo der nächste Engpass ist.
• 13:54
  Aber selbst wenn das Layout des Dungeons klar ist, bleiben manche Kämpfe.
• 13:57
  Denn wenn der Boss als Haufen von Debug-Federn getarnt auftaucht,
• 14:00
  ist der eigentliche Test, ob Sie sein Angriffsmuster lesen können.
• 14:02
  Husche!
• 14:03
  Und das ist ein Kampf, in den viele Entwickler immer noch blind hineingehen.
• 14:07
  Bosskämpfe beim Debuggen mit Co-Pilot meistern.
• 14:09
  Manchmal besteht die wahre Herausforderung gar nicht darin, neuen Code zu schreiben,
• 14:12
  sondern herauszufinden, warum etwas, das eigentlich in Ordnung schien, plötzlich fehlerhaft reagiert.
• 14:15
  Genau hier kommen Bosskämpfe beim Debuggen mit Co-Pilot ins Spiel.
• 14:20
  Das Debuggen in Powerpages kann sich anfühlen,
• 14:22
  als würde man sich mit einem Bossmonster duellieren, das seine Angriffsmuster verbirgt.
• 14:24
  Fehler sehen willkürlich aus.
• 14:26
  Die Protokolle schreien ohne Kontext.
• 14:28
  Sie durchsuchen lange Skripte.
• 14:30
  Unsicher, ob das Problem die Syntax, ein fehlerhaftes Liquid-Tag oder die nicht kooperierenden Dataverse-Bindungen sind.
• 14:35
  Was eine schnelle Lösung hätte sein sollen, verschlingt eine ganze Sitzung,
• 14:37
  weil Sie Zeile für Zeile Kauderwelsch übersetzen.
• 14:39
  Liquid macht das noch schwieriger.
• 14:41
  Ein winziges Tag kann die Seite verändern.
• 14:43
  Manchmal sauber, manchmal auf spektakuläre Weise falsch.
• 14:46
  Ein Prozent-Inklude-Prozent fügt Inhalte problemlos ein.
• 14:50
  Ein anderes in einem leicht geänderten Kontext zerstört das gesamte Layout.
• 14:53
  Dataverse-Bindungen sorgen für zusätzliche Reiben.
• 14:55
  Sie können auf einem Formular korrekt aufgelöst werden und auf einem anderen lautlos fehlschlagen.
• 14:59
  Die eigene Anleitung von Microsoft erkennt diese Eigenheit an.
• 15:01
  Liquid und Dataverse verhalten sich je nach Platzierung unterschiedlich, was bedeutet.
• 15:05
  Das einfach so lange verschieben, bis es funktioniert, zu ihrem inoffiziellen Workflow wird.
• 15:09
  Genau hier verbessert der Co-Pilot in Power Pages ihre Erfolgschancen.
• 15:13
  Anstatt einen Nachmittag mit blinden Experimenten zu verschwenden,
• 15:15
  können Sie den Code ins Rampenlicht rücken.
• 15:17
  Sie tippen einfach.
• 15:18
  At Power Pages erkläre den folgenden Code, Prozent-Inklude-Page-Copy-Prozent,
• 15:23
  in den Copy-The-Chat, in den Co-Pilot-Chat.
• 15:25
  Kein Herumgerede, keine allgemeinen Ratschläge.
• 15:28
  Das Ergebnis ist eine verständliche Erklärung, die erläutert, was das Tag tut, was es einbindet
• 15:31
  und warum seine Position auf der Seite das Verhalten beeinflusst.
• 15:35
  Im Grunde hören Sie auf zu raten und haben endlich ein lesbares Skripte-Angriffsmuster des Bosses.
• 15:39
  Um das Beste daraus zu machen, strukturieren Sie Ihr Debugging wie eine kurze Demo.
• 15:43
  Identifizieren Sie zuerst den fehlerhaften Code-Schnips.
• 15:44
  Ein Formular stürzt nach einem Include-Tag ab.
• 15:47
  Geben Sie zweitens den exakten Code mit dem Erklärungsbefehl den Co-Pilot ein.
• 15:50
  Drittens nutzen Sie die Erklärung von Co-Pilot für eine kleine Umschreibung oder Layout-Anpassung.
• 15:55
  Testen Sie dann.
• 15:56
  Die Schritte sind kompakt erklären, anwenden, testen.
• 15:58
  Sie sehen Ergebnisse, ohne in endlosem Ausprobieren gefangen zu sein.
• 16:01
  Und Co-Pilot geht weit über das Übersetzen hinaus.
• 16:03
  Im selben Chat können Sie um eine Lösung bitten.
• 16:05
  Co-Pilot kann beispielsweise vorschlagen, die Verschachtelung des Includes anzupassen,
• 16:08
  damit sie zum Layout passt oder JavaScript so zu optimieren,
• 16:10
  das ein Event-Händler feuert, ohne die Konsole zum Absturz zu bringen, ohne die Konsole zum Absturz zu bringen.
• 16:15
  Da es kontextbezogen in Ihrem Powerpages-Workspace arbeitet,
• 16:18
  bezieht sich der Rat direkt auf Ihre Umgebung, statt im allgemeinen Webraum zu schweben.
• 16:22
  Das ist der Unterschied zwischen einem zufälligen Trankverkäufer und jemandem,
• 16:24
  der den Endgegner wirklich kennt, gegen den Sie kämpfen.
• 16:26
  Der Nutzen ist unmittelbar.
• 16:28
  Statt einen halben Tag damit zu verbringen, eine defekte Bindung zu isolieren,
• 16:30
  gelangen Sie direkt zum Verständnis, warum Sie fehlschlägen.
• 16:32
  Das macht das Debugging von mühsamem Zufallsspiel zu etwas taktischem.
• 16:35
  Sie sehen, was kaputt war, wenden einen gezielten Patch an und bestätigen,
• 16:38
  ob sich das Verhalten stabilisiert. Es fühlt sich weniger wie das Ziehen von Würfeln aus einem verfluchten Beutel an,
• 16:42
  sondern mehr wie das Reagieren auf sichtbare Muster.
• 16:43
  Ist der Kontrast in der Praxis?
• 16:45
  Früher ließ sie eine Fehlermeldung wie
• 16:47
  Etwas ist schiefgelaufen, endlos um das Problem kreisen.
• 16:51
  Mit Co-Pilots-Erklärung erfahren Sie, dass das Include-Tag ein spezifisches Seitenfragment lädt
• 16:55
  und durch Ihre Platzierung einen erforderlichen Container überschrieb.
• 16:58
  Sie schreien die Platzierung wie vom Co-Pilot vorgeschlagen, umtesten erneut das Formulabel-Lapcheck.
• 17:02
  In drei Schritten gelangen Sie von der Verwirrung zur Lösung.
• 17:05
  Natürlich gibt es eine Regel, die man wiederholen muss.
• 17:07
  Co-Pilot macht gute Vorschläge, aber das ist keine Garantie.
• 17:10
  Überprüfen und testen Sie immer, bevor Sie in die Produktion gehen.
• 17:13
  Betrachten Sie die Ausgaben, mal Strategiehilfe nicht als sofortige Beute, die Sie blind ausrüsten können.
• 17:17
  Sie sparen Zeit, aber Ihr Urteilsvermögen hält das System stabil.
• 17:20
  Sobald Sie diesen Feedback-Kreislauf aus Erklären, Anpassen und Bestätigen aufgebaut haben,
• 17:24
  schwindet der Respekt vor dem Debugging.
• 17:25
  Liquid wirkt nicht mehr wie ein chaotischer Trickstar,
• 17:28
  Dataverse-Eigenheiten sind keine völligen Rätsel mehr
• 17:30
  und selbst JavaScript-Überraschungen werden zu handhabbaren Gegenangriffen.
• 17:33
  Ein Bosskampf bleibt eine Herausforderung,
• 17:36
  aber Sie kämpfen mit Durchblick statt Treffer aus zufälligen Winkeln einzustecken
• 17:38
  und dieser Perspektivwechsel ist der eigentliche Sieg.
• 17:41
  Das Debugging mit Co-Pilot beseitigt nicht die Begegnung selbst.
• 17:44
  Sie programmieren weiterhin, testen weiterhin und beheben weiterhin Fehler,
• 17:47
  aber Sie verschwenden keine Energie mehr damit, rätselhafte Ausgaben zu interpretieren,
• 17:50
  sondern nutzen zuverlässige Vorteile, was den Grundstein für das letzte Stück legt.
• 17:54
  Wozu all diese Änderungen führen, sobald Sie einen Schritt zurücktreten und das größere Ziel betrachten?
• 17:57
  Das Fazit läuft auf Folgendes hinaus.
• 18:00
  Co-Pilot überspringt keine Kämpfe, er verändert, wie sie es angeht.
• 18:03
  Sie bewegen sich weg von fragilem Ausprobieren hin zu KI-gestütztem Code,
• 18:07
  der sich selbst erklärt, auf Befehl verfeinert wird und Abläufe erstellt,
• 18:10
  die Benutzer ohne Frust bewältigen können.
• 18:12
  Hier sind Ihre fünf Erfolge.
• 18:14
  Liquid-Vorlagen optimieren, JavaScript- und Formularvalidierung beschleunigen,
• 18:17
  verständliche Erklärungen für knifflige Snippets erhalten,
• 18:19
  HTML und Bootstrap für Responsive Layouts einfügen
• 18:22
  und Web-AP-Aufrufe ohne Rätselraten vereinfachen.
• 18:24
  Einige Funktionen befinden sich noch in der Vorschau.
• 18:27
  Mandanten-Administratoren aktivieren diese über den Co-Pelder-Tab im Power-Plattform-Admin-Set.
• 18:31
  Fragen Sie also bei Ihrem Administrator nach, falls Funktionen fehlen sollten.
• 18:34
  Boss besiegt, Beute gesichert.
• 18:35
  Aktivieren Sie den Abonnieren-Buff, läuten Sie die Glocke für zukünftige Demos
• 18:38
  und hinterlassen Sie einen Kommentar mit dem Anvalidierungs- oder Liquid-Problem,
• 18:41
  das Co-Pilot als nächstes angeht.
• 18:42
  Wir werden zukünftige Anleitungen auf Ihre schwierigsten Anliegen zuschneiden.
• 18:45
  Untertitelung des ZDF, 2020