Latest / M365.FM – podcast o Microsoft 365, Copilot i AI po polsku / Szybka naprawa walidacji formularzy Power Pages z GitHub Copilot i @powerpages w VS Code (Dubbing AI)

Transcript

Szybka naprawa walidacji formularzy Power Pages z GitHub Copilot i @powerpages w VS Code (Dubbing AI) · M365.FM – podcast o Microsoft 365, Copilot i AI po polsku

• 0:00
  Znasz to uczucie, gdy formularz PowerPages nie chce się zwalidować, a komunikaty o błędach są tak samo przydatne jak błąd 404, mózg nieznaleziony.
• 0:07
  Ten właśnie problem rozwiążemy dzisiaj.
• 0:09
  Omówimy pięć kroków usprawnianie szablonów Liquid, przyspieszanie JavaScriptu i walidacji formularzy, uzyskiwanie wyjaśnień kodu prostym językiem,
• 0:17
  integrację HTML z Bootstrapem dla elastycznych układów oraz upraszczanie wywołań WebAPI.
• 0:21
  Jedna krótka uwaga, będziesz potrzebować VS Code z rozszerzeniem Power Platform Tools, GitHub Copilot Hat oraz zawartości witryny pobranej przez Cli Power Platform z uwierzytelnianiem Dataverse.
• 0:31
  Taka konfiguracja sprawia, że Copilot staje się świadomy kontekstu.
• 0:34
  Dzięki temu Copilot przestaje wyrzucać losowe fragmenty kodu.
• 0:37
  Zaczyna podawać iteracyjny kod kontekstowy, co ogranicza metodę prób i błędów.
• 0:40
  Pokażę Ci dokładne prompty, abyś mógł samodzielnie powtórzyć te wyniki.
• 0:43
  A ponieważ większość problemów zaczyna się od JavaScriptu, przejdźmy do tego, co się dzieje, gdy błędy formularza przypominają pechowe rzuty w grach RPG.
• 0:49
  Gdy JavaScript zachowuje się jak pechowy rzut, potrafi szybko zamienić proste sprawdzenie formularza w katastrofę.
• 0:55
  Jeden błędny znak i zamiast zatrzymać złe dane, cały proces załamuje się.
• 1:00
  Zazwyczaj wtedy siedzisz, wpatrując się w ekran i zastanawiając, jak banan mógł przejść przez Twoją starannie napisaną logikę walidacji.
• 1:06
  Znasz to nieszkodliwy formularz, walidator mający odfiltrować bzdury i sprytny użytkownik, który wpisuje coś, czego nie przewidziałeś.
• 1:13
  Nagle konsola wybucha błędami, a każda karta w VS Code wydaje się ślepym załukiem.
• 1:18
  Małe błędy bolą najbardziej.
• 1:20
  Brakujący średnik lub błąd zakresu, który w Twojej głowie ma sens, ale podczas uruchamiania kodu działa jak trucizna.
• 1:26
  Takie drobne wpadki zdarzają się w prawdziwych wdrożeniach cały czas i wyjaśniają, dlaczego niedziałająca walidacja to tak częsty problem w tworzeniu stron.
• 1:33
  Zazwyczaj Twoje podejście to siła brute force.
• 1:36
  Zmieniasz linię, odświeżasz, dostajesz kolejny błąd i powtarzasz cykl, aż w końcu coś zadziała.
• 1:41
  Wieczór mija, a efekt końcowy to często tylko łatany na taśmę skrypt, który po prostu działa.
• 1:46
  Bez elegancji, bez wartości edukacyjnej.
• 1:48
  Dlatego debugowanie walidacji przypomina klasyczną porażkę w grze.
• 1:52
  Próbujesz, ale szanse są przeciwko Tobie.
• 1:54
  Tu właśnie wkracza kopilot.
• 1:55
  Ogólne sugestie kopilota czasem pomagają, ale często wyglądają jak losowe fragmenty wyciągnięte z zapomnianego dziennika zadań.
• 2:02
  Użyteczne w założeniu, błędne w szczegółach.
• 2:04
  Dzieje się tak, ponieważ zwykły kopilot nie zna specyfiki Power Pages.
• 2:07
  Ale dodaj uczestnika Power Pages, a nagle przestaje on wyrzucać generyczny kod, oferując w zamian rozwiązania kontekstowe, dopasowane do Twojego środowiska.
