Przejdź transformację
od „ZERA” do komercyjnego programowania
w Java

Na start będziesz potrzebować bardzo mało programistycznej wiedzy.
Nie musisz znać nawet Javy!

Wg danych Eurostatu z 2020 r. deficyt programistów w polskich firmach to około 50 tysięcy, w Europie około 300 tysięcy i dalej rośnie!

Spełnij marzenia o wysokich zarobkach, pracy zdalnej i zapewnij sobie stabilną pozycję na rynku pracy na dekady!

Dlaczego warto wejść do IT?
Po co w ogóle uczyć się programowania?
Po co zmieniać branżę?

Powodów jest wiele – poniżej tylko kilka z nich:


Czym jest KierunekJava?

KierunekJava to nowatorski program edukacyjny, dzięki któremu przejdziesz transformację od zera do komercyjnego programowania w Java.

KierunekJava składa się z dwóch programów:
Java Od Podstaw + Efektywne Aplikacje Internetowe

Całość kompleksowo przygotowuje Cię do podjęcia pracy jako Junior Java Developer.
0
Programy
0
Moduły
0
Lekcji

Dlaczego warto dołączyć do KierunekJava?

Dzięki programowi Java Od Podstaw:

Dzięki programowi Efektywne Aplikacje Internetowe

W ramach KierunekJava otrzymasz:

Program edukacyjny – KierunekJava
  • 12-tygodniowy program (ponad 120 lekcji!) Java Od Podstaw1690 zł
  • 12-tygodniowy program (ponad 120 lekcji!) Efektywne Aplikacje Internetowe2498 zł
  • Dodatkowe prace domowe – sprawdzane automatyczne i przez mentora – 499 zł
  • Min. 3 spotkania live z mentorem3 x 199 zł
+ BONUSOWE MATERIAŁY:
  • BONUS Gotowy kod aplikacji
  • BONUS Materiały do powtórek
  • BONUS Zadania do samodzielnej realizacji – z automatyczną weryfikacją wyników
  • BONUS Licencja na Intellij Idea 6 miesięcy 100 $ = 400 zł
  • BONUS Wstęp na wszystkie przyszłe spotkania live! 199 zł x N
  • BONUS Dożywotni dostęp do aktualizacji programu 299 zł/ rok
  • BONUS Dożywotni dostęp do wszystkich nagrań webinarów 299 zł
  • BONUS eBook „CV Programisty” 99 zł
+ DODATKOWO:
  • BONUS Dostęp do społeczności kursantów BEZCENNY
  • BONUS Projekt grupowy – pomoc w doborze grup i rozpoczęciu wspólnego projektu BEZCENNY

Program przygotowany przez praktyka
– kim jest Twój trener?

Tomek Woliński

  • Absolwent informatyki na Politechnice Gdańskiej.
  • 13+ lat doświadczenia komercyjnego w IT
  • Senior Backend Developer
  • 4+ lat doświadczenia jako trener programowania
  • Doświadczenie w procesach rekrutacyjnych
    (po obu stronach stołu)
  • 2 dzieci (praktyczne doświadczenie w edukacji zdalnej) 🙃
  • Bloger
  • Podcaster

Dlaczego warto mi zaufać?
Opinie moich Klientów i współpracowników

Opinie uczestników programu
– sprawdź, co mówią osoby, które dołączyły
do programu

Zastanawiasz się czy ten program jest dla Ciebie?

KierunekJava jest dla Ciebie jeśli:

KierunekJava NIE jest dla Ciebie jeśli:


Jeśli mógłbyś dostać pracę jako
Junior Java Developer,
to ile byłoby to dla Ciebie warte?


Niektórzy uczestnicy programu już
osiągnęli sukces – zdobyli pierwszą pracę w IT!
Ty też możesz!

Czym różni się KierunekJava od większości kursów?

Większość kursów

Nowy program edukacyjny – KierunekJava

Poznaj wspaniałą społeczność KierunekJava!
Podczas całego procesu możesz liczyć na wsparcie w nauce, współpracę oraz ogrom motywacji!

CO ZAWIERA KIERUNEK JAVA?
Java Od Podstaw + Efektywne Aplikacje Internetowe


