In the design of Windows NT, which key object oriented concepts are used to structure kernel components and system services?

Introduction / Context:
Windows NT was influenced by object oriented design principles, even at the kernel and system service levels. Many of its internal components treat resources such as processes, files and devices as objects with standard operations. This question checks whether you can identify the classic object oriented concepts that Windows NT uses to organize these components, rather than confusing the system with older unstructured or purely functional designs.

Given Data / Assumptions:

• Windows NT is written largely in C and C like languages but its design uses object oriented ideas.

• System resources are exposed through well specified interfaces.

• The question focuses on key object oriented concepts rather than implementation details.

• Familiar concepts include encapsulation, inheritance and polymorphism.

Concept / Approach:
Object oriented design centers around encapsulation, which hides internal representation behind an interface, inheritance, which allows new object types to be derived from existing ones, and polymorphism, which allows the same interface to be used with different underlying implementations. In Windows NT, many kernel components and executive services treat resources as objects and expose operations on those objects through system calls and internal APIs. This allows a uniform mechanism for manipulating resources and makes the system more modular and extensible. The correct option must name these classic object oriented concepts and connect them to modeling system resources as objects with interfaces.

Step-by-Step Solution:
Step 1: Recall the three widely recognized basic object oriented principles: encapsulation, inheritance and polymorphism. Step 2: Think about how Windows NT represents processes, threads, files and other resources as kernel objects that can be referenced via handles. Step 3: Recognize that these objects are manipulated through a set of operations that form the public interface, while their internal details are hidden inside the kernel implementation. Step 4: Choose the option that explicitly names encapsulation, inheritance and polymorphism and states that they are used to model system resources as objects.

Verification / Alternative check:
You can verify by recalling that Windows NT has an object manager component that manages different object types with common mechanisms such as reference counting and security descriptors. This is a practical use of encapsulation and polymorphism. New object types can build on existing mechanisms, which reflects inheritance in the design. Therefore, any correct answer should highlight these object oriented ideas rather than suggest an unstructured or purely procedural design style.

Why Other Options Are Wrong:
Option B is wrong because it suggests that Windows NT uses only global variables and goto statements with no modularity, which is completely unrealistic for such a complex system. Option C is wrong because it claims that Windows NT relies only on functional programming and does not use objects, which contradicts the documented object based design of the system. Option D is wrong because, while hardware microcode may play a role at a very low level, the operating system itself clearly uses high level design concepts and is not built solely on microcode instructions.

Common Pitfalls:
Students sometimes believe that object oriented design applies only to high level application code and not to operating systems, but modern kernels often adopt object based structures to manage complexity. Another pitfall is to confuse implementation language with design style; even if parts of Windows NT are written in C, an object oriented design can still be implemented. Remembering that kernel objects, handles and common operations are organized around object oriented principles makes it easier to reason about how features such as security, reference counting and resource tracking are implemented.

Final Answer:
Hence, encapsulation, inheritance and polymorphism are used to model system resources as objects with well defined interfaces in the design of Windows NT.