• 2:14
  Firma Microsoft stworzyła to narzędzie z myślą o specyfice Power Pages, w tym szablonach Liquid i powiązaniach Dataverse,
• 2:19
  co oznacza, że sugestie uwzględniają funkcje, które zazwyczaj sprawiają najwięcej problemów.
• 2:23
  Nie chodzi tylko o generowanie fragmentów kodu, integracja Power Pages potrafi również wyjaśniać konstrukcje specyficzne dla Power Pages,
• 2:29
  dzięki czemu nie musisz kopiować w ciemno, a faktycznie rozumiesz, dlaczego skrypt działa tak, a nie inaczej.
• 2:33
  Dzięki temu debagowanie przestaje być jak błądzenie z zawiązanymi oczami, a zaczyna przypominać pracę u boku kogoś, kto już pokonał tę samą ścieżkę.
• 2:40
  Na przykład możesz wpisać dokładnie takie polecenie w czacie kopilota.
• 2:43
  Power Pages napisz kod JavaScript do walidacji pola formularza, aby zweryfikować, czy wartość pola telefonu ma prawidłowy format.
• 2:49
  To nie tylko teoria, to gotowy do użycia w demonstracji wkład, który zobaczysz później w tym przewodniku.
• 2:54
  Otrzymany kod nie jest niejasnym fragmentem z sieci, lecz rozwiązaniem bezpośrednio zastosowalnym i zaprojektowanym tak, by działało w kontekście Power Pages.
• 3:00
  Ta przewidywalność to prawdziwy przełom.
• 3:02
  Przy standardowym kopilocie czujesz się, jakbyś zaangażował barda, który może zagra odpowiedni akord,
• 3:06
  ale przez większość czasu melodia nie ma związku z twoją aktualną walką.
• 3:09
  Z Power Pages to bardziej jak podróżowanie z łowcą, który wie, gdzie kryją się pułapki.
• 3:13
  Wyprawa staje się mniej kwestią przetrwania w pułapkach, a bardziej projektowaniem przejrzystych doświadczeń użytkownika.
• 3:18
  Narzędzie nie zastępuje twojego osądu, lecz go wyostrza.
• 3:21
  To ty nadal decydujesz, co stanowi poprawne dane wejściowe i jak błędy powinny kierować użytkownikiem.
• 3:25
  Zamiast tracić czas na błędy składniowe i literówki w wartościach logicznych, skupiasz swoje wysiłki na tworzeniu intuicyjnego przepływu pracy.
• 3:31
  Właściwie obsłużone kroki walidacji przestają być przeszkodami, a stają się częścią płynnego procesu dla każdego, kto korzysta z formularza.
• 3:37
  Może nie wygląda to na spektakularne zwycięstwo, ale eliminacja podstawowych błędów chroni cię przed lawiną zgłoszeń w przyszłości.
• 3:44
  Gdy kopilot przejmuje żmudną pracę generowania dokładnego kodu walidacyjnego, twój czas przesuwa się z trybu przetrwania na rzeczywiste udoskonalanie działania aplikacji.
• 3:51
  Ta różnica ma znaczenie, ponieważ widząc, jak dobrze ukierunkowane polecenia zmieniają proces generowania kodu, zaczynasz zastanawiać się, co jeszcze mogą odblokować.
• 3:59
  I właśnie wtedy prawdziwa zaleta korzystania z kopilota w Power Pages staje się oczywista.
• 4:03
  Uzyskanie przewagi dzięki poleceniom kopilota. Uzyskanie przewagi oznacza tutaj znajomość odpowiednich poleceń dla kopilota, zamiast liczenia na łód szczęścia.
• 4:11
  To właśnie prawdziwa siła korzystania z uczestnika Power Pages.
• 4:14
  Przekształca on czat kopilota z ogólnego pomocnika w świadomego kontekstu partnera, stworzonego dla Twojego środowiska Power Pages.
• 4:20
  Oto jak go wywołać. W VS Code otwórz okno czatu kopilot, a następnie wpisz swoje polecenie, zaczynając od Power Pages.
• 4:27
  Ten znacznik sygnalizuje kopilotowi, aby załadował mózg Power Pages zamiast trybu standardowego.
