Przejdź do:

1. 1. Biblioteka Zod
2. 2. Czym jest walidacja danych Zod i dlaczego jest tak ważna?  
3. 3. Jak używać Zod w aplikacjach opartych na AI?
4. 4. Zastosowanie Zod w preprocessingu danych  
5. 5. Jak Zod usprawnia deployment modeli AI?  
6. 6. Kluczowe cechy Zod w JavaScript  
7. 7. Jak zaimplementować walidację formularza z użyciem Zod?  

Biblioteka Zod 

I właśnie tutaj dobrym rozwiązaniem jest Zod: lekka, szybka biblioteka do walidacji danych dla TypeScript, która pozwala jasno określić, jakich struktur oczekujemy od inputu. Zamiast zgadywać, czy odpowiedź będzie zgodna z oczekiwaniami, po prostu ją walidujemy. Jeśli coś się nie zgadza – dostajemy informację o błędzie i jasny komunikat. Jeśli wszystko gra – możemy bezpiecznie przetwarzać dane dalej. Mamy nad wszystkim kontrolę, jeszcze zanim przekażemy dalej dane do naszej logiki biznesowej.  

Zod działa jak filtr bezpieczeństwa – pozwala odrzucić błędne odpowiedzi, zanim trafią do logiki aplikacji. Dzięki temu zyskujemy nie tylko większą kontrolę, ale też spokój ducha: nawet jeśli AI trochę „zbłądzi”, warstwa frontend to odpowiednio obsłuży i tego nie odczuje.  

Czym jest walidacja danych Zod i dlaczego jest tak ważna?  

Zod to biblioteka TypeScript / JavaScript, która umożliwia tworzenie schematów danych (schemas), wykorzystywanych zarówno do walidacji danych w czasie rzeczywistym, jak i do generowania typów w czasie kompilacji. Dzięki niej możemy opisać strukturę danych, której aplikacja oczekuje, i automatycznie sprawdzić, czy rzeczywiste dane, które przekazaliśmy do inputu spełniają wszystkie nasze założenia.  

W kontekście AI – gdzie dane zwracane przez modele bywają nieprzewidywalne i często nie trzymają się jednej struktury, walidacja staje się wręcz obowiązkowa. Nawet drobna zmiana w odpowiedzi modelu może wywołać błąd w aplikacji, jeśli nasz kod zakłada konkretną strukturę danych. Zod pozwala temu zapobiec, sprawdzając zgodność danych, zanim trafią dalej do logiki biznesowej.  

Przeczytaj także:

• Najlepsze AI for coding
• AI w programowaniu: Github Copilot

Jak używać Zod w aplikacjach opartych na AI? (validation in AI with Zod) 

Zod można zintegrować z dowolną aplikacją JavaScript, zarówno po stronie frontendu, jak i backendu. W kontekście AI najczęściej wykorzystywany jest do:  

• walidacji odpowiedzi z API (np. OpenAI),  
• generowania interfejsów dynamicznych,  
• utrzymywania spójnych kontraktów danych między frontendem a modelem.  

Dzięki helperowi zodResponseFormat w SDK OpenAI możemy łatwo powiązać schemat Zod z odpowiedzią modelu:  

const MathResponse = z.object({
  steps: z.array(z.object({
    explanation: z.string(),
    output: z.string(),
  })),
  final_answer: z.string(),
});

const completion = await client.beta.chat.completions.parse({
  model: 'gpt-4o',
  messages: [...],
  response_format: zodResponseFormat(MathResponse, 'math_response'),
});

Taka integracja sprawia, że odpowiedź modelu jest walidowana automatycznie i możemy bezpiecznie korzystać z jej zawartości w aplikacji.  

Jeśli korzystamy z funkcji narzędzi (tool calls), możemy użyć zodFunction, by automatycznie zmapować argumenty na typy Zod:  

const queryArgs = z.object({ ... });

const completion = await client.beta.chat.completions.parse({
  model: 'gpt-4o',
  messages: [...],
  tools: [zodFunction({ name: 'query', parameters: QueryArgs })],
});

Zod daje nam kontrolę nad strukturą danych – zarówno tych zwracanych przez model, jak i tych przekazywanych do funkcji. Dzięki temu unikamy błędów wynikających z niespójności formatu i mamy większą przewidywalność działania aplikacji.  

Zastosowanie Zod w preprocessingu danych  

Zod sprawdza się nie tylko po stronie odbioru danych z modelu AI, ale również wcześniej – podczas przygotowania danych wejściowych. Preprocessing to moment, w którym możemy upewnić się, że to, co wysyłamy do modelu, jest kompletne, poprawnie sformatowane i zgodne z oczekiwanym typem.  

Typowe zastosowania Zod w preprocessingu:  

• walidacja danych wprowadzanych przez użytkownika przed wysłaniem zapytania do AI,  
• konwersja typów, np. zamiana ciągów znaków (stringa) na daty,  
• czyszczenie i porządkowanie danych z zewnętrznych źródeł, jak API czy formularze.  

const dateSchema = z.string().transform(str => new Date(str));
const parsedDate = dateSchema.parse("2024-08-06"); // => obiekt typu Date

Dzięki funkcji .transform() możemy nie tylko sprawdzić, czy dane mają odpowiedni format, ale też przekształcić wprowadzone dane do postaci, która jest odpowiednio dostosowana do dalszego przetwarzania w aplikacji. To szczególnie przydatne, gdy dane mają służyć jako prompt lub parametr w zapytaniu do modelu AI.  

Preprocessing z użyciem Zod to prosty sposób na zminimalizowanie błędów i zwiększenie kontroli nad danymi, zanim jeszcze trafią do modelu.  

Jak Zod usprawnia deployment modeli AI?  

Zod to nie tylko narzędzie deweloperskie – jego zastosowanie ma realne przełożenie na jakość wdrożeń modeli AI w środowiskach produkcyjnych. Pozwala budować solidny bufor bezpieczeństwa pomiędzy często nieprzewidywalnym modelem AI a wymaganiami naszej aplikacji.  

Biblioteka Zod w procesie deploymentu pomaga:  

• Zwiększyć odporność aplikacji na zmiany – zmiana prompta, wersji modelu czy struktury danych nie musi oznaczać błędów, jeśli dane przechodzą przez schematy walidacyjne tworzone przez Zoda.  
• Szybciej debugować problemy – zamiast domyślać się, co poszło nie tak, dostajemy jasne, czytelne komunikaty o błędach.  
• Pisać testy jednostkowe – schematy Zod mogą pełnić funkcję walidatorów i źródła przykładowych danych wejściowych do testów.  

Zamiast więc opierać się na założeniu, że wszystko w końcowej fazie projektu działa, możemy zbudować system, który rzeczywiście przewiduje błędy i potrafi się przed nimi obronić.  

Z perspektywy wdrożeniowej oznacza to mniej awarii, większą spójność danych i łatwiejsze utrzymanie całego pipeline’u – od prompta po końcowy interfejs użytkownika.  

Kluczowe cechy Zod w JavaScript  

Zod oferuje nowoczesne podejście do walidacji danych w JavaScript i TypeScript. Jego główne zalety to:  

• Deklaratywność – schematy są czytelne, przejrzyste i proste do napisania. Możemy z łatwością tworzyć złożone struktury bez nadmiaru kodu.  

const UserSchema = z.object({
  name: z.string().min(3),
  age: z.number().int().positive(),
  email: z.string().email(),
});

• Bezpośrednia integracja z TypeScriptem – Zod automatycznie wyciąga typy z definicji schematów (z.infer), dzięki czemu nie musimy pisać typów dwa razy.  

type User = z.infer<typeof UserSchema>;

• Walidacja i transformacja w jednym miejscu – możemy nie tylko sprawdzać dane, ale też odpowiednio je przekształcać (np. string → Date, liczba → boolean, itp.).  

const DateSchema = z.string().transform(str => new Date(str));
const parsedDate = DateSchema.parse("2024-08-06");

• Obsługa błędów – metody safeParse i parse pozwalają wygodnie obsługiwać błędy. Pierwsza nie rzuca wyjątku, a druga daje pełną kontrolę nad błędami typu ZodError.  

const result = UserSchema.safeParse(userData);
if (!result.success) {
  console.log(result.error.format());
}

• Czytelne komunikaty walidacyjne – błędy można formatować, w pełni kontrolować, mapować i wyświetlać w aplikacjach frontendowych w sposób przyjazny dla użytkownika.  

function formatZodErrors(error: z.ZodError) {
  return error.errors.reduce((acc, err) => {
    const field = err.path.join(".");
    acc[field] = err.message;
    return acc;
  }, {} as Record<string, string>);
}

• Rozszerzalność – dzięki metodzie .refine() możemy łatwo dodawać własne warunki i logikę walidacyjną.  

const PasswordSchema = z.string()
  .min(8, "Hasło musi mieć min. 8 znaków")
  .refine(val => /\d/.test(val), {
    message: "Hasło musi zawierać cyfrę",
  });

• Chaining – możemy łączyć wiele reguł walidacyjnych w łańcuchach co ułatwia tworzenie złożonych walidacji, np. .min(3).max(20).regex(…),.  

const NameSchema = z.string()
  .min(3, "Za krótkie")
  .max(50, "Za długie")
  .regex(/^[a-zA-Z\s]+$/, "Tylko litery i spacje");

• Użyteczność w całym stacku – Zod sprawdza się zarówno walidacji danych użytkownika w formularzach (React Hook Form), jak i walidacji odpowiedzi API czy typów w bazach danych  

Jak zaimplementować walidację formularza z użyciem Zod?  

Zod doskonale integruje się z popularnymi narzędziami do obsługi formularzy, takimi jak React Hook Form. Dzięki temu możemy w prosty sposób połączyć walidację danych z typowaniem w TypeScript i uzyskać czytelny kod oraz spójne komunikaty błędów.  

Załóżmy, że tworzymy prosty formularz rejestracyjny. Najpierw definiujemy schema:  

const RegisterSchema = z.object({
  name: z.string().min(3, "Imię musi mieć co najmniej 3 znaki"),
  email: z.string().email("Niepoprawny adres e-mail"),
  password: z.string()
    .min(8, "Hasło musi mieć co najmniej 8 znaków")
    .refine(val => /\d/.test(val), {
      message: "Hasło musi zawierać cyfrę",
    }),
});

Następnie łączymy schema z formularzem:  

import { useForm } from 'react-hook-form';
import { zodResolver } from '@hookform/resolvers/zod';

const form = useForm({
  resolver: zodResolver(RegisterSchema),
});

const { register, handleSubmit, formState: { errors } } = form;

W JSX podpinamy pola i wyświetlamy błędy:  

<form onSubmit={handleSubmit(formDetails => console.log(formDetails))}>
  <input {...register("name")} placeholder="Imię" />
  {errors.name && <p>{errors.name.message}</p>}

  <input {...register("email")} placeholder="Email" />
  {errors.email && <p>{errors.email.message}</p>}

  <input {...register("password")} placeholder="Hasło" type="password" />
  {errors.password && <p>{errors.password.message}</p>}

  <button type="submit">Zarejestruj się</button>
