Programming languages: Java, Go, C and C++

52 courses, 972 lessons. A real Kali Linux lab in the browser.

C language fundamentals (Level 101, 21 lessons): You learn C, the language of operating systems and many security tools, from scratch, including working with the compiler and reading its warnings.
C++ fundamentals (Level 101, 19 lessons): You learn C++, a fast and widely used language built on C, from scratch, compiling with g++ and writing small programs with the standard library.
Go fundamentals (Level 101, 29 lessons): You learn Go, common in security and infrastructure tools, from scratch and build small, fast programs that handle errors explicitly.
Java fundamentals (Level 101, 26 lessons): You learn Java, widespread in enterprise systems, from scratch, moving from variables to object-oriented design and safe error handling.
Rust fundamentals (Level 101, 18 lessons): You learn Rust, which enforces memory safety at compile time, from scratch, set up projects with cargo and write small, solid programs by reading the compiler's error messages.
C: pointers and memory management (Level 201, 22 lessons): You use pointers and dynamic memory correctly and find and prevent errors such as overruns and memory leaks using tooling.
Strings, files and data formats in C (Level 201, 20 lessons): You handle text safely in C, read and write text and binary files, and build parsers that survive malformed input.
Data structures and algorithms in C (Level 201, 21 lessons): You write arrays, lists, stacks, queues, hash tables and trees from scratch in C, measure their cost and test them without leaving memory bugs.
C practice (Level 201, 19 lessons): You reinforce loop, pointer, memory and file skills in C with short, realistic problems and test every solution against an automatic checker.
C++: classes, the STL and safe memory (Level 201, 19 lessons): You design classes, use the STL containers and algorithms, and write C++ that avoids memory errors through smart pointers.
The C++ standard library: containers and algorithms (Level 201, 20 lessons): You use STL containers knowing when to pick which, and write safe, fast code with algorithms and utility libraries instead of hand-written loops.
C++ practice (Level 201, 18 lessons): You strengthen your C++ by solving string, container, class and algorithm problems and test every solution with an automatic checker and sanitizers.
Go concurrency and HTTP services (Level 201, 19 lessons): You run work in parallel with goroutines and channels and write an HTTP service with safe defaults that shuts down cleanly.
Go practice (Level 201, 17 lessons): In each exercise you solve a small but real problem in Go and make a habit of writing code that passes its tests and handles errors properly.
Testing, debugging and code quality in Go (Level 201, 18 lessons): You test your code with table-driven tests, benchmarks and fuzzing, debug with delve and catch mistakes before they run with static analysis.
Command-line tools with Go (Level 201, 18 lessons): You write command-line tools with subcommands, config files and proper exit codes that ship as a single binary.
Java collections, generics and streams (Level 201, 22 lessons): You process larger data with safe, readable code using the Java collections framework, generics and the Stream API.
Object-oriented design and design patterns in Java (Level 201, 18 lessons): You practise designing classes that withstand change, the SOLID principles and the most used design patterns in small but realistic Java projects.
Java practice (Level 201, 16 lessons): You reinforce collection, stream, file and object design skills with short Java tasks that must pass ready-made tests.
Building, testing and debugging in Java (Level 201, 18 lessons): You build projects with Maven and Gradle, write thorough tests with JUnit 5 and Mockito and trace bugs to their source with jdb and logs.
Rust: ownership, borrowing and traits (Level 201, 19 lessons): You grasp ownership and borrowing, the heart of Rust's safety model, and write reusable code with traits, generics and iterators.
Debugging and development tooling for C (Level 301, 21 lessons): You find bugs in C programs systematically with gdb, Valgrind, sanitizers, strace and static analysis, and set up tidy projects with CMake and tests.
Linux system programming in C (Level 301, 23 lessons): You work with files, processes, signals, pipes and shared memory directly through system calls and write services that shut down cleanly and drop privileges.
Network programming in C (Level 301, 22 lessons): You write TCP and UDP clients and servers with sockets, handle many connections with select, poll and epoll, and build robust code that never trusts network data.
Modern C++: C++17, C++20 and C++23 (Level 301, 19 lessons): You write shorter, safer and faster modern C++ with move semantics, constexpr, optional, variant, expected, ranges and concepts.
C++ build, testing and quality tools: CMake and beyond (Level 301, 18 lessons): You set up projects with modern CMake, write tests with GoogleTest and Catch2, and check quality automatically with sanitizers, clang-tidy and continuous integration.
Systems and network programming in C++ (Level 301, 18 lessons): You wrap POSIX interfaces safely in RAII classes and write concurrent network services and tools with sockets and Asio.
Network programming with Go (Level 301, 19 lessons): You write TCP and UDP clients and servers with the net package, resolve DNS, set deadlines and TLS correctly and build reliable network tools in your own lab network.
Web services and REST APIs with Go (Level 301, 21 lessons): You build a production-ready REST API that routes with the standard library, writes safely to SQLite, authenticates users and logs in a structured way.
Concurrency and virtual threads in Java (Level 301, 18 lessons): You write safe parallel code with executors, CompletableFuture, locks and concurrent collections, and manage thousands of tasks simply with JDK 21 virtual threads.
Network and HTTP programming with Java (Level 301, 18 lessons): You write clients and servers with sockets, connect to services with HttpClient, manage keystores with keytool and configure TLS correctly.
Databases with Java: JDBC and JPA (Level 301, 17 lessons): You write safe queries with JDBC, manage transactions and connection pools and avoid performance and security traps when mapping objects to tables with JPA.
Web services with Spring Boot (Level 301, 19 lessons): You build a Spring Boot service with validated REST endpoints, database access and authentication that is observable and runs with secure defaults.
Command-line and systems tools with Rust (Level 301, 17 lessons): You write and ship fast, single-binary tools that work with files, processes and the network using clap, serde and the standard library.
Concurrency in C: POSIX threads (Level 401, 17 lessons): You run work in parallel with pthreads, prevent race conditions and deadlocks, and use atomics and thread pools correctly.
Secure coding in C: common mistakes (Level 401, 21 lessons): You learn, from the defender’s side, the C mistakes that become vulnerabilities, catch them in code review and prevent them with compiler protections and fuzzing.
C++ templates and generic programming (Level 401, 17 lessons): You design type-safe, reusable libraries with function and class templates, type traits, concepts and variadic templates.
Concurrency and the memory model in C++ (Level 401, 19 lessons): You write concurrent C++ with std::thread, locks, futures, atomics and parallel algorithms, and find races with ThreadSanitizer and fix them according to the memory model.
Secure coding in C++: common mistakes (Level 401, 19 lessons): You learn, from the defender’s side, how lifetime, type and bounds mistakes in C++ become vulnerabilities and prevent them with guidelines, hardening and fuzzing.
Advanced concurrency patterns in Go (Level 401, 16 lessons): You design concurrent systems that do not leak, can be cancelled and stay stable under load using errgroup, semaphores, rate limiting and atomics.
Secure coding in Go and common mistakes (Level 401, 19 lessons): You find and fix the security mistakes common in Go programs in a weak service in your own lab, and stop them returning with tests and analysis.
Secure coding in Java and common mistakes (Level 401, 19 lessons): You find the most common flaws of Java applications in a weak app in your own lab, understand their root cause, fix them and make the fix stick with tests.
Concurrency and async in Rust (Level 401, 15 lessons): Using a type system that rules out data races at compile time, you write threads, channels and tokio-based async services.
C binaries: ELF, linking and hardening (Level 501, 19 lessons): You examine the ELF structure, linking and in-memory layout of a compiled C program and ship releases hardened with protections such as ASLR, NX, RELRO and seccomp.
C projects: a shell, an HTTP server and a log collector (Level 501, 17 lessons): You take three realistic C projects from design to testing and combine your memory, systems and secure coding skills at production quality.
Performance in C++: measuring and speeding up (Level 501, 16 lessons): You find bottlenecks with sound measurement and profiling and speed C++ code up, with evidence, through data layout, allocation and compiler optimisation.
C++ projects: a tool, an integrity monitor and a network service (Level 501, 16 lessons): You take three realistic C++ projects from design to delivery and combine modern C++, testing, concurrency and secure coding at production quality.
Go internals and performance (Level 501, 16 lessons): You get to know the scheduler, the garbage collector and escape analysis through measurement and use profiles and traces to find bottlenecks and cut allocations.
Go project workshop (Level 501, 13 lessons): You build, end to end, the kind of tools real teams use, combining design, testing, security and shipping in your own lab network.
JVM internals and performance (Level 501, 16 lessons): You get to know class loading, bytecode, the JIT and the garbage collectors through measurement and use JFR and heap dumps to find and fix slowness and memory leaks.
Java project workshop (Level 501, 13 lessons): You build three realistic Java projects end to end in your own lab network, combining design, testing, security and performance.
Rust: unsafe, FFI and security review (Level 501, 17 lessons): You learn the limits of unsafe code, interoperating with C and the real security bugs of Rust projects, and verify your code with miri and fuzzing.