• 4:32
  Możesz prosić o walidatory, fragmenty kodu Liquid, a nawet wywołania powiązane z Dataverse, a kopilot dostosuje odpowiedzi do systemu, w którym faktycznie kodujesz.
• 4:41
  Zanim to zadziała, potrzebujesz odpowiedniego przygotowania.
• 4:44
  Zainstalowane Visual Studio Code, rozszerzenie Power Platform Tools, rozszerzenie GitHub Kopilot HAT oraz Power Platform CLI uwierzytelnione w Twoim środowisku Dataverse.
• 4:53
  Krok uwierzytelnienia jest najważniejszy, ponieważ kopilot rozumie Twoje środowisko dopiero wtedy, gdy pobierzesz zawartość witryny do VS Code będąc zalogowanym.
• 5:00
  Bez tego tylko zgaduję. I jeszcze jedna uwaga dotycząca zarządzania.
• 5:04
  Niektóre funkcje kopilota dla Power Pages są wciąż w fazie testów, a administratorzy dzierżawy kontrolują ich włączanie przez kopilot hub w ustawieniach zarządzania.
• 5:10
  Nie zdziw się, jeśli prezentowane tu funkcje są wyłączone w Twojej organizacji.
• 5:13
  To przełącznik administratora, a nie błąd.
• 5:15
  Oto różnica, gdy już wszystko skonfigurujesz.
• 5:18
  Zwykły kopilot jest jak proszenie barda o porady na polu bitwy.
• 5:20
  Dostaniesz przyjemną melodię, może jakiś ogólny komentarz, ale żadnych szczegółów potrzebnych przy pracy z szablonami Liquid lub polami NC Dataverse.
• 5:28
  Uczestnik Power Pages jest bardziej jak zwiadowca, który już zbadał teren.
• 5:32
  To nie tylko kod, który się kompiluje.
• 5:33
  To kod, który odwołuje się do poprawnych powiązań, pasuje do walidatorów formularzy i zgadza się z działaniem Power Pages.
• 5:39
  Jedna metafora, jeden kontrast, jedna korzyść.
• 5:42
  Użyteczne wyniki świadome kontekstu zamiast kruchych, generycznych fragmentów.
• 5:46
  Porozmawiajmy o wynikach.
• 5:47
  Jeśli poprosisz zwykłego kopilota o procedurę walidacji, prawdopodobnie dostaniesz skrypt działający w prostym formularzu HTML.
• 5:53
  Wklej go jednak do Power Pages, a napotkasz martwe punkty.
• 5:55
  Brak rozpoznania schematu NC, brak pojęcia o znacznikach Liquid i zdecydowanie brak świadomości reguł Dataverse.
• 6:01
  Działa jak taśma klejąca, trzyma się, ale jest zawodne.
• 6:04
  Wpisz to samo zapytanie z Power Pages na początek, a nagle otrzymasz walidatory, które nie tylko działają, ale łączą się z odpowiednimi polami NC, których potrzebujesz.
• 6:11
  To samo zapytanie, wyjście dostosowane do kontekstu, bez konieczności nocnego poprawiania kodu.
• 6:15
  I nie chodzi tu tylko o generowanie skryptów.
• 6:18
  Polecenia typu Power Pages wyjaśni poniższy kod %IncludePageCopyProcent oferują proste wyjaśnienia konstrukcji Liquid lub elementów specyficznych dla Power Pages.
• 6:26
  Nie kopiujesz na ślepo, lecz faktycznie budujesz swoje zrozumienie.
• 6:29
  To inny rodzaj mocy, ponieważ uczysz się run, jednocześnie ich używając.
• 6:33
  Im dłużej pracujesz z tymi poleceniami, tym bardziej zmienia się twój sposób pracy.
• 6:37
  Zamiast poprawiać błędy w samotności o drugiej w nocy, traktujesz kopilota jak drugą parę oczu, która zna już przyczyny awarii z 90% podobnych projektów.
• 6:45
  Te polecenia nie dają kodów do oszukiwania, dają wgląd i gotowe przykłady, które szanują specyficzne dziwactwa Twojego środowiska.
• 6:51
  Oszczędzają Ci niekończących się cykli poprawek.
• 6:53
  W standardowej roli kopilota znajdziesz się gdzieś po środku.
• 6:56
  Przyzwoity skrypt, trochę poprawek, trochę prób i błędów, zanim wszystko zacznie działać.