</form>

Taka integracja daje nam:  

• automatyczną walidację pól,  
• pełne typowanie danych,  
• spójne i konfigurowalne komunikaty błędów,  
• prostą integrację z istniejącym kodem Reacta.  

AI w programowaniu | bezpłatny e-book

Zautomatyzuj kodowanie z AI! Pobierz darmowy e-book i odkryj nowe możliwości

Pobierz teraz!

Podsumowanie  

W świecie, gdzie dane generowane przez AI są dynamiczne i często nieprzewidywalne, warto zadbać o silne fundamenty naszych projektów. Zod może pełnić rolę warstwy ochronnej – zapewniając walidację, transformację i typowanie danych w jednym miejscu. To nie tylko techniczny dodatek, ale kluczowy element architektury, który pozwala budować odporne, stabilne i łatwe w utrzymaniu integrację z modelami AI.  

Zod to solidna biblioteka z rosnącą społecznością i aktywnym wsparciem, którą z powodzeniem można wykorzystać nie tylko w integracjach z wykorzystaniem AI, ale także w codziennych projektach frontendowych – od formularzy po obsługę API.  

I choć treść książki ma pesymistyczne wybrzmienie, może stanowić źródło inspiracji na temat drogi rozwoju sztucznej inteligencji w dalekiej przyszłości i zmusić do refleksji nad kierunkiem podążania przez współczesne algorytmy. Chociaż obecne możliwości AI nie są jeszcze aż tak rozwinięte (w porównaniu do przytoczonego Golema), to już mają istotny wpływ na cyfrową transformację, przekształcając świat na wielu płaszczyznach. 

AI w programowaniu  

Generowanie kodu  

Od jakiegoś czasu narzędzia sztucznej inteligencji rewolucjonizują wiele obszarów, nie pomijając procesu tworzenia oprogramowania. Wprowadzają nowe możliwości zwiększające nie tylko produktywność, ale też dokładność i innowacyjność, przyspieszają również sam proces tworzenia oprogramowania. W tym momencie należy wyróżnić przede wszystkim generatywną sztuczną inteligencję (GenAI – uogólniając, to AI potrafiąca tworzyć nowe treści), która usprawnia cały proces poprzez automatyzację istotnych kroków – generowania pomysłów, gromadzenia wymagań, a także kodowania oraz jego nieodłącznego procesu testowania. 

Wsparcie prac programistycznych 

AI szybko staje się integralną częścią oprogramowania wykorzystywanego w developmencie aplikacji, będąc jednym z elementów cyfrowej transformacji przedsiębiorstw. Zespoły deweloperskie dostosowują swoje środowiska, integrując narzędzia sztucznej inteligencji, zapewniając nie tylko interoperacyjność, ale również stawiają czoła nowym wyzwaniom, jak choćby bezpieczeństwo danych. Rosnąca rola AI w tym obszarze podkreśla jej potencjał do zrewolucjonizowania metod tworzenia oprogramowania. 

Wykorzystanie algorytmów w automatyzacji 

Obecnie mamy do dyspozycji wiele narzędzi, za pomocą których znacząco można przyspieszyć prace nad projektem. Interpretują opisy tworzone w języku naturalnym (prompty) i generują sugestie, kod, zasoby potrzebne do testów i wiele innych, przydatnych rzeczy – zależnie od potrzeb. Zaawansowane algorytmy analizują środowisko, kod, optymalizując rozwiązania i wspomagając zespoły w codziennej pracy. Umożliwiają również analizę ogromnych zbiorów danych, wspierając optymalizację wydajności aplikacji oraz przewidywanie potencjalnych problemów. Ma to znaczący wpływ na szybkość tworzenia kodu, redukcję ludzkich błędów, przyczynia się do poprawy bezpieczeństwa, a przede wszystkim pozwala programistom skupić się na realizowaniu bardziej złożonych i kreatywnych zadań. 

Jakie są korzyści z użycia AI w procesie tworzenia oprogramowania 

Korzyści w ujęciu ogólnym przedstawiłem we wstępie, więc w tej sekcji postaram się zwięźle opisać kilka konkretnych przykładów, które moim zdaniem zasługują na szczególną uwagę: 

• Przewidywanie błędów – poprzez analizę wzorców w repozytoriach projektu narzędzia AI mogą pomóc wykryć potencjalne błędy, luki lub podatności. 

• Testowanie – odpowiednio przygotowane wymagania i kryteria akceptacji mogą posłużyć za bazę do stworzenia scenariuszy testowych, dzięki czemu znacznie skraca się czas, potrzebny zwykle na wymyślanie ich od podstaw. W asyście AI można także pokusić się o refaktoryzację już istniejących przypadków testowych, co może pomóc w ich optymalizacji i zwiększeniu pokrycia testów. 

• Generowanie kodu – dzięki narzędziom AI programiści mają możliwość korzystania z pomocy wirtualnego asystenta, który wspomaga ich w codziennej pracy. Na podstawie danych wejściowych pisanych w języku naturalnym, asystent AI zasugeruje fragment kodu lub wygeneruje całą funkcję, co przyspiesza pracę i może automatyzować rutynowe działania (np. pisanie prostych, schematycznych skryptów).
  
• Optymalizacja i refaktoryzacja – łączy się z powyższym. Z pomocą AI można optymalizować istniejący kod, dzięki czemu aplikacja może być stabilniejsza, bezpieczniejsza, wydajniejsza, a więc i bardziej niezawodna. 

• Bezpieczeństwo – z pomocą narzędzi AI można pokusić się o próbę zidentyfikowania potencjalnych luk bezpieczeństwa, a w przypadku ich znalezienia – AI zasugeruje poprawki. Narzędzia te pozwalają również analizować zachowanie uzytkowników i wykrywać nietypowe działania, wskazujące na przykład na próby ataku lub potencjalne przejęcie konta klienta.  
   
  Tak działa na przykład weryfikacja behawioralna banku ING. Algorytmy AI na bieżąco uczą się zachowania użytkownika poprzez analizowanie jego interakcji z aplikacją banku, co zwiększa prawdopodobieństwo zablokowania dostępu do konta w przypadku przejęcia go przez przestępcę. Innym przykładem niech będzie sytuacja opisana przez Google –  dzięki sztucznej inteligencji udało się znaleźć błąd 0-day (nieznana podatność lub luka, mogąca zostać wykorzystana do przeprowadzenia ataku).  

• Zarządzanie – można i w tym procesie zaprzęgnąć sztuczną inteligencję i wykorzystać ją w celu zautomatyzowania planowania i zarządzania zasobami. Mając historyczne dane, narzędzia AI mogą zasugerować potencjalny czas trwania nowych etapów tworzenia oprogramowania i pomóc w odpowiedniej alokacji zasobów w celu optymalnego ich wykorzystania. 

• Tworzenie dokumentacji – wielu programistów nie przepada za sporządzaniem dokumentacji. Jest to czasochłonny proces, który można by poświęcić między innymi na rozwój i utrzymanie kodu. I w tym aspekcie sztuczna inteligencja wyciąga pomocną dłoń – jest doskonałym narzędziem do prowadzenia dokumentacji projektowej, odciążając programistów. Na podstawie kodu aplikacji tworzy opis i zapewnia stałą aktualizację dokumentacji.  

• Projektowanie UX – można wykorzystać AI do wspomagania projektowania doświadczenia użytkowników. Przykładowo – prowadząc testy A/B i wykorzystując dane z nich zgromadzone, AI może zasugerować odpowiedni interfejs bądź funkcjonalność. Odpowiednie polecenia w  narzędziu AI generującym obrazy pomogą wygenerować szablon UI, mogący stanowić bazę pod ostateczny wygląd aplikacji. 

• Pomoc w tworzeniu bardziej inteligentnych aplikacji – wprowadzając zaawansowane funkcje AI do tworzonego programu (na przykład rozpoznawanie mowy, czat) można podnieść wartość i atrakcyjność aplikacji, dzięki czemu będzie ona wyróżniała się na tle konkurencji i może zwiększyć liczbę jej użytkowników. 

• Analiza danych użytkowników – AI może analizować dane użytkowników w celu poprawy doświadczeń podczas korzystania z aplikacji. Szczególne korzyści może przynieść to branży e-commerce, gdzie AI wspiera  tworzenie algorytmów rekomendacji, dzięki czemu klienci mogą widzieć reklamy i sugestie produktów najbardziej pasujące do ich potrzeb. 

• Wspomaganie DevOps i CI/CD – z pomocą AI można analizować systemowe logi, raporty, historie wdrożeń, aby wykrywać anomalie i przewidywać potencjalne awarie. Narzędzia takie jak Datadog czy Splunk wykorzystują uczenie maszynowe do monitorowania aplikacji i infrastruktury w czasie rzeczywistym. Wdrożenie AI w DevOps i CI/CD pozwala zespołom programistycznym i operacyjnym na bardziej efektywne zarządzanie cyklem życia oprogramowania. 

Jak korzystać z narzędzi AI w praktyce? Tworzymy prompty do testowania 

Poniżej zaprezentuję prosty przykład wykorzystania AI jako asystenta w programowaniu. Bazę stanowi kod Playwright dostępny bezpośrednio po zainstalowaniu narzędzia. Znajduje się w nim plik z przykładowymi testami, w którym utworzę jeden dodatkowy test z wykorzystaniem GitHub Copilot. Test jest prosty: polega na otwarciu strony domowej Playwright, kliknięciu przycisku ‘Get Started’ i asercji przekierowania na stronę ’https://playwright.dev/docs/intro’ poprzez zweryfikowanie poprawności adresu URL i tekstu wyświetlonego na niej nagłówka (Installation). 

1. Prompt opisujący test: 

Write a test that navigates to 'https://playwright.dev/’ page and clicks 'Get started’ button. Then verify that user has landed on 'https://playwright.dev/docs/intro’ page by verifying page header text that should be 'Installation’. 

2. Odpowiedź wygenerowana przez Copilot: 

Here’s the Playwright test that navigates to the 'https://playwright.dev/’ page, clicks the 'Get started’ button, and verifies that the user has landed on the 'https://playwright.dev/docs/intro’ page by checking the page header text: 

import { test, expect } from '@playwright/test'; 

test('navigate to Get Started and verify Installation page', async ({ page }) => { 

  // Navigate to the Playwright homepage 

  await page.goto('https://playwright.dev/'); 

  // Click the 'Get started' button 

  await page.getByRole('link', { name: 'Get started' }).click(); 

  // Verify the URL is correct 

  await expect(page).toHaveURL('https://playwright.dev/docs/intro'); 

  // Verify the page header text is 'Installation' 

  await expect(page.getByRole('heading', { name: 'Installation' })).toBeVisible(); 

});

Copilot stworzył test, dodatkowo opatrując komentarzem każdą znajdującą się w nim akcję. Poniżej zamieszczam zrzut ekreanu z VS Code, na którym widać UI z wykorzystaniem czatu AI. 

