A-level Computer Science Syllabus

A-level Computer Science Syllabus

Let’s be honest for a second.

The Cameroon GCE Advanced Level Computer Science exam (Subject Code 0795) is one of the most technically demanding subjects in high school.

You aren’t just memorizing definitions. You’re expected to normalize IEEE 754 floating-point numbers, minimize Boolean circuits with Karnaugh maps, trace CPU scheduling Gantt charts, write recursive C and Python programs, normalize databases up to BCNF, and subnet IPv4 networks using CIDR.

And if you’re trying to figure out how Lower Sixth and Upper Sixth topics connect? Most syllabuses make it feel like a maze.

Here’s the good news:

When you map the official MINESEC National Harmonised Progression Sheets for Lower Sixth (122 lessons) and Upper Sixth (103 lessons) into one unified curriculum, the A-level Computer Science Syllabus becomes completely structured:

  • 7 self-contained modules
  • 21 focused chapters
  • 225 chronological lessons
  • 0 cross-module splits

In this guide, I’m going to break down the entire A-level Computer Science Syllabus module by module—so you know every single competency, hands-on lab, and exam topic from Lower Sixth (L6) through Upper Sixth (U6).

Let’s dive in.


How the A-level Computer Science Syllabus Is Structured

Every Computer Science domain in the A-level Computer Science Syllabus lives inside a single self-contained module with zero cross-class duplication. Inside each chapter, lessons progress chronologically from Lower Sixth (L6) to Upper Sixth (U6).

Here is the complete 225-lesson breakdown:

237Exams.com · GCE Advanced Level (0795)

Download the Complete A-level Computer Science Syllabus (PDF)

Get the full 22-page unified curriculum guide covering all 7 Modules, 21 Chapters, and 225 chronological lessons (Lower Sixth to Upper Sixth) from the official MINESEC Progression Sheets.

⬇ Download A-Level CS Syllabus PDF Format: PDF • 22 Pages • Lower Sixth – Upper Sixth
ModuleFocus AreaChaptersLessons
Module 01Computer Applications, AI, Emerging Tech & Socio-Economic Implications223
Module 02Data Representation, Digital Logic & Computer Architecture447
Module 03Operating Systems & System Software327
Module 04Data Structures, Algorithms & Complexity339
Module 05Programming Paradigms, C/Python Coding & Software Engineering339
Module 06Information Systems, Databases & SQL331
Module 07Computer Networks, Cybersecurity & Web Development319
TotalComplete GCE 0795 Curriculum21225

Notice where the weight sits?

Modules 02, 04, and 05 alone account for 125 of the 225 lessons (over 55% of the entire syllabus). That’s architecture, digital logic, data structures, algorithms, and C/Python programming—the exact core of GCE 0795.

Let’s break down each module in detail.


Module 01: Computer Applications, AI, Emerging Tech & Socio-Economic Implications (2 Chapters · 23 Lessons)

Module 01 connects modern AI and data analysis with digital collaboration, simulation systems, and the legal/ethical rules of computing.

Chapter 1.1: Artificial Intelligence, Machine Learning & Data Analysis (12 Lessons)

  • Core Competency: Define AI/ML, ethical AI, intelligent systems, data collection/analysis, and Python AI development.
  • What You’ll Master: AI history and ethics; supervised, unsupervised, and reinforcement learning; primary vs. secondary data; quantitative, qualitative, structured, and unstructured data; data collection tools (questionnaires, interviews, digital forms); and why Python is the go-to language for AI development.

Chapter 1.2: Digital Systems, Productivity Tools & Socio-Economic/Ethical Impact (11 Lessons)

  • Core Competency: Use collaboration/productivity tools, compare manual vs. automated/AI systems, and evaluate security, cybercrime, and legal/ethical duties.
  • What You’ll Master: Manual vs. automated systems, batch vs. online processing, simulation/modelling and AI condition monitoring, general-purpose productivity tools, the CIA Triad + privacy, cybercrime, copyright/data protection laws, and the digital divide.