• 7:00
  W roli Power Pages czuje się to jak naturalne 20 na kości.
• 7:03
  Skrypty walidacji idealnie pasują do formularza Power Pages, wstawki Liquid przechodzą, a powiązania Dataverse nie wyrzucają błędów.
• 7:10
  To nieszczęście, to efekt sytuacji, w której kopilot zna teren, na którym kodujesz.
• 7:15
  Ta przewaga daje jednak tylko pierwszy szkic.
• 7:17
  Działający fragment kodu nie oznacza gotowego rozwiązania.
• 7:20
  Użytkownicy wpisują dziwne dane, komunikaty błędów potrzebują szczegółów, a skrypty muszą wyewoluować poza szkielet, który daje Ci kopilot.
• 7:26
  I tu zaczyna się kolejne wyzwanie.
• 7:28
  Droga od szkieletów skryptów do w pełni opancerzonego kodu zaczyna się tam, gdzie większość walidacji od podstaw.
• 7:35
  Dostajesz pierwszy szkic, prosty skrypt, który technicznie działa, ale blokuje tylko najbardziej oczywiste błędy.
• 7:40
  Pomyśl o tym jak o wojowniku na pierwszym poziomie z tekturową tarczą.
• 7:43
  Działa przy jednym czy dwóch słabych ciosach, ale gdy prawdziwy użytkownik zaczyna atakować, tarcza pęka.
• 7:48
  Każdy, kto wdrożył formularz, wie, że skrypt nie przetrwa długo w swojej początkowej formie.
• 7:52
  Zabezpieczasz się przed prostymi błędami, ale potem użytkownik wkleja emoji w pole telefonu lub wpisuje datę urodzenia z przyszłości.
• 7:59
  Nagle Twoja obrona upada, zgłoszenia trafiają do skrzynki, a Ty zostajesz z kruchą walidacją, która jest bezradna.
• 8:04
  Głównym problemem nie jest tylko zakres walidacji, ale informacja zwrotna.
• 8:08
  Komunikat typu nieprawidłowe dane to programowy odpowiednik zamkniętych drzwi bez żadnej tabliczki.
• 8:13
  Nic nie mówi użytkownikom, więc zgadują, znów popełniają głąd i ostatecznie zwalają problem na Ciebie.
• 8:17
  To właśnie wtedy zgłoszenia do pomocy technicznej mnożą się z tych samych przewidywalnych powodów.
• 8:21
  Oto zmiana.
• 8:21
  Te tekturowe skrypty nie muszą pozostać kruche.
• 8:24
  Z kopilotem nie tylko akceptujesz szkielet, ale przekuwasz go w zbroję.
• 8:28
  A przepływ pracy jest na tyle prosty, że można go zapamiętać jako czterostopniową pętlę.
• 8:32
  Wygeneruj szkielet, poproś kopilota o poprawę komunikatów błędów, dodaj obsługę przypadków brzegowych i wdruż.
• 8:37
  Każdy krok zmienia delikatny projekt w prawdziwą broń, której ufasz w terenie.
• 8:41
  Kopilot pracuje w sesji, co sprawia, że jest to szybkie.
• 8:44
  Ponieważ jesteś w tym samym czacie, z którego pochodził szkielet, po prostu wpisujesz, zaktualizuj kod i napisz szczegółowe komunikaty błędów.
• 8:50
  Kopilot nie zaczyna od zera, on dosłownie aktualizuje kod, który masz bezpośrednio w edytorze.
• 8:55
  Bez przełączania się między kartami przeglądarki i tworzenia promptów od zera.
• 8:58
  To proces iteracyjny, a nie kopiuj w klej.
• 9:00
  I od razu widzisz efekt.
• 9:02
  Wyobraź sobie stan przed i po.
• 9:04
  Twój pierwszy szkic wyrzuca nieprawidłowe dane wejściowe.
• 9:06
  Po jednej poprawce brzmi, numer telefonu musi składać się z samych cyfr i mieć co najmniej 10 znaków.
• 9:11
  Ta jasność zmienia doświadczenie użytkownika.
• 9:14
  Zamiast muru budujesz linę prowadzącą.
• 9:16
  Użytkownicy wiedzą, co poszło nie tak i jak samodzielnie to naprawić.
• 9:19
  Zero zgłoszeń, zero narzekań, mniej straconego czasu po Twojej stronie.
