Fundamentals of computer systems — AQA A-Level Computer Science

Fundamentals of computer systems is the bedrock of AQA A-Level Computer Science, covering how hardware and software interact to form a functional computing device. This topic explores the von Neumann architecture, the fetch-execute cycle, and the role of system software like operating systems and translators. Understanding these principles is crucial because they explain how programs are stored, processed, and executed, forming the foundation for more advanced topics such as computer organisation, networking, and programming paradigms.

At its core, this topic demystifies what happens inside a computer when you run a program. You'll learn about the CPU's components—ALU, control unit, registers (PC, MAR, MDR, CIR, ACC)—and how they work together to fetch, decode, and execute instructions. The concept of stored program control, where both data and instructions are held in memory, is central. This knowledge is not just theoretical; it helps you debug code, optimise performance, and understand limitations like the von Neumann bottleneck.

This topic also introduces the layered model of computer systems: from hardware (CPU, memory, I/O) to system software (OS, utilities) and application software. You'll explore how the OS manages resources, provides a user interface, and handles file management. Translators (assembler, compiler, interpreter) are covered, highlighting the journey from high-level code to machine code. Mastery of these fundamentals is essential for tackling later topics like data representation, networks, and databases, making it a cornerstone of the A-Level course.

• →Von Neumann architecture: A design where data and instructions are stored in the same memory, accessed via a single bus. Key components include the CPU (ALU, CU, registers), memory (RAM), and I/O systems.
• →Fetch-execute cycle: The continuous process where the CPU fetches an instruction from memory (using PC and MAR), decodes it (in the CU), and executes it (using ALU or other components). Registers like MDR, CIR, and ACC play specific roles.
• →System software vs. application software: System software (OS, utilities, translators) manages hardware and provides a platform for applications. Application software (word processors, games) performs user-oriented tasks.
• →Role of the operating system: Manages processor scheduling, memory management (paging, segmentation), file systems, I/O control, and provides a user interface (CLI/GUI).
• →Translators: Assembler converts assembly code to machine code; compiler translates high-level code to machine code in one go; interpreter translates and executes line by line. Each has trade-offs in speed, debugging, and portability.

• Define hardware and software and explain their relationship.
• Explain the functions of system software including operating systems, utility programs, libraries, and translators.
• Describe the role of an operating system in hiding hardware complexity and managing resources.
• Classify programming languages into low-level (machine code, assembly) and high-level (imperative).
• Explain the roles of assemblers, compilers, and interpreters.
• Distinguish between compilation and interpretation and identify appropriate use cases.
• Explain the production and use of intermediate languages like bytecode.
• Differentiate between source code and object/executable code.

• 💡Ensure you can clearly define and provide examples for system software versus application software.
• 💡Be prepared to compare compilation and interpretation in terms of speed, portability, and error reporting.
• 💡Understand why an OS is necessary for managing hardware resources like memory and processors.
• 💡Be able to explain the advantages and disadvantages of low-level languages compared to high-level languages.
• 💡In questions about the fetch-execute cycle, always name the specific registers involved at each stage (e.g., PC holds address of next instruction, MAR holds address being accessed, MDR holds data fetched). Use the correct acronyms and explain their roles clearly.
• 💡When comparing translators, mention trade-offs: compiled code runs faster but is harder to debug; interpreted code is slower but allows line-by-line testing. Use examples like Python (interpreted) vs. C++ (compiled).
• 💡For OS questions, structure your answer around the key functions: processor management (scheduling algorithms), memory management (paging/segmentation), file management (hierarchical structure), I/O management (drivers), and user interface. Link each to a real-world scenario.

• Confusing the specific roles of different types of system software.
• Failing to clearly distinguish between the processes of compilation and interpretation.
• Misunderstanding the purpose of intermediate languages like bytecode.
• Inaccurately describing the relationship between hardware and software.
• Misconception: The CPU can access data directly from the hard drive. Correction: The CPU only works with data in RAM or cache. The hard drive is secondary storage; data must be loaded into RAM first via the memory bus.
• Misconception: The fetch-execute cycle only runs once per program. Correction: It runs continuously in a loop, fetching and executing instructions one by one until the program terminates. Each instruction goes through fetch, decode, execute, and store (if needed).
• Misconception: An interpreter and compiler are essentially the same. Correction: A compiler translates the entire source code into machine code before execution, producing an executable file. An interpreter translates and executes each line sequentially, without producing a standalone file. Compilers are faster for final programs; interpreters are better for debugging.