AGENDA JOP
JAVA OD PODSTAW
  • Lekcja 1: Intro (0:55)
  • Lekcja 2: Plan gry (6:20)
  • Lekcja 3: Wprowadzenie do programu – jak będziemy pracować? (5:08)
  • Lekcja 4: Twój pierwszy program – aplikacja 'Hello World’ (5:21)
  • Lekcja 5: Kto jest Twoim instruktorem? (9:00)
  • Lekcja 6: Praca domowa (4:24)
  • Dodatek: Discord – jak korzystać? (1:39)
  • Lekcja 1: Wstęp (2:27)
  • Lekcja 2: Co to jest Java, JDK i JRE? (7:57)
  • Lekcja 3: Instalacja Java (10:22)
  • Lekcja 4: Cykl życia aplikacji: kompilacja oraz uruchomienie (5:58)
  • Lekcja 5: Zintegrowane środowisko programistyczne (ang. IDE) (11:29)
  • Lekcja 6: Struktura przykładów i jak z nich korzystać (8:45)
  • Lekcja 7: Podsumowanie (3:07)
  • Lekcja 8: Praca domowa (2:46)
  • Dodatek: IntelliJ IDEA (2:15)
  • Lekcja 1: Wstęp (3:51)
  • Lekcja 2: Zmienne (10:49)
  • Lekcja 3: Stałe (2:26)
  • Lekcja 4: Typy proste (4:56)
  • Lekcja 5: Zakres zmiennych (8:46)
  • Lekcja 6: Konwersje typów prostych w Javie (12:12)
  • Lekcja 7: String (6:49)
  • Lekcja 8: Operacje na stringach (7:08)
  • Lekcja 9: Podsumowanie (3:17)
  • Lekcja 10: Praca domowa (2:49)
  • Lekcja 1: Wstęp (3:37)
  • Lekcja 2: Metody (9:16)
  • Lekcja 3: Metoda main (2:32)
  • Lekcja 4: Operatory arytmetyczne (7:50)
  • Lekcja 5: Operatory relacyjne (2:06)
  • Lekcja 6: Operatory logiczne (5:45)
  • Lekcja 7: Operatory przypisania (2:24)
  • Lekcja 8: Pierwszeństwo operatorów (3:45)
  • Lekcja 9: Porównywanie stringów oraz inne podstawowe operacje (6:27)
  • Lekcja 10: Podsumowanie (4:07)
  • Lekcja 11: Praca domowa (3:03)
  • Lekcja 1: Wstęp (5:06)
  • Lekcja 2: Bloki kodu (4:53)
  • Lekcja 3: Instrukcje warunkowe (8:58)
  • Lekcja 4: Switch (8:13)
  • Lekcja 5: Pętle (10:17)
  • Lekcja 6: Niestandardowe przebiegi pętli (5:40)
  • Lekcja 7: Podsumowanie (4:29)
  • Lekcja 8: Praca domowa (2:46)
  • Lekcja 1: Wstęp (5:20)
  • Lekcja 2: Komentarze i samodokumentujący się kod (12:04)
  • Lekcja 3: Clean code (11:11)
  • Lekcja 4: Debugowanie (11:11)
  • Lekcja 5: Testowanie (15:01)
  • Lekcja 6: Testy jednostkowe Java (10:23)
  • Lekcja 7: Git – pierwsze kroki (10:37)
  • Lekcja 8: Git – podstawowe operacje (12:16)
  • Lekcja 9: Git – praca ze zdalnym repozytorium na przykładzie GitHub (8:20)
  • Lekcja 10: Code review (10:46)
  • Lekcja 11: Code review – przykładowy pull request na GitHub (8:18)
  • Lekcja 12: Maven (10:26)
  • Lekcja 13: Podsumowanie (3:33)
  • Lekcja 14: Praca domowa (2:48)
  • Lekcja 1: Wstęp (5:16)
  • Lekcja 2: Co to jest OOP? (8:39)
  • Lekcja 3: Klasy i obiekty (7:23)
  • Lekcja 4: Referencja i zmienna referencyjna (11:33)
  • Lekcja 5: Przekazywanie parametrów przez wartość (5:38)
  • Lekcja 6: Konstruktory, tworzenie obiektów (13:00)
  • Lekcja 7: Dziedziczenie (9:34)
  • Lekcja 8: Klasa Object (7:23)
  • Lekcja 9: Kontekst statyczny (5:15)
  • Lekcja 10: Wrappery, czyli klasy opakowujące typy proste (6:54)
  • Lekcja 11: Podsumowanie (5:13)
  • Lekcja 12: Praca domowa (3:40)
  • Lekcja 1: Wstęp (5:25)
  • Lekcja 2: Struktury danych (6:58)
  • Lekcja 3: Tablice (14:39)
  • Lekcja 4: Podstawowe operacje na tablicach (6:56)
  • Lekcja 5: Listy (12:54)
  • Lekcja 6: LIFO i FIFO (7:08)
  • Lekcja 7: Zbiory (4:44)
  • Lekcja 8: Mapy (3:11)
  • Lekcja 9: Enum (9:36)
  • Lekcja 10: Typy generyczne (13:08)
  • Lekcja 11: HashCode i equals (19:06)
  • Lekcja 12: Podsumowanie (7:53)
  • Lekcja 13: Praca domowa (3:40)
  • Lekcja 1: Wstęp (6:36)
  • Lekcja 2: Klasy oraz metody abstrakcyjne (7:08)
  • Lekcja 3: Interfejsy (10:43)
  • Lekcja 4: Polimorfizm (11:07)
  • Lekcja 5: Pakiety (12:17)
  • Lekcja 6: Enkapsulacja, hermetyzacja (9:39)
  • Lekcja 7: Modyfikatory dostępu (7:53)
  • Lekcja 8: Wielkie liczby (9:17)
  • Lekcja 9: String oraz StringBuffer i StringBuilder (6:44)
  • Lekcja 10: Pula stringów (4:23)
  • Lekcja 11: Podsumowanie (6:40)
  • Lekcja 12: Praca domowa (3:15)
  • Lekcja 1: Wstęp (3:45)
  • Lekcja 2: Sytuacje wyjątkowe, happy path oraz warunki brzegowe (13:02)
  • Lekcja 3: Logowanie komunikatów (8:22)
  • Lekcja 4: Wyjątki (5:47)
  • Lekcja 5: Zgłaszanie oraz obsługa wyjątków (8:29)
  • Lekcja 6: Hierarchia wyjątków (8:48)
  • Lekcja 7: Automatyczne sprzątanie i zamykanie zasobów (9:28)
  • Lekcja 8: Optional (4:02)
  • Lekcja 9: Pobranie danych od użytkownika oraz ich walidacja (8:04)
  • Lekcja 10: Podsumowanie (4:50)
  • Lekcja 11: Praca domowa (3:14)
  • Lekcja 1: Wstęp (2:18)
  • Lekcja 2: Wymagania projektowe oraz projektowanie aplikacji obiektowej (11:33)
  • Lekcja 3: Struktura klas oraz pseudocode (13:45)
  • Lekcja 4: Główna pętla programu oraz komunikacja z użytkownikiem (14:27)
  • Lekcja 5: Testy aplikacji i TDD (13:42)
  • Lekcja 6: Implementacja obsługi komend (13:46)
  • Lekcja 7: Komunikacja z systemem plików oraz utrwalenie danych (15:31)
  • Lekcja 8: Serializacja obiektów (7:44)
  • Lekcja 9: Refaktoryzacja kodu (19:49)
  • Lekcja 10: Logi, obsługa wyjątków oraz walidacja danych (21:59)
  • Lekcja 11: Dalszy rozwój aplikacji (4:16)
  • Lekcja 12: Podsumowanie (2:56)
  • Lekcja 13: Praca domowa (2:11)
  • Lekcja 1: Gratulacje i podziękowanie (3:16)
  • Lekcja 2: Co dalej (2:34)
  • Lekcja 3: Prośba o informację zwrotną (2:18)
  • Lekcja 4: Klub pierwsza aplikacja (0:49)
  • Lekcja 5: KierunekProgramista (1:34)