Module 02: Data Representation, Digital Logic & Computer Architecture (4 Chapters · 47 Lessons)

This is the largest module in the A-level Computer Science Syllabus—and it’s packed with high-yield calculation and circuit-design questions.

Chapter 2.1: Number Systems, Signed/Fractional Arithmetic & Data Encoding (11 Lessons)

  • Core Competency: Convert bases, perform two’s complement and IEEE 754 floating-point arithmetic, and encode characters, images, and sound.
  • What You’ll Master: Binary, octal, decimal, and hex conversions; kibi/kilo to tebi/tera units; BCD; sign-magnitude, one’s complement, and two’s complement arithmetic (overflow/underflow); ASCII, EBCDIC, Unicode, image/sound digitization; and fixed-point and IEEE 754 floating-point representation and normalization.

Chapter 2.2: Digital Logic Gates, Circuits, Flip-Flops & K-Map Minimisation (10 Lessons)

  • Core Competency: Design combinational, arithmetic, and sequential (SR/JK) circuits, and simplify expressions via Boolean algebra and Karnaugh maps.
  • What You’ll Master: Combinational logic, half-adders, full-adders, half/full-subtractors, sequential SR and JK flip-flops, universal NAND/NOR implementations, De Morgan’s laws, SOP/POS standard forms, and Karnaugh map (K-map) minimisation.

Chapter 2.3: Computer Organisation, Processor Architectures & Machine Cycle (18 Lessons)

  • Core Competency: Explain hardware components, embedded systems, buses, fetch-decode-execute cycle, RISC/CISC, Flynn’s taxonomy, and assembly labs.
  • What You’ll Master: Von Neumann vs. Harvard, RISC vs. CISC (pipelining, registers), Flynn’s taxonomy (SISD, SIMD, MISD, MIMD), CRAY and Dataflow architectures, system buses, fetch-decode-execute cycle, polling vs. interrupts, assembly addressing modes (immediate, direct, indirect, register, relative, indexed), plus hands-on C CPU simulation and assembly simulator projects.

Chapter 2.4: Memory Hierarchy, Storage Technologies & I/O Communication (8 Lessons)

  • Core Competency: Evaluate RAM/ROM/Cache, address-line calculations, secondary storage, peripheral interfaces, and I/O controllers.
  • What You’ll Master: SRAM vs. DRAM, cache hierarchy, calculating memory capacity from address lines, HDD/SSD/optical performance, peripheral interfaces, and polling vs. interrupt-driven I/O controllers.

Module 03: Operating Systems & System Software (3 Chapters · 27 Lessons)

Ad Space Available

Advertise to 50,000+ Students

Promote your school, program, or business directly to Cameroonian scholars.

Taught in Upper Sixth, Module 03 goes deep under the hood of how an operating system manages processes, memory, and files.

Chapter 3.1: Software Classification, System Utilities & OS Interfaces (7 Lessons)

  • Core Competency: Classify system/application software, describe utilities and linking loaders, and compare OS types and interfaces.
  • What You’ll Master: Device drivers, linking loaders, subroutine libraries, OS evolution (batch to modern systems), and CLI vs. GUI selection.

Chapter 3.2: Process Management, CPU Scheduling, Synchronisation & Deadlock (9 Lessons)

  • Core Competency: Apply FCFS, SJF, SRTF, Round Robin, locks/semaphores, and RAG deadlock strategies, including OS scheduling simulation.
  • What You’ll Master: Process states and context switching; non-preemptive (FCFS, SJF, Priority) and preemptive (SRTF, Round Robin) scheduling with Gantt charts, starvation, and ageing; locks, semaphores, and monitors; Resource-Allocation Graphs (RAG) and deadlock prevention/avoidance/detection/recovery; plus a CPU & Memory Allocation Simulator project.