Projects

A cold store temperature summary in C: You write a C program that reads Ayçiçeği Gıda's cold store temperature readings, work out the minimum, maximum and average, and flag the readings above the threshold.
A library loan summary in Go: You write a Go program that reads Gelincik Okulları library's loan records, and list the most borrowed books and overdue returns using slices and maps.
A billable hours calculator in Java: You write a Java program that reads Sedirli Hukuk Bürosu's lawyer time records, work out hours and amounts per client, and report invalid records separately.
A nautical unit converter in Rust: You write a Rust command-line program for Lodoskaya Denizcilik that converts units such as nautical miles, knots and fathoms, and handle invalid input with error types.
A leak-free inventory table in C: You write a C program that reads Karaçam Mobilya's parts inventory from a file into a hash table, implement insert, lookup and delete, and show it passes a memory check with no leaks.
A booking ledger in C++ with classes and the standard library: You write a C++ program that models rooms and bookings for Mercanköşk Otelcilik with classes, find clashes using smart pointers and standard algorithms, and produce an occupancy summary.
A price list audit tool in Go: You write a Go command-line tool that compares Turnalı Perakende's store price lists with the head office list, report mismatched prices, and verify the tool with table-driven tests.
A concurrent service uptime checker in Go: You write a Go program that polls Selvikent Belediyesi's own web services in the lab concurrently with a worker pool, handle timeouts, and serve a status page summarising response times.
Order analysis with Java collections and streams: You write a Java program that models Ayçiçeği Gıda's order records with classes, group them by region and product using streams, and produce a best-sellers report.
Turn a fault ticket module into a tested Maven project: You turn Yakamoz Telekom's fault ticket module, a set of loose Java classes, into a Maven project, write unit tests, and find and fix the bugs the tests reveal using the debugger.
A sensor reading library in Rust with traits and error handling: You write a Rust library that parses readings from Demirsu Enerji's different meter types behind a shared trait, design it to fit the ownership rules, and verify it with unit tests.
A small supervisor for worker processes in C: You write a supervisor in C that starts Demirsu Enerji's meter-reading worker, restarts it when it crashes and shuts down cleanly on signals, and verify its behaviour with debugging tools.
Bring loose C++ code into shape with CMake, tests and checks: You move Göktaşı Yazılım's hand-compiled legacy C++ library into a CMake project, add unit tests, and fix the problems raised by sanitizers and static analysis using modern C++.
A shipment tracking REST API in Go: You write a REST API in Go for Mavikaya Lojistik that creates shipment records and updates their status, add validation, logging and timeout middleware, and test the endpoints.
A course registration service with Spring Boot: You write a Spring Boot service for Saklıvadi Üniversitesi where students register for courses, store the data in a database, enforce the capacity rule, and test the endpoints.
An exchange rate collector with Java virtual threads: You write a Java program that fetches data from Yelkovan Bankası's rate services in the lab concurrently with virtual threads, handle timeouts and retries, and produce a merged rate table.
A fast log filter tool in Rust: You write a Rust command-line tool that filters Kuzeyyıldızı Kargo's large sorting-hub logs, filter by field, output JSON, and keep memory use low on a big file.
Review a legacy C message parser and make it safe: You review the source of Yelkovan Bankası's legacy message parser, expose its memory errors with sanitizers, fix them safely, and collect the findings in a review report.
A thread-safe generic job queue in C++: You write a template-based job queue and worker pool that distributes Ilgıntepe Tekstil's production line jobs, and show it runs clean under the race detector and shuts down properly.
Secure code review and race fixes in a Go service: You review the Go source of Lavinya Klinikleri's patient notification service with security scanners and the race detector, fix the mistakes you find, and write the review report.
Secure code review and fixes in a Java web service: You review the Java source of Selvikent Belediyesi's citizen portal service, fix its unsafe query, serialisation and input-handling mistakes, and write a report that proves each fix with a test.
Build and verify a C log collector with hardening flags: You complete a small log collector in C for Selvikent Belediyesi's servers, compile it with protection flags, verify each protection in the binary, and write a build hardening note.
A file integrity monitor in C++: You write a C++ tool that builds a baseline of file hashes for Sedirli Hukuk Bürosu's case folders and reports later changes, then measure and improve its speed on large folders.
Auditing unsafe code in a Rust FFI wrapper: You go through each unsafe block in Göktaşı Yazılım's Rust crate that wraps a C library, expose undefined behaviour with tooling, rewrite it behind a safe interface, and prepare the audit report.