AGENDA EAI
EFEKTYWNE APLIKACJE INTERNETOWE
  • Lekcja 1: Intro
  • Lekcja 2: Plan gry
  • Lekcja 3: Wprowadzenie do programu – jak będziemy pracować?
  • Lekcja 4: Praca domowa
  • Lekcja 1: Praca z zadaniem (6:28)
  • Lekcja 2: Ogarniamy chaos – lista TODO i priorytety (14:11)
  • Lekcja 3: Cykl życia oprogramowania i śledzenie błędów (10:31)
  • Lekcja 4: System kontroli wersji, czyli śledzenie zmian w kodzie źródłowym – Git (15:17)
  • Lekcja 5: Git podstawowe operacje (13:53)
  • Lekcja 6: Git praca ze zdalnym repozytorium na przykładzie github.com (8:28)
  • Lekcja 7: Git zaawansowane mechanizmy, git flow (25:54)
  • Lekcja 8: Proces code review (14:58)
  • Lekcja 9: Repozytorium EAI
  • Lekcja 10: Projekt EAI w Asana (3:19)
  • Lekcja 11: Praca domowa (3:59)
  • Bonus: Obsługa Asana (8:13)
  • Bonus: Przyspieszony kurs szukania w Google (14:08)
  • Quiz
  • Lekcja 1: Praca z projektem (3:11)
  • Lekcja 2: Zbieranie i analiza wymagań – jak zrozumieć biznes? (9:37)
  • Lekcja 3: Event Storming – główne założenia (18:15)
  • Lekcja 4: Nasza pierwsza sesja event storming (24:12)
  • Lekcja 5: Prototypowanie aplikacji (9:16)
  • Lekcja 6: MVP (3:26)
  • Lekcja 7: Dokumentacja, markdown (9:09)
  • Lekcja 8: Proces podejmowania decyzji technologicznych (12:27)
  • Lekcja 9: Budowanie projektu i obsługa zależności Maven (10:23)
  • Lekcja 10: Praca domowa (2:13)
  • Bonus 1: Budowanie projektu i obsługa zależności Gradle
  • Bonus 2: Praca projektowa w grupie, narzędzia do pracy zdalnej
  • Bonus 3: Clean code
  • Bonus 4: Statyczna analiza kodu
  • Bonus 5: Team matching
  • Lekcja 1: Czym jest i jak działa Spring Framework oraz Spring Boot (8:42)
  • Lekcja 2: Pierwsza aplikacja Spring Boot (12:15)
  • Lekcja 3: Spring Container i Application Context (6:08)
  • Lekcja 4: Bean (13:56)
  • Lekcja 5: IoC (Inversion of Control), DI (Dependency injection) (19:05)
  • Lekcja 6: Stereotypy beanów – stereotype (6:06)
  • Lekcja 7: Zakresy beanów – scope (7:55)
  • Lekcja 8: Zarządzanie konfiguracją (14:09)
  • Lekcja 9: Zaawansowane mechanizmy zależności (7:04)
  • Lekcja 10: Błędy początkujących (5:21)
  • Lekcja 11: Projekt i struktura Twojej aplikacji Spring (16:06)
  • Lekcja 12: Praca domowa (2:59)
  • Bonus 1: Spring Boot Dev Tools
  • Bonus 2: Java adnotacje
  • Bonus 3: Spring i XML
  • Bonus 4: Sterters
  • Lekcja 1: Protokół HTTP – żądanie i odpowiedź (24:41)
  • Lekcja 2: Protokół HTTP – nagłówki i statusy (8:54)
  • Lekcja 3: API REST, Spring Web MVC – pierwszy endpoint (12:23)
  • Lekcja 4: Mapowanie requestów i przekazywanie parametrów (14:29)
  • Lekcja 5: Mapowanie żądań oraz odpowiedzi (15:17)
  • Lekcja 6: Typy zawartości oraz negocjowanie zawartości (15:11)
  • Lekcja 7: Wyjątki i obsługa błędów (14:47)
  • Lekcja 8: Obsługa ciasteczek (12:33)
  • Lekcja 9: Błędy początkujących i potencjalne problemy (6:31)
  • Lekcja 10: Projekt i struktura Twojej aplikacji Spring (29:57)
  • Lekcja 11: Praca domowa (2:01)
  • Lekcja 1: Backend vs Frontend
  • Lekcja 2: Statyczne pliki oraz podstawy HTML i CSS
  • Lekcja 3: Wykorzystanie JavaScript
    do komunikacji z backendem
  • Lekcja 4: Architektura trójwarstwowa oraz różne silniki widoków
  • Lekcja 5: Thymeleaf
  • Lekcja 6: Rozwiązywanie widoków
  • Lekcja 7: Formularze i linki
  • Lekcja 8: Web aware scopes
  • Lekcja 9: Bootstrap
  • Lekcja 10: Thymeleaf – szablony
  • Lekcja 11: Projekt oraz implementacja aplikacji użytkownika
  • Lekcja 12: Projekt oraz implementacja aplikacji użytkownika – szablon i struktura projektu
  • Lekcja 13: Projekt oraz implementacja aplikacji użytkownika – obsługa kategorii
  • Lekcja 14: Projekt oraz implementacja aplikacji administratora
  • Lekcja 15: Projekt oraz implementacja aplikacji administratora – obsługa kategorii
  • Lekcja 16: Błędy początkujących i problemy
  • Lekcja 17: Praca domowa
  • Lekcja 1: Gratulacje i podziękowanie
  • Lekcja 2: Co dalej
  • Lekcja 3: Prośba o informację zwrotną
  • Lekcja 4: Klub pierwsza aplikacja
  • Lekcja 5: KierunekProgramista