• 9:22
  Naciśnij ponownie w przypadku nietypowych sytuacji, a kopilot rozszerzy ochronę.
• 9:25
  Musisz sprawdzić, czy znaki specjalne nie przedostają się do pól liczbowych?
• 9:28
  Zapytaj kopilota w tym samym wątku.
• 9:30
  Chcesz więcej warstwowych odpowiedzi dla różnych typów błędów?
• 9:33
  Ten sam proces.
• 9:34
  Za każdym razem skrypt staje się nieco solidniejszy, a dzieje się to w kontekście Twojego środowiska Power Pages, a nie tylko ogólnego kodu webowego.
• 9:41
  W rzeczywistości zmienia się sposób, w jaki debagujesz.
• 9:43
  Przestajesz gasić pożary pojedynczych linii zepsutej składni, a zaczynasz rzeźbić działające wersje.
• 9:48
  Kopilot daje Ci już gotową podstawę, więc Twoja energia idzie w dopracowywanie szczegółów.
• 9:52
  Zamiast prób i błędów z dziwactwami składni, celowo kształtujesz to, jak kod odpowiada użytkownikowi.
• 9:57
  To redukuje godziny poprawek i ogranicza napływ zgłoszeń do wsparcia.
• 10:00
  Kiedy spojrzysz na to przez pryzmat pętli, szkielet, dopracowanie komunikatów, wzmocnienie na nietypowe przypadki, wdrożenie zdasz sobie sprawę, że nie tylko zapobiegasz chaosowi danych, ale aktywnie zmniejszasz przyszłe obciążenie wsparcia.
• 10:10
  Każdy starannie przygotowany komunikat o błędzie to jedno pytanie, dlaczego to nie działa?
• 10:13
  Mniej, mniej w Twojej kolejce zgłoszeń.
• 10:15
  Każdy obsłużony nietypowy przypadek to jedno kruche pole mniej, które mogłoby zawieść na produkcji.
• 10:20
  Gdy poprawki kopilota zostaną nałożone, szkielet wciąż istnieje pod pancerzem, ale jest całkowicie odmieniony.
• 10:25
  To, co zaczęło się jako rozwiązanie tymczasowe, staje się czymś wystarczająco odpornym dla danych produkcyjnych, z informacją zwrotną, która edukuje użytkownika zamiast go blokować.
• 10:33
  Jak papierowa tarcza przekuta w płytową, zmienia to odczucia obu stron ekranu.
• 10:37
  I choć walidacja skryptowa to tylko element układanki, wokół niej rozciąga się większe pole bitwy.
• 10:42
  Kot może być opancerzony, ale pojawia się pytanie, jak zarządzać całą strukturą, w której się znajduje, nie spowalniając tempa.
• 10:48
  To właśnie tutaj pojawia się kolejne wyzwanie, nie w samym skrypcie, ale w sposobie, w jaki zarządzasz mapą swojej witryny.
• 10:53
  Edycja mapy lochów za pomocą CLI i VS Code
• 10:56
  Gdy chcesz wyjść poza pojedyncze skrypty i zacząć zarządzać całą witryną, potrzebujesz czegoś więcej niż tylko siłowej edycji.
• 11:02
  Potrzebujesz porządnej mapy.
• 11:04
  Edycja mapy lochów za pomocą CLI i VS Code to sposób na to, by przestać błądzić po ciemnych korytarzach i mieć każdy z nich na widoku.
• 11:10
  Chaotyczny sposób to żonglowanie kartami w studiu projektowym przeglądarki, przeskakiwanie do terminala i ciągłe przerzucanie plików tylko po to, by wprowadzić drobną zmianę.
• 11:17
  To działa, ale jest mało wygodne. Zintegrowane podejście polega na pobraniu całej zawartości witryny lokalnie za pomocą Power Platform CLI, a następnie edycji i wdrażaniu przez rozszerzenie Power Platform Tools w VS Code.
• 11:27
  Jeden przepływ pracy bez zbędnych kroków.
• 11:29
  Oto jak to wygląda.
• 11:30
  Zanim cokolwiek zrobisz, uwierzytelniasz się w swoim środowisku Dataverse.
• 11:34
  Pomyśl o tym, jak o otwarciu drzwi wejściowych, aby CLI mogło uzyskać dostęp do Twojej witryny.