Następnie poprosiłem Copilota o małą refaktoryzację stworzonego przez niego kodu – aby zaktualizował go poprzez przeniesienie hardkodowanych wartości do zmiennych w celu poprawy czytelności kodu. 

 
1. Prompt:  

Refactor the proposed code by moving hardcoded values to variables, in order to make the code more readable. 

2. Odpowiedź: 

Here’s the refactored code with hardcoded values moved to variables for better readability: 

import { test, expect } from '@playwright/test'; 

test('navigate to Get Started and verify Installation page', async ({ page }) => { 

  // Define reusable variables 

  const baseUrl = 'https://playwright.dev/'; 

  const getStartedLinkName = 'Get started'; 

  const expectedUrl = 'https://playwright.dev/docs/intro'; 

  const expectedHeader = 'Installation'; 

  // Navigate to the Playwright homepage 

  await page.goto(baseUrl); 

  // Click the 'Get started' button 

  await page.getByRole('link', { name: getStartedLinkName }).click(); 

  // Verify the URL is correct 

  await expect(page).toHaveURL(expectedUrl); 

  // Verify the page header text is 'Installation' 

  await expect(page.getByRole('heading', { name: expectedHeader })).toBeVisible(); 

});

Zgodnie z przewidywaniem Copilot poradził sobie z tym zadaniem poprawnie, identyfikując parametry mogące być przypisane do zmiennych i tworząc je. 

Na koniec poprosiłem o stworzenie dokumentacji testu: 

 
1. Prompt: 

Write and apply a description of the test that could be used as documentation. 

2. Odpowiedź: 
 
Test Description: 

Test Name: Navigate to Get Started and Verify Installation Page 

This test verifies the navigation flow on the Playwright documentation website. It performs the following steps: 
 