Chapter 3.3: Memory Management, Virtual Memory, I/O & File Systems (11 Lessons)

  • Core Competency: Apply placement policies, paging/segmentation, demand paging, DMA/interrupt I/O, and compare FAT, NTFS, and ext file systems.
  • What You’ll Master: Logical vs. physical addresses, first-fit, best-fit, and worst-fit allocation, internal/external fragmentation, paging and segmentation, virtual memory and demand paging (page faults), programmed I/O vs. interrupt-driven I/O vs. DMA, and comparing FAT, NTFS, and ext file systems.

Module 04: Data Structures, Algorithms & Complexity (3 Chapters · 39 Lessons)

If you want to dominate Paper 2 and Paper 3 in the A-level Computer Science Syllabus, Module 04 is where you build real algorithmic muscle.

Chapter 4.1: Algorithm Design Strategies, Control Structures, Subroutines & Recursion (18 Lessons)

  • Core Competency: Design algorithms using stepwise refinement, sequence/selection/loops, parameter passing, call stacks, and recursion.
  • What You’ll Master: Brute force, divide-and-conquer, stepwise refinement, and greedy strategies; trace tables; FOR, WHILE, and REPEAT...UNTIL loops; pass-by-value vs. pass-by-reference; call stacks; and recursion vs. iteration.

Chapter 4.2: Data Structures, Linked Lists, Hash Tables & ADTs (Stacks, Queues, BSTs) (14 Lessons)

  • Core Competency: Manipulate arrays, records, linked lists, hash tables, stacks (RPN), queues, and Binary Search Trees.
  • What You’ll Master: 1D/2D arrays, records, linked lists, hash tables (linear probing & separate chaining), stack and queue ADTs, Reverse Polish Notation (RPN) and infix/prefix/postfix conversion, Binary Search Trees (BSTs) (preorder/inorder/postorder traversals, search, insert, delete), and a C Data Indexing & Search project.

Chapter 4.3: Searching, Sorting, Big-O Complexity & Computability (7 Lessons)

  • Core Competency: Trace search/sort algorithms, analyse time/space complexity in Big-O, and distinguish P/NP, decidable/undecidable, and Turing machines.
  • What You’ll Master: Big-O notation, P and NP classes, tractable vs. intractable and decidable vs. undecidable problems (Halting Problem, TSP), Turing machines, linear vs. binary search, and bubble, selection, and insertion sort.

Module 05: Programming Paradigms, C/Python Coding & Software Engineering (3 Chapters · 39 Lessons)

Module 05 turns algorithmic thinking into working C and Python code, backed by formal software engineering and automata theory.

Chapter 5.1: Programming Languages, Paradigms, Translators & Debugging (6 Lessons)

  • Core Competency: Compare imperative/OOP vs. declarative paradigms, assemblers/compilers/interpreters, and debugging tools.
  • What You’ll Master: Imperative (procedural, OOP—encapsulation, abstraction, inheritance, polymorphism, coupling, cohesion) vs. declarative (logic, functional, SQL) paradigms, translation/compilation stages, and using debuggers, breakpoints, and watchpoints.

Chapter 5.2: Programming in C & Python (23 Lessons)

  • Core Competency: Write, test, and debug C and Python programs using variables, selection, loops, strings, 1D/2D arrays, structs, and subroutines.
  • What You’ll Master: Coding in both Python and C (input()/scanf(), selection, loops, string.h/ctype, 1D/2D arrays for matrix operations, structs and arrays of records, pass-by-value/reference functions, and recursive helpers).

Chapter 5.3: Software Engineering, SDLC Models, Testing & Automata (10 Lessons)

  • Core Competency: Evaluate SDLC models, SRS, modular design, CASE/VCS tools, V&V testing, PERT/Gantt, maintenance, and Finite State Machines.
  • What You’ll Master: Writing an SRS, CASE tools and version control, Verification & Validation (V&V), PERT/Gantt critical path, and Finite State Machines (FSM) and automata.

Module 06: Information Systems, Databases & SQL (3 Chapters · 31 Lessons)

