
Naucz się C na poziomie seniora!
Poznaj dobre praktyki i używaj odpowiednich narzędzi!
Sprawniej realizuj projekty i zarabiaj więcej!
Czy zdarzyło Ci się:
To normalny etap w programistycznym rozwoju.
Masz już solidne podstawy i trochę praktyki jako programista C.
Teraz musisz zrobić kolejny krok!
Co jeśli zignorujesz problemy?
Co jeśli zignorujesz te problemy ?
Chcesz wejść na wyższy poziom?
JESTEŚ W DOBRYM MIEJSCU!
Znam Twoje problemy, sam się z nimi mierzyłem i wiem jak je rozwiązać.
Dlatego właśnie stworzyłem kurs online:
„C dla Zaawansowanych”
MODUŁÓW
Godzin lekcji wideo
GodzinY MATERIAŁÓW BONUSOWYCH
Oparte na 10 latach doświadczeń w branży embedded!
Nie znajdziesz drugiego kursu o podobnej tematyce,
tym bardziej w języku POLSKIM!

Po ukończeniu kursu:
Po prostu będziesz osobą, którą każdy chce mieć w swoim projekcie!
Twój prowadzący:
Nazywam się Maciek Gajdzica i jestem programistą embedded od 2012 roku. Przez ten czas poznałem na własnej skórze skutki zbyt sprytnego kodu, czy nadmiernego uzależnienia od narzędzi, których działania do końca nie rozumiałem.
Nauczyłem się wspomagać różnymi narzędziami i technikami zmniejszającymi ilość błędów, czy automatyzującymi żmudne czynności. Miałem również trudności ze znalezieniem materiałów do nauki na bardziej zaawansowanym poziomie.
Dlatego teraz sam takie materiały tworzę i dzięki temu Ty nie musisz popełniać moich błędów.
W ciągu ostatnich kilku lat powstało:
- Około 200 artykułów na blogu ucgosu.pl
- Ponad 40 live’ów na moim kanale YouTube
- Kursy online „TDD w systemach embedded”, „Linker w embedded”, „Linker w embedded”, „Git w embedded”,

Co znajdziesz w kursie?
A co będę samemu pisać, oddajmy głos uczestnikom poprzednich edycji 🙂
Zakamarki składni

„Dużo wartościowej wiedzy, dla osób które już programują w C od jakiegoś czasu, a nie w kółko same podstawy, jak pisać pętle i ify.”
Kacper Brzostowski, Uczestnik III edycji kursu
„Podobało mi się spojrzenie na pozornie proste tematy z innej strony i drążenie tematu”
Mateusz , Uczestnik II edycji kursu
„Nawet jeżeli myślisz, że dany problem znasz to odnajdując to zagadnienie w kursie może się okazać, że jednak coś się się jeszcze dowiesz”
Uczestnik IV edycji kursu
Dobre praktyki i antywzorce

„Kurs porusza trudne tematy, a właściwie pozwala uniknąć wielu pułapek i wiele uświadamia. Można doczytać wiele informacji w materiałach dodatkowych.”
Łukasz Majewski, Uczestnik IV edycji kursu
Gdy już zna się podstawy języka C, kurs pomoże nabrać głębszego zrozumienia składni języka oraz poznać działanie kompilatora. Najbardziej podobało mi się zwrócenie uwagi na to jak prawidłowo programować i z jakich części języka lepiej nie korzystać.
Polecam go osobom, które chcą lepiej zrozumieć działanie języka i poznać prawidłowe metody pisania kodu.
Adrian Dobosz, Uczestnik III edycji kursu
Analiza asemblerowa

„Najbardziej podobały mi się przykłady pokazywane w kompilatorze online.
Nie spodziewałem się jaki wpływ niektóre sprawy mają na program wynikowy.”
Sławek Holojda, Uczestnik III edycji kursu
„Najbardziej podobało mi się omawianie przykładów w kompilatorze online, smaczki
dotyczące preprocesora i liczne odnośniki do materiałów rozszerzających wiedzę”
Uczestnik III edycji kursu
„Polecam ten kurs, ponieważ duża ilość zawartej wiedzy wynika z doświadczenia
prowadzącego i podparta jest kodem oraz analizą asemblerową.”
Paweł Leśniowski, Uczestnik II edycji kursu
Konfiguracja projektu