1. Navigates to the Playwright homepage (https://playwright.dev/). 

2. Clicks the „Get started” link on the homepage. 

3. Verifies that the user is redirected to the „Introduction” page (https://playwright.dev/docs/intro).  

4. Confirms that the page header text is „Installation”. 

Nie tylko programowanie – sztuczna inteligencja w testach 

Testowanie to krytyczny etap w wytwarzaniu oprogramowania. Ma kluczowe znaczenie w gwarantowaniu jakości kodu, niezawodności, wiarygodności i bezpieczeństwa tworzonego systemu. Obecnie testowanie napotyka na swojej drodze różne trudności. Rosnąca złożoność struktur oprogramowania sprawia, że przetestowanie wielu potencjalnych ścieżek mogących zawierać błędy staje się po prostu skomplikowane. Narzędzia technologii AI znajdują zastosowania i tutaj – za ich pomocą tester może zoptymalizować swoją pracę w zakresie: 

• generowania przypadków testowych, które można w dalszym etapie modyfikować, gdy zajdzie taka potrzeba; 

• wspomagania generowania skryptów automatycznych – z wykorzystaniem narzędzi typu Copilot; 

• automatyzacji powtarzalnych zadań – co pozwala zaoszczędzić czas i skupić się na bardziej istotnych lub skomplikowanych zadaniach; 

• analizowania i tworzenia raportów testowych – dzięki asyście przy analizie i tworzeniu raportów można uzyskać bardziej szczegółowe dane na temat wyników testów, co pozwala na uzyskanie jakościowych informacji na temat stanu oprogramowania i ewentualnych błędów; 

• tworzenia danych testowych – AI może analizować wymagania aplikacji oraz specyfikację systemu, aby automatycznie generować odpowiednie dane testowe, które będą używane w różnych scenariuszach testowych. Dane mogą być bardzo różnorodne, co przekłada się na ich lepszą reprezentatywność dla rzeczywistych przypadków użycia aplikacji. Również przypadki brzegowe (edge cases), które bywają trudne do przewidzenia, mogą zostać zidentyfikowanie przez AI i odpowiednio pokryte danymi wejściowymi. Dzięki temu z pozoru rzadkie, ale ważne scenariusze, mogące mieć wpływ na stabilność aplikacji, mogą zostać zidentyfikowane i odpowiednio zaadresowane. Zwiększa to również pokrycie testów, pomagając w wykrywaniu potencjalnych problemów, które mogłyby umknąć tradycyjnym metodom testowania; 

• tworzenie dokumentacji testowej – AI można wykorzystać do tworzenia i utrzymywania dokumentacji testowej. 

Jakie są najlepsze narzędzia AI dla programistów i testerów 

Na rynku istnieją już setki, jeśli nie tysiące narzędzi wykorzystujących sztuczną inteligencję. Możliwości tych innowacyjnych rozwiązań z powodzeniem  mogą być wykorzystywane przez programistów i testerów. Wybór odpowiednich rozwiązań może jednak stanowić wyzwanie, dlatego warto skupić się na tych, które rzeczywiście zwiększają efektywność pracy, automatyzują powtarzalne zadania i pomagają unikać błędów. Wśród dostępnych narzędzi znajdują się zarówno inteligentni asystenci wspomagający pisanie kodu, jak i zaawansowane systemy do testowania, analizy błędów oraz optymalizacji procesów CI/CD.

W tej sekcji krótko omówię kilka narzędzi, których wykorzystanie może usprawnić codzienną pracę w projekcie. 

GitHub Copilot 

To obecnie jedno z najpopularniejszych narzędzi wspomagających pisanie kodu. Za jego pomocą można pisać kod efektywniej i szybciej, dzięki czemu programiści mogą więcej czasu poświęcić na rozwój oprogramowania w szerszym kontekście – współpracy w zespole czy skupieniu się na problemach związanych z logiką w aspekcie całościowym aplikacji. Słowem – zwiększa produktywność i przyspiesza wytwarzanie oprogramowania. 

Narzędzia takie jak GitHub na bieżąco w trakcie pisania kodu sugerują rozwiązania, można też użyć funkcji czatu w celu uzyskania pomocy dotyczącej pisanego kodu. Istnieje też możliwość korzystania z niego przez CLI. 

Dodatkowo w wersji Enterprise oferuje opcję generowania opisu pull requestów oraz tworzenie i zarządzanie dokumentacjami repozytoriów w formie baz wiedzy (knowledge bases), które stanowią kontekst dla czatu Copilot. Dzięki temu Copilot przeszukuje bazę wiedzy pod kątem odpowiednich informacji i zwraca zsyntezowaną odpowiedź.  

Doskonale sprawdza się jako narzędzie do uzupełniania kodu, w szczególności dla przypadków, w których zwykle poszukujemy inspiracji w internecie, np. na StackOverFlow. Często zdarza się, że podobny problem, nad którym pracujemy, został już kiedyś napotkany i opisany, więc analiza danego wątku pozwala na zaimplementowanie rozwiązania w swoim kodzie. Dzięki Copilotowi można pominąć ten etap i za pomocą odpowiedniego prompta sprecyzować, czego potrzebujemy. Z dużym prawdopodobieństwem wygenerowany zostanie odpowiedni kod, nie zawsze idealny, ale wystarczający, żeby po niewielkich modyfikacjach otrzymać działającą funkcję. 

Jego zaletą jest też możliwość zintegrowania go z najpopularniejszymi IDE – Visual Studio, Visual Studio Code, JetBrains. 

Cursor 

Cursor, w przeciwieństwie do GitHub Copilota, nie jest jedynie rozszerzeniem, ale pełnym IDE korzystającym z narzędzi AI. Został zaprojektowany w celu zwiększenia produktywności programistów poprzez integrację zaawansowanych funkcji sztucznej inteligencji bezpośrednio ze środowiskiem kodowania. Warto wiedzieć, że powstał na bazie VS Code (jest jego forkiem), a więc zachowuje interfejs i ekosystem VS Code, co ułatwia ewentualne przejście na ten edytor. 

Posiada opcje takie jak generowanie, przewidywanie i uzupełnianie kodu oraz automatyczne poprawianie. 

Jego kluczową cechą jest sposób “rozumienia” przez niego kodu – analizuje cały kontekst projektu. Oferuje kilka dodatkowych funkcji, dzięki którym asystent AI może działać jeszcze dokładniej. Jest to na przykład indeksowanie bazy kodu (które jest włączone domyślnie), każdy nowo dodany plik zostanie zaindeksowany i włączony do kontekstu aplikacji. Oprócz indeksowania plików, oferuje również tworzenie reguł dostosowujących działanie AI: globalnie oraz z ograniczeniami w ramach konkretnego projektu. 

ChatGPT 

To jedno z najpopularniejszych narzędzi AI dostępne w internecie, może być również z powodzeniem wykorzystane w inżynierii oprogramowania. Jest uniwersalne zarówno dla programistów jak i testerów – za jego pomocą można tworzyć między innymi kod, skrypty, dane testowe, scenariusze – i tak dalej. Dzięki wszechstronności może być wykorzystany jako asystent służący dobrą radą w wielu aspektach. 

Oprócz czata GPT można w tym celu wykorzystać również inne narzędzia ogólnego przeznaczenia bazujące na LLM, jak Gemini czy Microsoft Copilot. 

Applitools 

To narzędzie służące głównie do testowania, monitorowania i zarządzania wizualnym aspektem aplikacji. Wykorzystuje sztuczną inteligencję do wykonywania testów wizualnych, skutecznie identyfikując wizualne błędy w aplikacjach, na przykład przez analizę elementów wyświetlanych w interfejsie – czy nie nakładają się na siebie, są w jakiś sposób niewidoczne, wychodzą poza swój obszar. Swoje testy może wykonywać na wielu przeglądarkach i platformach. Można za jego pomocą sprawdzać również pliki PDF. Applitools można zintegrować z popularnymi narzędziami do automatyzacji testów, takimi jak Selenium, Playwright, Appium, Cypress. 

Amazon CodeGuru 

To narzędzie wspierające przegląd kodu. Dzięki wykorzystaniu uczenia maszynowego i zautomatyzowanego procesu “rozumowania” pomaga zidentyfikować luki w kodzie, dostarcza zalecenia dotyczące sposobu ich naprawienia i śledzi ich status aż do momentu ich zamknięcia. Można je zintegrować na dowolnym etapie wytwarzania oprogramowania, włączając je w proces CI/CD. Twórcy dodatkowo zapewniają, że nie jest konieczne wykorzystywanie dodatkowych maszyn wirtualnych w celu jego uruchomienia – wystarczy zintegrować CodeGuru z wykorzystywanymi już narzędziami, a w zależności od obciążenia będzie samoczynnie skalowany w górę lub w dół. 

Testcraft 

To bezpłatne i otwartoźródłowe rozszerzenie przeglądarki, wykorzystujące sztuczną inteligencję do wspomagania testowania. Jego kluczową cechą jest możliwość generowania pomysłów na testy w oparciu o elementy widoczne na stronie internetowej. Pozwala również na automatyczne generowanie skryptów testowych dla popularnych frameworków automatyzacji – Playwright, Cypress, czy biblioteki Selenium. Skrypty można wygenerować w wielu językach programowania, znajdzie więc miłośników zarówno wśród testerów manualnych, jak i automatyzujących. 

Podsumowanie: Wykorzystanie AI w programowaniu i testowaniu  

Dobrze zaimplementowana sztuczna inteligencja może odegrać kluczową rolę w rozwoju oprogramowania, znacząco przyspieszając i usprawniając procesy na różnych etapach tworzenia oprogramowania. Dzięki AI można automatyzować pisanie kodu, testowanie, debugowanie oraz zarządzanie procesami CI/CD, co prowadzi do zwiększenia efektywności, redukcji kosztów i minimalizacji liczby błędów. 

Jednak należy pamiętać o drugiej stronie medalu. Sztuczna inteligencja, choć pozwala oszczędzać czas i ułatwia wykonywanie powtarzalnych zadań, nie zawsze generuje poprawne lub optymalne rozwiązania. Mając na uwadze fakt, że nowoczesne aplikacje często składają się z wielu modułów, są zintegrowane z wieloma zewnętrznymi usługami i systemami, sztuczna inteligencja, mimo że stanowi potężne wsparcie, nie zawsze jest bezbłędna, zwłaszcza w tak złożonych środowiskach.  

AI dobrze radzi sobie z podstawowymi i średnio zaawansowanymi zadaniami, ale może mieć trudności z bardziej skomplikowanymi zagadnieniami, np. optymalizacją wydajności w dużych systemach, ze specyficznymi wzorcami projektowymi czy zaawansowanym debugowaniem. Nie można pominąć również potencjalnych zagrożeń w kwestii bezpieczeństwa. 

Ostatecznie, AI powinna być traktowana jako wsparcie, a nie całkowite zastępstwo dla ludzkiej wiedzy i doświadczenia. Skuteczność automatyzacji opartej na AI zależy od jej mądrego wykorzystania. W połączeniu z kompetencjami specjalistów może ona stać się potężnym narzędziem wspierającym rozwój i utrzymanie wysokiej jakości oprogramowania.  Jednak wymaga świadomej kontroli i odpowiedzialnego wdrażania w procesy technologiczne.  

Choć obecne systemy AI, w tym narzędzia wspierające programistów i testerów, nie osiągnęły jeszcze poziomu przedstawionego przez Lema w “Golem XIV”, to ich rola w cyfrowej transformacji staje się coraz bardziej widoczna. Sztuczna inteligencja zyskuje na znaczeniu, automatyzując powtarzalne procesy, optymalizując kod oraz wspomagając analizy danych w czasie rzeczywistym. Współczesne algorytmy, choć bardzo zaawansowane, nie są jeszcze pozbawione błędów i ograniczeń, szczególnie w kontekście złożonych aplikacji oraz integracji z innymi systemami. To, co dziś oferuje sztuczna inteligencja, to jedynie przedsmak tego, co może się wydarzyć w przyszłości. 

Według badań firmy McKinsey rozwiązania AI i low-code mogą pozytywnie wpłynąć na produktywność deweloperów, zwiększając ją nawet o 45%. Jednym z cenionych narzędzi bazujących na sztucznej inteligencji jest GitHub Copilot, który zmienia oraz usprawnia proces programowania.

Jak korzystać z GitHub Copilot w codziennym programowaniu? 

Aby rozpocząć korzystanie z GitHub Copilot, musimy spełnić kilka prostych warunków.

Po pierwsze – jeśli nie posiadamy konta na github.com – musimy je założyć. Będzie to niezbędny krok do aktywowania subskrypcji naszego asystenta. Jeśli to mamy już za sobą, logujemy się na swoje konto, wybieramy pakiet, który odpowiada naszym potrzebom. Dostępnych mamy kilka wariantów – od planu darmowego służącego do nauki po plan dla profesjonalistów. 

Kolejnym krokiem, jaki musimy podjąć, jest uruchomienie naszego ulubionego edytora kodu i instalacja wtyczki. Następnie łączymy swoje konto GitHub z IDE i nasz osobisty asystent jest gotowy do pracy. Od tej pory GitHub Copilot analizuje kod w naszych plikach! 

Dzięki analizie Copilot jest w stanie podpowiedzieć nam kolejne linie, metody oraz algorytmy. W chwili, gdy zaczynamy pisać kod, asystent proponuje autouzupełnienie – możemy je zaakceptować, wciskając klawisz Tab, lub odrzucić. 

Różnica pomiędzy autouzupełnianiem kodu, jaką znamy z popularnych IDE (VSC lub JetBrains), jest taka, że edytory udzielają nam podpowiedzi, bazując na wcześniej zadeklarowanych klasach, zmiennych, metodach oraz zasadach składni. 
 
Copilot idzie nieco dalej. Wykorzystuje AI oraz modele językowe do przewidywania całych bloków kodu. Nie jest ograniczony jedynie składnią – sugeruje gotowe metody, a nawet algorytmy; podpowiedzi są dużo bardziej zaawansowane niż w przypadku tradycyjnego autouzupełniania. 

// Create a function to validate an email address 
function isValidEmail(email: string): bBoolean{...}

Skuteczne okazuje się również generowanie kodu na podstawie komentarzy. Przykładowo, gdy chcemy napisać metodę, możemy po prostu opisać ją jako komentarz, a Copilot zaproponuje gotową implementację: 
  

Kolejnym sposobem na skuteczną komunikację z Copilotem jest też funkcja czatu. Wystarczy, że wciśniemy kombinację klawiszy CTRL + I i pojawi się okienko, w którym możemy zadawać pytania naszemu asystentowi. 

Jakie możliwości funkcji GitHub Copilot oferuje programistom? 

Asystent AI może wspierać nas na różnych etapach rozwoju oprogramowania: 

• Generowanie kodu w czasie rzeczywistym – analizuje nasze poczynania i sugeruje zmiany – od pojedynczych sugestii po całe klasy lub funkcje. 

• Tworzenie całych struktur kodu – gdy poprosimy Copilota o wygenerowanie całego komponentu, np. w React / Angularze, modułu w Nest.js lub zapytań SQL – bez problemu zareaguje wygenerowaniem odpowiednich linii kodu. 

// Create a service to connect to the API 
  

• Tworzenie testów jednostkowych – ogromną zaletą Copilota jest możliwość autotworzenia UT. Jest w stanie wygenerować testy, np. w znanych frameworkach, jak Jest czy Jasmine. Na podstawie analizy implementacji funkcji podpowiada nam odpowiednie przypadki testowe. 

// Create a UT for getUsers function. 
  

• Optymalizowanie oraz refaktoring kodu – któż z nas nie widział mnóstwa powtarzających się metod lub niewydajnych rozwiązań? Copilot bierze ten ciężar na siebie i sugeruje alternatywy – bardziej wydajne i zgodne z najlepszymi zasadami. 

• Generowanie dokumentacji kodu – Copilot może pomóc w generowaniu użytecznych komentarzy w formacie JSDoc lub Markdown, dzięki czemu ułatwimy innym programistom pracę nad naszym kodem – nie tracąc czasu na ręczne pisanie komentarzy. 

/** 
* Gets user data based on user ID 
* @param userId – user ID 
* @returns User object or null 
*/ 
  

Jak GitHub Copilot może pomóc w rozwiązywaniu problemów z kodem? 

Poza standardową pomocą w codziennych czynnościach związanych z kodem Copilot zapewnia także wsparcie w debugowaniu i naprawianiu błędów. Jest w stanie przeanalizować kod pod kątem potencjalnych bugów, np.: 

• Nieodpowiednia składnia – brak nawiasu, średnika czy innego elementu składniowego. 

• Naprawa nieprawidłowych typów – np. próba przypisania nieodpowiedniego typu do zmiennej. 

• Błędne / nieistniejące nazwy zmiennych lub funkcji. 

Jeśli mamy problem z działaniem metody – wystarczy, że zakomunikujemy to naszemu pomocnikowi: 

// The following function is not working properly, fix it 
function getUserData(id: number) { 
  return fetch(`/api/user/${id}`).then((res) => res.json()); 
} 
  

Otrzymamy poprawiony kod: 

async function getUserData(id: number) { 
  try { 
    const response = await fetch(`/api/user/${id}`); 
    if (!response.ok) throw new Error("data download error"); 
    return await response.json(); 
  } catch (error) { 
    console.error(error); 
    return null; 
  } 
} 
  

Jakie są najlepsze praktyki podczas korzystania z GitHub Copilot? 

• Zawsze sprawdzaj wygenerowany kod. Copilot generuje kod, który na pierwszy rzut oka wygląda dobrze, ale może zawierać błędy. 

• Stosuj precyzyjne prompty i opisy funkcji. Im dokładniejszy opis, tym lepsze wyniki. 

• Zwracaj uwagę na bezpieczeństwo. Unikaj generowania kodu zawierającego wrażliwe dane. 

• Wykorzystuj Copilota jako narzędzie edukacyjne. Można go używać do nauki nowych wzorców czy technologii. 

Jakie są opinie użytkowników na temat narzędzia GitHub Copilot? (wady i zalety) 

Według ogólnodostępnych badań:   

• Deweloperzy korzystający z Copilota byli w stanie ukończyć zadania nawet o 55% szybciej niż ci, którzy z niego nie korzystali. 

• 70% deweloperów deklarowało znacznie mniejszy wysiłek umysłowy przy wykonywaniu powtarzalnych zadań. 

Tyle statystyki, a jak to wygląda w praktyce? Copilot rodzi bardzo mieszane uczucia wśród użytkowników. Z jednej strony, usłyszymy głosy, że jest to rewolucja w wytwarzaniu oprogramowania, a narzędzie poprawia produktywność i ułatwia rozwiązywanie problemów. Z drugiej zaś strony są też nie do końca pozytywne opinie, które wskazują na przykład na jakość generowanego kodu oraz zagrożenia dotyczące bezpieczeństwa. 
 
Moje doświadczenie potwierdza te obserwacje. W moim środowisku Copilot cieszy się dużym zainteresowaniem – programiści doceniają przede wszystkim to, że mogą zaoszczędzić czas na pisaniu kodu czy testów jednostkowych. Ale z drugiej strony podchodzą do narzędzia sceptycznie, zwracając uwagę na błędy, które popełnia, lub nieefektywne rozwiązania. 

Przeczytaj także: The best AI for coding – czego używać w 2025 roku?

Zalety tworzenia oprogramowania z GitHub Copilot: 

• Zwiększenie produktywności. 

• Wsparcie dla Junior Developerów i osób uczących się nowych technologii. 

• Obsługa wielu języków programowania. 

Wady tworzenia oprogramowania z GitHub Copilot: 

• Możliwość generowania błędnego kodu. 

• Czasem proponuje przestarzałe rozwiązania. 

• Ograniczona wersja darmowa – pełna funkcjonalność wymaga opłaty. 

Gdzie dowiedzieć się więcej o GitHub Copilot? 

Najlepszym miejscem jest oficjalna dokumentacja. Warto też sprawdzić kursy na YouTube: 

• Traversy Media – przegląd Copilota i jego możliwości. 

• Fireship – szybkie wprowadzenie w kilka minut. 

• The Primeagen – krytyczna analiza Copilota w praktyce. 

Poza darmowymi materiałami warto odwiedzić: 

• Udemy – kursy dla różnych języków. 

• Pluralsight – kursy dla profesjonalistów. 

• Coursera – akademickie podejście do AI w programowaniu. 

Podsumowanie: AI w programowaniu 

Narzędzia bazujące na sztucznej inteligencji stają się coraz lepsze i dzięki temu odciążają programistów już chyba w każdym projekcie IT. Możemy programować szybciej, oszczędzając czas na powtarzalnych zadaniach, takich jak pisanie testów jednostkowych czy przeglądanie dokumentacji. Z drugiej jednak strony – wymagają uważności, czujności i świadomości ograniczeń tej technologii. Wykorzystanie takich narzędzi jak GitHub Copilot wymaga od nas ciągłego poszerzania wiedzy w zakresie możliwości AI, do czego was zachęcam! 

Na chwilę obecną posiadamy wiele narzędzi, modeli AI oraz bardzo dużo integracji z oprogramowaniem, z którego korzystamy na co dzień, więc każdy znajdzie coś dla siebie. Nieważne, czy programujesz, zajmujesz się marketingiem, czy grafiką – AI jest obecne wszędzie… Zapraszam was do dalszej części artykułu, gdzie porozmawiamy o tym, jak AI w codziennej pracy pozwala programistom przyspieszyć wydajność oraz poprawić jakość i czytelność naszego kodu. 

AI for coding: najlepsze narzędzia AI do programowania w 2025 r.

Czy wiesz, że już nawet 76% osób zajmujących się programowaniem korzysta lub planuje używać narzędzi związanych z AI w swojej codziennej pracy? Albo że użytkownicy Copilota wykonywali zadania o około 55% szybciej niż bez AI? Tak wynika z przeprowadzonej przez Stack Overflow w 2024 roku ankiety.  

Na chwilę obecną narzędzia AI są już tak zaawansowane, że nie tylko kod generują, ale również wspierają cały cykl tworzenia oprogramowania. 

Jakie są najlepsze AI do generowania kodu?

Część z was pewnie ma już swoje ulubione narzędzia, z których korzysta na co dzień. Obecnie najbardziej popularne narzędzia, o których pewnie słyszała większość osób w branży, to GitHub Copilot, ChatGPT (OpenAI) i Amazon CodeWhisperer. 

Ta wymieniona trójka to pionierzy wśród asystentów i chatbotów AI, ale na rynku są też inne narzędzia, o których opowiem za chwilę. 

• GitHub Copilot 

Zacznijmy od GitHub Copilota – pioniera wśród asystentów AI, który korzysta z modeli OpenAI. Możemy go zintegrować z popularnym VS Code, dzięki czemu podczas pisania kodu będziemy mieli podpowiedzi bezpośrednio w edytorze. 

• ChatGPT 

Kolejnym ciekawym narzędziem, o którym pewnie słyszała większość z was, jest ChatGPT. Chat ten korzysta z modeli OpenAI, czyli tak samo jak Copilot, ale z tą różnicą, że nie jest on zintegrowany z edytorami. Pomoże ci napisać fragmenty kodu albo rozwiązać jakiś problem związany z kodem. 

• CodeWhisperer 

Z topowej trójki zostaje nam jeszcze CodeWhisperer od Amazon. Jest to swojego rodzaju asystent do programowania z użyciem usług takich jak AWS i nie tylko, więc jeśli zajmujesz się tematyką chmurową, to myślę, że warto go sprawdzić! 

• Tabnine 

Poza tymi, które wymieniłem, są jeszcze inne narzędzia. Zacznijmy od Tabnine. Narzędzie to jest oparte na autouzupełnianiu i, co najważniejsze, może działać jako self-hosted, gwarantując, że nasz kod nigdzie nie wypłynie. 

• Codeium 

Możliwe, że część użytkowników słyszała o darmowej alternatywie dla Copilota, a mianowicie Codeium. Użytkownicy bardzo chwalą narzędzie, że działa całkiem przyzwoicie jako alternatywa, zapewnia automatyczne uzupełnianie i sugestie kodu, które wcale nie ustępują komercyjnym rozwiązaniom. 

• Gemini Code Assist 

Ostatnim z popularnych AI, tym razem od Google, jest Gemini Code Assist. Narzędzie to potrafi zrobić nawet code review, więc jeśli szukasz AI, które wstępnie sprawdzi twój kod, to może warto spróbować? 

Jak widzisz, mamy tutaj całkiem sporo narzędzi i ciężko jest jednoznacznie stwierdzić, które narzędzie będzie dla ciebie odpowiednie, a jeszcze trudniej wskazać, które będzie najlepsze z nich wszystkich. Każdy z nas oczekuje czegoś innego. Jedni będą pracować z technologiami AWS i wybiorą CodeWhisperer, a ktoś inny postawi na privacy-first i wybierze Tabnine. Znajdą się też osoby, dla których wystarczy chatbot, i wybiorą ChatGPT. W mojej ocenie każde z tych narzędzi na pewno pomoże ci w codziennej pracy. 

Które narzędzia AI są darmowe?

Z narzędzi wymienionych do generowania kodu mamy dostępnych kilka opcji, ale zawsze trzeba zwracać uwagę na to, czy będziemy z nich korzystać hobbystycznie, czy realizując projekt komercyjny. 

Większość narzędzi jest darmowa dla użytkowników indywidualnych, a za lepsze wersje lub dodatki trzeba po prostu zapłacić. 

• Google Gemini Code Assist – udostępnia darmowy plan z bardzo wysokimi limitami zapytań i, według mnie, jest to najlepsza alternatywa spośród wszystkich wymienionych. 
• Amazon CodeWhisperer – ma plan darmowy, ale tylko dla użytkowników indywidualnych, więc jeśli tworzysz projekt dla siebie w technologiach np. AWS, warto go sprawdzić. 
• Codeium – dla użytkowników indywidualnych jest całkowicie darmowy, oferuje nielimitowane podpowiedzi kodu i wspiera wiele języków programowania. Według mnie to bardzo ciekawy wybór. 
• ChatGPT – tak jak wspominałem na początku i pewnie nie skłamię, pisząc, że większość osób w branży IT słyszała o tym chatbocie. W wersji bezpłatnej pomoże ci wygenerować np. komponent w React albo zrobić refaktoryzację kodu, jeśli oczywiście wpiszesz odpowiedni prompt. Jednak za wersję premium trzeba już zapłacić. 

Są też inne narzędzia wymienione wcześniej takie jak GitHub Copilot, Tabnine, które są co prawda bezpłatne w podstawowej wersji i będą nam generowały kod, ale jeśli oczekujemy od nich czegoś więcej, to trzeba wykupić pełny plan lub specjalną subskrypcję, więc nie są w pełni darmowe. 

Tak naprawdę, jeśli tworzymy coś hobbistycznie i w mniejszej skali, to większość tych narzędzi będzie dla nas dostępna za darmo (z większymi lub mniejszymi limitami). Wszystko zależy więc od licencji, i od tego, do czego użyjemy danego narzędzia. Pamiętajmy też o tym, że to, co w momencie pisania artykułu jest darmowe, za miesiąc może już nie być, bo licencja się zmieni, więc warto sprawdzić to na własną rękę przed instalacją. 

Jakie są dostępne funkcje AI w edytorach kodu, takich jak VS Code?

Większość narzędzi, które wcześniej wymieniałem, posiada integracje z popularnymi edytorami np. (VS Code) lub IDE. Github Copilot może zostać włączony bezpośrednio w VS Code, dzięki czemu możemy się cieszyć podpowiedziami w kodzie właściwie od razu. 

Copilot Chat pozwala za to zadawać pytania o kod, a Copilot w trybie „agent” wykonuje już złożone polecenia, np. uruchamia unit testy. 

Tak jak widzimy, mamy cały wachlarz możliwości – od chatu w VS Code, poprzez autouzupełnianie kodu,  na uruchamianiu unit testów czy modyfikowaniu całych plików kończąc. Dodatkowo pamiętajmy, że z powyżej wymienionych mamy narzędzia, które nie wysyłają kodu na zewnętrzne serwery, więc nawet przy projektach o wysokich wymaganiach bezpieczeństwa nasze zespoły security będą zadowolone, a dzięki temu będziemy mogli korzystać z AI. 

Jak AI wpływa na jakość kodu

AI to nie tylko generowanie kodu komponentów i rozwiązywanie codziennych problemów w kodzie. Na chwilę obecną AI potrafi przeanalizować istniejący kod w poszukiwaniu błędów lub celem sugerowania innych usprawnień. Powiem więcej, zrobi refaktoryzację i code review! Możemy ustawić takie narzędzie AI jako dodatkowego „recenzenta” naszego kodu, który wykrywa np. podejrzany kod marnej jakości, czyli tzw. „code smells”, a nawet luki w bezpieczeństwie. 

Jak AI może pomóc w code review

Dla przykładu, Gemini Code Review wykona analizę pull requesta i podkreśli fragmenty, na które warto zwrócić uwagę i ewentualnie je poprawić. 

Jeśli korzystasz z GitHuba i jego rozwiązań, to Gemini Code Assist wyłapie nawet niespójności w konwencji kodowania i sprawdzi, czy ich przestrzegasz. 

Tak jak widzisz, temat jest bardzo rozległy, i jeśli dobrze dobierzemy narzędzia AI, to możemy uniknąć wielu roboczogodzin przy sprawdzaniu tego typu rzeczy podczas rozwoju oprogramowania. AI wyłapie te niuanse za nas, a my będziemy mogli skupić się na innej pracy. 

Najlepsze praktyki używania AI do poprawy jakości kodu

1. Sprawdzaj 

Zasada numer jeden, której według mnie należy przestrzegać, to ta, że AI ma ci pomóc w „nakierowaniu” na rozwiązanie twojego problemu. Pamiętaj, aby zweryfikować wszystko, co podpowie ci AI, bo nie zawsze odpowiedzi, które otrzymasz, będą prawidłowe. Jeśli już zastosujesz się do powyższej zasady, to możemy przejść dalej. 

Słyszałem już od wielu osób, że AI bardzo pomaga w pisaniu testów jednostkowych, przynajmniej we frontendzie. Pisanie testów jednostkowych do najprzyjemniejszych nie należy, a w wielu przypadkach trzeba napisać bardzo dużo powtarzającego się kodu typu boilerplate. AI wygeneruje ci unit testy bardzo szybko i zaoszczędzisz przy tym sporo czasu na development, ale pamiętaj – zawsze weryfikuj to, co dostarcza ci AI. 

2. Postaw na iteracyjną refaktoryzację 

Kolejną rzeczą, do której według mnie AI sprawdzi się na co dzień, jest iteracyjna refaktoryzacja i ulepszanie twojego kodu. Wiesz, jak wygląda kod, w którym ktoś dopisał kawałek kodu w pośpiechu, bez większego zastanowienia, aby tylko działało? Czasami taki kod jest zupełnie nieczytelny, albo dochodzi do wielu zagnieżdżeń i tzw. ifologii. W takim przypadku AI poprawi to za ciebie i zasugeruje ci optymalne rozwiązanie. Pozbędziesz się w ten sposób mało czytelnego kodu, a twoje funkcje będą bardziej przejrzyste, kod ładnie sformatowany, a pull request dla osób robiących ci review – przyjemniejszy do czytania. 

3. Bądź elastyczny  

Pamiętaj, że AI nie zwalnia z samodzielnego myślenia, a najlepsze efekty osiągniesz, gdy będziesz weryfikować, ale i stosować pomysły, które według ciebie sprawdzą się w danym projekcie. 

Tutaj trzeba wybrać, co jest odpowiednie w danej chwili.  

Korzyści użycia AI w programowaniu

• Oszczędność czasu 

Ja osobiście dostrzegam tutaj dwie główne korzyści – oszczędność czasu na prostych i powtarzalnych zadaniach oraz zwiększenie produktywności. AI świetnie sprawdza się przy generowaniu powtarzalnego i żmudnego kodu typu boilerplate, więc możemy ten czas poświęcić na coś bardziej kreatywnego. 

• Większa produktywność  

Druga rzecz to produktywność – taki asystent może sprawić, że zajmiemy się trudniejszymi zadaniami, a te proste oddamy AI, więc będziemy też bardziej produktywni. 

• Łatwiejsze wyszukiwanie  

Ważną i niedocenianą rzeczą jest też fakt, że AI dobrze radzi sobie z dokumentacjami. Nie musimy już walczyć z przeszukiwaniem internetu czy dokumentacji, aby znaleźć jakieś informacje – AI zrobi to dużo szybciej. Dzięki temu możemy poświęcić się pracy bardziej kreatywnej, czyli skupić się np. na architekturze aplikacji, a nie na powtarzalnej i nudnej „drobnicy”. 

Potencjalne pułapki z AI w programowaniu

• Halucynacje AI 

Jednym z największych problemów związanych z AI jest to, że doświadczają tzw. halucynacji. To, co czasami wydaje się na pierwszy rzut oka poprawne, po głębszej analizie może (ale nie musi) zawierać błędy logiczne, albo może robić coś zupełnie innego, niż oczekujemy. 

Jeśli porcja kodu, którą dostaliśmy od AI, jest duża, to może zdarzyć się, że będzie to trudne do wykrycia. Jeśli nie masz dobrych unit testów, to możesz nawet nie zdawać sobie sprawy, że AI właśnie dodało ci błąd w kodzie, albo, co gorsza, wprowadzić podatność bezpieczeństwa, z której nawet nie zdajesz sobie sprawy. 

• Brak rozwoju kompetencji programistycznych 

Kolejną pułapką jest spadek umiejętności osób, które korzystają z AI na co dzień. Jeśli będziemy zdawali się wyłącznie na AI i jesteśmy na początkującej drodze, to nasze kompetencje mogą ulec zanikowi albo nie zrobimy takiego progresu, jaki byśmy chcieli. Nie oszukujmy się, ale jeśli ktoś dostaje gotowe rozwiązanie, to jest duża szansa, że nie nauczy się tego na własną rękę i nie będzie potrafił wyjaśnić logiki działania wygenerowanego kodu. Nie mówię tutaj tylko o AI, ale generalnie o tzw. gotowcach. Krótkoterminowo raczej nikt na tym nie ucierpi, ale zastanowiłbym się, czy przy długofalowym korzystaniu z tego narzędzia nasze umiejętności rozwiązywania problemów nie spadną drastycznie. 

Zalecałbym szczególnie juniorom, aby analizowali kod i pisali go samodzielnie, a to, co wygeneruje AI, traktowali bardziej jak odpowiedź na Stack Overflow, czyli bardziej jako sugestię i materiał do dalszego researchu. 

• Kwestie prawne 

Na koniec pamiętajmy też o kwestiach prawnych. Nie od dzisiaj wiadomo, że chatboty i inne generatory kodu uczą się na „cudzym” kodzie, który jest np. publicznie dostępny. Zawsze sprawdzajmy i czytajmy polityki prywatności i licencje, aby wiedzieć, co udostępniamy AI, ale jednocześnie też uważajmy na to, co samo AI nam dostarcza, aby nie otrzymać kodu łudząco podobnego do jakiegoś fragmentu z np. open source. Pamiętajmy też o aspektach security i polityce firmy, bo chyba nie chcemy, aby nasze poufne hasła czy klucze API krążyły w sieci, bo były przez nas używane w promptach, a co za tym idzie, mogły zostać użyte do trenowania modeli, prawda? 

Różnice między różnymi asystentami AI

Ilość narzędzi AI oraz różnego rodzaju asystentów potrafi przytłoczyć, a podejrzewam, że to dopiero początek. Spróbujemy zaraz porównać kilka modeli AI oraz narzędzi, które posłużą nam do programowania i codziennej pracy z kodem. 

Porównanie różnych modeli AI do programowania

Obecnie na rynku mamy sporo popularnych modeli AI oraz asystentów programowania, ale generalnie ich cel jest zbliżony – mają ułatwić i przyspieszyć pisanie kodu. Jeśli chodzi o główne różnice, to za wszystkim stoją różne modele językowe i firmy, które nad nimi pracują. 

Przykładowo, GitHub Copilot korzysta z OpenAI, CodeWhisperer od Amazon jest trenowany na kodzie źródłowym open-source, a inne narzędzia korzystają z własnych modeli, które możemy uruchomić lokalnie (Tabnine), więc mamy tutaj alternatywę dla usług chmurowych. 

I teraz pewnie część z was się domyśli, że OpenAI będzie nam płynnie odpowiadał w wielu językach, a CodeWhisperer będzie z kolei lepszy w kontekście AWS, bo na takich danych był trenowany. Tak właśnie jest z tymi narzędziami – takie są subtelne różnice między nimi. 

Różnice, które dostrzegamy gołym okiem, będą dla nas widoczne w integracjach i ekosystemie. Mamy z jednej strony chatboty bez możliwości wejścia w kontekst projektu (chociaż są pluginy pod ChatGPT, które integrują go z edytorem), a z drugiej strony mamy Tabnine, CodeWhisperer i Gemini jako wtyczki bezpośrednio pod IDE, które dają podpowiedzi na żywo w kodzie. 

Warto też zwrócić uwagę na licencję i koszty, i tutaj, jak się pewnie domyślacie, mamy dużą rozpiętość – od darmowych po bardzo drogie. Jeśli chodzi o mnie, to chyba poleciłbym któreś z tych darmowych i najbardziej dostępnych AI – Gemini lub Codeium. Dają praktycznie nieograniczone możliwości korzystania z AI bez opłat, co może być decydującym czynnikiem w niektórych przypadkach.  

Z drugiej strony firma może chcieć wykorzystać narzędzie, które będzie zgodne z politykami wewnętrznymi i wtedy trzeba będzie zapłacić więcej (np. Tabnine on-premise ze względów bezpieczeństwa). 

Jak widzicie, mamy tutaj spore różnice, jeśli chodzi o modele, narzędzia, pluginy oraz modele subskrypcji i licencji. Generalnie, jeśli chodzi o samą funkcjonalność, to jest ona bardzo podobna – dostajemy wygenerowany kod na podstawie prompta, ale czasami mamy możliwość skorzystania z dodatkowych funkcjonalności, takich jak np. agent mode w Copilot. 

W trybie agent mode AI nie tylko podpowiada nam kod, który chcemy dodać, ale też może modyfikować całe pliki projektu i wykonywać dodatkowe czynności, np. uruchamiać komendę do unit testów. Ciekawe, prawda? 

Co wyróżnia Gemini Code Assist spośród innych narzędzi?

Wyobraź sobie, że masz pod ręką wirtualnego asystenta, który robi również np. code review. Właśnie tak w skrócie działa Gemini Code Assist. Jeśli tworzysz projekt hobbistyczny, jest on dostępny od Google całkowicie za darmo, a do tego oferuje bardzo wysokie limity miesięczne, których raczej w standardowej sytuacji nie będziesz w stanie wykorzystać. 

Google zadbało również o to, aby dostroić asystenta do zadań stricte programistycznych, ponieważ był trenowany na rzeczywistych przypadkach kodowania. Wyróżniającą cechą jest także fakt, że Gemini potrafi czytać bardzo duży kontekst naraz. Oznacza to, że można mu przekazać cały kod źródłowy do analizy, co stanowi bardzo duży krok naprzód w porównaniu do innych narzędzi. 

Jeśli szukasz wsparcia w pisaniu kodu w edytorze za pomocą AI, chcesz, aby asystent zrobił code review i podał sugestie, co poprawić (nawet pod względem code guide w obecnym projekcie), warto zainteresować się Gemini. 

Najnowsze trendy w obszarze AI for coding w 2025 roku

Na chwilę obecną widać gwałtowne przyspieszenie rozwoju narzędzi typu AI for coding. Duże firmy technologiczne, takie jak Microsoft, Amazon czy Google, prześcigają się we wprowadzaniu AI do swoich produktów.   

Ostatnio widziałem, że AI nie tylko generuje kod, ale potrafi stworzyć taska w Jira nawet na podstawie treści nieczytelnej dla człowieka (np. z logów błędu na AWS). Mało tego – rozpisuje odpowiednie subtaski w bardzo ciekawy sposób, więc nie tracimy już cennego czasu na takie prace. Wystarczy, że wkleimy kawałek kodu i zweryfikujemy to, co nam podpowiada AI. Wydaje mi się, że AI będzie coraz bardziej wspierać tworzenie dokumentacji, testów, konfiguracji np. CI/CD czy analizę wymagań w oparciu o przyjętą architekturę projektu. 

Najlepsze praktyki korzystania z AI w programowaniu

AI, tak jak każde inne narzędzie, potrafi pomóc, ale też trzeba uważać na pewne pułapki. Przedstawię kilka propozycji w kolejności od tych najważniejszych według mnie, które są warte przeczytania i zastosowania, kiedy będziesz korzystać z AI na co dzień w swojej pracy z kodem. 

1. Zasada numer jeden – dbaj o prywatność swojego kodu i zasady panujące w danym projekcie (lub, jeśli pracujesz dla kogoś – w danej firmie lub organizacji). Warto upewnić się, czy korzystanie z AI w tym przypadku jest zgodne z umową lub polityką firmy/organizacji. Sprawdź też dodatkowo, czy można wyłączyć trenowanie modeli na twoim kodzie i nigdy nie wrzucaj danych, które są tajemnicą przedsiębiorstwa, do prompta. Jeśli już musisz, to zanonimizuj kod tak, aby nie zawierał danych wrażliwych, unikalnych projektowo nazw funkcji czy zmiennych, a kodu nigdy nie dało się powiązać z danym klientem/projektem/firmą czy czymkolwiek. Mam nadzieję, że wiesz, o co mi chodzi. 
2. AI ma ci pomagać, a nie wyręczać cię w codziennej pracy. Ma być bardziej pomocnikiem przy generowaniu powtarzalnego kodu, np. unit testów, lub nakierować cię na jakieś rozwiązanie. Sprawdź zawsze kod, który dostarcza ci AI. Przeanalizuj i zrozum, w jaki sposób AI dodało np. funkcję w kodzie. Taka refleksja nad kodem będzie ćwiczyła twój umysł, a dzięki temu umiejętności pozostaną na wysokim poziomie. 
3. Przy pisaniu testów jednostkowych stosujemy zasadę nr 2, ale dodatkowo uruchamiamy testy. Zobaczmy, czy rzeczywiście sprawdzają to, co trzeba, sprawdźmy, czy testowane są np. przypadki brzegowe. Zmuś się do analizowania tego kodu, tak jak by to był zwykły pull request na repozytorium do sprawdzenia. Błędy się zdarzają, więc zawsze sprawdzaj dwa razy.  
4. Warto wykorzystać technologię AI do robienia rzeczy, które wychodzą jej lepiej od innych, a te bardziej złożone – lepiej robić na własną rękę. Jeśli masz do wyboru wygenerowanie np. unit testów, zrobienie konwersji jednego formatu na drugi lub optymalizację już istniejącej funkcji, to AI sprawdzi się tutaj dużo lepiej, niż miałaby stworzyć to od podstaw. Skomplikowaną architekturę oraz funkcje zostaw sobie na start, a jeśli poziom skomplikowania się zwiększy lub potrzebujesz refaktoryzacji – wtedy udaj się z pytaniem do AI po sugestie. Nie zaniedbuj szkolenia się w danej dziedzinie. Wiem, że AI potrafi nas odciążyć i trochę zwolnić z myślenia, ale to nie powód, aby nie doszkalać się z danej dziedziny. Unikaj szczególnie “metody Copy’ego Paste’a”, czyli kopiowania i wklejania treści kodu bez przeczytania i zrozumienia, co się tam dzieje. 

Podsumowanie 

Tak naprawdę, jeśli zastosujemy te zasady w naszej codziennej pracy, to będzie się nam pracowało dużo lepiej, a jednocześnie zapewnimy większe bezpieczeństwo naszego kodu. Nasze umiejętności pozostaną na wysokim poziomie, a efektywność będzie rosła dzięki wsparciu AI. 

Temat, który dzisiaj omówiliśmy, jest bardzo rozległy i dynamiczny, ale mam nadzieję, że zaciekawiłem was nim i odpowiedziałem na parę nurtujących pytań. Na koniec powiem jeszcze chyba najważniejszą rzecz odnośnie AI. Ostatecznie to my dostarczamy kod i się pod nim podpisujemy, nie AI. Trzeba o tym pamiętać i zachować po prostu zdrowy rozsądek – tak jak we wszystkim. 

Zrozumienie poruszonych aspektów pozwala odpowiedzieć na istotne pytania. Jakie struktury wykorzystywać, by uniknąć krytycznych błędów? Jak zwiększyć efektywność pracy w Pythonie i zadbać o czysty kod? Jak asystenci AI wspierają codzienną pracę programistów?

Trochę historii na początek – przykłady problemów z liczbami zmiennoprzecinkowymi

Błąd systemu obrony przeciwrakietowej Patriot 

Podczas wojny w Zatoce Perskiej w 1991 roku system nie zadziałał prawidłowo i nie przechwycił rakiety Scud, która uderzyła w koszary wojskowe w Dhahran w Arabii Saudyjskiej, zabijając 28 osób. Przyczyną był błąd w obliczeniach czasu. System śledził czas za pomocą liczby całkowitej reprezentującej liczbę taktów zegara, przy czym każdy takt odpowiadał za około 0.1 sekundy. Aby obliczyć dokładny czas, liczba całkowita była mnożona przez 0.1, która w pamięci była reprezentowana jako liczba przybliżona ze względu na ograniczenia formatu IEEE 754. Z każdym kolejnym cyklem zegara błąd się kumulował, przez aż 100 godzin od uruchomienia systemu, ostatecznie narastając do około 0.34 sekundy. Ta różnica spowodowała, że system obliczył błędne położenie rakiety Scud i nie zadziałał na czas. Po incydencie wprowadzono aktualizację oprogramowania, która resetowała zegar systemowy częściej, zmniejszając wpływ kumulacji błędów. Ta tragiczna w skutkach historia amerykańskiego systemu obrony rakietowej Patriot to jeden z klasycznych przykładów błędu wynikającego z ograniczeń liczb zmiennoprzecinkowych. Ta historia pokazuje, że w tak istotnych obliczeniach należy unikać stosowania przybliżeń i używać precyzyjniejszych typów danych.  

Wybory parlamentarne w Schleswig-Holstein 

Innym przykładem są wybory parlamentarne z 1992 r. w niemieckim Schleswig-Holstein. W tym, jak i w większości niemieckich landów, obowiązuje system proporcjonalny, w którym partie muszą uzyskać co najmniej 5% głosów, aby otrzymać mandaty w parlamencie. Wyniki wyborów były prezentowane w procentach, a zaokrąglenia miały miejsce na różnych etapach obliczeń. Partia Zielonych uzyskała 4.97%, ale na etapie prezentacji wyników wartość została zaokrąglona do 5%, a więc próg został spełniony, co całkowicie zmieniło rozkład mandatów w parlamencie. Doprowadziło to do wielu kontrowersji i publicznej debaty, jednak mimo to wyniki zostały uznane za wiążące. W systemie nie przewidziano procedury na wypadek błędu zaokrąglenia.  

Float – liczby zmiennoprzecinkowe w Pythonie

W tym kontekście bardzo ciekawą prelekcją z mojej perspektywy była ta o typie Float, czyli liczbach zmiennoprzecinkowych w Pythonie.  

Liczby te można tworzyć na różne sposoby, poprzez dosłowne przekazanie liczby, czyli np. 1.0, używając klasy tj. float(1) lub poprzez działania matematyczne takie jak 1/1. 

Standard IEEE 754 binary64 

Z dokumentacji Pythona dowiadujemy się, że we wszystkich znanych implementacjach interpretera Pythona float zdefiniowany jest jako double. Bardziej szczegółowo typ ten jest opisany według standardu IEEE 754 binary64 i wygląda to następująco: 

Patrząc po kolei od lewej: 

• 1 bit jest poświęcony na znak (liczba dodatnia lub ujemna). 
• 11 bitów wyraża wykładnik potęgowy. 
• 52 bity wyrażają ułamek. 

A wszystko to można przedstawić za pomocą poniższego wzoru: 

(-1)^sign x 2^(exp-1023) x 1.fraction 

Według omówionego standardu poniżej kilka przykładów reprezentacji binarnej: 

a) Liczba 0.0 

0 (sign) 00000000000 (exponent)

(0).0000000000000000000000000000000000000000000000000000 (fraction) 

b) Liczba 1.0 = 1 x 1.0 = 2^0 x 1.0 = 2^(1024-1024) x 1.0 

