Computer ScienceQ&A by dot point

Assembly language: the instruction set with its opcode and operand, common operations (load, store, add, jump, compare), the relationship between assembly and machine code, and immediate, direct and indirect addressing modes.

Input, output and storage: the role of input and output devices, the memory hierarchy from registers and cache to RAM and secondary storage, and the operating principles, advantages and uses of magnetic, optical and solid-state storage.

Networks: LANs and WANs, network topologies (bus, star, mesh), the client-server and peer-to-peer models, and the hardware that connects a network (network interface cards, switches, routers and the role of the internet).

Processor performance: the factors affecting CPU performance (clock speed, number of cores, cache size and word length), the difference between RISC and CISC, and the use of pipelining and parallel processing.

The fetch-decode-execute cycle: the special-purpose registers (PC, MAR, MDR, CIR, ACC) and their use in fetching, decoding and executing an instruction, and the effect of the cycle on the registers.

Computer architecture: the components of the CPU (the ALU, the control unit, the registers and the system buses), the Von Neumann stored-program concept, and the difference between Von Neumann and Harvard architectures.

Static data structures: one- and multi-dimensional arrays, records (structs), tuples and sets, how they are stored contiguously in memory, address calculation for array elements, and choosing the appropriate structure for a task.

Recursion and algorithmic complexity: the base case and recursive case, how recursion uses the call stack, and Big-O notation for the time and space complexity of algorithms (constant, logarithmic, linear, polynomial and exponential).

Searching and traversal algorithms: linear search and binary search with their conditions and efficiency, and the breadth-first and depth-first traversals of trees and graphs.

Sorting algorithms: bubble sort and insertion sort and their quadratic efficiency, merge sort and quick sort and their use of divide and conquer, and comparing sorting algorithms by time complexity and stability.

Dynamic data structures: stacks (LIFO) and queues (FIFO) with their push, pop, enqueue and dequeue operations and pointer management, linear and circular queues, and singly and doubly linked lists with insertion and deletion.

Trees, graphs and hash tables: binary search trees and their traversals (in-order, pre-order, post-order), graphs as adjacency matrices and adjacency lists, and hashing for direct-access tables including collision handling.

Compression, encryption and error checking: lossy and lossless compression (run-length encoding and dictionary methods), symmetric and asymmetric encryption, and error-detection methods (parity, checksums and check digits).

Data transmission: serial and parallel transmission, packet switching and the structure of a packet, network protocols and the layers of the TCP/IP stack, and the role of standards in communication.

Organisation and structure of data: files, records and fields with key fields and file access methods, relational databases with primary and foreign keys, normalisation to third normal form, and SQL for querying and manipulating data.

Floating-point representation: storing a real number as a mantissa and an exponent in two's complement, evaluating a stored floating-point value, normalising a mantissa, and the trade-off between range and precision.

Data representation of numbers: converting between binary, denary and hexadecimal, representing negative numbers with sign and magnitude and two's complement, binary addition and subtraction, and detecting overflow.

Representing text, images and sound: character sets (ASCII and Unicode), bitmap images with resolution, colour depth and the file-size calculation, and sampled sound with sample rate, bit depth and the file-size calculation.

The functional paradigm: functions as first-class values, pure functions and referential transparency, immutability and the avoidance of side effects, the use of recursion instead of iteration, and how functional differs from imperative programming.

Higher-order functions and list processing: passing and returning functions, the map, filter and fold (reduce) operations, function composition, and how lists are processed by the head and tail.

Memory management: how the operating system allocates and protects memory between processes, paging and segmentation, and virtual memory using secondary storage to extend the apparent size of main memory.

Software applications: the distinction between system software and application software, generic, special-purpose and bespoke applications, the role of utility programs (compression, defragmentation, backup, antivirus), and how software is licensed.

The operating system: its role as the interface between the user, applications and hardware, process management and CPU scheduling, the handling of interrupts, and the management of input/output and the file system.

Logical operations: the logic gates (AND, OR, NOT, NAND, NOR, XOR) and their truth tables, building and reading truth tables for expressions, the laws of Boolean algebra and De Morgan's laws, and simplifying expressions with Karnaugh maps.

Programming principles: primitive and composite data types, variables and constants, scope and lifetime, and the three programming constructs of sequence, selection and iteration used to build structured programs.

Program construction: the features of an integrated development environment (IDE), modular and structured program design, the use of libraries, and writing maintainable code with sensible naming, comments and indentation.

Procedural and object-oriented programming: subroutines (procedures and functions) with parameters and return values, and the object-oriented concepts of classes and objects, encapsulation, inheritance and polymorphism.

Testing and correctness: the types of program error (syntax, runtime and logic), test strategies and test data (normal, boundary and erroneous), trace tables and dry runs, and validation and verification of input data.

Program construction and translators: compilers, interpreters and assemblers and their differences, the distinction between source, object and executable code, and the stages of compilation (lexical analysis, syntax analysis, semantic analysis, code generation and optimisation).

Economic, moral, legal, ethical and cultural issues: the impact of computer science on individuals and society, the relevant UK legislation (Data Protection, Computer Misuse, Copyright and Freedom of Information), and ethical concerns such as privacy, surveillance and the digital divide.

Software engineering tools: the tools that support analysis, design, programming and testing, the role of an IDE in the development process, and version (source) control for managing changes and team collaboration.

System design: designing the inputs, outputs, processing and data structures, the use of flowcharts and pseudocode, the data dictionary, file and interface design, and specifying the hardware and software the proposed system needs.

Systems analysis: identifying stakeholders, gathering requirements (interviews, questionnaires, observation, document analysis), analysing the current system, the feasibility study and its factors, and writing a requirements specification.

The software development lifecycle: the stages from analysis through design, implementation, testing, installation, evaluation and maintenance, and a comparison of the waterfall and iterative or agile development methodologies.