„Rozdział o kompilacji i linkowaniu był najlepszy ze wszystkich”
Teodor Rosołowski, Uczestnik III edycji kursu
„Ostatnio używałem nieświadomie liczb double i nie wiedziałem co pochłania mi >50% CPU (robiłem DSP). U Ciebie na kursie dowiedziałem się o tym by zmienić na floaty.
Zużycie czasu CPU spadło do około 10%. Dobrze wiedzieć. Po co tyrać CPU jeśli można nie.”
Uczestnik kursu
Projektowanie aplikacji

„Najlepsze były lekcje o „Interfejsach” oraz „Jak odciąć się od cudzego bałaganu”.
Uczestnik kursu
„W kursie znalazłem przekrój wiedzy o C i technikach programowania embedded, obalanie mitów z dawnej nauki i zwrócenie uwagi na babole w kodzie, które potem pokutowały. Najbardziej podobały mi się lekcje o wykorzystaniu mapperów, interfejsów i struktur. Właściwie każda lekcja zawierała coś co mnie zaskakiwało”
Mateusz , Uczestnik II edycji kursu
Narzędzia i techniki

„Gorąco polecam osobom, które od jakiegoś czasu programują w C, ale czują, że im brakuje wiedzy odnośnie ogólnego zarysu i spojrzenia na projekt oraz chciałyby poznać przydatne narzędzia stosowane przy programowaniu w C. Każda osoba pracująca w embedded znajdzie wartościowe rzeczy w kursie.”
Piotr Czaplicki, Uczestnik II edycji kursu
Agenda

1.1 Intro [1:10]
1.2 Dla kogo jest ten kurs? [4:01]
1.3 Czy warto uczyć się C [3:52]
1.4 Typowe błędy podczas nauki [5:57]
1.5 Efekt końcowy [2:15]
1.6 Jak studiować ten kurs? [5:33]
1.7 Plan działania [3:58]
1.8 Twój instruktor [1:17]
1.9 Praca domowa [1:09]

2.1 Intro [0:42]
2.2 Liczby całkowite [18:20]
2.3 Liczby zmiennoprzecinkowe [27:23]
2.4 Typ logiczny – Bool [11:06]
2.5 Typ znakowy – Char [6:52]
2.6 Typ wyliczeniowy – Enum [11:29]
2.7 Jaki typ zmiennej wybrać? – Część 1 [21:37]
2.8 Jaki typ zmiennej wybrać? – Część 2 [17:26]
2.9 Stałe liczbowe [18:29]
2.10 Inicjalizacja zmiennych [8:43]
2.11 Praca domowa [0:58]
2.B1 Bonus – Tutorial Godbolta [2:38]
2.B2 Bonus – Systemy liczbowe [8:18]
2.B3 Bonus – Systemy zapisu liczb ujemnych [9:35]
2.B4 Bonus – Typy z biblioteki
standardowej [7:54]

3.1 Intro [0:41]
3.2 Struktury [16:54]
3.3 Pola bitowe [12:10]
3.4 Pola bitowe vs Maski bitowe [6:44]
3.5 Unie [9:42]
3.6 Inicjalizacja struktur, unii i pól bitowych [8:18]
3.7 Wskaźniki – Podstawy [14:51]
3.8 Wskaźniki – Rozszerzenie [13:33]
3.9 Wskaźniki – Typowe błędy [14:01]
3.10 Arytmetyka wskaźników [7:12]
3.11 Tablice [9:17]
3.12 Tablice jako argumenty
funkcji [5:43]
3.13 Stringi w C [13:20]
3.14 Inicjalizacja tablic [5:04]
3.15 Wskaźniki vs Tablice [7:49]
3.16 Praca domowa [2:35]
3.B1 Bonus – Wyrównanie pamięci [16:16]