0 (sign) 01111111111 (exponent)

(1).0000000000000000000000000000000000000000000000000000 (fraction) 

c) Liczba 3.0 = 2 x 1.5 = 2^1 x 1.5 =2^(1025-1024) x 1.5 

0 (sign) 10000000000 (exponent)

(1).1000000000000000000000000000000000000000000000000000 (fraction) 

Precyzja typu Float 

Powyższe przykłady są dość proste z punktu widzenia reprezentacji binarnej, jednak problem pojawia się przy liczbach niecałkowitych, ponieważ nie zawsze jesteśmy w stanie zapisać je w pamięci z pełną precyzją. Można to zaobserwować, używając w Pythonie metody as_integer_ratio(), aby sprawdzić, jakie liczby są użyte do dzielenia, by uzyskać oczekiwany wynik. Jak widać na poniższym przykładzie, dla liczby 0.1 nie ma liczb 1 i 10, jak byśmy tego oczekiwali, tylko 3602879701896397 i 36028797018963968. Są to liczby, które dają najbardziej precyzyjne przybliżenie do 0.1 i możliwe do zapisu w pamięci według omawianego standardu. Natomiast to, że wywołując print() na obliczeniu 1/10 otrzymujemy 0.1, wynika wyłącznie z tego, że print() automatycznie zaokrągla nam do najkrótszego zapisu dziesiętnego, który się mieści w ramach ostatniego bitu precyzji.  