Module 06 takes you from organizational information flow all the way to multi-table SQL queries and PHP/HTML web-database integration.

Chapter 6.1: Information Systems, Organisational Levels, SDLC & GIS (9 Lessons)

  • Core Competency: Evaluate organisational IS, data capture/validation, UML/DFD system design, GIS layers, and IS maintenance.
  • What You’ll Master: Management information flow across organizational levels, data verification/validation, UML and DFD system design, and GIS layers and queries.

Chapter 6.2: Database Models, ER Modelling, Normalisation (1NF–BCNF) & Integrity (12 Lessons)

  • Core Competency: Design ERDs, normalise schemas through 3NF/BCNF, enforce integrity constraints, and explain ACID/BASE.
  • What You’ll Master: 3-Level ANSI-SPARC architecture, ER modelling, decomposing M:N relationships, normalizing tables through 1NF, 2NF, 3NF, and BCNF, entity/referential integrity, and ACID vs. BASE transactions.

Chapter 6.3: SQL, RDBMS Implementation & Web-Database Integration (10 Lessons)

  • Core Competency: Write DDL, DML, DQL, JOIN, and aggregate queries, build Access/Base apps, and connect SQL databases to HTML/PHP forms.
  • What You’ll Master: SQL DDL (CREATE, ALTER, DROP), DML (INSERT, UPDATE, DELETE), DQL (SELECT, WHERE, ORDER BY), JOINs, aggregate functions (COUNT, SUM, AVG, MIN, MAX with GROUP BY and HAVING), MS Access/Base, and connecting SQL databases to HTML/PHP forms.

Module 07: Computer Networks, Cybersecurity & Web Development (3 Chapters · 19 Lessons)

The final module of the A-level Computer Science Syllabus combines hands-on IPv4 subnetting with error-detecting codes and web authoring.

Chapter 7.1: Computer Networks, Topologies, OSI Model, IP Addressing & Subnetting (10 Lessons)

  • Core Competency: Configure LANs, compare topologies/media, map protocols to OSI layers, and implement IPv4 CIDR/subnetting.
  • What You’ll Master: Topologies, switches/routers/modems, the 7 OSI layers, IPv4 addressing, CIDR, and subnetting, mux/demux, baseband/broadband, and a virtual LAN simulation lab using ping and traceroute.

Chapter 7.2: Network Security, Internet Standards & Safe Online Services (4 Lessons)

  • Core Competency: Apply error-detecting codes (Hamming/CRC), firewalls, encryption, compare OSI vs. TCP/IP, and use internet services safely.
  • What You’ll Master: Parity, Hamming code, and CRC error detection; OSI vs. TCP/IP (TCP, UDP, IP, FTP); firewalls, encryption, and safe online practices.

Chapter 7.3: Web Development Technologies (HTML & CSS) (5 Lessons)

  • Core Competency: Evaluate online information literacy and build structured, styled webpages using HTML and CSS.
  • What You’ll Master: Information literacy, HTML document structure (text, headings, lists, links, images, tables), and styling layouts with CSS.

How to Master the A-level Computer Science Syllabus

If you want to turn these 225 lessons into a top GCE 0795 grade, focus on three habits:

  1. Practice the Hands-On Labs Early: The A-level Computer Science Syllabus includes dedicated C, Python, SQL/PHP, Assembly, and Subnetting labs. Don’t wait until Upper Sixth mocks to install a C compiler or write SQL JOIN queries.
  2. Master the Core Calculations: Two’s complement, IEEE 754 normalization, K-maps, memory address-line math, CPU scheduling Gantt charts, Big-O, and CIDR subnetting are guaranteed mark-winners when practiced regularly.
  3. Connect Theory to Architecture: When studying OS scheduling or recursion, always tie it back to what the CPU, stack, and memory hierarchy are actually doing.

Leave a Comment

Your email address will not be published. Required fields are marked *

Scroll to Top