Software developers for Windows should understand the way Windows works, its mechanisms and algorithms, so they are able to write better software that can take advantage of Windows' strengths. The course deals with all the major terms in Windows, such as processes, threads, virtual memory and more. Whether you're a Win32 programmer, a .NET programmer or a device driver programmer, you should benefit from understanding Windows, which may help in troubleshooting difficult issues as well.
Introduction Hi. My name is Pavel, and I'd like to welcome you on this Windows Internals course here on Pluralsight. The first thing we'll talk about is the course objectives. We'll see what this course is all about to give you a better idea of what to expect. Then we'll talk briefly on the various Windows versions and how they relate to this course. And finally, we'll talk about the tools we're going to use and how to get them. And of course we'll sum things up. So, the course is really about understanding the way Windows works. That's not just in terms of features, but mostly in terms of architecture and the way things are working beneath the surface. If you are a Windows programmer, whether you're doing that in user mode with the Windows API or with something more high level like. NET, you should find this course both interesting. And if you are working on the kernel side, this certainly will give you more understanding of how Windows works under the covers. So, the focus here is for developers. So, if you are an administrator or a system guy, that's something. You'll probably get something out of this course, but I specifically target developers for this course. And the idea is that we want to be able to write better software for Windows. And to do that, we need to understand how Windows works and how to best utilize the facilities it provides.
Basic Concepts Hi, and welcome back to the second module of the Windows Internals course on Pluralsight. In this module we'll talk about some of the basic concepts that comprise the way Windows works. We'll delve deeper into this concept in subsequent modules. Specifically, we'll talk about what user mode is versus kernel mode and what that means for code running at these modes. We'll talk about the concept of a process, which is one of the most important concepts in Windows. We'll talk about threads, which actually do work and execute on processors. And finally, we'll talk about virtual memory and how that relates to threads and processors. Then we'll conclude with a discussion about objects and handles and how they're typically used in applications. And finally we'll sum things up.
System Architecture (Part 2) Hi. Welcome back to the fourth module of the Windows Internals course. This will continue the previous module on System Architecture. Specifically, we'll talk about the core system files that comprise the Windows operating system in the kernel and in the user space. Then we'll talk about the multiprocessing capability of Windows and how does that manifest itself. We'll discuss subsystems and the role of NTDLL when subsystems are concerned. And then we'll talk about some of the system processes that are always there and serve the entire system, not just a particular process. Finally, we'll talk about Wow64, the ability to run 32-bit processes on a 64-bit operating system and how that works and what that means for applications running in that scenario. And then we'll sum things up.
Processes and Threads (Part 1) Hi. Welcome to the fifth module of the Windows Internals course. In this module we'll take a deeper look at processes and threads. Specifically, we'll look at processes and some of their internals, how to create a process, and exactly what happens when the process is starting up. We'll take a look at threads including the idea of scheduling how our threads are scheduled to execute on processors, how our priority is determined, how can we influence those priorities. We'll take a look at thread synchronization and what that means and some of the common ways threads need to communicate to synchronize execution in various ways. We'll take a brief look at thread pools and some higher level mechanisms for managing threads. And finally, we'll take a look at jobs, which are kernel objects that allow us to manage a set of processes as a group. So let's begin.