Inną przydatną metodą w Pythonie, pozwalającą zyskać więcej informacji na temat floatów, jest sys.float_info. Dzięki niej możemy się dowiedzieć, że float pozwala na przechowywanie do 15 cyfr znaczących (dodatkowo ewentualnie znak plus-minus i/lub przecinek).  

To wszystko może sprawić, że zaczniemy się zastanawiać nad tym, jak dużo ucieka nam precyzji podczas używania typu float. Do tego przydatna jest metoda math.ulp() (czyli Unit in the Last Place), co w praktyce zwraca nam różnicę pomiędzy podaną liczbą a następną, którą jesteśmy w stanie zapisać w tym formacie w pamięci. W przypadku małych liczb te różnice są bardzo marginalne, jednak przy takiej liczbie jak 2^52 ta różnica wynosi już równo 1.0. Oznacza to, że właściwie od tej liczby wzwyż całkowicie tracimy części ułamkowe. Idąc dalej, przy 2^53 różnica ta wynosi już 2.0. Zatem ważnym wnioskiem jest, by tak dużych liczb, nawet całkowitych, nie przechowywać jako float, ponieważ tylko liczby parzyste w tym przypadku zachowałyby swoją precyzję. 

Symbole specjalne 

W standardzie IEEE 754 przewidziano również miejsce dla specjalnych symboli. Jeśli 11-bitowa część exponent jest cała wypełniona jedynkami, a 52-bitowa część wyrażająca ułamek wypełniona zerami, to mamy do czynienia z reprezentacją binarną nieskończoności. Zapełniając zerem bit odpowiedzialny za znak otrzymujemy plus nieskończoność, a jedynką minus nieskończoność. 

