Chapter 21: Windows 10: Design Principles, System Components, and Networking

Welcome to Last Minute Lecture.

This free chapter overview is designed to help students review and understand key concepts.

These summaries supplement, not replace, the original textbook and may not be redistributed or resold.

For complete coverage, always consult the official text.

Ever wondered what actually makes your computer, well, work?

You know, what's going on under the hood when you click an icon or browse the web or even just turn it on?

Yeah, it's something we take for granted.

Exactly.

So today we're taking a deep dive into one of the most ubiquitous and really complex pieces of software out there,

Microsoft Windows 10.

Right.

It's the silent workhorse behind, what, billions of devices, laptops, desktops, even some appliances.

For sure.

So our mission today is basically to unpack its core design, look at the crucial components and you know, how it manages everything from running your favorite game to just connecting you to the internet.

Think of it like a shortcut maybe to understanding this incredibly sophisticated engine that powers so much of our digital lives and our guide for this exploration.

It's a really comprehensive chapter on Windows 10 from the authoritative text, operating system concepts, 10th edition by Silverschatz, Gelvin and Ginnia.

So get ready for some surprising insights, I think, into how this OS prioritizes things like security, speed, even battery life, often in ways you wouldn't expect.

Okay.

So let's unpack this journey because Windows 10, it didn't just appear overnight, right?

It's the result of decades of evolution.

Right.

Its roots go way, way back, mid 1980s, believe it or not, Microsoft and IBM were collaborating on OS2.

OS2.

Yeah.

And that was written in assembly language for a single processor Intel 80286 chip.

Assembly language.

That's intense, a real blast from the past.

Totally.

Okay.

But then 1988, Microsoft made a really pivotal move.

They hired Dave Cutler.

Ah, the legendary Dave Cutler.

Known for VMS, right?

The very same.

His mission?

Build a portable new technology OS.

NT.

NT.

Okay.

And the key here was a shift.

Moving away from the older OS2 API to a new 32 -bit Windows API, what we now know as Win 32.

Got it.

This led to early NT versions like Windows NT 3 .1, then NT 4 .0 and NT 4 .0, that's where they adopted the Windows 95 user interface everyone recognized.

Right.

The look and feel.

But here's a fascinating trade -off they made.

For better performance, they moved UI and graphics code into the kernel.

Into the kernel.

Yeah.

Which maybe predictably had the side effect of decreasing reliability and security.

It was that classic performance versus stability dilemma.

So a learning curve right from the start.

Right.

Which brings us to Windows 2000.

Exactly.

Windows 2000 introduced some really significant enterprise features.

Active Directory, better networking, plug and play, finally getting solid, a big step up for businesses.

Okay.

Then October 2001, we got Windows XP.

Ah, XP.

Yeah.

Everyone remembers XP.

Yeah.

A major update.

It really embraced consumer features, you know, auto -repair stuff, better device experiences like zero configuration wireless.

It just hit that sweet spot between consumer -friendly and enterprise reliability.

Became incredibly popular.

But then came 2007 and Windows Vista.

Oh, Vista.

Yeah.

It didn't get the best reception.

No, it didn't.

People generally felt it was sluggish and there were compatibility headaches.

Microsoft definitely listened though.

Windows 7 in 2009 was kind of their redemption arc.

They really focused on engineering improvements.

Used sophisticated event tracing, for instance, to analyze system behavior in hundreds of scenarios, really digging into performance.

So data -driven improvements.

Very much so.

Constantly monitoring, refining the user experience.

Okay.

Which brings us to Windows 8, 2012.

That felt like a massive shift.

It was maybe the most significant and daring change since XP, really driven by the whole pivot to mobile computing.

The tiles.

The tiles, exactly.

The Metro user interface, animated tiles, heavy touchscreen focus, plus a whole new programming model.

WinRTime Microsoft even jumped into hardware with the Surface RT and Windows Phone.

I remember that Surface RT.

Yeah.

But yeah, the whole Windows 8 thing.

Yeah.

It didn't quite land smoothly, especially on traditional desktops.

Yeah.

What was the core problem?

Well, fundamentally, it was forcing that tablet -first interface onto desktops.

Users who were used to keyboards and mice, they just found it frustrating.

Some things just didn't have good keyboard support.

And the Windows Store, which was meant to be the app hub, it kind of suffered from a doof of applications, how the book puts it.

Just not enough apps compared to the competition.

Windows 8 .1 came up pretty quickly with fixes, trying to bring back some traditional usability.