Jak program wygląda od środka?

1. Lekcje w formie nagrań wideo

Każdy z modułów składa się z kilku(nastu) lekcji w formie nagrań wideo.
Zobacz, jak wygląda jedna z nich:

Poniżej znajdziesz kilka przykładowych lekcji z różnych modułów KierunekJava:

Java Od Podstaw

Efektywne Aplikacje Internetowe

2. Zadania i prace domowe

Każda z tematycznych lekcji – poza wyjaśnieniem samego zagadnienia na przykładach zawiera zadania do samodzielnego rozwiązania. Zadania są przygotowane w ten sposób, że po ich rozwiązaniu dostajesz automatycznie odpowiedź, czy wszystko jest OK.

Tego typu przykłady są też świetną referencją na przyszłość i można je wykorzystać do powtórek materiału.

Chcesz np. przypomnieć sobie, co można zrobić z interfejsami? => to otwierasz plik poświęcony interfejsom i wręcz kopiujesz fragment kodu do swojej aplikacji.

3. Checklisty

Kolejnym, miłym dodatkiem są różnego rodzaju checklisty – tak, by jeszcze łatwiej można było się zorientować, co już masz za sobą, a czego jeszcze warto się douczyć 🙂

Po co dołączać do programu skoro w internecie jest mnóstwo materiałów i mogę nauczyć się sam?