• 11:39
  Po uwierzytelnieniu uruchamiasz jedno polecenie, aby pobrać zawartość witryny do lokalnego obszaru roboczego.
• 11:45
  To pobranie sprowadza szablony, skrypty, pliki CSS i zasoby.
• 11:49
  Pełna kopia danych Twojej witryny na Twoim komputerze.
• 11:52
  Kopilot również na tym zyskuje, ponieważ dzięki lokalnym plikom może odwoływać się do obiektów specyficznych dla środowiska, zamiast zgadywać.
• 11:59
  Od tego momentu cały czas jesteś w VS Code.
• 12:02
  Chcesz dostosować szablon Liquid?
• 12:03
  Plik jest pod ręką.
• 12:05
  Naprawić logikę walidacji?
• 12:06
  Otwórz plik JavaScript znajdujący się obok, a ponieważ wszystko jest scentralizowane, widzisz w czasie rzeczywistym, jak łączą się elementy, zamiast przełączać się między narzędziami bez pełnego obrazu sytuacji.
• 12:15
  Rozszerzenie Power Platform Tools sprawia, że polecenia CLI są łatwiejsze w obsłudze.
• 12:19
  Nadal masz do dyspozycji surowy wiersz poleceń, ale teraz żyje on w zintegrowanym terminalu VS Code, powiązany z obszarem roboczym, w którym już kodujesz.
• 12:26
  Oznacza to brak konieczności zapamiętywania długich ciągów znaków przy każdym uruchamianiu tych samych krótkich poleceń.
• 12:31
  Pobierz, edytuj, wdruż.
• 12:32
  Płynny cykl.
• 12:33
  Żadne fragmenty nie wymkną się z synchronizacji.
• 12:36
  Samo wdrażanie również staje się prostsze.
• 12:38
  Po dokonaniu edycji używasz tego samego przepływu pracy opartego na CLI, aby wypchnąć zmiany z powrotem do środowiska Power Pages.
• 12:44
  To zamyka pętlę bez typowego podwójnego przetwarzania czy błędów wersji.
• 12:48
  Nie kopiujesz folderów ręcznie ani nie martwisz się, czy sesja przeglądarki wygasła.
• 12:52
  Trzymasz wszystko w jednym środowisku, które faktycznie kontrolujesz.
• 12:56
  Wzrost produktywności jest naprawdę widoczny, gdy włączysz do tego kopilota.
• 13:00
  Zamiast żonglować odizolowanymi fragmentami, Twoje zapytania Power Pages odbywają się teraz w tym samym obszarze roboczym, co zawartość witryny.
• 13:06
  Możesz poprawić skrypt walidacji i natychmiast przetestować, jak współdziała z szablonami Liquid w sąsiedniej karcie.
• 13:11
  Jedno środowisko, jeden kontekst, jeden krok od pytania do odpowiedzi.
• 13:14
  Aby pokazać to konkretnie, przedstawię krótkie demo.
• 13:17
  Uruchom jedno polecenie CLI, aby pobrać witrynę, otwórz plik Liquid, stronę oraz skrypt walidacji w VS Code, a następnie poproś Power Pages o ulepszenie komunikatów o błędach.
• 13:26
  To cały cykl.
• 13:27
  Mapa przed Tobą, pliki w zasięgu ręki, asystent AI w gotowości.
• 13:32
  Prawdziwy zysk nie polega na dodawaniu kolejnych narzędzi, lecz na ich konsolidacji.
• 13:36
  Eliminujesz przełączanie kontekstów, utrzymujesz skupienie i pracujesz w ramach jednego stabilnego środowiska, gdzie kod, zawartość i wsparcie współgrają ze sobą.
• 13:43
  Oszczędza to czas, ale co ważniejsze, chroni przed marnowaniem energii na rozpraszacze zamiast na faktyczne budowanie.
• 13:49
  Mając wreszcie mapę w dłoniach, nie błąkasz się już bez celu, zastanawiając się, gdzie jest kolejny punkt krytyczny.
• 13:54
  Jednak nawet przy przejrzystym układzie lochu, niektóre walki pozostają, bo gdy boss pojawia się pod postacią sterty błędów debugowania, prawdziwym testem jest to, czy potrafisz odczytać jego schemat ataku.
• 14:03
  I to jest walka, do której wielu programistów wciąż przystępuje na oślep.