But getting traction in the mobile market remained a real challenge for Microsoft.

Which leads us neatly to Windows 10, launched in 2015.

And this was another huge strategic shift, right?

Massive.

The move to Windows as a service?

WAS.

WAS.

Okay, what does that mean in practice?

It means continuous updates.

Like monthly feature roll -ups, bigger eight -month updates.

It's more like how cloud services operate.

They use live telemetry data from user machines.

The Insider Program.

Exactly.

The Windows Insider Program is key.

They do A -B testing, dynamically managed features.

It's constant experimentation and refinement based on real -world usage.

And for users, what were the big changes?

Well, crucially, they brought back the start menu.

Big cheer went up for that one.

And restored robust keyboard support.

The Metro interface, now called Modern, was redesigned so it could run side -by -side with your traditional desktop apps.

They used something called the Windows Desktop Bridge for that.

So trying to bridge the old and new.

Precisely.

The big takeaway is Microsoft really committing to continuous evolution and trying hard with backward compatibility.

Okay.

And you mentioned something earlier, Pico providers.

That sounded interesting.

Yeah.

This is where it gets really fascinating, especially for developers.

Windows 10 introduced this concept of Pico providers.

Basically they allow unmodified binaries from different operating systems to run natively.

Different operating systems.

Like Linux.

Exactly like Linux.

The prime example is the Windows Subsystem for Linux, WSL.

It lets you run actual unmodified Linux ELF binaries.

Wow.

Directly in a Linux user space environment.

Think Ubuntu, OpenC, running right there on Windows.

That's kind of mind -blowing.

How does that work?

Is it a virtual machine?

Not exactly.

It's more like a custom mini -kernel.

They call it LX Core.

It sits there and translates Linux system calls into something Windows understands.

So those Linux programs feel like they're running natively.

Are there limitations?

Oh, sure.

There are definitely limitations currently.

Like it doesn't support Linux kernel drivers directly or graphical Linux apps without some extra workarounds, but core networking, fully functional.

It's a game changer for developers who need both worlds.

I can see that.

What else came with Windows 10?

Well, there's an IoT addition for small devices like Raspberry Pi, built -in containerization support with Docker.

Microsoft Hyper -V virtualization is baked in now, used for security features and running virtual machines.

And multi -user support.

That's evolved too, from the traditional server terminal services to fast user switching on desktop PCs, making it easy for families or colleagues to share one machine.

And the graphics.

Things feel smoother these days.

Yeah, the graphical user interface itself, things like the desktop window manager or DirectX, they've seen massive optimizations.

And they leverage the GPU, the graphics processing unit, for more than just graphics now, general purpose computing.

GPGPU.

Right.

You can actually see GPU usage tracked in Task Manager now, which is pretty neat.

The whole 64 -bit transition has been huge too, hasn't it?

Absolutely.

XP took the first steps, but Windows 10 is pretty much exclusively 64 -bit on client systems now.

But it can still seamlessly mix 32 -bit and 64 -bit applications.

Impressive compatibility.

And looking forward, there's emerging ARM64 support with emulation for older by 86 apps.

It just shows that ongoing commitment to portability across different hardware.

So all this evolution,

decades of work, what does it tell us about the core design principles?

What was Microsoft actually aiming for with Windows 10?

Well, the book lists a pretty ambitious set of goals.

Security, reliability,

compatibility, high performance, extensibility, portability, international support, energy efficiency,

and dynamic device support.

That's a lot.

It is.

And they aren't just buzzwords.

These goals are like deeply embedded in the system's architecture.

Okay, let's unpack a few.

Security seems like a good place to start.

How does Windows 10 tackle that?

It's more than just passwords, right?

Oh, way more.

Windows moved beyond basic file permissions, what they called discretionary access controls, quite a while ago.

Since Vista, actually, we've had integrity levels.

Integrity levels?

Yeah, think of it like a security clearance system, but for programs.

Low, medium, high.

A process running at a lower integrity level, like say your web browser.

Which might encounter dodgy websites.

Exactly.

It cannot modify or even read objects marked with a higher integrity level, like an administrative tool.

Even if your user account technically has permission.

Ah, so it's an extra layer, like a built -in sandbox.

Precisely.

It contains the potential damage.

Windows 10 builds on this with things like attribute -based access control, ABAC for more dynamic server security, and of course BitLocker for encrypting entire drives.

Really strong protection against physical theft.

And what about preventing malicious code, like viruses or ransomware, from running in the first place?