4.1 Intro [0:41]
4.2 If – Else [14:20]
4.3 Operator warunkowy (? 🙂 [4:07]
4.4 Switch – Case [12:51]
4.5 Pętle [15:07]
4.6 Goto considered harmful? [9:22]
4.7 Funkcje [24:31]
4.8 Wskaźniki na funkcje [8:38]
4.9 Callbacki i interfejsy [12:01]
4.10 Mappery [13:43]
4.11 Funkcje inline [12:01]
4.12 Typedef [13:40]
4.13 Praca domowa [1:26]

5.1 Intro [0:36]
5.2 Jak działa preprocesor? [9:30]
5.3 Dyrektywa include [18:04]
5.4 Dyrektywa define – Stałe [16:31]
5.5 Dyrektywa define – Macra [14:26]
5.6 Kompilacja warunkowa [26:29]
5.7 Predefiniowane symbole [11:54]
5.8 Dyrektywy pragma, error i
warning [11:39]
5.9 Operacje na tekście [12:58]
5.10 Praca domowa [0:49]

6.1 Intro [1:34]
6.2 Operatory i ich kolejność [14:22]
6.3 Rzutowanie jawne i niejawne [18:08]
6.4 Modyfikator Const [12:49]
6.5 Modyfikator Volatile [16:58]
6.6 Modyfikator Restrict [3:49]
6.7 Widoczność symboli [13:05]
6.8 Czas życia symboli [12:14]
6.9 Static i Extern [8:08]
6.10 Łączenie modyfikatorów [16:12]
6.11 Stos [17:41]
6.12 Dynamiczna alokacja
pamięci [12:17]
6.13 Undefined behavior [9:33]
6.14 Praca domowa [1:38]

7.1 Intro [1:57]
7.2 dlaczego czytelność kodu jest ważna? [18:41]
7.3 Jak pisać czysty kod? [7:31]
7.4 Poziomy czytelności kodu [7:49]
7.5 Jak wybierać nazwy? [25:41]
7.6 Czytelność każdej linijki kodu [22:23]
7.7 Jak pisać dobre funkcje? [20:38]
7.8 Komentarze [15:29]
7.9 Dokumentacja w kodzie [7:56]
7.10 Formatowanie kodu [10:25]
7.11 Obsługa błędów [23:44]
7.12 Zasady w projekcie [6:26]
7.13 Praca domowa [1:17]

8.1 Intro [1:57]
8.2 Co się dzieje podczas
kompilacji? [15:12]
8.3 Pliki tworzone podczas
kompilacji [16:11]
8.4 Flagi kompilacji [19:26]
8.5 Skrypty linkera [23:45]
8.6 Co się dzieje przed funkcją
main? [10:42]
8.7 Rozszerzenia kompilatora
8.8 Standardy C [14:26]
8.9 Biblioteki prekompilowane [11:40]
8.10 Kompilacja inkrementalna [12:20]
8.11 Skrypty makefile [8:38]
8.12 Jak skracać czas kompilacji? [23:37]
8.13 Co znajdziemy w naszym
toolchainie? [6:53]
8.14 Praca domowa [1:27]

9.1 Intro [0:44]
9.2 Biblioteka standardowa C [5:31]
9.3 Biblioteka stdlib.h [11:15]
9.4 Biblioteka stdio.h [13:52]
9.5 Biblioteka string.h [9:01]
9.6 Inne przydatne headery [10:09]
9.7 Syscalls – interfejs między
biblioteką C a systemem [11:02]
9.8 Jak działa procesor? [18:47]
9.9 Podstawy asemblera [17:07]
9.10 Łączenie asemblera z C [15:47]
9.11 Łączenie C z C++ [15:17]
9.12 Praca domowa [1:15]

10.1 Intro [0:51]
10.2 Mity o optymalizacji [17:15]
10.3 Optymalizacja vs dobra praktyka
[17:03]
10.4 Jak mierzyć wydajność [26:03]
10.5 Kiedy optymalizować? [10:29]
10.6 Wrogowie wydajności – złożoność
obliczeniowa [14:35]
10.7 Wrogowie wydajności
oczekiwanie na zasoby [20:52]
10.8 Kiedy wiemy więcej niż kompilator [13:49]
10.9 Mikrooptymalizacje [15:08]
10.10 Optymalizacja z wykorzystaniem
tablic [20:17]
10.11 Praca domowa [1:08]

11.1 Intro [1:27]
11.2 Wizualizacja projektu całego
systemu [20:51]
11.3 Podział na warstwy [19:58]
11.4 Elementy aplikacji – logika,
scenariusze, infrastruktura [10:43]
11.5 Interfejsy [17:03]
11.6 Jak odcinać się od cudzego
bałaganu? [20:30]
11.7 Zależności [11:54]
11.8 Wzorce projektowe [18:23]
11.9 Na jakiej części systemu
najbardziej się skupić? [15:18]
11.10 Architektura a testy [11:59]
11.11 Czytelność projektu [13:54]
11.12 Ewolucja architektury [18:22]
11.13 Praca domowa [1:28]

12.1 Intro [0:52]
12.2 System kontroli wersji [14:47]
12.3 Continuous Integration [12:38]
12.4 Test Driven Development [29:02]
12.5 Code Review [17:46]
12.6 Dokumentacja [20:27]
12.7 Narzędzia do analizy kodu [16:22]
12.8 W czym pisać kod? [18:44]
12.9 Debugowanie [19:58]
12.10 Jak wprowadzać usprawnienia
[10:42]
12.11 Praca domowa [1:41]

13.1 Intro [0:25]
13.2 Co dalej? – Inne języki
programowania [2:57]
13.3 Co dalej? – Hardware [2:38]
13.4 Co dalej? – Test Driven
Development [1:27]
13.5 Co dalej? – Projektowanie i
Architektura Systemów [1:46]
13.6 Co dalej? – Metody Prowadzenia
Projektów [4:40]
13.7 Co dalej? – Dzielenie się wiedzą
[2:23]
13.8 Praca domowa [1:38]

1. Refactoring [1:39:39]
2. Konfiguracja cmake [1:36:58]
3. TDD – konfiguracja projektu [1:16:37]
4. Debugowanie z użyciem konsoli
[1:41:35]
5. Architektura Embedded [1:58:13]
6. Programowanie według norm [1:28:56]
7. Strategie include’owania modułów
[1:16:05]
8. Kroki kompilacji, generowane pliki,
sposoby kontrolowania [1:32:51]
Co otrzymasz dołączając do kursu?
Ale ile to wszystko kosztuje?
Cena kursu to:
1999 zł
Ale do środy 26 sierpnia do godziny 21:00 możesz dołączyć za:
1499 zł (1219 zł netto)
Najniższa cena w ostatnich 30 dniach: 1999zł
Po tym czasie kończy się promocja i wracamy do regularnych cen.
Kolejna promocja dopiero za kilka miesięcy, ale cena nigdy nie będzie niższa niż teraz.
Kurs od środka
Obejrzyj przykładowe lekcje:
Zobacz jak wygląda platforma kursowa:
Dostęp do platformy i wszystkich materiałów otrzymasz NATYCHMIAST po zakupie!
Dostęp do kursu nie ma ograniczeń czasowych!
Otrzymasz również bonusy!
Nagrania z Live Q&A
To źródło wielu dodatkowych informacji podpartych praktyką, których nie znajdziesz nigdzie indziej!
Grupa dla kursantów
Certyfikat ukończenia

Co mówią uczestnicy?
Do tej pory w kursie wzięło udział ponad 650 osób!
Oto kilka z ich opinii:
Czy ten kurs jest dla Ciebie?
|
Tak jeżeli:
|
|---|
Jeżeli nie masz pewności, czy kurs jest dla Ciebie – napisz na kontakt@ucgosu.pl i wspólnie przeanalizujemy, czy kurs jest dla Ciebie. Pamiętaj również o 30 dniach na zwrot. Chcę, aby do kursu dołączały jedynie osoby, które go potrzebują.
Podsumowując co otrzymasz?
Gwarancja satysfakcji

Przygotowałem szkolenie najlepiej jak potrafię. Zawarłem tam wiedzę, do której dochodziłem wiele lat. Umieściłem treści, które sam chciałbym otrzymać i które pomogłyby mi w różnych sytuacjach jakie napotykałem na swojej ścieżce zawodowej.
Jeżeli jednak z jakiegokolwiek powodu uznasz, że to szkolenie nie jest dla Ciebie – wystarczy, że napiszesz na kontakt@ucgosu.pl.
Otrzymasz wtedy zwrot 100% Twojej wpłaty.
Masz na to 30 dni.