• 14:07
  Debugowanie walk z bossami z kopilotem.
• 14:09
  Czasami prawdziwym testem nie jest pisanie nowego kodu, lecz odkrycie, dlaczego coś, co wydawało się sprawne, nagle staje się problematyczne.
• 14:16
  Właśnie tutaj do gry wchodzi debugowanie walk z bossami przy użyciu kopilota.
• 14:20
  Debugowanie Power Pages może przypominać wymianę ciosów z bossem, który ukrywa swój schemat ataku.
• 14:25
  Błędy wyglądają na przypadkowe.
• 14:26
  Logi krzyczą bez żadnego kontekstu.
• 14:28
  Przeszukujesz długie skrypty, nie mając pewności, czy problemem jest składnia błąd tagu liquid, czy niedziałające powiązania datavers.
• 14:34
  To, co powinno być szybką poprawką, pochłania całą sesję, ponieważ linijka po linijce tłumaczysz bełkot.
• 14:39
  Liquid dodatkowo to utrudnia.
• 14:41
  Jeden mały tag może zmienić całą stronę.
• 14:43
  Czasami elegancko, a czasami w sposób katastrofalny.
• 14:46
  Jeden znacznik %include% wstawia treść bez żadnego problemu.
• 14:50
  Inny, w nieco innym kontekście, niszczy cały układ strony.
• 14:53
  Powiązania datavers dodają jeszcze więcej trudności.
• 14:56
  Mogą działać poprawnie na jednym formularzu, a na innym zawieść w ciszy.
• 14:59
  Własna dokumentacja Microsoftu przyznaje, że to dziwne zachowanie istnieje.
• 15:02
  Liquid i datavers zachowują się różnie w zależności od umiejscowienia,
• 15:05
  co sprawia, że Twoim nieoficjalnym trybem pracy staje się przesuwanie elementów, aż zadziałają.
• 15:09
  Właśnie tutaj udział Copilota w Power Pages zmienia Twoje szanse.
• 15:13
  Zamiast tracić popołudnie na ślepe eksperymenty, możesz rzucić na kod odpowiednie światło.
• 15:18
  Wpisujesz dosłownie w czat Copilota at Power Pages wyjaśnij poniższy kod %include page copy%
• 15:24
  Żadnego wymijania, żadnych ogólnych porad.
• 15:28
  Wynikiem jest wyjaśnienie prostym językiem, co robi dany tak, co pobiera i dlaczego jego pozycja na stronie wpływa na zachowanie.
• 15:35
  W efekcie przestajesz zgadywać i masz wreszcie czytelny zapis ruchów bossa.
• 15:39
  Aby w pełni z tego skorzystać, zorganizuj swoje debugowanie jak szybkie demo.
• 15:43
  Najpierw zidentyfikuj błędny fragment.
• 15:45
  Formularz sypie się zaraz po tagu include.
• 15:47
  Po drugie, wrzuć ten konkretny kod do Copilota z komendą wyjaśnienia.
• 15:50
  Po trzecie, wykorzystaj wyjaśnienie Copilota do drobnej poprawki kodu lub zmiany układu.
• 15:54
  Następnie przetestuj.
• 15:55
  Kroki są zwięzłe, wyjaśnij, zastosuj, przetestuj.
• 15:58
  Widzisz wyniki bez wpadania w pułapkę niekończących się prób i błędów, a Copilot idzie znacznie dalej niż tylko tłumaczenie.
• 16:03
  W tym samym czacie możesz poprosić o poprawkę.
• 16:05
  Na przykład Copilot może zasugerować zmiany zagnieżdżenia include, aby pasowało do układu strony, albo skorygować JavaScript, by obsługa zdarzeń nie zaujszała konsoli.
• 16:14
  Dzięki temu, że działa w oparciu o kontekst Twojego obszaru roboczego, Power Pages porady odnoszą się bezpośrednio do Twojego środowiska, zamiast być ogólnymi wskazówkami z sieci.
• 16:22
  To różnica między przypadkowym sprzedawcą mikstur, a kimś, kto naprawdę zna bossa, z którym walczysz.
• 16:26
  Korzyść jest natychmiastowa.
• 16:28
  Zamiast spędzać pół dnia na izolowaniu jednego uszkodzonego powiązania, od razu przechodzisz do zrozumienia przyczyny błędu.