Jasne, że możesz! Tylko czy na pewno warto?

KierunekJava

Samodzielna nauka


Program KierunekJava

To najlepsza inwestycja, jaką możesz podjąć w kierunku wejścia do branży IT i zdobycia pierwszej pracy jako Junior Java Developer.

FAQ

Najczęściej zadawane pytania

Tak, nie musisz od razu kupować całego programu KierunekJava za 1497 PLN, możesz zacząć od Java Od Podstaw za 597 PLN brutto, a później skorzystać ze specjalnej oferty na Efektywne Aplikacje Internetowe.

Tak, nie musisz od razu płacić całej kwoty – możesz skorzystać z rat, wybierając metodę płatności TPay Raty.

Tak, na wszystkie produkty wystawiam fakturę VAT 23%. Ten zakup możesz „wrzucić w koszty” odliczając w ten sposób podatki.

Masz gwarancję 100% satysfakcji – pokochaj program lub zwracam Ci pieniądze. Masz na to 30 dni. 🙂

Tak. Kurs skierowany jest przede wszystkim do osób, które chcą nauczyć się programować i znaleźć pierwszą pracę w IT.

Na naukę nigdy nie jest za późno. Znam osoby, które zdecydowały się zmienić pracę mając już pokaźne doświadczenie w innej branży, a teraz są specjalistami IT. Tutaj nie ma reguły – zazwyczaj im później podejmiesz decyzję tym trudniej, jednak wszystko zależy od Twojego samozaparcia.

Wszystkie materiały są przygotowane po polsku. Może się jednak zdarzyć, że będę odsyłał do dodatkowych treści w języku angielskim. Jeśli jednak nie znasz angielskiego – nie przejmuj się! Zawsze możesz poprosić o pomoc na grupie. Dodatkowo na platformie discord mamy dedykowany chat, który pomaga w nauce tego języka 🙂

Spokojnie. Nie stracisz dostępu do materiałów. Wrócisz do kursu po powrocie. Materiały są dostępne cały czas, to Ty decydujesz, kiedy chcesz z nich korzystać.

Gwarancja 100% satysfakcji!

Pokochaj materiał lub zwracam Ci pieniądze!

Program został przygotowany tak, by spełniać oczekiwania najbardziej wymagających użytkowników. Rozumiem jednak, że możesz mieć wątpliwości, dlatego wprowadziłem gwarancję satysfakcji.

Masz 30 dni od daty zakupu, na zmianę decyzji.

Jeżeli z jakichś powodów uznasz, że nie jest on dla Ciebie odpowiedni, wystarczy, że napiszesz do mnie wiadomość na adres kontakt@stormit.pl i zwrócę Ci 100% Twojej wpłaty
gwarancja