Definition
Computer science is the study of computation: what problems can be solved by algorithmic means, how efficiently they can be solved, and how the software and hardware systems that perform computation are designed and built. It sits at the intersection of mathematics, engineering, and logic, drawing on each while being reducible to none.
The discipline divides roughly into theoretical and applied branches, though they inform each other constantly. Theoretical computer science asks foundational questions: which problems are computable at all (computability theory), how much time or space an algorithm requires relative to problem size (complexity theory), what the limits of formal proof systems are (proof theory), and how information can be quantified and transmitted reliably (information theory). Applied computer science and software engineering address the practical construction of programs, operating systems, networks, databases, and interfaces — turning theoretical insights into working systems.
What unifies the field is the concept of algorithm: a finite, unambiguous sequence of steps that transforms an input into an output. Algorithms are the primary object of study in computer science. Understanding an algorithm means understanding what it computes, how quickly, how much memory it uses, and under what conditions it fails. The history of computer science is largely a history of discovering new algorithms (or proving that certain algorithms cannot exist) and building systems that execute them at scale.
Why it matters
How it works
Abstraction layers and the systems stack
A modern computing system is a stack of abstractions. At the bottom, physical transistors implement binary logic. Logic gates implement arithmetic and memory. Instruction set architectures abstract over hardware. Operating systems abstract over hardware resources (memory, processors, storage, network) and expose them to programs through system calls. Programming languages abstract over machine instructions. Libraries and frameworks abstract over common programming patterns. Applications abstract over all of the above.
Each layer hides the complexity of those below it, allowing practitioners to work productively at their chosen level without mastering everything beneath. A web developer can build sophisticated applications without understanding processor pipelining; a CPU designer can optimise instruction execution without knowing the semantics of JavaScript. The price of abstraction is that misunderstandings about what happens at lower layers can produce subtle bugs, performance problems, and security vulnerabilities that are difficult to diagnose without descending through the stack.
Algorithms and computational complexity
The central question of algorithm design is: given a problem, what is the most efficient procedure that reliably solves it? Efficiency is measured in two dimensions: time complexity (how the number of computational steps grows with input size) and space complexity (how the memory requirement grows with input size). An algorithm that runs in O(n log n) time scales much more gracefully than one that runs in O(n²), and the difference is decisive when inputs are large.
Complexity theory organises problems into classes based on their inherent difficulty. The class P contains problems solvable in polynomial time; the class NP contains problems whose solutions can be verified in polynomial time. The famous P vs NP question asks whether P = NP — whether every problem whose solution is easy to check is also easy to solve. A proof in either direction would transform mathematics, cryptography, and optimisation.
Where it goes next
Computer science is increasingly intertwined with mathematics (particularly combinatorics, number theory, and logic), with cognitive science (through AI and machine learning), and with every field that produces or consumes data at scale. The most generative frontiers include quantum computing (exploiting quantum mechanical effects to solve certain problems exponentially faster), formal verification (proving correctness of critical software), and the theoretical understanding of deep learning systems whose empirical performance far outpaces their theoretical explanation.