• 16:32
  To zmienia debagowanie z żmudnego losowania w działanie taktyczne.
• 16:35
  Widzisz, co się zepsuło? Stosujesz precyzyjną poprawkę i sprawdzasz, czy system się stabilizuje.
• 16:39
  Mniej przypomina to losowanie kości z przeklętej sakiewki, a bardziej reagowanie na widoczne wzorce.
• 16:44
  Oto kontrast w praktyce.
• 16:45
  Wcześniej komunikat o błędzie typu, coś poszło nie tak, sprawiał, że kręciłeś się w kółko wokół problemu.
• 16:51
  Dzięki wyjaśnieniu kopilota dowiadujesz się, że znacznik include ładuje fragment strony, który w Twoim ustawieniu nadpisywał wymagany kontener.
• 16:58
  Zmieniasz położenie zgodnie z sugestią kopilota, testujesz ponownie i formularz działa.
• 17:02
  W trzech krokach przechodzisz od dezorientacji do rozwiązania.
• 17:04
  Oczywiście jest jedna zasada, którą warto powtarzać.
• 17:07
  Kopilot przedstawia trafne sugestie, ale nie daje gwarancji.
• 17:11
  Zawsze sprawdzaj i testuj kod przed wdrożeniem na produkcję.
• 17:13
  Traktuj wyniki jak poradnik strategiczny, a nie jak gotowy łup, który możesz wyposażyć w ciemno.
• 17:17
  Oszczędzają czas, ale to Twój osąd zapewnia stabilność systemu.
• 17:20
  Gdy zbudujesz tę pętlę zwrotną wyjaśnij, dostosuj, potwierdź, zmniejszasz onieśmielający charakter debugowania.
• 17:26
  Liquid przestaje być chaotycznym psotnikiem, dziwactwa Dataverse przestają być zagadkami,
• 17:30
  a nawet niespodzianki w JavaScript stają się możliwymi do odparcia atakami.
• 17:34
  Walka z bossem nadal jest wyzwaniem, ale walczysz z wizją, zamiast zbierać ciosy z nieznanych stron,
• 17:39
  a ta zmiana perspektywy to prawdziwa wygrana.
• 17:41
  Debugowanie z kopilotem nie usuwa trudnych zadań.
• 17:44
  Nadal kodujesz, testujesz i rozwiązujesz problemy,
• 17:47
  ale przestajesz marnować energię na wpatrywanie się w tajemnicze komunikaty
• 17:50
  i zyskujesz przewagę, co przygotowuje grunt pod ostatni etap.
• 17:54
  Oto co oznaczają te wszystkie zmiany, gdy spojrzysz na całość z szerszej perspektywy.
• 17:58
  Wniosek sprowadza się do tego.
• 18:00
  Kopilot nie pomija walk, on zmienia sposób, w jaki je toczysz.
• 18:03
  Przechodzisz od kruchych prób i błędów do kodu wspomaganego przez AI,
• 18:06
  który tłumaczy swoje działanie, udoskonala się na żądanie i tworzy procesy,
• 18:09
  w których użytkownicy mogą się poruszać bez rezygnacji z frustracji.
• 18:12
  Oto pięć korzyści.
• 18:13
  Usprawnienie szablonów Liquid, przyspieszenie JavaScriptu i walidacji formularzy,
• 18:17
  proste wyjaśnienia trudnych fragmentów kodu,
• 18:19
  łatwe wstawianie HTML i Bootstrap dla responsywnych układów
• 18:22
  oraz uproszczenie wywołań API bez zgadywania.
• 18:25
  Niektóre funkcje są wciąż w fazie testowej.
• 18:27
  Administratorzy dzierżawy włączają je w Centrum Kopilot w Power Platform Admin Center,
• 18:31
  więc sprawdź u nich, jeśli czegoś brakuje.
• 18:33
  Bo spokonany łup zabezpieczony.
• 18:35
  Włącz subskrypcję i powiadomienia, aby nie przegapić nowych prezentacji
• 18:38
  oraz zostaw komentarz z problemem dotyczącym walidacji lub Liquid,
• 18:40
  którym Kopilot ma zająć się w następnej kolejności.
• 18:42
  Dopracujemy przyszłe poradniki pod kątem Twoich najtrudniejszych zgłoszeń.
• 18:45
  Dziękuje za uwagę.