Hoare's inaugural lecture at Queen's University Belfast, defining computer science as the art of designing efficient and elegant methods for solving problems by computer.

An account of how structured program design, mathematical reasoning and progressive refinement can make software easier to understand, verify and modify.

A critique of programming languages, professional habits and computing education, questioning whether avoiding uncomfortable conclusions undermines the integrity of computer science.

A critique of exaggerated claims about computers, advocating sceptical public understanding and questioning whether automation necessarily improves human activities.

An argument for computing science as a formal mathematical discipline, centred on effective reasoning, simplicity and elegance.

A critique of commercial pressures, technological hype and educational shortcomings that divert computing science from simplicity, precision and disciplined reasoning.

A course outline presenting elegance as practical simplicity and examining how it supports effective reasoning, design and problem selection.

A description of Quicksort, a divide-and-conquer sorting algorithm that partitions data around a pivot element and recursively sorts the resulting sections.

An axiomatic method for proving the correctness of computer programs, using logical rules to reason about how statements change program variables.

Practical advice on designing programming languages, arguing that they should prioritise simplicity, reliability and the needs of the programmer over elaborate features.

An argument that programming should be regarded as a branch of engineering, combining scientific foundations with practical discipline and professional responsibility for reliability.

Hoare's Oxford inaugural lecture, arguing that programming is a mathematical activity and that mathematical methods can ensure programs are correct and reliable.

A formal language and theory for describing systems of concurrent processes that interact by communication, providing a rigorous basis for reasoning about concurrency.

Hoare examines why software had become highly reliable despite little use of formal proof, and how mathematical theory and engineering practice reinforce one another.

A talk in which Hoare reflects on his 1965 invention of the null reference, calling it a mistake that caused decades of costly software errors.

An essay arguing that artificial intelligence poses serious near-term risks that can be mitigated through technology, regulation, adaptation, and public understanding.