Right, exploit mitigations.

These are crucial.

There's data execution prevention, DEP.

It marks areas of memory as non -executable.

So if an attacker tries to inject code into data buffers, it just won't run.

Stops buffer overflows.

Correct.

Then there's ASLR, address -based layout randomization.

This shuffles the locations of key program components in memory each time it runs, makes it much harder for attackers to predict where things are, which foils many common attack techniques.

Like finding gadgets for code reuse attacks.

Exactly.

There's also CFG, Control Flow Guard, and ACG, arbitrary code guard, adding even more layers to prevent attackers from hijacking program execution.

And for businesses, you mentioned Device Guard.

Yeah, Device Guard is an enterprise feature.

It takes security up a notch by moving the checks for whether software is digitally signed into a highly secure, isolated part of the system called the secure kernel.

Even if the main Windows kernel gets compromised somehow, Device Guard can still prevent unsigned drivers or malicious code from loading.

It's really strong defense.

But despite all this tech,

malware is still a huge problem.

It is, and the book makes a great point here.

Despite all these sophisticated defenses, crimeware often thrives because it relies on user ability and curiosity.

Social engineering.

Phishing.

Exactly.

Tricking users into willingly running the bad stuff, no operating system can fully patch human behavior.

That's a sobering but important point.

Okay, what about reliability, keeping the system stable?

That's another area where Windows has matured a lot.

Years of stress testing, automatic error detection.

But a key architectural improvement was moving things out of the kernel.

Like what?

Things like third -party font rendering code, audio processing stacks.

They used to run in the kernel.

Now many run as user mode services.

Why does that help reliability?

Because if one of those user mode services crashes,

it doesn't bring down the entire operating system.

The kernel keeps running, makes the whole system much more resilient to buggy drivers or components.

Oh, okay.

Containment again.

Right.

And Windows 10 has neat features like runtime memory diagnostics.

If your system starts crashing weirdly, the kernel might suspect bad RAM.

So during idle time, it can proactively test memory sections and warn you if it finds problems, often without even needing a reboot.

That's pretty clever.

It is.

And underlying a lot of these improvements is Microsoft's increasing reliance on telemetry.

Collecting data from users' machines.

Yeah, anonymized data about performance, what software is running, crash reports.

It helps them build a massive picture of the entire Windows ecosystem, see what's working, what's breaking, and guide those continuous improvements.

Got it.

Let's switch gears to compatibility.

This is a big one for Windows.

Why does that ancient piece of software often just work on Windows 10?

Yeah, it's often down to something called the shim engine.

Shim engine.

It's basically a compatibility layer.

It intercepts calls from older applications and makes Windows 10 look, as the book says, almost bug -for -bug compatible with previous versions.

It ships with thousands of these little fixes or shims for specific application quirks.

So it's like a translator for old apps.

Kind of, yeah.

And there are also specific thunking layers, like woww64windows on Windows 64.

That translates 32 -bit API calls so they run correctly on the native 64 -bit system.

Let's older apps run seamlessly.

And if even that doesn't work.

Well, as we touched on, there's Hyper -V.

You can literally run an older OS, like Windows XP or even DOS, inside a virtual machine for near -perfect, bug -for -bug compatibility if you absolutely need it.

Extreme compatibility.

Okay, performance.

The need for speed.

Always important.

The original NT design actually laid a pretty good foundation for performance, using techniques like asynchronous I .O., optimized networking, sophisticated file caching rights in the start.

And handling multiple processors.

That's become critical.

Absolutely key.

Early on, it was about symmetrical multiprocessing, SMP, allowing multiple threads to run truly concurrently, even inside the kernel.

But as chips started getting more and more core.

Moore's law shifting from faster clocks to more cores.

Clock speeds hit a wall.

So chipmakers started putting more CPUs on a single chip.

This meant Windows had to seriously re -architect its internal locking mechanisms.

You couldn't just have one big lock protecting kernel data when you have dozens or hundreds of cores trying to access it.

Bottleneck.

Huge bottleneck.

So they broke things down into more granular locks per processor data structures.

It's crucial for scalability.

As the book notes, Omdahl's law, which governs parallel computing, will rule the future.

You have to minimize the parts of the system that can only run sequentially.

Fascinating insight into that shift.

And what about power?

Especially for laptops and mobile devices.

Increasingly critical.

Windows 10 has to balance performance with energy efficiency.

Features like core parking intelligently put CPU cores into deep sleep states when they're not needed.