Z kolei mając również 11-bitową część exponent wypełnioną jedynkami, ale także część wyrażającą ułamek wypełnioną jedynkami, otrzymujemy symbol NaN (Not a Number). Wszelkie operacje porównujące takie jak =, >, < z udziałem NaN zwracają False, co może być problematyczne w różnych okolicznościach. Zwłaszcza kiedy użytkownik ma braki w danych i sądzi, że porównywana jest faktyczna liczba, a nie pusta reprezentacja w postaci NaN.  

Zaokrąglenia 

Co jednak, jeśli nie jest potrzebna nam aż taka dokładność i chcemy uprościć jakieś obliczenia? Odpowiedzią są zaokrąglenia i należy wiedzieć, że uzyskać je można na różne sposoby. Co istotne, nie różnią się jedynie nazwy funkcji, ale ich implementacje mają odrębne podejścia. W prezentacji podczas Python Summit 2024 przedstawiono następujące metody: 

1. Funkcja round() – zaokrągla zadaną liczbę do najbliższej liczby z określoną liczbą miejsc po przecinku, domyślnie do liczby całkowitej. Natomiast szczególnym przypadkiem jest sytuacja, gdy liczba jest równo w połowie i w obie strony jest taka sama odległość. Wtedy najmniej znacząca cyfra zaokrąglana jest do liczby parzystej, co według statystyków minimalizuje skumulowany błąd podczas wykonywania wielu operacji zaokrąglania. Czyli przykładowo zarówno 1.5, jak i 2.5 zostaną zaokrąglone do 2, jeśli interesuje nas liczba całkowita. Co ciekawe, w przypadku takich liczb jak 1.15 i 1.25 również obie powinny zostać zaokrąglone do 1.2, gdyby chcieć zachować dokładność do jednego miejsca po przecinku. Jednak tylko 1.25 zwróci poprawnie 1.2, a dla 1.15 zostanie zwrócone 1.1. Wynika to właśnie z tego, że liczby 1.15 nie da się precyzyjnie przechować w pamięci według standardu IEEE 754, a będzie to 1.1499999999999999. Czyli nie jest to de facto równo w połowie, a więc zaokrągli w dół do 1.1. 

