EDUCATION SUBJECT ATLAS · COMPUTER SCIENCE · Wintour House V1.0 · CivDJ
What Is Computer Science?
Computer science is the study of computation: what problems can be represented so that a machine can solve them, how solutions can be expressed as algorithms, how data can be organised, how programs and systems can be built reliably, and what fundamental limits constrain computation.
It is broader than learning to code. Programming is one of its central tools, just as algebra is a tool of mathematics and experimentation is a tool of science. Computer science studies the ideas underneath software: abstraction, algorithms, data structures, logic, complexity, operating systems, databases, networks, security, artificial intelligence, human-computer interaction and the relationship between software and hardware.
Computer science is the discipline of turning problems into representations, representations into procedures and procedures into dependable computation.
The first idea: computation is transformation
A computation takes some representation of input, applies a defined process and produces output. A calculator transforms numbers. A search engine transforms a query into ranked results. A navigation system transforms location, road and traffic data into a route. A language model transforms tokens and learned parameters into a sequence of predicted tokens.
Computer science asks whether the representation is suitable, whether the procedure is correct, how much time and memory it requires, how it behaves on unusual inputs and whether the result can be trusted.
Algorithms
An algorithm is a finite, unambiguous procedure for solving a class of problems. Algorithms can sort records, find paths, compress files, schedule work, match patterns, encrypt messages or estimate values.
Two algorithms can produce the same correct result while requiring very different resources. This is why computer science studies efficiency, not just correctness. A method that works for one hundred records may become unusable for one billion.
Correctness
A program is correct when it satisfies its specification for the inputs covered by that specification. Correctness therefore begins before code: the requirement itself must be clear. If “fast” or “secure” is left undefined, testing cannot fully establish success.
Computer scientists use testing, assertions, invariants, type systems, formal verification and proofs to gain confidence that software behaves as intended. No single method is sufficient for every system.
Abstraction
Abstraction hides unnecessary detail so that a problem can be managed at the right level. A programmer can use a list without thinking about individual memory cells. A web developer can send a network request without manually controlling electrical signals. A database user can query records without knowing exactly where each byte sits on disk.
Abstraction is one of the deepest ideas in computing because complex systems are built as layers. Each layer offers a simpler interface while relying on lower layers to perform detailed work.
Representation
Computers operate on representations. Text becomes encoded numbers. Images become arrays of pixel values. Sound becomes sampled waveforms. Maps become coordinates and graph structures. Programs themselves become machine-readable instructions.
The representation determines what operations are easy, expensive or even possible. Choosing a data representation is therefore part of solving the problem, not merely an implementation detail.
Binary and digital information
Modern digital computers commonly represent information using bits with two states, conventionally written as 0 and 1. Groups of bits can encode numbers, characters, colours, instructions and other structures.
Binary is useful because physical systems can reliably distinguish two ranges of states. But the important computer-science idea is not the symbol 0 or 1. It is that complex information can be encoded using simple discrete states and systematically transformed.
Data structures
Data structures organise information so operations can be performed efficiently. Arrays support indexed access. Linked structures support flexible insertion. Stacks and queues organise order. Trees represent hierarchy. Hash tables support fast lookup. Graphs represent networks and relationships.
The best structure depends on the operations a program needs most. A route planner, document editor and social network may store information differently even when all operate on large collections of data.
Complexity
Algorithmic complexity describes how resource requirements grow as the input grows. Big-O notation gives a language for comparing growth rates. An algorithm whose work grows roughly linearly with input size scales differently from one whose work grows quadratically or exponentially.
Complexity matters because hardware speed cannot rescue every inefficient algorithm. Some problems become computationally enormous as input size increases, even on powerful machines.
Computability
Some questions cannot be solved by any general algorithm. Theoretical computer science studies these limits. The halting problem is a famous example: there is no universal procedure that can correctly determine for every possible program and input whether the program will eventually stop.
This matters conceptually. Computing is powerful, but not unlimited. Some barriers come from insufficient hardware; others are mathematical limits of computation itself.
Programming languages
A programming language gives humans a structured way to express computation. Languages differ in syntax, type systems, abstraction mechanisms, execution models and intended uses.
- Imperative programming describes sequences of state-changing commands.
- Functional programming emphasises evaluation of functions and controlled state.
- Object-oriented programming organises behaviour around interacting objects.
- Declarative programming specifies desired results while leaving more execution detail to the system.
No paradigm is universally best. Different problems reward different forms of expression.
Compilers and interpreters
Programming languages must ultimately connect to machine execution. Compilers translate source code into another form, often machine code or intermediate representation. Interpreters execute instructions through another program. Many modern systems combine techniques such as ahead-of-time compilation, bytecode and just-in-time optimisation.
This translation pipeline is a major example of layered abstraction: human-readable intent becomes machine-executable operations through several structured stages.
Software engineering
Computer science studies computation; software engineering studies how to build software systems reliably at scale. Real systems involve requirements, architecture, source control, testing, deployment, monitoring, documentation, teamwork and maintenance.
A program that works once on a developer’s laptop is different from a service that must operate continuously for millions of users. Reliability, observability, security and recoverability become first-class design concerns.
Operating systems
An operating system manages hardware resources and provides common services to programs. It schedules processor time, allocates memory, manages files, controls devices, enforces permissions and coordinates concurrent activity.
The operating system creates the illusion that many programs each have orderly access to a machine that is actually sharing finite resources among them.
Concurrency and parallelism
Concurrency concerns multiple tasks making progress during overlapping periods. Parallelism concerns work happening simultaneously. Modern software often uses both.
Concurrency introduces difficult problems: race conditions, deadlocks, inconsistent state and coordination overhead. Correct programs can fail when timing changes unless shared state is carefully controlled.
Computer architecture
Computer architecture studies the organisation of processors, memory, storage and input-output systems. Instructions are executed through hardware components whose design affects speed, energy use and capability.
Software performance depends partly on architecture. Memory hierarchy, caches, branch prediction, vector instructions and specialised accelerators can all influence how efficiently a program runs.
Networks
Computer networks allow machines to exchange data. The internet works through layered protocols that divide communication into manageable responsibilities. Applications rely on transport, routing, addressing and physical transmission without controlling every layer directly.
Networks introduce latency, packet loss, congestion, partial failure and hostile environments. Distributed software must therefore assume that communication can be delayed, duplicated, reordered or interrupted.
Distributed systems
A distributed system consists of multiple computers cooperating over a network. Cloud services, databases, content delivery networks and large internet platforms all rely on distributed computing.
Distribution creates scale and resilience but also complexity. Different machines may disagree temporarily about state. Engineers must manage consistency, replication, failure detection and recovery.
Databases
Databases organise persistent data and provide mechanisms to store, retrieve, update and protect it. Relational databases model data through tables and relationships; other systems use documents, key-value stores, graphs, columns or specialised structures.
Database design is about more than storage. It concerns integrity, transactions, indexing, concurrency, backup, access control and the meaning of the schema.
Information retrieval and search
Search systems must decide which documents or items are relevant to a query and how to rank them. This can involve indexing, tokenisation, statistical relevance, semantic representations, link structure, freshness and user context.
Search is a computer-science problem because efficient retrieval from enormous collections requires specialised data structures and algorithms.
Cybersecurity
Cybersecurity protects confidentiality, integrity and availability. It includes cryptography, authentication, access control, secure software design, network defence, vulnerability management and incident response.
Security is adversarial. A system must not merely work under expected use; it must resist actors intentionally trying to exploit assumptions. This changes how systems are designed and tested.
Cryptography
Cryptography uses mathematical methods to protect information and establish properties such as confidentiality, authenticity and integrity. Modern digital systems rely on encryption, digital signatures and cryptographic hashes.
Good cryptography depends on carefully studied algorithms, correct implementation and secure key management. Inventing an untested secret scheme is not equivalent to cryptographic security.
Artificial intelligence
Artificial intelligence studies computational systems that perform tasks associated with perception, prediction, reasoning, planning, language or decision-making. AI includes symbolic methods, search, optimisation, probabilistic models, machine learning and neural networks.
Machine learning differs from traditional explicit programming because behaviour is partly learned from data. A model is trained by adjusting parameters to improve performance on an objective. This creates new questions about data quality, generalisation, interpretability, robustness and bias.
Machine learning
Supervised learning uses labelled examples, unsupervised learning discovers structure without the same labels, and reinforcement learning learns through interaction and reward. Each approach fits different problem types.
A model that performs well on training data may fail on new data. Generalisation is therefore central. Evaluation requires representative test data, suitable metrics and careful separation between development and final assessment.
Human-computer interaction
Computing systems are built for people, so interface design matters. Human-computer interaction studies usability, accessibility, cognition, interaction patterns and the social effects of technology.
A technically correct system can still fail if users cannot understand it, trust it or recover from mistakes. Good interfaces make system state visible and support human goals rather than forcing people to adapt unnecessarily to machine structure.
Graphics, simulation and virtual worlds
Computer graphics transforms mathematical representations of shape, light and material into images. Simulation uses computational models to explore how systems behave. Games and virtual environments combine graphics, physics, AI, networking and human interaction.
Simulation is powerful because it allows controlled experimentation on models, but simulation output is only as trustworthy as the assumptions and data built into the model.
Robotics
Robotics connects computation to the physical world. A robot must sense, estimate state, plan, control movement and respond to uncertainty. This combines computer science with engineering, mathematics and physics.
The physical world is noisy and partially observable, which makes robotics different from software that operates entirely within digital state.
Computational thinking
Computational thinking is a way of structuring problems so they can be solved systematically. It includes decomposition, abstraction, pattern recognition, algorithm design, representation, testing and iteration.
- Decomposition: break a large problem into manageable parts.
- Abstraction: keep relevant detail and suppress irrelevant detail.
- Representation: encode the problem in a workable form.
- Algorithm design: specify a procedure.
- Evaluation: test correctness, efficiency and edge cases.
- Iteration: revise based on evidence.
Testing and debugging
Bugs are mismatches between intended and actual behaviour. Debugging is the process of isolating causes. Good debugging is scientific: form a hypothesis, gather observations, narrow the state space, test the suspected cause and verify the repair.
Tests can check individual functions, interactions among components, full-system behaviour, performance, security and regressions. Testing cannot prove the absence of every defect, but it can systematically reduce risk.
APIs and modularity
Large systems become manageable when components expose stable interfaces. An API specifies how one component can request services from another. Modularity allows teams to change internal implementation without forcing every dependent system to change.
This works only when contracts are clear. Inputs, outputs, errors, versioning and performance expectations all form part of a dependable interface.
Open source and software ecosystems
Modern software is rarely built from nothing. Developers depend on operating systems, libraries, frameworks, package managers and open-source projects. This accelerates development but creates dependency chains and supply-chain risks.
Computer science education therefore increasingly includes not only how to write software, but how to reason about the systems and dependencies in which software lives.
Ethics in computing
Computing changes power because software can operate at enormous scale. Privacy, surveillance, bias, accessibility, labour effects, misinformation, platform governance and autonomous systems all raise ethical questions.
Technical feasibility does not settle whether a system should be built or how it should be governed. Computer scientists must understand the social context of deployment, especially when systems affect rights, safety or opportunity.
A CivDJ model of computer science
- ENTITY: users, processes, services, devices, files, models and data records.
- STATE: memory, configuration, permissions, variables and system health.
- OCCURRENCE: events, requests, transactions, failures and deployments.
- RELATIONSHIP: calls, dependencies, network links, ownership and trust boundaries.
- INTENT: specifications, user goals and system objectives.
- OBSERVATION: logs, metrics, traces, tests and sensor data.
- ARTIFACT: source code, binaries, schemas, models, protocols and documentation.
- CLAIM: statements about correctness, performance, security or capability.
- VOID: untested states, unknown dependencies, unobserved failures and undecidable questions.
The CivDJ view is especially natural for computing. A system is not only code; it is entities changing state through events under contracts. Reliable engineering requires the machine to preserve evidence about what happened and to expose the voids where observability is missing.
How to think like a computer scientist
- Define the problem precisely.
- Choose a representation.
- Decompose the system.
- Design an algorithm or protocol.
- State the invariants and constraints.
- Analyse time and memory costs.
- Test normal and edge cases.
- Consider failure and adversarial behaviour.
- Observe the running system.
- Revise the abstraction when evidence shows it is wrong.
Common misconceptions
- “Computer science is coding.” Coding is a tool; the discipline studies computation, systems and information.
- “A faster computer solves every performance problem.” Poor algorithmic scaling can overwhelm hardware improvements.
- “If software passes tests, it is correct.” Tests cover selected cases; specifications and deeper reasoning still matter.
- “The cloud is somewhere outside computing fundamentals.” Cloud systems are computers, networks, storage and software organised at scale.
- “AI understands because it produces fluent output.” Capability must be evaluated by behaviour and evidence, not surface fluency alone.
- “Security can be added at the end.” Security depends on architecture, trust boundaries and implementation choices from the beginning.
Mini case: finding a name in a list
Suppose a program must find a name among one million records. If the records are unsorted, it may need to inspect many entries. If the records are sorted, binary search can repeatedly halve the remaining search space. If the program performs millions of lookups, a hash-based structure may be even more suitable.
The visible task is “find a name.” The computer-science problem is choosing a representation and algorithm that remain efficient at the required scale.
Mini case: an online checkout
An online checkout looks simple to the user but may involve inventory, pricing, authentication, payment, fraud detection, tax, shipping and confirmation services. If payment succeeds but inventory reservation fails, the system must recover consistently. If the user retries after a timeout, the order must not accidentally be charged twice.
This is why distributed systems rely on identifiers, transactions, idempotency, retries and observability. Computer science turns a familiar button into a precise system of state transitions.
Computer science across the learning journey
Young learners can begin with sequencing, patterns, simple algorithms and block-based programming. Later they can study variables, control flow, functions, data structures, networks and databases. Advanced study adds algorithms, complexity, operating systems, compilers, computer architecture, theory of computation, machine learning, cybersecurity and distributed systems.
The progression is not simply from easy code to difficult code. It is from controlling small procedures to reasoning about large abstractions, formal limits and systems that must remain correct under uncertainty.
Why computer science belongs inside education
Computer science teaches learners to formalise problems, separate interfaces from implementation, reason about scale, test assumptions and design systems that remain understandable when complexity increases. It also provides the literacy needed to understand software, data, AI, cybersecurity and digital infrastructure.
As more of modern life is mediated by computation, computer science is not only vocational preparation. It is a way to understand how digital systems make decisions, where they can fail and how human intentions become machine behaviour.