Heterogeneous multiprocessing, or HMP, lets Windows schedule tasks smartly across different types of cores on some modern chips like high -power cores and low -power efficiency cores.

Sending the right job to the right core.

Exactly.

Saving battery life without sacrificing performance when you need it.

And we mentioned GPUs earlier.

Right.

Graphics processing units.

Not just for pushing pixels anymore.

Windows uses direct compute to let applications leverage the massive parallel processing power of GPUs for general computing tasks.

Video encoding, scientific simulations, AI model training.

Speeding things up dramatically.

Hugely.

And Task Manager now shows you GPU usage so you can see how hard it's working alongside your CPU.

Okay, let's quickly round out those other design principles.

Extensibility.

That comes from its layered architecture.

The client -server model used internally.

It makes it easier to add new services, new features, without messing up the core OS.

Keeps it adaptable.

Portability.

Primarily written in C and C++ air, which are quite portable.

And the hardware abstraction layer, the HAL, hides the specific differences between chipsets and motherboards.

Allows the same Windows kernel to run on lots of different hardware.

International support.

Built in from the ground up.

The NLS API handles local formats for dates, times, currency.

Full Unicode support for different character sets.

Vista even introduced the Multi -User Interface, MUI, allowing multiple languages to be installed and used concurrently on the same system.

Energy efficiency we touched on sleep states.

Right, there's sleep, low power, keeps memory alive for quick resume.

And hibernation saves memory to disk, powers off completely.

Windows 8 added the Process Lifetime Manager for mobile apps, to spending idle ones to save battery, and Connected Standby for that instant -on experience while sipping power.

And Dynamic Device Support.

Plug and Play is the classic example, automatically recognizing and loading drivers.

But on the server side, it gets really cool.

Windows Server supports dynamic hot add and hot replace of CPUs and RAM.

You can add memory while it's running.

Yep, without rebooting.

Absolutely vital for cloud computing, those infrastructure as a service platforms where downtime is a killer.

Wow.

Okay, that covers the high -level goals.

Yeah.

Let's dive just a bit deeper into some key system components.

You mentioned the layers earlier.

Right.

If you visualize it, user mode is on top of your apps, system services.

Below that, in kernel mode, protected territory, you have the HAL at the bottom, talking to hardware, the kernel itself, and the executive.

The executive.

Yeah, that's a collection of managers that provide all the fundamental OS services.

Things like the Object Manager, Memory Manager, Process Manager, I .O.

Manager.

The manager's doing the actual work.

Pretty much.

And underpinning some modern security is that virtual secure mode, BSM we mentioned, using Hyper -V to create isolated, secure worlds, even from the main kernel.

That's where things like Credential Guard run, protecting your logins in a super -hardened environment.

Okay.

And at the very heart, the kernel itself has the dispatcher.

The dispatcher, yeah.

It's the absolute core of scheduling and synchronization.

It manages all the threads, the tiny units of execution, decides which thread gets to run on which CPU core at any given microsecond.

How does it prioritize?

It uses a 32 -level priority scheme.

Some priorities are dynamic, changing based on what the thread is doing.

Some are fixed, real -time priorities.

The goal is always to keep the system responsive.

So interactive things get boosted.

Exactly.

If a thread finishes an I .O.

operation, like reading from disk or getting network data, it often gets a temporary priority boost.

Same for the thread handling the foreground window you're interacting with.

It makes things feel snappy.

Clever.

Now tell me about the object manager and the executive.

You said everything's an object.

Almost everything the OS manages internally, yeah.

Files, processes, threads, synchronization objects like mutexes, they're all represented as objects.

When your program wants to use one, it gets a handle.

Like a ticket or a key.

Good analogy.

It's a secure reference to that kernel object, and the object manager is central.

It controls naming, creation, deletion, and crucially, security.

How does it handle security efficiently?

When you first open an object, say, requesting write access to a file, the object manager checks your permissions via the security reference monitor.

If you're allowed, it gives you the handle.

But it caches the allowed access rights, like write allowed, in the handle itself.

Ah, so the next time you write.

The system just checks the cache rights in the handle much faster than going through a full permission check every single time.

It's one of those hidden optimizations that makes a big difference.

That makes sense.

What about the virtual memory manager?

Huge job.

Manages the virtual address space for each process, that massive 256 terabytes on 64 -bit systems.

It maps virtual addresses to physical RAM or the paging file on disk.

Handles allocation, deallocation, sharing memory between processes using section objects.

And superfetch.

You mentioned that earlier.

Right.