2. int() lub math.trunc() – co prawda nie są to funkcje zaokrąglające, tylko obcinające liczbę, ale ich efekt działa tak, jakbyśmy zaokrąglali liczbę w kierunku 0. Czyli przykładowo 1.9 zostanie ucięte (zaokrąglone) do 1, natomiast -1.9 zostanie sprowadzone do -1.  

3. math.floor() lub x // 1 – pierwsza z nich po prostu zaokrągla w dół, w kierunku –nieskończoności. Natomiast druga to dzielenie bez reszty, przy czym dzieląc przez jeden, uzyskamy ten sam efekt co w przypadku pierwszej funkcji. Przykładowo dla obu z nich -1.9 zostanie zaokrąglone do -2, a 1.9 do 1. 

4. math.ceil() – zaokrąglanie w górę, w kierunku + nieskończoności. Używając tego samego przykładu -1.9 zostanie zaokrąglone do -1, natomiast 1.9 zaokrągli do 2. 

Developer Experience – jak mierzyć efektywność developera?

W przeszłości na różne sposoby próbowano mierzyć efektywność developerów. Jedną z bardziej popularnych, a zarazem nietrafionych metod, było mierzenie efektywności poprzez liczbę napisanych linii kodu. Podczas drugiej z wspomnianych prezentacji przytoczono koncepcję, która nie tyle pozwala na mierzenie produktywności, co pomaga zadbać o efektywne środowisko pracy. Mowa tutaj o DevEX (Developer Experience), które wyróżnia 3 filary: 

1. Stan przepływu (Flow state) – z punktu widzenia developera jest to stan głębokiego skupienia, w którym jesteśmy w stanie spokojnie pracować. Jeśli cele nie są jasno doprecyzowane, może wystąpić konieczność przerwania zadania, by ustalić nieścisłości. 
2. Pętle zwrotne (Feedback loops) – oznacza, ile czasu mija, zanim developer się dowie, że kod nie działa. W przypadku testów jednostkowych ten feedback jest bardzo szybki, ale w przypadku code review na feedback trzeba zaczekać dłużej. 
3. Ładunek kognitywny (Cognitive load) – oznacza wysiłek umysłowy wymagany do skutecznego pisania kodu. Jeśli programista spotyka się z projektem o innej strukturze niż zwykle albo nie ma do dyspozycji dokumentacji, do której zawsze miał dostęp, ten ładunek będzie wyższy. 

Narzędzia do efektywnej pracy w Pythonie

Wielu programistów rozpoczyna przygodę z Pythonem, gdyż zachęca ich intuicyjna składnia i wszechstronność zastosowań tego języka w analizie danych. W miarę rozwoju umiejętności w naturalny sposób poszukujemy narzędzi pozwalających zwiększyć efektywność pracy i ułatwiających życie. Podczas kolejnej prezentacji, w której miałem okazję brać udział w trakcie Python Summit 2024, zostały omówione takie narzędzia: 

1. Formatery  

Formatowanie kodu to bardzo istotny aspekt, ponieważ to od tego głównie będzie zależało, czy programiście wygodnie się czyta oraz pisze kod. Jednak każdy z nas może mieć nieco inne preferencje, przyzwyczajenia, dlatego najlepiej, aby został przyjęty jeden ściśle określony sposób formatowania. Zaleca się korzystanie ze standardu PEP 8. Jest to dość długi dokument, dlatego dbanie samodzielnie o każdy szczegół mogłoby być bardzo czasochłonne – ładunek kognitywny rośnie. Dodatkowo podczas code review to byłaby rzecz, na którą trzeba zwracać uwagę, zatem przekłada się to na dodatkowy czas poświęcony po stronie zespołu, a i pętla zwrotna się wydłuża. I tutaj z pomocą przychodzą formatery kodu, które mogą wykonać całą pracę za nas. Przykładowe formatery kodu w Pythonie to: black, isort, ruff, yapf. 

2. Lintery 

Są to narzędzia do statycznej analizy kodu, dzięki którym możemy dowiedzieć się o niektórych błędach jeszcze przed uruchomieniem kodu. Ponadto lintery są w stanie naprawiać za nas takie błędy jak np. literówki powstałe poprzez użycie nieistniejącej zmiennej. Inne kwestie, które mogą być sprawdzane automatycznie, to ilość znaków w każdej linii, długość nazw funkcji, zmiennych, ilość argumentów do funkcji itp. Przykłady linterów w Pythonie to: pylint, flake8, ruff. 
 

3. Adnotacje typów i type checkery 

W kwestii typów zmiennych Python jest bardzo liberalny, ponieważ mamy tu do czynienia z typowaniem dynamicznym. Mimo to określanie typów, jakie przewidujemy dla danych zmiennych, jest postrzegane jako dobra praktyka w Pythonie. Jest to funkcja, która została wprowadzona od wersji Pythona 3.5. Należy mieć na uwadze, że adnotacje typów są jedynie komentarzem i nie są uwzględniane przez program, o ile nie ma zewnętrznej biblioteki, która by je interpretowała. Używając jednak PyCharma, jednego z najpopularniejszych IDE dla Pythona, możemy odnieść korzyści z adnotacji typów natychmiastowo. PyCharm posiada wbudowany type checker, dzięki czemu będziemy widzieć różne podpowiedzi dotyczące typów. Inne popularne zewnętrzne type checkery to: mypy, pyright czy też pyre. 

Rekomendacja dotycząca omówionych narzędzi bardzo przypadła mi do gustu. Według prelegentów Python Summit 2024 dobrym wyborem będzie ruff, ponieważ świetnie sprawdza się zarówno jako formater, jak i linter. Zastępuje inne narzędzia oraz jest bardzo szybki. Dodatkowym argumentem, by się bliżej przyjrzeć tej bibliotece, jest to, że w planach jest rozszerzenie jej funkcjonalności również o type checker. Jednak na ten moment należy korzystać ze sprawdzonych i popularnych narzędzi do sprawdzania typów, takich jak mypy oraz pyright.  

Asystenci AI jako wsparcie produktywnej pracy

Na koniec temat, bez którego trudno obecnie wyobrazić sobie przyszłość programowania – mianowicie narzędzia sztucznej inteligencji. Poza wspomnianymi tradycyjnymi narzędziami do usprawniania pracy w Pythonie podczas konferencji w prezentacjach osobną część poświęcono nowoczesnym podejściom do tworzenia oprogramowania wykorzystującym asystentów AI.  

O ile obecnie raczej nie ma co liczyć na to, że napiszą za nas cały program, o tyle mogą świetnie się sprawdzić jako usprawnienie pracy. Zainstalowanie takiej wtyczki jak chociażby Copilot może przyspieszyć proste operacje czy też tworzenie komentarzy dzięki trafnym podpowiedziom.  

Jeśli nie pamiętamy składni, argumentów biblioteki etc., sprawdzanie dokumentacji może okazać się już zbędne. Asystenci AI mogą również przyspieszyć pisanie prostych testów jednostkowych. Warto jednak najpierw napisać kilka z nich samodzielnie, by asystent mógł lepiej rozpoznać poprawny wzór. 

Poniżej kilka przykładów najbardziej popularnych narzędzi programistycznych.   

• GitHub Copilot – narzędzie analizuje kontekst kodu i pozwala zautomatyzować, a tym samym przyspieszyć uzupełnianie fragmentów kodu. Przydatny w tworzeniu i przeglądzie dokumentacji oraz wyszukiwaniu konkretnych rozwiązań. 
• Supermaven – sugeruje zależności i poprawki w kodzie, eliminując błędy i optymalizując wydajność aplikacji. Narzędzie może zasugerować użycie najlepszej biblioteki pod kątem danego projektu, co skraca czas analizy i przyspiesza proces wdrażania nowych rozwiązań. 
• Cursor AI – usprawnia pracę programistów Python dzięki inteligentnemu autouzupełnianiu, generowaniu kodu na podstawie języka naturalnego oraz możliwości szybkiego refactoringu. 
• Tabnine – pozwala uzupełniać kod w czasie rzeczywistym, co zwiększa produktywność i pomaga unikać błędów składniowych, a także eliminuje powtarzalność zadań związanych z pisaniem kodu. 
• Sourcegraph Cody – sprawdza się świetnie w zaawansowanym przeszukiwaniu kodu. Pozwala na zrozumienie zależności w projektach oraz – dzięki kontekstowej analizie całej bazy kodu – na szybkie odnajdywanie i poprawianie błędów. 

AI w programowaniu | bezpłatny e-book

Zautomatyzuj kodowanie z AI! Pobierz darmowy e-book i odkryj nowe możliwości

Pobierz teraz!

Podsumowanie

Mnogość dostępnych technologii w świecie IT potrafi przyprawić o zawrót głowy. Samo określenie roli w projekcie IT jeszcze nie determinuje wyboru narzędzi, z których będziemy korzystać. Decydować o tym będą w głównej mierze wymagania systemu. Czy powinien być nastawiony na wydajne przetwarzanie dużych ilości danych, czy może bardziej istotna jest prostota w implementacji i szybkie wdrożenie rozwiązania kosztem niższej wydajności? Odpowiedzenie sobie na te pytania czasem nie wystarczy, ponieważ bywa, że kilka technologii spełnia wszystkie wymagania i wybór sprowadza się do względów czysto estetycznych i preferencji osobistych.  

Na szczęście są społeczności i organizacje, które skupiają ludzi zainteresowanych określoną tematyką i pomagają odnaleźć się w gąszczu wiedzy oraz poszerzać horyzonty, by być na bieżąco. Dla osób związanych zawodowo z językiem programowania Python takim miejscem jest właśnie konferencja Python Summit. Prelekcje dostępne w trakcie Python Summit 2024 i zagadnienia, które omówiłem, stanowią tylko mały wycinek wiedzy, jaki można było wynieść z tego spotkania. Zapewniam, że każdy znalazłby coś dla siebie, nawet jeśli wybrane przeze mnie tematy nie są w centrum zainteresowania danego programisty. 

Przeczytaj także nasze artykuły dotyczące bibliotek Python:  

• NumPy 
• Matplotlib 
• Pandas