Computer science, from first principles.
Eight modules that explain what's actually happening inside the machine — data, algorithms, complexity, code, networks and databases — in plain English with real depth. Finish with a 25-question exam and an instant certificate.
What you'll be able to do.
Written as demonstrable outcomes, the way the AQF frames them. On completing this course you will be able to:
- CLO1Explain how computers represent and process data — binary, encodings, and the roles of CPU, memory and storage.
- CLO2Apply computational thinking — decomposition, abstraction and algorithm selection — to routine and non-routine problems.
- CLO3Select and justify appropriate data structures for predictable and sometimes unpredictable problems.
- CLO4Analyse and compare algorithm efficiency using Big-O reasoning.
- CLO5Apply programming fundamentals and collaborative engineering practice — control flow, functions, error handling, version control, testing and debugging.
- CLO6Describe how networks, the web and databases operate, and transmit that understanding clearly to others.
Who it's for: anyone starting in tech, working alongside developers, or wanting the foundations under their AI skills. No prior programming required — just curiosity. Pairs well with AI Essentials.
Eight modules, first principles to practice.
Each module states its learning outcomes, teaches the content, and sets an Apply it task. Everything in the exam is covered here.
Module 1How computers compute
- LO1.1Explain why digital hardware uses binary and how bits and bytes represent values.
- LO1.2Describe how text, numbers and images are encoded as data.
- LO1.3Outline the roles of CPU, memory and storage in executing a program.
Core content
Everything in computing reduces to bits — two states, on/off — because two states are what electronic hardware can distinguish quickly and reliably, billions of times per second. Eight bits make a byte (256 possible values), and from bytes we build everything: integers counted in binary, text as numbers mapped to characters by an encoding (today, usually UTF-8), images as grids of pixel values, sound as sampled waveforms.
The machine itself is a simple loop at heart: the CPU fetches an instruction from memory (RAM) — fast, temporary — executes it, and repeats, while storage (SSD/disk) holds data permanently. Speed comes from doing this absurdly fast, not from intelligence. When a program "runs", it's this fetch–execute cycle marching through your instructions.
Module 2Algorithms & computational thinking
- LO2.1Define algorithms and express them precisely (steps/pseudocode).
- LO2.2Apply decomposition, pattern recognition and abstraction to problems.
- LO2.3Compare linear and binary search and state when each applies.
Core content
An algorithm is a precise, step-by-step procedure for solving a problem — precise enough that a machine (which never "gets the gist") can follow it. Computational thinking is the craft of getting there: decomposition (break the problem into smaller solvable parts), pattern recognition (spot the repeats), abstraction (ignore irrelevant detail), then express the steps unambiguously.
The classic illustration: finding a name in a list. Linear search checks every item — works on anything, scales badly. Binary search halves the search space each step — spectacularly fast, but with a precondition: the data must be sorted. That trade-off (preparation buys speed) recurs throughout computing. Correctness matters as much as speed: an algorithm must handle the edge cases — empty lists, missing items, duplicates — not just the happy path.
Module 3Data structures
- LO3.1Describe arrays/lists, stacks, queues, hash tables, trees and graphs.
- LO3.2Select a structure to fit a problem's access pattern and justify the choice.
Core content
Data structures are about matching shape to access pattern. Arrays/lists hold items in order — great for "give me item 7". A stack is last-in-first-out (undo history, browser back button); a queue is first-in-first-out (print jobs, fair processing). A hash table (dictionary/map) gives near-instant lookup by key — the workhorse behind caches, indexes and symbol tables. Trees model hierarchy (folders in folders, org charts, the structure of this web page); graphs model networks (roads, social connections, dependencies).
The practitioner's question is never "which structure is best?" but "how will this data be accessed?" — by position, by key, in order of arrival, by relationship? Answer that and the structure usually picks itself.
Module 4Complexity & efficiency (Big-O)
- LO4.1Explain what Big-O notation describes and why it matters.
- LO4.2Recognise O(1), O(log n), O(n) and O(n²) behaviour and compare solutions.
Core content
Big-O describes how an algorithm's work grows as the input grows — not how fast it runs on your laptop today, but what happens when 100 items become 10 million. The landmark classes: O(1) constant (hash lookup), O(log n) logarithmic (binary search — doubling the data adds one step), O(n) linear (scan everything once), O(n²) quadratic (compare everything with everything — double the input, four times the work).
This is why "it worked in testing" systems die in production: a quadratic algorithm is invisible at 100 records and catastrophic at a million. It's also why binary search justifies the cost of sorting, and why indexes exist in databases. Time isn't the only currency — memory trades against speed constantly (caching is exactly that trade).
Module 5Programming fundamentals
- LO5.1Use variables, types, control flow and functions to express logic.
- LO5.2Explain error handling (exceptions) and why it matters.
- LO5.3Describe version control (Git) and its role in collaboration.
Core content
All mainstream code is built from a tiny vocabulary: variables (named values with types), control flow (if/else decisions, loops), and functions — reusable, named blocks that take inputs and return outputs. Functions are the unit of thought: name them well, keep them small, and a program reads like prose. When something goes wrong at runtime, an exception signals it — and well-written code catches and handles expected failures (missing file, bad input) instead of crashing or, worse, continuing wrongly.
Paradigms — procedural, object-oriented, functional — are styles of organising the same fundamentals; modern languages mix them. And no code is professional without version control: Git tracks every change, lets many people work in parallel via branches, and makes "who changed what, when, and why" answerable forever.
Module 6Software engineering practice
- LO6.1Explain testing levels (unit, integration) and what each protects.
- LO6.2Apply a systematic debugging method.
- LO6.3Describe code review and iterative delivery (agile vs waterfall) and their purpose.
Core content
Software engineering is what turns code into a product that survives contact with users. Unit tests verify one small piece in isolation; integration tests verify pieces work together; together they make change safe — the test suite is a safety net that lets you refactor without fear. Debugging is a method, not a mood: reproduce reliably first, then isolate (binary-search the cause), fix, and add a test so it never returns.
Code review — a second person reading changes before they merge — catches defects early and spreads knowledge through the team; it's quality control and training in one. Delivery style matters too: waterfall plans everything up front (fine when requirements are fixed); agile ships small increments and adjusts from feedback (fits most software, where requirements are discovered, not known).
Module 7Networks & the web
- LO7.1Trace what happens when a browser loads a page — DNS, IP, TCP, HTTP.
- LO7.2Explain HTTPS/TLS and what it protects.
- LO7.3Describe APIs and the client–server model.
Core content
The internet moves packets — small chunks of data, individually addressed by IP address and reassembled at the destination (TCP handles ordering and retransmission). When you visit a site, DNS translates the name into an IP address first — the internet's phone book — then your browser (the client) sends an HTTP request to a server, which responds with the page.
HTTPS is HTTP wrapped in TLS: it encrypts the conversation, protects it from tampering, and authenticates that you're talking to the real server — which is why anything involving logins or payments must use it. And an API is simply a defined interface for programs to talk to programs — the same request/response pattern, returning data instead of pages. Modern software is mostly programs calling each other's APIs.
Module 8Databases & data
- LO8.1Explain the relational model — tables, rows, keys and joins.
- LO8.2Describe what indexes and transactions provide, and their trade-offs.
- LO8.3Recognise when non-relational stores fit, and why backups are non-negotiable.
Core content
Relational databases organise data into tables of rows and columns. Each row gets a primary key — a value that uniquely identifies it — and tables reference each other through those keys, letting a SQL JOIN combine related rows across tables (customers with their orders) without duplicating data. Indexes are the database's sorted shortcuts: dramatically faster reads on a column, paid for with slower writes and extra storage — the Big-O trade-off again.
Transactions exist for the moments that must not half-happen: ACID guarantees mean a group of operations either all succeed or all fail — the reason a bank transfer can't debit one account without crediting the other. Non-relational ("NoSQL") stores trade some of this structure for flexibility or scale and fit some jobs well. Whatever the store: data you haven't backed up — and tested restoring — is data you've agreed to lose.
How this course maps to AQF Level 4.
The Australian Qualifications Framework defines each level by three criteria — knowledge, skills, and application of knowledge and skills. This course's outcomes and exam are designed against the Level 4 criteria (the level of the Certificate IV), quoted below from the framework.
| AQF Level 4 criterion | The framework says… | How this course addresses it |
|---|---|---|
| Knowledge | "Graduates at this level will have broad factual, technical and some theoretical knowledge of a specific area or a broad field of work and learning." | Modules 1, 4, 7 and 8 build broad factual and technical knowledge of computing — data representation, complexity theory at working depth, networking and the relational model (CLO1, CLO4, CLO6). |
| Skills | "A broad range of cognitive, technical and communication skills to select and apply a range of methods, tools, materials and information to: complete routine and non-routine activities; provide and transmit solutions to a variety of predictable and sometimes unpredictable problems." | Algorithm and data-structure selection (M2–M3), debugging method and testing (M6), and the explain-it-to-others Apply it tasks in every module train selection, application and transmission of solutions (CLO2, CLO3, CLO5). |
| Application of knowledge and skills | "Graduates at this level will apply knowledge and skills to demonstrate autonomy, judgement and limited responsibility in known or changing contexts and within established parameters." | Applied tasks require autonomous work with judgement inside set parameters — estimating scaling behaviour (M4), designing a small schema (M8), and recording a systematic debug (M6) (CLO4, CLO5). |
Criteria quoted from the AQF levels published at aqf.edu.au. The AQF also specifies volume of learning for qualification types (typically 0.5–2 years for a Certificate IV); at ~10 hours plus practice, this course aligns its outcome design to Level 4 descriptors but does not approach a qualification's volume of learning — one more reason it is not, and does not claim to be, an AQF qualification.
Plain-English status: this is a non-accredited course. Its certificate is a completion certificate issued by Course Contact, designed with reference to AQF Level 4 descriptors. It is not an AQF qualification (only ASQA/TEQSA-accredited providers can issue those), confers no licence, and Course Contact is not a registered training organisation. Want an accredited Certificate IV in IT or similar? We'll match you with providers, free →
Foundations laid. Prove them.
25 questions across all eight modules — 80% to pass, options shuffle every attempt, certificate issued instantly.