That's part of the MM's world.

It's actually a user -mode service, but it works closely with the kernel.

It watches your disk access patterns, learns which data and code you use frequently, especially during startup.

Then it proactively fetches that stuff into RAM before you even ask for it.

So apps launch faster.

That's the idea.

Makes the system feel more responsive by anticipating your needs.

It's pretty smart, actually.

It even turns itself off if you have a fast SSD where the benefit is smaller.

Process manager.

Creates and manages processes, which are basically containers for threads.

And it handles those job objects.

We talked about grouping processes together to enforce limits on CPU, memory, I .O.

Really powerful for sandboxing or resource management, like with Docker containers, which Windows calls silos internally sometimes.

And the I .O.

manager.

Manages all communication with hardware devices through device drivers.

It uses an I .O.

stack model.

Requests flow down through layers of drivers, including filter drivers.

Filter drivers.

Think antivirus scanners intercepting file access, or disk encryption drivers like BitLocker working transparently underneath the file system, or volume snapshotting for backups.

They can examine or modify I .O.

requests as they pass through.

Powerful stuff.

And the cache manager.

Works closely with the memory manager and the I .O.

manager to provide a centralized cache for file data.

It caches things at the logical file level, not just raw disk blocks.

Uses write -back caching by default for performance writes, go to the cache quickly, then get flushed to disk later.

Okay, that gives us a good picture of the core internals.

What about connecting Windows machines together?

Networking.

Networking is built deep into Windows.

It supports the standard TCPIP protocols, IPv4, IPv6.

Has a built -in firewall.

The core protocol for Windows file and print sharing is SMB, Server Message Block, allows you to access remote files using standard path games like server -share -file .txt, making them look almost local.

Through redirectors.

Exactly.

A redirector component intercepts file requests, sees if they're for a remote machine, and sends them over the network using SMB.

On the server side, the SMB server receives the request and handles it.

And for bigger networks.

Domains.

Right.

Windows uses the domain concept, a group of machines sharing a common security policy and user database.

Managed by Active Directory, which is Microsoft's implementation of LDFP directory services.

It stores user accounts, group policies, the whole network topology.

Uses Kerberos for secure authentication.

It's the backbone for managing large corporate networks.

Got it.

Lastly, let's quickly touch on programming Windows.

The Win32 API.

That's the main interface for developers, right?

It is.

That's how applications interact with all those kernel objects we talked about.

You call functions like createFile, createThread, createMutex, and you get back a handle.

And you use those handles to do work.

Exactly.

You pass the handle to other functions like readFile, writeFile, setToLamp.

How do applications coordinate?

Synchronization.

The API provides functions like waitForSingleObject or waitForMultipleObjects.

You tell Windows to pause your thread until a specific event happens, like a mutex becoming available or data arriving.

There are also more efficient user mode synchronization objects like critical sections and newer slim reader -writer locks for common scenarios.

And managing threads.

Apps can create threads directly, but often it's more efficient to use thread pools.

Windows manages a pool of worker threads and your application just submits tasks.

The pool reuses threads, avoiding the overhead of constantly creating and destroying them.

Much better performance for many types of server or background tasks.

And memory management for apps.

Several ways.

There's direct virtual memory allocation, virtual alloc.

There's using memory -matched files, which maps a file directly into your processes address space.

Also a very common way to share memory between processes.

And then there's the standard heap allocation.

Heap alloc, similar to malloc and C, for smaller general purpose allocations.

So lots of options depending on the need.

Definitely.

Windows provides a rich, complex, but powerful environment for developers.

We've really covered a lot of ground here.

We've peeled back the layers of Windows 10, haven't we?

From its sometimes bumpy history to its core design goals.

The intricate kernel components, networking, the programming interface.

It's pretty clear how much engineering has gone into making it this powerful and importantly adaptable operating system that focus on security, reliability, compatibility, performance it shows.

Yeah, it's a system designed for, well, almost everything it seems.

Extensibility, portability, handling multiple processors, security, performance, energy saving, plus that rich API.

And it's constantly changing, evolving with that Windows as a service model.

Learning, adapting to new hardware, new user needs.

It really is a testament to continuous engineering over decades.

So here's a final thought to leave you with.

As operating systems like Windows keep evolving and they start blending hardware, software, even AI more deeply,

what new boundaries do you think will blur next?

How might our interaction with our digital worlds change in the coming years?

Something to ponder.

Definitely something to think about.

Thank you for joining us on this deep dive into the fascinating world of Windows 10.