Master the Windows APIs behind fast, reliable native software. Continuing from part 1, Pavel Yosifovich, author of Windows 10 System Programming and co-author of Windows Internals, teaches job objects, threads and thread pools, every synchronization primitive, synchronous and asynchronous I/O, and memory management with the Virtual API, heaps and memory mapped files, with labs and solution walkthroughs.
or $99 X 3 installments
11+ hours
on-demand video
Labs
with full solution walkthroughs
61
video lessons
3
downloadable resources
11 CPE
CEU credits, self-reported
Certification
Certificate of completion
Most hard problems in native Windows software come down to four things: threads, synchronization, I/O and memory. Data races and deadlocks, a UI that freezes while it waits, I/O that blocks a whole server, memory that leaks or grows without explanation. Fixing them requires understanding what the Windows primitives really do, not just copying patterns.
In this course Pavel Yosifovich continues where Windows System Programming 1 left off. You start with job objects, which manage groups of processes with limits on CPU, memory and I/O. Then threads in depth: creating and controlling them, priorities, scheduling and stacks, the thread pool, and std::thread compared with the Windows API. The synchronization module covers data races and atomic operations, then every primitive in turn: mutex, critical section, slim reader writer lock, semaphore and event, with RAII lock wrappers and deadlock avoidance. Then file and device I/O, including asynchronous I/O and DeviceIoControl, and finally memory: the process address space, page states, VMMap, the Virtual API, heaps and memory mapped files.
The course is a recording of a live class: 61 video lessons, with the slides, a labs PDF and the lab code. Lab walkthroughs build a tool that closes a handle in another process, a CPU rate limiter, a multithreaded prime counter and a cross-process file writer. Every video has English captions, and you learn at your own pace with lifetime access.
Pavel is the author of “Windows 10 System Programming”, “Windows Kernel Programming” and “Windows Native API Programming”, the co-author of “Windows Internals, 7th Edition, Part 1” (Microsoft Press), and a Microsoft MVP, with more than 25 years as a developer, consultant, trainer, author and speaker.
He writes Windows system software every day, and teaches the API the same way: with the internals behind each call, the tools to see what is happening, and labs that turn every topic into a working program.
Not the right fit if you have not yet learned handles, kernel objects and process creation (take Windows System Programming 1 first), if your gap is the C++ language itself (take Modern C++ Programming), or if you want kernel driver work (take Windows Kernel Programming 1).
Windows System Programming 2 is the second part of the three-part series on the documented Windows API. Windows System Programming 1 covers the API conventions, kernel objects and handles, and processes. This part covers jobs, threads, synchronization, I/O and memory, and Windows System Programming 3 finishes with DLLs, security, COM fundamentals and windowing.
Every module combines slides, live coding and the Sysinternals tools, such as Process Explorer, VMMap and WinObj, so you see exactly what your code does to the system. The labs are followed by full solution walkthroughs.
Concurrency and memory bugs are the most expensive bugs in native code: they are intermittent, hard to reproduce and often show up only in production. Understanding the Windows scheduler, the synchronization primitives and the virtual memory model lets you design code that avoids them, and diagnose them quickly when they happen. The same knowledge is essential for performance work, server development and security tools that inspect other processes.
Every concept is shown in the tools first: jobs in Process Explorer, CPU limits with CPUStress, threads and stacks in the Visual Studio debugger, devices in WinObj, and address spaces in VMMap. Then you build it: a handle-closing tool, a CPU rate limiter, a multithreaded prime counter, a cross-process file writer and a commit-on-demand memory demo. The course is part of the Windows Master Developer learning path and the Windows System Programming Bundle.
An overview of the course and how it continues Windows System Programming 1, with a preview of the modules: jobs, threads and synchronization, file and device I/O, and memory management. The slides, the labs PDF and the lab code are available here.
Managing groups of processes with job objects. You learn the limit types (process count, CPU time, CPU rate, affinity, priority, memory, I/O and UI), the job API for setting limits and reading accounting information, nested jobs, and how to inspect jobs in Process Explorer. Two labs build a tool that closes a handle inside another process and a CPU rate limiter tested with CPUStress.
Windows threads in depth. The chapter covers thread states, the hardware behind them (sockets, cores and logical processors), creating threads and the fork-join pattern, termination and its pitfalls, stack reserve and commit, priorities and scheduling, and APIs for suspend, resume, affinity and descriptions. It then covers the thread pool, enumerating threads, threads that own windows, and std::thread versus the Windows API.
Making threads work together correctly. You start with data races and Interlocked atomic operations, then dispatcher objects and the wait functions, and every synchronization primitive: mutex, critical section, slim reader writer lock, semaphore and event. The chapter covers RAII lock wrappers, deadlock avoidance, APCs and alertable waits, and waiting without freezing a GUI. Labs build a multithreaded prime counter and a cross-process file writer synchronized with a named mutex.
File and device I/O. The chapter explains the I/O system architecture, CreateFile and its parameters, synchronous ReadFile and WriteFile, and asynchronous I/O with OVERLAPPED and the different ways to be notified of completion. It also covers cancelling I/O, opening devices through their symbolic links with WinObj, and talking to devices with DeviceIoControl.
Memory management for system programmers. You learn virtual memory and page sizes, the 32-bit and 64-bit address space layouts, page states, and how to read VMMap and the memory counters. Then the memory APIs: the Virtual API with a reserve-then-commit demo using exception handling, heaps and heap types, private heaps with C++ operator new, and memory mapped files, both for sharing memory between processes and for working with large files.
Yes, or equivalent knowledge. This course continues directly from part 1 and assumes handles, kernel objects, error handling and process creation. Start with Windows System Programming 1 if those are new to you.
Comfortable C++, not just C. The code uses RAII lock wrappers, std::thread, std::atomic, smart pointers and the standard containers. If the C++ is the shaky part, take Modern C++ Programming first.
A Windows 10 or 11 PC with Visual Studio and its C++ workload, plus free Sysinternals tools such as Process Explorer, VMMap, WinObj and CPUStress. Some labs need administrator rights.
Yes, alongside the Windows API. The course compares std::thread with Windows threads, uses std::atomic and std::mutex, and uses the Parallel Patterns Library for a parallel lab. The focus is on what the Windows primitives do underneath.
Yes. The File I/O chapter covers asynchronous I/O with OVERLAPPED, the different ways to be notified of completion, cancelling I/O, and talking to devices with DeviceIoControl.
Yes. Lab walkthroughs build a tool that closes a handle in another process, a CPU rate limiter, a multithreaded prime counter and a cross-process file writer, and further exercises are described in the lessons. A labs PDF and the lab code are included.
Recorded and self-paced. It is a recording of a live class. You get lifetime access, and every video has English captions.
This course teaches the documented Windows API. Windows Native API Programming covers similar subjects at the undocumented NtDll layer below it. Take this course first.
Windows System Programming 3, which finishes the series with DLLs, security, COM fundamentals and windowing. The three parts are also available together in the Windows System Programming Bundle.
Yes. When you complete every lesson you receive a certificate of completion and a Credly digital badge. The course also earns 11 CPE/CEU credits, which you self-report to your certification body using your certificate.
Yes. Two lessons are free to preview: Introduction to Jobs and Thread Stack. Watch them on the course page.
61 video lessons, more than 11 hours of video, plus lab time. Most students spread it over a few weeks.
$295 as a single payment, or 3 monthly payments of $99 ($297 in total). All three parts together are cheaper as the Windows System Programming Bundle: $749, or 5 payments of $150.
Lifetime access to the purchased course.
Yes. Refunds are available up to 14 days after purchase, to the original payment method. Email [email protected].
Pavel is the author of “Windows 10 System Programming”, “Windows Kernel Programming” and “Windows Native API Programming”, the co-author of “Windows Internals, 7th Edition, Part 1” (Microsoft Press), and a Microsoft MVP, with more than 25 years as a developer, consultant, trainer, author and speaker.
He writes Windows system software every day, and teaches the API the same way: with the internals behind each call, the tools to see what is happening, and labs that turn every topic into a working program.
Master the Windows APIs behind fast, reliable native software. Continuing from part 1, Pavel Yosifovich, author of Windows 10 System Programming and co-author of Windows Internals, teaches job objects, threads and thread pools, every synchronization primitive, synchronous and asynchronous I/O, and memory management with the Virtual API, heaps and memory mapped files, with labs and solution walkthroughs.
