Od poznawania technologii do coraz bardziej samodzielnego tworzenia
W wieku 12–16 lat programowanie może stać się czymś znacznie więcej niż kolejnym zajęciem dodatkowym. To moment, w którym młodzież może już pracować z prawdziwym kodem, tworzyć większe projekty, poznawać różne technologie i coraz częściej samodzielnie szukać sposobu rozwiązania problemu.
Na naszych zajęciach uczestnicy tworzą strony internetowe, programy, gry i projekty łączące kod z elektroniką. Uczą się nie tylko pisać kod, ale również planować strukturę projektu, analizować działanie programu, testować rozwiązania i poprawiać błędy.
Korzystamy z różnych technologii – od HTML, CSS i JavaScriptu, przez Python i Lua, aż po MicroPython i Raspberry Pi Pico – ponieważ nie zależy nam na nauczeniu jednego języka „na pamięć”. Zależy nam na zrozumieniu zasad, które można wykorzystać niezależnie od wybranego narzędzia.
Im więcej potrafię, tym mniej potrzebuję gotowych odpowiedzi – i tym więcej mogę stworzyć sam.
Co rozwija programowanie w wieku 12–16 lat?
Na tym etapie programowanie staje się coraz bardziej świadomym treningiem:
- logicznego i analitycznego myślenia,
- rozwiązywania bardziej złożonych problemów,
- planowania większych projektów,
- samodzielnego podejmowania decyzji,
- czytania i analizowania kodu,
- debugowania i wyszukiwania błędów,
- wytrwałości w pracy nad rozwiązaniem,
- kreatywności i projektowania własnych rozwiązań,
- świadomego korzystania z nowych technologii.
Jak wyglądają zajęcia?
Poznajemy problem lub projekt
Zaczynamy od konkretnego celu: strony, programu, gry, urządzenia albo funkcji, którą chcemy stworzyć.
2. Planujemy rozwiązanie
Zastanawiamy się, jakie elementy będą potrzebne, jak powinny ze sobą współpracować i od czego najlepiej rozpocząć.
3. Programujemy
Tworzymy kod i wykorzystujemy technologie właściwe dla danego kursu.
4. Uruchamiamy i testujemy
Sprawdzamy, czy projekt działa zgodnie z założeniem oraz jak reaguje na różne sytuacje.
5. Debugujemy i poprawiamy
Analizujemy błędy, szukamy ich przyczyn i testujemy kolejne rozwiązania.
6. Rozwijamy projekt
Dodajemy nowe funkcje, optymalizujemy kod i coraz częściej wprowadzamy własne pomysły oraz rozwiązania.
A co, jeśli nie działa?
Debugowanie jest częścią programowania
Im bardziej rozbudowany projekt, tym większa szansa, że coś nie zadziała od razu. Błąd może znajdować się w składni, logice programu, danych, konfiguracji albo sposobie połączenia poszczególnych elementów.
Nie naprawiamy kodu za uczestnika tylko po to, żeby projekt jak najszybciej ruszył.
Uczymy analizować problem:
Co miało się wydarzyć? → Co wydarzyło się naprawdę? → W którym miejscu może być błąd? → Jak możemy to sprawdzić? → Co warto zmienić?
Z czasem uczestnik coraz częściej potrafi samodzielnie znaleźć przyczynę, przetestować hipotezę i poprawić własne rozwiązanie.
Nie chodzi o to, żeby nigdy nie popełniać błędów. Chodzi o to, żeby wiedzieć, co zrobić, kiedy się pojawią.
Oferta na rok szkolny 2026/27
Grupa wiekowa: 12 – 16 lat
Web Development – od interfejsu do aplikacji
(HTML, CSS, JavaScript, Go)
Kurs dla młodzieży w wieku 12–16 lat, która chce zrozumieć, jak powstają współczesne aplikacje internetowe – od tego, co użytkownik widzi w przeglądarce, po logikę działającą w po stronie serwera.
Zaczynamy od technologii tworzących frontend. HTML pozwala budować strukturę strony, CSS odpowiada za jej wygląd, a JavaScript dodaje interakcje i sprawia, że projekt zaczyna reagować na działania użytkownika.
Na tym jednak nie kończymy. Wprowadzamy również język Go, dzięki któremu uczestnicy poznają podstawy działania backendu – czyli tej części aplikacji, której użytkownik nie widzi, ale która odpowiada m.in. za przetwarzanie danych, logikę i komunikację pomiędzy elementami systemu.
Dzięki temu młodzież zaczyna rozumieć aplikację internetową jako całość:
INTERFEJS → LOGIKA → DANE → ODPOWIEDŹ APLIKACJI
W trakcie kursu proste strony stopniowo rozwijają się w coraz bardziej funkcjonalne projekty. Uczestnicy uczą się nie tylko pisać kod, ale również planować strukturę aplikacji, testować jej działanie i szukać rozwiązań pojawiających się problemów.
Po tym kursie Twoje dziecko:
- stworzy własne strony i pierwsze aplikacje webowe,
- będzie korzystać z HTML, CSS i JavaScript,
- pozna podstawy programowania po stronie serwera w języku Go,
- zrozumie różnicę pomiędzy frontendem i backendem,
- nauczy się łączyć różne technologie w jeden działający projekt,
- zdobędzie podstawy do dalszego rozwoju w kierunku web developmentu i tworzenia aplikacji internetowych.
Nie tylko tworzymy to, co widać w przeglądarce. Zaczynamy rozumieć, co dzieje się również po drugiej stronie aplikacji.
Program kursu:
Program kursu – od interfejsu do aplikacji – frontend i backend
HTML, CSS, JavaScript, Go
Kurs prowadzi uczestników od pierwszej własnej strony internetowej do projektów, w których frontend zaczyna współpracować z logiką działającą po stronie serwera. Uczestnicy poznają HTML, CSS i JavaScript, a następnie podstawy backendu w języku Go.
Nie uczymy wyłącznie tworzenia ładnych stron. Pokazujemy, jak zbudowana jest współczesna aplikacja internetowa i jak jej poszczególne elementy współpracują ze sobą.
1. Jak działa współczesna strona internetowa?
Zaczynamy od zrozumienia roli przeglądarki, serwera i poszczególnych technologii. Uczestnicy poznają różnicę pomiędzy frontendem i backendem oraz dowiadują się, za co odpowiadają HTML, CSS, JavaScript i Go.
2. HTML – budujemy strukturę strony
Poznajemy podstawowe znaczniki HTML i uczymy się tworzyć logiczną strukturę dokumentu: nagłówki, akapity, listy, linki, obrazy, sekcje i formularze.
Przykładowe projekty: strona „O mnie”, wizytówka internetowa, prosta strona tematyczna.
3. CSS – projektujemy wygląd
Nadajemy stronom własny styl. Uczestnicy poznają kolory, typografię, odstępy, obramowania, układy elementów oraz podstawy nowoczesnego projektowania stron.
Przykładowe projekty: karta produktu, portfolio, strona wydarzenia.
4. Responsywność – strona na komputerze i telefonie
Pokazujemy, że współczesna strona powinna dobrze działać na różnych ekranach. Uczestnicy uczą się dostosowywać układ do telefonu, tabletu i komputera.
5. JavaScript – strona zaczyna reagować
Wprowadzamy pierwsze skrypty w JavaScript. Uczestnicy poznają zmienne, warunki, zdarzenia i podstawową logikę potrzebną do tworzenia interaktywnych elementów.
Przykładowe projekty: interaktywny przycisk, licznik, zmiana treści i wyglądu strony, prosty quiz.
6. Formularze i dane od użytkownika
Tworzymy formularze i uczymy się pobierać dane wpisywane przez użytkownika. Pokazujemy, jak sprawdzać poprawność informacji i wykorzystywać je w działaniu aplikacji.
7. JavaScript – bardziej rozbudowane interakcje
Łączymy poznane wcześniej elementy w większe projekty. Uczestnicy zaczynają planować, jak ma zachowywać się interfejs i jakie działania powinny następować po konkretnych zdarzeniach.
8. Pierwsze kroki z backendem i językiem Go
Przechodzimy na drugą stronę aplikacji internetowej. Uczestnicy poznają podstawy języka Go i uczą się uruchamiać prosty serwer, który może odbierać żądania i zwracać odpowiedź do przeglądarki.
9. Frontend spotyka backend
Łączymy część widoczną dla użytkownika z kodem działającym na serwerze. Uczestnicy zaczynają rozumieć przepływ:
UŻYTKOWNIK → PRZEGLĄDARKA → SERWER → ODPOWIEDŹ APLIKACJI
10. Dane i logika aplikacji
Tworzymy projekty, w których backend przetwarza informacje przesłane przez użytkownika i zwraca odpowiedni wynik. Uczestnicy uczą się oddzielać wygląd aplikacji od jej logiki.
Przykładowe projekty: formularz z odpowiedzią serwera, prosta aplikacja użytkowa, generator danych.
11. Testowanie i debugowanie
Sprawdzamy działanie strony i aplikacji na różnych etapach. Uczestnicy uczą się korzystać z narzędzi przeglądarki, analizować błędy i systematycznie szukać ich przyczyn.
12. Projekt własnej aplikacji webowej
Na końcowym etapie uczestnicy planują i realizują własny projekt łączący poznane technologie. Zakres projektu jest dopasowany do poziomu grupy i może obejmować zarówno rozbudowaną stronę, jak i prostą aplikację internetową z częścią frontendową i backendową.
W trakcie kursu uczestnicy uczą się m.in.:
- tworzyć strukturę stron w HTML,
- projektować wygląd za pomocą CSS,
- dodawać interakcje w JavaScript,
- tworzyć responsywne układy,
- pracować z formularzami i danymi użytkownika,
- rozumieć różnicę pomiędzy frontendem i backendem,
- tworzyć pierwsze programy serwerowe w Go,
- łączyć kilka technologii w jeden projekt,
- testować i debugować własne rozwiązania.
Przykładowe projekty realizowane podczas kursu:
wizytówka WWW • portfolio • strona wydarzenia • interaktywny quiz • formularz •
responsywna strona mobilna • prosty serwer w Go • aplikacja klient–serwer •
własny projekt webowy
Program ma charakter przykładowy. Kolejność projektów, wykorzystywane technologie i zakres poszczególnych zagadnień mogą być modyfikowane w zależności od poziomu grupy, tempa pracy uczestników oraz aktualizowanego programu zajęć.
czas trwania zajęć: 90 minut.
Cena za zajęcia: 65,00 zł
Kwota opłaty miesięcznej może się zmieniać w zależności od ilości zajęć przypadających w danym miesiącu.
Zniżki:
– 10% zniżki dla każdego z rodzeństwa, uczęszczającego w tym samym terminie.
– 10% zniżki dla posiadaczy karty „Duża Rodzina”.
– 10% zniżki na drugie i kolejne zajęcia w tym samym czasie.
Zniżki nie łączą się ze sobą.Zajęcia trwają cały rok szkolny i odbywają się raz w tygodniu.
Oferta na rok szkolny 2025/26
Grupa wiekowa: 12- 16 lat
Programowanie tekstowe – od logiki do własnego kodu
(Microsoft Small Basic, Lua)
Kurs dla młodzieży w wieku 12–16 lat, która chce rozpocząć świadomą pracę z kodem tekstowym i nauczyć się zamieniać problemy w działające programy.
To kurs skupiony przede wszystkim na fundamentach programowania, które pozostają aktualne niezależnie od tego, z jakiego języka uczestnik będzie korzystał w przyszłości.
Pracując m.in. z Microsoft Small Basic i Lua, młodzież poznaje zmienne, instrukcje warunkowe, pętle, funkcje, operacje na danych oraz sposób organizowania większego programu.
Nie chodzi nam jednak o zapamiętywanie kolejnych komend. Uczestnik uczy się przede wszystkim analizować problem, podzielić go na mniejsze części, zaplanować rozwiązanie, napisać kod, uruchomić go i znaleźć przyczynę, jeśli coś nie działa.
Wraz z rozwojem umiejętności coraz mniej korzystamy z gotowych fragmentów programu. Coraz więcej decyzji pozostawiamy uczestnikowi.
Po tym kursie Twoje dziecko:
- apisze pierwsze samodzielne programy tekstowe,
- zrozumie działanie zmiennych, warunków, pętli i funkcji,
- nauczy się czytać i analizować kod,
- będzie potrafiło samodzielnie szukać i poprawiać błędy,
- rozwinie logiczne i algorytmiczne myślenie,
- zdobędzie fundamenty ułatwiające późniejszą pracę z Pythonem, JavaScriptem i innymi językami programowania.
Składnia języka może się zmienić. Umiejętność znalezienia rozwiązania zostaje.
Program kursu:
Program kursu – Programowanie tekstowe – od logiki do własnego kodu
Microsoft Small Basic, Lua
Kurs wprowadza uczestników w świat programowania tekstowego i pokazuje, jak znane wcześniej zasady logicznego myślenia można zapisywać za pomocą prawdziwego kodu. Pracujemy m.in. z Microsoft Small Basic i Lua.
Nie chodzi o zapamiętywanie składni konkretnego języka. Najważniejsze jest zrozumienie problemu, zaplanowanie rozwiązania i zapisanie go w kodzie.
1. Pierwszy program tekstowy
Poznajemy środowisko pracy, sposób uruchamiania kodu oraz podstawową strukturę programu. Uczestnicy tworzą pierwsze instrukcje i obserwują ich efekt.
2. Zmienne i dane
Uczymy się przechowywać informacje w zmiennych i wykorzystywać je w kolejnych operacjach. Poznajemy podstawowe typy danych i sposoby ich użycia.
Przykładowe projekty: kalkulator, przelicznik, prosty program użytkowy.
3. Program komunikuje się z użytkownikiem
Tworzymy programy pobierające dane i reagujące na informacje wpisywane przez użytkownika. Uczestnicy uczą się łączyć dane wejściowe z logiką programu.
4. Warunki – różne decyzje, różne wyniki
Poznajemy instrukcje warunkowe i uczymy się tworzyć programy posiadające kilka możliwych ścieżek działania.
Przykładowe projekty: quiz, prosty system logowania, gra z wyborem odpowiedzi.
5. Pętle – automatyzujemy powtarzalne działania
Wprowadzamy pętle i uczymy się wykorzystywać je do powtarzania instrukcji, przetwarzania danych i tworzenia bardziej dynamicznych programów.
6. Losowość i proste gry
Poznajemy generowanie wartości losowych i wykorzystujemy je w projektach, które mogą przebiegać inaczej przy każdym uruchomieniu.
Przykładowe projekty: zgadywanie liczby, kostka do gry, prosta gra tekstowa.
7. Funkcje – dzielimy program na mniejsze części
Uczestnicy poznają funkcje i uczą się porządkować większy program. Pokazujemy, dlaczego podział kodu na mniejsze elementy ułatwia jego rozwijanie i poprawianie.
8. Kolekcje danych
Wprowadzamy podstawowe sposoby przechowywania większej liczby informacji. Uczestnicy uczą się przeglądać dane, modyfikować je i wykorzystywać w programie.
9. Lua – ten sam problem, inny język
Przechodzimy do kolejnego języka i pokazujemy, że poznane wcześniej mechanizmy pozostają aktualne. Zmienia się składnia, ale logika programu nadal opiera się na zmiennych, warunkach, pętlach i funkcjach.
10. Algorytm przed kodem
Przed rozpoczęciem bardziej rozbudowanych zadań uczestnicy uczą się zaplanować rozwiązanie: podzielić problem na etapy, określić dane wejściowe i przewidzieć oczekiwany rezultat.
11. Debugowanie – szukamy przyczyny, nie gotowej odpowiedzi
Uczestnicy analizują komunikaty o błędach, sprawdzają kolejne fragmenty kodu i uczą się systematycznie dochodzić do źródła problemu.
Błąd staje się częścią procesu tworzenia, a nie końcem pracy nad projektem.
12. Coraz więcej samodzielności
W kolejnych zadaniach prowadzący określa cel, ale nie podaje kompletnego kodu. Uczestnik sam wybiera poznane mechanizmy, tworzy rozwiązanie i sprawdza jego działanie.
13. Własny projekt programistyczny
Na zakończenie uczestnicy wykorzystują poznane elementy do stworzenia własnego programu dopasowanego do poziomu grupy – aplikacji konsolowej, gry tekstowej lub innego narzędzia.
W trakcie kursu uczestnicy uczą się m.in.:
- pisać pierwsze samodzielne programy tekstowe,
- korzystać ze zmiennych, warunków, pętli i funkcji,
- pracować z danymi i prostymi kolekcjami,
- planować rozwiązanie przed napisaniem kodu,
- czytać i analizować cudzy oraz własny kod,
- debugować program i wyszukiwać przyczyny błędów,
- przenosić poznane zasady pomiędzy różnymi językami,
- coraz bardziej samodzielnie realizować własne projekty.
Przykładowe projekty realizowane podczas kursu:
kalkulator • przelicznik • quiz • system logowania • zgadywanie liczby •
generator losowań • gra tekstowa • program z menu • projekt w Lua • własny program
Program ma charakter przykładowy. Kolejność projektów, wykorzystywane języki i zakres zagadnień mogą być modyfikowane w zależności od poziomu grupy, tempa pracy uczestników oraz aktualizowanego programu zajęć.
czas trwania zajęć: 90 minut
Cena za zajęcia: 65,00 zł
Kwota opłaty miesięcznej może się zmieniać w zależności od ilości zajęć przypadających w danym miesiącu.
Zniżki:
– 10% zniżki dla każdego z rodzeństwa, uczęszczającego w tym samym terminie.
– 10% zniżki dla posiadaczy karty „Duża Rodzina”.
– 10% zniżki na drugie i kolejne zajęcia w tym samym czasie.
Zniżki nie łączą się ze sobą.Zajęcia trwają cały rok szkolny i odbywają się raz w tygodniu.
Oferta na rok szkolny 2025/26
Grupa wiekowa: 12- 16 lat
Programowalna elektronika i inteligentne urządzenia
(Raspberry Pi, MicroPython)
Kurs dla młodzieży w wieku 12–16 lat, która chce połączyć programowanie z elektroniką i tworzyć urządzenia reagujące na otaczający je świat.
Uczestnicy pracują z mikrokontrolerem Raspberry Pi Pico, budują rzeczywiste układy elektroniczne i programują ich działanie w języku MicroPython.
Tutaj efekt napisania programu nie kończy się na ekranie komputera. Kod może zapalić diodę, odczytać temperaturę, wykryć ruch, zmierzyć odległość, sterować silnikiem, uruchomić alarm albo wyświetlić dane na ekranie.
Wraz z kolejnymi projektami pojedyncze elementy zaczynamy łączyć w całe systemy:
CZUJNIK → DANE → PROGRAM → DECYZJA → REAKCJA URZĄDZENIA
To praktyczne wprowadzenie do świata programowalnej elektroniki, automatyki, systemów IoT i inteligentnych urządzeń. Uczestnicy zaczynają rozumieć, w jaki sposób oprogramowanie może komunikować się ze światem fizycznym.
Dużą częścią pracy jest również diagnozowanie problemów. Czasem błąd znajduje się w kodzie, czasem w połączeniu przewodów, a czasem w ustawieniach układu. Trzeba umieć znaleźć przyczynę.
Po tym kursie Twoje dziecko:
- zaprogramuje mikrokontroler Raspberry Pi Pico w MicroPythonie,
- pozna podstawy elektroniki i działania mikrokontrolerów,
- nauczy się korzystać z czujników, ekranów i elementów wykonawczych,
- będzie tworzyć urządzenia reagujące na informacje z otoczenia,
- zrozumie zależność pomiędzy czujnikiem, danymi, programem i reakcją urządzenia,
- nauczy się diagnozować problemy zarówno w kodzie, jak i w elektronice,
- stworzy własne programowalne urządzenia i bardziej rozbudowane systemy.
Tutaj kod wychodzi z ekranu i zaczyna sterować prawdziwym światem.
Program kursu:
Program kursu – Programowalna elektronika i inteligentne urządzenia
Raspberry Pi Pico, MicroPython
Kurs łączy programowanie z elektroniką i prowadzi uczestników od prostych układów do projektów, w których czujniki zbierają dane, program je analizuje, a urządzenie reaguje na otoczenie.
Pracujemy z mikrokontrolerem Raspberry Pi Pico i językiem MicroPython. Teoria pojawia się wtedy, kiedy jest potrzebna do zrozumienia projektu. Najwięcej czasu przeznaczamy na budowanie, programowanie, testowanie i diagnozowanie.
1. Mikrokontroler jako „mózg” urządzenia
Poznajemy Raspberry Pi Pico, wejścia i wyjścia oraz sposób, w jaki program steruje podłączonymi elementami. Budujemy pierwsze proste obwody.
2. Światło i sterowanie
Pracujemy z diodami LED i RGB, poznajemy zmianę jasności oraz podstawy sygnału PWM. Uczestnicy obserwują, że ten sam układ może zachowywać się inaczej w zależności od kodu.
Przykładowe projekty: lampka RGB, animacje świetlne, inteligentna sygnalizacja.
3. Czujniki – urządzenie zaczyna „widzieć” otoczenie
Wprowadzamy czujniki ruchu, światła, temperatury, wilgotności i odległości. Uczestnicy uczą się odczytywać dane i wykorzystywać je w programie.
4. Dane, pomiary i wyświetlacze
Pracujemy z ekranami LCD, OLED i matrycami LED. Uczestnicy uczą się prezentować wyniki pomiarów i tworzyć urządzenia przekazujące informacje użytkownikowi.
Przykładowe projekty: elektroniczna miarka, termometr, licznik, ekran informacyjny.
5. Mini stacja pogodowa
Łączymy czujniki i wyświetlacz w jeden większy projekt. Uczestnicy odczytują temperaturę i wilgotność, przetwarzają dane i prezentują wynik w czytelnej formie.
6. Ruch i elementy wykonawcze
Poznajemy serwomechanizmy i inne elementy, dzięki którym program może wprawić rzeczywisty mechanizm w ruch.
Przykładowe projekty: automatyczna bariera, wskaźnik, prosty zamek elektroniczny.
7. Dźwięk, alarmy i sygnalizacja
Wprowadzamy buzzer i sygnały dźwiękowe. Łączymy dźwięk z warunkami i czujnikami, tworząc układy reagujące na konkretne zdarzenia.
Przykładowe projekty: alarm antywłamaniowy, sygnalizator ostrzegawczy, elektroniczny dzwonek.
8. Ruch, położenie i żyroskop
Poznajemy dane opisujące ruch i orientację urządzenia oraz uczymy się wykorzystywać je do sterowania projektem.
Przykładowe projekty: elektroniczna klepsydra, sterowanie przechyleniem, animacje reagujące na ruch.
9. Mikrokontroler komunikuje się z komputerem
Pokazujemy, że Raspberry Pi Pico może pełnić rolę kontrolera lub urządzenia wejściowego dla programu działającego na komputerze.
Przykładowe projekty: własny kontroler, sterowanie aplikacją, mikrokontroler jako klawiatura lub mysz.
10. Inteligentny system – kilka elementów, jedna logika
Łączymy czujniki, program i elementy wykonawcze według schematu:
CZUJNIK → DANE → PROGRAM → DECYZJA → REAKCJA URZĄDZENIA
Powstają projekty wykorzystujące kilka elementów jednocześnie.
Przykładowe projekty: czujnik parkowania, inteligentne oświetlenie, rozbudowany alarm, automatyczna bariera.
11. Diagnozowanie problemów
W elektronice problem może znajdować się w kodzie, przewodach, ustawieniach lub jednym z elementów układu. Uczymy systematycznego sprawdzania:
PROGRAM → POŁĄCZENIA → ELEMENTY → USTAWIENIA → TEST → POPRAWKA
12. Własne inteligentne urządzenie
Uczestnicy wykorzystują poznane technologie do stworzenia własnego projektu lub rozbudowania jednego z wcześniejszych urządzeń o nowe funkcje.
W trakcie kursu uczestnicy uczą się m.in.:
- programować Raspberry Pi Pico w MicroPythonie,
- budować i analizować proste układy elektroniczne,
- pracować z czujnikami, ekranami i elementami wykonawczymi,
- odczytywać i przetwarzać dane z otoczenia,
- tworzyć reakcje urządzeń na określone warunki,
- łączyć kilka elementów w jeden działający system,
- diagnozować problemy w kodzie i elektronice,
- projektować coraz bardziej samodzielne urządzenia.
Przykładowe projekty realizowane podczas kursu:
lampka RGB • inteligentne światła • elektroniczna miarka • mini stacja pogodowa •
alarm antywłamaniowy • automatyczna bariera • elektroniczna klepsydra •
czujnik parkowania • własny kontroler • inteligentne urządzenie własnego pomysłu
Program ma charakter przykładowy. Kolejność projektów, wykorzystywane elementy i zakres poszczególnych zagadnień mogą być modyfikowane w zależności od poziomu grupy, tempa pracy uczestników, dostępnych technologii oraz aktualizowanego programu zajęć.
czas trwania zajęć: 90 minut
Cena za zajęcia: 70,00 zł
Zniżki:
– 10% zniżki dla każdego z rodzeństwa, uczęszczającego w tym samym terminie.
– 10% zniżki dla posiadaczy karty „Duża Rodzina”.
– 10% zniżki na drugie i kolejne zajęcia w tym samym czasie.
Zniżki nie łączą się ze sobą.Zajęcia trwają cały rok szkolny i odbywają się raz w tygodniu.
Oferta na rok szkolny 2025/26
Grupa wiekowa: 13-16 lat
Programowanie Python – od kodu do samodzielnych projektów
(Python)
Kurs dla młodzieży w wieku 13–16 lat, która chce rozwijać programowanie tekstowe w jednym z najczęściej wykorzystywanych współczesnych języków programowania.
Python jest stosowany w bardzo wielu obszarach technologii – od tworzenia aplikacji i automatyzacji, przez analizę danych, aż po rozwiązania związane ze sztuczną inteligencją. Na kursie wykorzystujemy go przede wszystkim do rozwijania świadomego i coraz bardziej samodzielnego programowania.
Uczestnicy poznają m.in. zmienne, instrukcje warunkowe, pętle, funkcje, kolekcje danych i sposoby organizowania większych programów. Nowe zagadnienia wykorzystujemy od razu w praktyce – podczas tworzenia programów użytkowych, quizów, prostych gier, narzędzi i kolejnych projektów programistycznych.
Ważnym etapem jest odejście od gotowych przykładów. Z czasem uczestnik coraz częściej otrzymuje problem do rozwiązania zamiast gotowego kodu do przepisania.
Musi zaplanować rozwiązanie, dobrać odpowiednie mechanizmy, napisać program, przetestować go i poradzić sobie z błędami.
Po tym kursie Twoje dziecko:
- będzie samodzielnie tworzyć programy w Pythonie,
- nauczy się wykorzystywać zmienne, warunki, pętle, funkcje i kolekcje danych,
- będzie potrafiło zaplanować strukturę bardziej rozbudowanego programu,
- nauczy się czytać, analizować i debugować własny kod,
- rozwinie umiejętność samodzielnego rozwiązywania problemów,
- zdobędzie solidny fundament do dalszego rozwoju w kierunku programowania, automatyzacji, analizy danych i innych obszarów współczesnej informatyki.
Celem nie jest zapamiętanie Pythona. Celem jest dojście do momentu, w którym uczestnik potrafi sam zaplanować rozwiązanie i zamienić je w działający program.
Program kursu:
Program kursu – Python – od kodu do samodzielnych projektów
Python
Kurs prowadzi uczestników od podstaw składni Pythona do coraz bardziej samodzielnych projektów. Nowe zagadnienia od razu wykorzystujemy w praktyce – w programach użytkowych, grach tekstowych, quizach i zadaniach wymagających samodzielnego rozwiązania problemu.
Nie uczymy Pythona na pamięć. Uczymy rozumieć kod, planować rozwiązanie, testować je i rozwijać własny projekt.
1. Pierwszy program w Pythonie
Poznajemy środowisko pracy, uruchamianie skryptów oraz podstawową składnię języka. Uczestnicy tworzą pierwsze programy wyświetlające informacje i wykonujące proste operacje.
2. Zmienne i typy danych
Uczymy się przechowywać liczby, teksty i inne informacje. Poznajemy sposób wykonywania działań i przetwarzania danych.
Przykładowe projekty: kalkulator, przelicznik, generator komunikatów.
3. Program rozmawia z użytkownikiem
Pobieramy dane z klawiatury i wykorzystujemy je w działaniu programu. Powstają pierwsze interaktywne skrypty.
4. Warunki – program wybiera rozwiązanie
Wprowadzamy instrukcje if/elif/else i tworzymy programy reagujące inaczej w zależności od danych lub decyzji użytkownika.
Przykładowe projekty: quiz, kalkulator rozszerzony, prosty system logowania.
5. Pętle – automatyzacja działań
Poznajemy pętle for i while. Uczestnicy uczą się powtarzać działania, przetwarzać dane i budować programy działające do momentu spełnienia określonego warunku.
Przykładowe projekty: zgadywanie liczby, gra punktowa, powtarzany quiz.
6. Listy, słowniki i kolekcje danych
Uczymy się przechowywać większą liczbę informacji i operować na całych zestawach danych. Poznajemy listy oraz wybrane inne struktury wykorzystywane w Pythonie.
Przykładowe projekty: lista wyników, ranking, baza pytań do quizu.
7. Funkcje – budujemy większy program
Dzielimy projekt na mniejsze części. Uczestnicy poznają argumenty, wartości zwracane i sposoby ponownego wykorzystywania fragmentów kodu.
8. Moduły i biblioteki – korzystamy z gotowych narzędzi
Pokazujemy, że programista nie musi tworzyć wszystkiego od zera. Uczestnicy poznają ideę bibliotek i uczą się korzystać z wybranych modułów Pythona.
Przykładowe projekty: generator losowań, program wykorzystujący czas, datę lub funkcje matematyczne.
9. Pliki i trwałe zapisywanie danych
Uczestnicy uczą się zapisywać informacje do plików i ponownie je odczytywać. Dzięki temu program może pamiętać dane również po zakończeniu działania.
Przykładowe projekty: notatnik, lista zadań, prosty zapis wyników.
10. Gry i projekty tekstowe
Łączymy poznane mechanizmy w większe projekty wykorzystujące warunki, pętle, funkcje, kolekcje i losowość.
Przykładowe projekty: gra przygodowa, quiz z punktacją, rozbudowane zgadywanie liczby.
11. Algorytm i plan przed napisaniem kodu
Przy bardziej złożonych zadaniach uczymy się najpierw zaplanować rozwiązanie, podzielić problem na mniejsze kroki i dopiero później rozpocząć programowanie.
12. Debugowanie i czytanie komunikatów o błędach
Uczestnicy uczą się analizować traceback, sprawdzać wartości zmiennych i szukać przyczyny nieprawidłowego działania programu.
Nie chodzi o to, żeby nie popełniać błędów – chodzi o to, żeby wiedzieć, jak je znaleźć i poprawić.
13. Kod coraz bardziej samodzielny
W kolejnych zadaniach ograniczamy gotowe przykłady. Uczestnik otrzymuje cel i sam musi dobrać odpowiednie konstrukcje, zaplanować rozwiązanie i napisać kod.
14. Własny projekt w Pythonie
Na zakończenie uczestnicy przygotowują bardziej samodzielny projekt: program użytkowy, grę tekstową, narzędzie lub inny projekt dopasowany do poziomu grupy.
W trakcie kursu uczestnicy uczą się m.in.:
- samodzielnie pisać programy w Pythonie,
- korzystać ze zmiennych, warunków, pętli i funkcji,
- pracować z listami, słownikami i innymi kolekcjami,
- korzystać z modułów i bibliotek,
- zapisywać i odczytywać dane z plików,
- planować strukturę większego programu,
- czytać komunikaty o błędach i debugować kod,
- coraz bardziej samodzielnie realizować własne projekty.
Przykładowe projekty realizowane podczas kursu:
kalkulator • quiz • system logowania • zgadywanie liczby • generator losowań •
ranking wyników • notatnik • lista zadań • gra tekstowa • program użytkowy •
własny projekt w Pythonie
Program ma charakter przykładowy. Kolejność projektów, wykorzystywane biblioteki i zakres poszczególnych zagadnień mogą być modyfikowane w zależności od poziomu grupy, tempa pracy uczestników oraz aktualizowanego programu zajęć.
czas trwania zajęć: 90 minut
Cena za zajęcia: 70,00 zł
Zniżki:
– 10% zniżki dla każdego z rodzeństwa, uczęszczającego w tym samym terminie.
– 10% zniżki dla posiadaczy karty „Duża Rodzina”.
– 10% zniżki na drugie i kolejne zajęcia w tym samym czasie.
Zniżki nie łączą się ze sobą.Zajęcia trwają cały rok szkolny i odbywają się raz w tygodniu.
Dlaczego warto wybrać programowanie w Akademii EMT KIDS?
- Technologie, które mają realne zastosowanie
- Pracujemy z narzędziami i językami wykorzystywanymi we współczesnym świecie technologii – od HTML, CSS i JavaScriptu, przez Go, Lua i Pythona, aż po MicroPython i Raspberry Pi Pico. Nie uczymy jednak technologii „dla samej technologii”. Pokazujemy, jak wykorzystać je do tworzenia konkretnych projektów.
- Od podstaw do coraz większej samodzielności
- Wraz z rozwojem umiejętności uczestnicy otrzymują coraz mniej gotowych rozwiązań, a coraz więcej problemów do samodzielnego rozwiązania. Uczą się planować projekt, pisać kod, testować go, analizować błędy i rozwijać własne pomysły.
- Nie przywiązujemy do jednego języka
- Technologie zmieniają się szybko. Dlatego zależy nam przede wszystkim na rozwijaniu logicznego myślenia, rozwiązywania problemów, pracy z dokumentacją i umiejętności odnajdywania się w nowych narzędziach. To kompetencje, które pozostają wartościowe niezależnie od tego, jaki język będzie popularny za kilka lat.
- Technologia + doświadczenie edukacyjne
- Za Akademią EMT KIDS stoją EMT-Systems oraz Akademia Nauki i Rozwoju. Łączymy technologiczne zaplecze i doświadczenie w szkoleniach technicznych z wieloletnią praktyką w edukacji dzieci i młodzieży.
- Autorskie programy, które cały czas rozwijamy
- Nasze programy zajęć powstały na bazie wieloletniego doświadczenia i są regularnie aktualizowane. Modyfikujemy projekty, technologie i sposób pracy tak, aby odpowiadały zmieniającemu się światu technologii oraz potrzebom młodych uczestników.
Proste zasady dla rodziców
Najpierw zajęcia próbne, potem decyzja
Nie trzeba podpisywać umowy przed pierwszym spotkaniem. Uczestnik może najpierw sprawdzić, czy odpowiada mu kurs, grupa i sposób prowadzenia zajęć. Jeśli nie chce kontynuować – nie pobieramy opłaty za pierwsze zajęcia. Jeśli zostaje, pierwsze spotkanie wliczamy do harmonogramu płatności.
Bez zobowiązania na cały rok szkolny
Umowę można wypowiedzieć w dowolnym momencie ze skutkiem na koniec danego miesiąca. Nie naliczamy kar ani dodatkowych opłat za wcześniejszą rezygnację.
Płacisz za zajęcia, które faktycznie się odbywają
Miesięczna opłata zależy od liczby zajęć przypadających w danym miesiącu. Nie płacisz za święta, ferie, wakacje ani inne dni, w których zgodnie z harmonogramem zajęcia się nie odbywają.
10% zniżki
Oferujemy 10% zniżki dla rodzeństwa, posiadaczy Karty Dużej Rodziny oraz na drugie i kolejne zajęcia.