--- title: "Computing" description: "260 topics for ages 5 to 24, in the order they build on each other." canonical: https://lightmysky.com/learn/computing source: https://lightmysky.com/learn/computing.md retrieved: 2026-10-19 --- > **Agent view.** This is the Markdown twin of the page, for tools and assistants. > When to use this site, and the call that answers each job: https://lightmysky.com/agent-instructions.md > API description (OpenAPI 3.1): https://lightmysky.com/openapi.json · Authentication: https://lightmysky.com/auth.md > Pricing: https://lightmysky.com/pricing.md · Catalog: https://lightmysky.com/llms.txt · Full catalog: https://lightmysky.com/llms-full.txt > Every machine-readable file on this domain: https://lightmysky.com/.well-known/ai-catalog.json > Ask for Markdown with `Accept: text/markdown`, a `.md` address, or `?mode=agent`. # Computing 260 topics for ages 5 to 24, in the order they build on each other. Page: https://lightmysky.com/learn/computing ## Artificial Intelligence 30 topics, ages 5 to 16. https://lightmysky.com/learn/computing/areas/artificial-intelligence - [Computers in Everyday Life](https://lightmysky.com/learn/computing/computers-in-everyday-life-mt_XbGfVhfiUz): Identifying computers in everyday life: not just laptops but phones, tablets, smart speakers, traffic lights, washing machines; what makes something a computer - [Smart Versus Not-Smart Devices](https://lightmysky.com/learn/computing/smart-versus-not-smart-devices-mt_WRRv1ABECC): Comparing ordinary objects with devices that have computer features, such as answering spoken questions. Sensors detect things and trigger responses, but sensing or using electricity alone does not prove that a device has smart computer features. - [Step-by-Step Instructions](https://lightmysky.com/learn/computing/step-by-step-instructions-mt__p5n8z5soJ): Step-by-step instructions for everyday tasks (making a sandwich, brushing teeth); that if instructions are wrong or missing, things go wrong; computers follow instructions exactly - [Real-World Robots](https://lightmysky.com/learn/computing/real-world-robots-mt_jvJ35MmCvK): Real robots use computers to control moving parts for physical jobs. Examples include robot vacuums, factory arms and doctor-controlled surgery arms. Robots use software and are not living things. - [Voice Assistants and How They Work](https://lightmysky.com/learn/computing/voice-assistants-and-how-they-work-mt_u6SYiVx7FX): How voice-assistant software handles spoken requests. A simple model follows listening, working out a request, finding an answer and speaking. Assistants can mishear, misinterpret requests or give mistaken answers. They are programs, not people with human feelings. - [AI in Daily Life](https://lightmysky.com/learn/computing/ai-in-daily-life-mt_AzTrT5ySCx): Recognise AI uses such as face unlock, learned word prediction, video recommendations, photo sorting and voice assistants; distinguish learned patterns from a fixed sensor rule - [Data and Information for Computers](https://lightmysky.com/learn/computing/data-and-information-for-computers-mt_kH1DzOPsXG): What data is: information that computers use, such as numbers, words, pictures, and sounds. Computers use data they receive and can make new results from that data. - [Patterns and Classification](https://lightmysky.com/learn/computing/patterns-and-classification-mt_ofOGCQ7FWj): Sorting items by a shared rule is classification. A computer can learn patterns from examples, and varied examples help us test whether its sorting works on new items. - [AI in Computer Games](https://lightmysky.com/learn/computing/ai-in-computer-games-mt_fT4G0QloX5): How computer opponents choose game actions using fixed rules, move search or learning from examples; difficulty adjustment and level generation; why changed behavior alone does not prove learning - [Machine Learning Basics](https://lightmysky.com/learn/computing/machine-learning-basics-mt_K6qtan847r): A basic explanation of machine learning: a computer studies many examples, finds patterns and makes predictions about new things. Includes hands-on practice with Teachable Machine or a similar tool. - [AI Mistakes and Limitations](https://lightmysky.com/learn/computing/ai-mistakes-and-limitations-mt_bPFToj0OhZ): Machines make mistakes; they only know what they've been shown; bad training data leads to bad results; AI is not magic — just maths on data; showing edge cases and failures - [Humans Versus Machines](https://lightmysky.com/learn/computing/humans-versus-machines-mt_oajUvqAiBJ): Compare people and computers on particular tasks, including calculation, storage, repetition, creativity and care. Introduce a simplified text-chat Turing Test and the limits of its conclusions. - [Recommendation Systems and Filter Bubbles](https://lightmysky.com/learn/computing/recommendation-systems-and-filter-bubbles-mt_EedcpioR0v): Recommendation systems use data, such as viewing history, to suggest things a person might like. Suggestions can save search time or introduce something new. Narrow suggestions can contribute to a filter bubble that limits exposure to different topics or views. - [Bias in AI Systems](https://lightmysky.com/learn/computing/bias-in-ai-systems-mt__BbOjiY5A5): If training data is biased, AI will be biased; examples: facial recognition working better for some skin tones, translation assuming gender; where bias comes from and whether we can fix it - [AI and Fairness in Decisions](https://lightmysky.com/learn/computing/ai-and-fairness-in-decisions-mt_cVp_nop-5L): Whether AI should make important decisions about people: jobs, loans, justice; who is responsible when AI makes unfair decisions; introduction to algorithmic fairness - [Deepfakes and AI-Generated Content](https://lightmysky.com/learn/computing/deepfakes-and-ai-generated-content-mt_tzMr83pS8v): AI-generated images, writing and deepfakes; why appearance and writing style cannot prove how content was made; checking original sources and evidence before believing or sharing - [Designing Fair AI Rules](https://lightmysky.com/learn/computing/designing-fair-ai-rules-mt_1z-gJBJFlM): Design thinking applied to AI ethics: if you were designing an AI system, what rules would you give it? Who should it help? What should it not be allowed to do? - [How a Chatbot Picks Its Next Token](https://lightmysky.com/learn/computing/how-a-chatbot-picks-its-next-token-mt_1Zbhamhzai): A language-model chatbot generates text in small pieces called tokens. It uses learned patterns and the available context to select a next token, adds it, and repeats. Some chatbots also retrieve information with tools. - [Weighted Models: Learned Parameters and Written Code](https://lightmysky.com/learn/computing/weighted-models-learned-parameters-and-written-code-mt_3_1toZUxak): In a weighted model, training fits numerical parameters to examples. Human-written code defines the calculation and training process. Small models can be traced directly; interpreting a large model can be harder. - [Training Data: Where It Came From and What It Leaves Out](https://lightmysky.com/learn/computing/training-data-where-it-came-from-and-what-it-leaves-out-mt_1Lw0TMHShk): Training-data coverage, collection dates and permitted use provide evidence about a model's risks. They do not establish suitability alone. Testing should reflect the people, conditions and task where the model will be used. - [Writing a Prompt That Says What You Actually Want](https://lightmysky.com/learn/computing/writing-a-prompt-that-says-what-you-actually-want-mt_dJ5-SDX3Ck): A chatbot uses the context available to it, not private intentions that were never supplied. Stating the task, audience, format and limits helps reduce unwanted assumptions and provides criteria for reviewing its answer. - [AI and the Future of Work](https://lightmysky.com/learn/computing/ai-and-the-future-of-work-mt__AWSThGJ0d): How AI can change tasks within jobs, create work around AI systems and reduce demand for some work; why human judgment, creativity, empathy and problem-solving remain useful - [AI Data Collection and Privacy](https://lightmysky.com/learn/computing/ai-data-collection-and-privacy-mt_HopZomN12L): Personal data that apps and AI services may collect; why companies use it; cookies and tracking; smart-speaker activation; checking permissions, storage and deletion controls with an adult - [Checking a Model's Claim Against a Source](https://lightmysky.com/learn/computing/checking-a-models-claim-against-a-source-mt_Qh4Pnnfqv2): Checking a model's claim means inspecting relevant external evidence, judging the source and comparing the exact claim with its original context. Record what is supported, contradicted or unconfirmed before using it. - [AI and the Environment](https://lightmysky.com/learn/computing/ai-and-the-environment-mt_ZpCcTU8j_o): Electricity used to train and run AI; water used by some data-centre cooling systems; possible environmental uses such as forest monitoring and renewable-energy forecasting; comparing costs and actual benefits - [The Future of AI](https://lightmysky.com/learn/computing/the-future-of-ai-mt__LiAEHt9nk): What AI might do in 10 years; what we want it to do and what we're worried about; children as future designers and decision-makers about AI; hopeful, empowered framing - [Why a Chatbot Can Be Confidently Wrong](https://lightmysky.com/learn/computing/why-a-chatbot-can-be-confidently-wrong-mt_TMHNkprrks): A language-model chatbot can generate fluent but false claims or references. Confident wording is not proof of accuracy. Retrieval can supply evidence, but claims and cited sources still need checking. - [Using an AI Tool on Schoolwork Without Cheating Yourself](https://lightmysky.com/learn/computing/using-an-ai-tool-on-schoolwork-without-cheating-yourself-mt_fjlXx-hkp_): Use AI within assignment rules while practicing the intended skill. Plan tool-free work, check suggestions, protect private information and describe assistance accurately. Disclosure does not make prohibited use acceptable. - [What You Owe a Reader When a Model Helped](https://lightmysky.com/learn/computing/what-you-owe-a-reader-when-a-model-helped-mt_VsUSovHzfI): Work a model helped produce still carries its author's name. What the reader is owed is a plain statement of what the tool did and what the author checked, in whatever form the setting asks for. - [Agents That Take Actions, Not Just Answer](https://lightmysky.com/learn/computing/agents-that-take-actions-not-just-answer-mt_D7KzIdIsjb): Once a model can send a message, spend money or change a file, a wrong answer stops being a wrong answer and becomes a wrong action. What the tool is allowed to reach sets how bad a mistake can get. ## Computing Fundamentals 16 topics, ages 5 to 14. https://lightmysky.com/learn/computing/areas/computing-fundamentals - [Simple Programs: Sequences and Instructions](https://lightmysky.com/learn/computing/simple-programs-sequences-and-instructions-mt_IUvBwahibH): Write, run and fix simple programs by putting instructions in order: plan a sequence of steps, predict what the program will do before running it, and hunt down the step that went wrong when it doesn't behave as expected - [Creating Digital Content](https://lightmysky.com/learn/computing/creating-digital-content-mt_dfhHVURsn6): Use technology purposefully to create and manage digital work: write and edit documents, make pictures, slides and simple videos, save files where they can be found again, and choose or combine the right software for the job - [Networks and the Internet](https://lightmysky.com/learn/computing/networks-and-the-internet-mt_JmrMg6v8V_): Connected computers can share information. The internet is a network of networks. Services such as the world wide web, email and video calls use it to pass data from machine to machine. - [Programming with Loops and Variables](https://lightmysky.com/learn/computing/programming-with-loops-and-variables-mt_9x5zgShXPg): Design and debug programs that use repetition, selection and variables: repeat actions with loops, branch with if-blocks, keep score in a variable, and break a bigger problem into smaller parts that can be programmed one at a time - [Searching and Evaluating Online](https://lightmysky.com/learn/computing/searching-and-evaluating-online-mt_S-XboPwA8k): Search the web effectively and judge what comes back: choose precise search words, understand that results are selected and ranked by a program rather than checked by a person, and weigh whether a page is trustworthy and relevant - [Events: Programs That React to What the User Does](https://lightmysky.com/learn/computing/events-programs-that-react-to-what-the-user-does-mt_HFtGUhZHz4): A program does not have to run from top to bottom. A handler sits waiting for a click, a key press or a collision, and runs only when that thing happens. - [Conditions That Combine: And, Or and Not](https://lightmysky.com/learn/computing/conditions-that-combine-and-or-and-not-mt_ZYdtXQZy5r): One test is often not enough. Joining tests with and, or and not lets a single decision depend on several things at once, and each joiner changes when the branch is taken. - [Inside the Box: Input, Processing, Storage and Output](https://lightmysky.com/learn/computing/inside-the-box-input-processing-storage-and-output-mt_Oms8067Pnm): Every computer, from a phone to the controller in a washing machine, does the same four jobs: take data in, work on it, keep it, and send results out. Naming which part does which job explains what any device is. - [Random Numbers and Programs That Differ Each Run](https://lightmysky.com/learn/computing/random-numbers-and-programs-that-differ-each-run-mt_t8GTOW3hyN): A random value makes a program behave differently every time it runs. That is what games and simulations need, and it changes what counts as having tested the program. - [Finding a Bug by Changing One Thing at a Time](https://lightmysky.com/learn/computing/finding-a-bug-by-changing-one-thing-at-a-time-mt_DMgajrUSy_): Changing several things at once hides which change mattered. Working one change at a time, with a prediction written down before each run, finds the fault and says what caused it. - [Why a Computer Works with Only Two Symbols](https://lightmysky.com/learn/computing/why-a-computer-works-with-only-two-symbols-mt_r0wLIjpi5R): Inside the machine every value is a pattern of switches that are either on or off. Two states can be told apart reliably in a circuit, which is the reason a computer counts in twos rather than tens. - [An Agreed Code: How the Same Bits Mean Letters or Colours](https://lightmysky.com/learn/computing/an-agreed-code-how-the-same-bits-mean-letters-or-colours-mt_IQY-PHtZVZ): A pattern of bits means nothing on its own. It becomes a letter, a colour or a note only because a code says so, and both ends have to be using the same code. - [Addresses on a Network: IP Addresses, Hostnames and Paths](https://lightmysky.com/learn/computing/addresses-on-a-network-ip-addresses-hostnames-and-paths-mt_tGgw0Vhd8b): IP addresses identify destinations for network data. Ordinary devices on one local network need distinct addresses, while separate private networks can reuse them. A web address contains a hostname and a path. DNS can look up IP addresses for the hostname. - [Reading a Program Someone Else Wrote](https://lightmysky.com/learn/computing/reading-a-program-someone-else-wrote-mt_VdxhuxjBSn): Most code a person meets was written by somebody else. Working out what an unfamiliar program does, and then changing it on purpose, is a different skill from writing one from a blank screen. - [Spotting a Mistake in Stored or Sent Data](https://lightmysky.com/learn/computing/spotting-a-mistake-in-stored-or-sent-data-mt_wKwax55eo-): Data gets corrupted on the way, so systems send extra bits that only fit when nothing has changed. A parity bit or a check digit catches an error without anybody reading the message. - [Writing an Algorithm Down: Flowcharts and Pseudocode](https://lightmysky.com/learn/computing/writing-an-algorithm-down-flowcharts-and-pseudocode-mt_RCm-4b4Lof): An algorithm can be recorded before any code exists, as a flowchart or as pseudocode. Both fix the order, the decisions and the repetitions, so the plan can be checked on paper and argued about with someone else. ## Digital Literacy 6 topics, ages 8 to 13. https://lightmysky.com/learn/computing/areas/digital-literacy - [Typing Without Looking at the Keys](https://lightmysky.com/learn/computing/typing-without-looking-at-the-keys-mt_BJ_yVASyuV): Finding keys by feel instead of by eye frees a writer's attention for what they are writing. It is built by short regular practice with settled fingering, not by chasing speed. - [Where a File Lives: Folders, Names and Backups](https://lightmysky.com/learn/computing/where-a-file-lives-folders-names-and-backups-mt_UvLO9CA3BY): Files sit inside folders inside other folders, and the path is the address that says which one. A name that describes the work, a place that makes sense and a second copy elsewhere are what make work findable later. - [Spreadsheets: Rows, Columns and a Formula That Updates Itself](https://lightmysky.com/learn/computing/spreadsheets-rows-columns-and-a-formula-that-updates-itself-mt_iWyPF0-Abz): A spreadsheet holds values in cells and formulas that refer to those cells by name. Change one value and everything computed from it recalculates, which is what makes a sheet a model rather than a table. - [Passwords, Logins and Keeping an Account Yours](https://lightmysky.com/learn/computing/passwords-logins-and-keeping-an-account-yours-mt_ohI6ct6tO4): An account is only as private as the way into it. Length beats cleverness in a password, one password reused spreads a single break across every account, and a second factor stops most of what is left. - [Reusing Someone Else's Work: Licences and Giving Credit](https://lightmysky.com/learn/computing/reusing-someone-elses-work-licences-and-giving-credit-mt_SeLxugBmM7): Images, music and text found online belong to whoever made them, and a licence says what other people may do with it. Reading that licence, and naming the source, is what separates reuse from taking. - [Sorting and Filtering a Table to Answer a Question](https://lightmysky.com/learn/computing/sorting-and-filtering-a-table-to-answer-a-question-mt_6-UzZXVWwV): A table of a few hundred rows will not answer a question by being read. Sorting brings the extremes to the top and filtering drops the rows that do not bear on the question, and what is left is the answer. ## Programming 26 topics, ages 14 to 18. https://lightmysky.com/learn/computing/areas/programming - [Variables and Assignment in Text Code](https://lightmysky.com/learn/computing/variables-and-assignment-in-text-code-mt_uLHLaX8BQq): Storing a value under a name in written code, then replacing it later. The name holds whatever was last assigned to it, which is how a program remembers anything. - [Input, Output and Type Conversion](https://lightmysky.com/learn/computing/input-output-and-type-conversion-mt_lZmkGSELbC): Reading what a user types, printing results back, and converting typed text into a number before doing arithmetic with it. - [Arithmetic in Code: Integer Division and Remainder](https://lightmysky.com/learn/computing/arithmetic-in-code-integer-division-and-remainder-mt_ZPnPrLGPmT): The arithmetic a program actually offers, including whole-number division and the remainder, and the order operators are applied in. - [Boolean Expressions and Comparison Operators](https://lightmysky.com/learn/computing/boolean-expressions-and-comparison-operators-mt_0aIh-DPCZ4): Expressions that come out true or false: comparisons between values, and the way and, or and not combine them. - [Selection with if, elif and else](https://lightmysky.com/learn/computing/selection-with-if-elif-and-else-mt_zylJ-p9g1g): Making a program take one path or another according to a condition, including several branches tested in order until one fits. - [Count-Controlled Loops](https://lightmysky.com/learn/computing/count-controlled-loops-mt_r1eXTWI_6j): Repeating a block a known number of times, with a loop variable that takes each value of a range in turn. - [Condition-Controlled Loops](https://lightmysky.com/learn/computing/condition-controlled-loops-mt_LjxO2n3Fy6): Repeating for as long as a condition stays true, for when the number of repeats is not known in advance, and making sure something inside the loop can make the condition false. - [Strings: Indexing, Slicing and Length](https://lightmysky.com/learn/computing/strings-indexing-slicing-and-length-mt_33hA050_Qz): Treating text as a sequence of characters that can be measured, indexed from zero, and cut into parts. - [Lists: Many Values Under One Name](https://lightmysky.com/learn/computing/lists-many-values-under-one-name-mt_ipB6kmyK85): Holding a whole collection of values in a single variable, then reading and changing items by their position. - [Tracing a Program by Hand](https://lightmysky.com/learn/computing/tracing-a-program-by-hand-mt__rsnZ5Goow): Following code line by line with a table of the variables, to say what it does and where it goes wrong. Errors that stop the program are found differently from errors that give a wrong answer. - [Traversing a List to Build a Result](https://lightmysky.com/learn/computing/traversing-a-list-to-build-a-result-mt_lusbjHFt95): Looping over every item in a collection while carrying a running result: a total, a count, or the largest value seen so far. - [Defining a Function with Parameters](https://lightmysky.com/learn/computing/defining-a-function-with-parameters-mt_pyo7yBg4H3): Giving a named block of code a job of its own and passing values into it, so the same steps run on different data. - [Linear Search](https://lightmysky.com/learn/computing/linear-search-mt_32LwZIhSiB): Looking for a value by checking items one after another until it is found or the collection runs out, and counting the checks that takes in the best and worst case. - [Binary Search on Sorted Data](https://lightmysky.com/learn/computing/binary-search-on-sorted-data-mt_3avV-VasFZ): Finding a value in sorted data by halving the range that is still in play at every step, and the reason the method breaks on unsorted data. - [Return Values and Variable Scope](https://lightmysky.com/learn/computing/return-values-and-variable-scope-mt_jivtTHpZc7): Sending a result back out of a function, and the rule that a name created inside a function does not exist outside it. - [Decomposing a Problem into Subprograms](https://lightmysky.com/learn/computing/decomposing-a-problem-into-subprograms-mt_P293LckCnd): Splitting a task into parts small enough to write and check one at a time, then wiring the parts together into the whole program. - [Dictionaries: Values Found by Key](https://lightmysky.com/learn/computing/dictionaries-values-found-by-key-mt_mofpj0n5AM): A collection where each value is stored under a key of the programmer's choosing instead of a position. Looking a value up by key stays fast however many pairs are stored. - [Classes and Objects: Bundling Data with Behaviour](https://lightmysky.com/learn/computing/classes-and-objects-bundling-data-with-behaviour-mt_kRvg7LZ_kk): A class defines a kind of object, with attributes for its data and methods for its behaviour. Each instance can hold its own state. An initializer sets starting values; access rules require deliberate design. - [Functions at Depth: Default and Keyword Arguments](https://lightmysky.com/learn/computing/functions-at-depth-default-and-keyword-arguments-mt_SR8RhRmYhz): Giving a parameter a default so callers can leave it out, and naming arguments at the call so their order stops mattering. This is how one function serves several jobs without a second copy of the code. - [Inheritance and Overriding Behaviour](https://lightmysky.com/learn/computing/inheritance-and-overriding-behaviour-mt_wBp7j_B6fj): A subclass reuses a superclass's methods and can extend its initialization or replace methods. Instance fields still need initialization. Shared behaviour is written once, with each difference in the class responsible for it. - [Designing with Objects: Deciding What Each Class Owns](https://lightmysky.com/learn/computing/designing-with-objects-deciding-what-each-class-owns-mt_De_gpvpOzg): Reading a problem description and deciding which things deserve a class, what each one is responsible for, and where the boundaries between them fall. The judgement is about responsibility, not about syntax. - [Reading and Writing Files, Including CSV](https://lightmysky.com/learn/computing/reading-and-writing-files-including-csv-mt_j5qb4FdkdI): Opening a file, reading it line by line or writing to it, and closing it again, plus the row-and-column shape of CSV. This is where a program's data starts outliving the run that produced it. - [Exceptions: Raising, Catching and Recovering](https://lightmysky.com/learn/computing/exceptions-raising-catching-and-recovering-mt_hEVa1JRrGu): Signalling an unusable input or failed operation with an exception, then choosing a deliberate handling policy. Expected failures may be recovered from; other failures may be reported and propagated rather than silently suppressed. - [Unit Tests: Deciding What Is Worth Testing](https://lightmysky.com/learn/computing/unit-tests-deciding-what-is-worth-testing-mt_tuIQecq5Le): Writing small automated checks that call a function with chosen inputs and compare its behaviour with a specified contract. Choose ordinary cases, relevant boundaries and specified errors; empty input matters when the contract makes it relevant. - [Debugging as a Method: Reproduce, Isolate, Fix](https://lightmysky.com/learn/computing/debugging-as-a-method-reproduce-isolate-fix-mt_2JGE4ICRf6): Working from a fault to its cause by a repeatable route: reproduce it reliably, cut the program down until the fault is cornered, then change one thing and check. Guessing edits is the habit this replaces. - [The Project Arc: Building a Program in Stages](https://lightmysky.com/learn/computing/the-project-arc-building-a-program-in-stages-mt_hACOaB3nA_): Taking a project from a written aim to working software in stages: a thin version that runs end to end, then features added one at a time, each kept working. Refactoring is the step that keeps the code liveable as it grows. ## Algorithms & Data Structures 40 topics, ages 16 to 24. https://lightmysky.com/learn/computing/areas/algorithms-and-data-structures - [Counting Operations to Compare Algorithms](https://lightmysky.com/learn/computing/counting-operations-to-compare-algorithms-mt_JkN961niFG): Working out how many comparisons or swaps a method performs on an input of a given size, and writing that count as a formula in n. Two algorithms can then be compared without running either one. - [Stacks: Last In, First Out](https://lightmysky.com/learn/computing/stacks-last-in-first-out-mt_Evw7zeJE6Q): A collection where the only value within reach is the one added most recently. Push puts a value on top, pop takes it off, and that single restriction is what makes undo, back buttons and bracket checking straightforward. - [Queues: First In, First Out](https://lightmysky.com/learn/computing/queues-first-in-first-out-mt_4U1bT0JW4g): A collection where values leave in the order they arrived: enqueue at the back, dequeue at the front. The circular queue keeps the front from drifting off the end of the storage. - [Recursion and the Call Stack](https://lightmysky.com/learn/computing/recursion-and-the-call-stack-mt_VGjfeF3F2e): A function that calls itself on a smaller version of the same problem, with a base case that stops the descent. Every call that has not returned yet waits on the call stack, which is why deep recursion runs out of room. - [Big-O Notation and Orders of Growth](https://lightmysky.com/learn/computing/big-o-notation-and-orders-of-growth-mt_mkqgxhJ509): Describing how the work an algorithm does grows with the size of its input, keeping only the term that dominates and dropping constants. It gives O(1), O(log n), O(n), O(n log n) and O(n squared) as a way to compare methods at any scale. - [Linked Lists and Nodes That Point](https://lightmysky.com/learn/computing/linked-lists-and-nodes-that-point-mt_HvY7_-M2Zj): Storing a sequence as nodes that each hold a value and a reference to the next node. Inserting in the middle costs two pointer changes, but reaching the five hundredth item means walking there one node at a time. - [Hash Tables and Near-Constant Lookup](https://lightmysky.com/learn/computing/hash-tables-and-near-constant-lookup-mt_7v94MJEdmJ): Turning a key into a slot number with a hash function, so a value is reached by calculation instead of by searching. Two keys can land in the same slot, and the table needs a rule for what happens when they do. - [Quadratic Sorts: Bubble and Insertion](https://lightmysky.com/learn/computing/quadratic-sorts-bubble-and-insertion-mt_cBUIBa15jQ): Two sorting methods that work by comparing neighbouring values, one bubbling the largest to the end each pass and one placing each value into an already sorted front. Both do work proportional to n squared, which is where big-O first bites. - [Merge Sort and Divide and Conquer](https://lightmysky.com/learn/computing/merge-sort-and-divide-and-conquer-mt_OAutL4c7_l): Sorting by splitting the data in half, sorting each half the same way, then merging two sorted halves in one pass. The splitting gives log n levels and each level costs n, which is where O(n log n) comes from. - [Trees and Binary Search Trees](https://lightmysky.com/learn/computing/trees-and-binary-search-trees-mt_7PGHiAY54b): A structure of nodes with one root and no cycles, and the binary search tree rule that keeps smaller values left and larger values right. Walking the tree left, node, right returns the values in sorted order. - [Graphs and How to Store Them](https://lightmysky.com/learn/computing/graphs-and-how-to-store-them-mt_tSO-F1sTuu): Nodes joined by edges, with the edges possibly directed and possibly carrying a weight. The same graph can be held as an adjacency matrix or as an adjacency list, and the choice decides which questions are cheap to ask. - [Breadth-First and Depth-First Search](https://lightmysky.com/learn/computing/breadth-first-and-depth-first-search-mt_q8IEzoBhzy): Two ways to visit every node reachable from a start point: one takes a queue and spreads out level by level, the other takes a stack and follows one path as far as it goes. The choice of structure is the whole difference between them. - [Dijkstra's Shortest Path](https://lightmysky.com/learn/computing/dijkstras-shortest-path-mt_GvUzbY92qL): Finding the cheapest route through a weighted graph by always settling the nearest unsettled node next and relaxing the distances to its neighbours. Fewest hops and cheapest cost stop being the same answer once edges carry weights. - [Finite State Machines and What They Recognise](https://lightmysky.com/learn/computing/finite-state-machines-and-what-they-recognise-mt_gIk7tQ229w): A machine with a fixed set of states that moves between them as it reads one input symbol at a time, drawn as a state transition diagram or written as a table. It has no memory beyond the state it is in, which fixes what it can and cannot recognise. - [Turing Machines and the Universal Machine](https://lightmysky.com/learn/computing/turing-machines-and-the-universal-machine-mt_vS_QC1tCSM): A machine with a fixed set of states plus an unlimited tape it can read, write and move along. Adding the tape is enough to compute anything any computer can, and one such machine can read another's description and run it. - [The Halting Problem: A Task No Program Can Do](https://lightmysky.com/learn/computing/the-halting-problem-a-task-no-program-can-do-mt_KeuKGHFWqr): There is no program that can take any program and its input and always say correctly whether it will finish. The proof feeds the checker its own description, and the contradiction is where computability stops. - [Loop Invariants and Proving an Algorithm Correct](https://lightmysky.com/learn/computing/loop-invariants-and-proving-an-algorithm-correct-mt_fWnstju2ns): A loop invariant is a statement that holds before a loop starts, survives every pass, and gives the wanted result once the loop stops. Stating one turns the claim that code seems to work into an argument that it works on every input. - [Asymptotic Notation Made Precise](https://lightmysky.com/learn/computing/asymptotic-notation-made-precise-mt_B0Z6Syy8Ve): The definition behind big-O: f(n) is O(g(n)) when some constant multiple of g stays above f from some input size onward. Big-Omega bounds from below and big-Theta bounds from both sides, so a claim about growth becomes something a student can argue for rather than assert. - [Recurrence Relations and the Master Theorem](https://lightmysky.com/learn/computing/recurrence-relations-and-the-master-theorem-mt_aOvLPV7rR8): A recursive algorithm's cost is written as an equation that refers to itself, such as T(n) = 2T(n/2) + n. Solving it by expansion, by a recursion tree, or by the master theorem gives the running time without tracing a single call. - [Divide and Conquer as a Design Method](https://lightmysky.com/learn/computing/divide-and-conquer-as-a-design-method-mt_YITRNb-HTE): Split the input, solve the pieces the same way, and spend the remaining effort combining. Seen as a method rather than as one sorting trick, it produces fast multiplication, closest-pair search, and selection without sorting. - [Randomised Quicksort and Expected Running Time](https://lightmysky.com/learn/computing/randomised-quicksort-and-expected-running-time-mt_fcKF7zfzpX): Quicksort partitions around a pivot, and its worst case is quadratic. Choosing the pivot at random makes the bad case a matter of luck rather than of input, and the expected running time is n log n whatever the adversary supplies. - [The Comparison-Sorting Lower Bound](https://lightmysky.com/learn/computing/the-comparison-sorting-lower-bound-mt_7AfUsPV-jW): Any sort that only compares pairs of elements is a decision tree with n factorial leaves, so its height is at least n log n. This is a statement about every possible algorithm, not about the ones anybody has written. - [Heaps and Priority Queues](https://lightmysky.com/learn/computing/heaps-and-priority-queues-mt_W-ofiMiXWs): A binary heap keeps the smallest item at the root using an array and a simple shape rule, so insert and extract both cost log n. It gives a sort that meets the comparison bound and, more usefully, a queue ordered by importance rather than by arrival. - [Amortised Analysis](https://lightmysky.com/learn/computing/amortised-analysis-mt_1zLrl5RKGr): Some operations are occasionally expensive and usually cheap, so the worst case of one call overstates the cost of a run of calls. Amortised analysis charges the rare expensive step to the many cheap ones and reports the average per operation over any sequence. - [Greedy Choice and the Exchange Argument](https://lightmysky.com/learn/computing/greedy-choice-and-the-exchange-argument-mt_9Fj28VDAV-): A greedy method takes the locally best option and never reconsiders. It is right only when a proof says so, and the usual proof takes any optimal solution and swaps its first choice for the greedy one without making it worse. - [Dynamic Programming: Optimal Substructure and Overlapping Subproblems](https://lightmysky.com/learn/computing/dynamic-programming-optimal-substructure-and-overlapping-subproblems-mt__hWkCDnzNY): When a problem's best answer is built from best answers to smaller versions, and the same smaller versions keep reappearing, storing each answer once turns an exponential recursion into a polynomial one. The two conditions are what decide whether the method applies. - [Dynamic Programming on Two Sequences](https://lightmysky.com/learn/computing/dynamic-programming-on-two-sequences-mt_uNUgHcKKQN): Longest common subsequence and edit distance both fill a grid where each cell asks one question about the last character of each string. The table gives the answer, and walking back through it gives the alignment that produced it. - [Dynamic Programming with a Capacity: Knapsack](https://lightmysky.com/learn/computing/dynamic-programming-with-a-capacity-knapsack-mt_T5pbU_DpdC): A 0/1 knapsack table stores the best value for an item prefix and an allowed capacity. With integer weights, its O(n(W+1)) work depends on numeric capacity W, which may be large compared with the number of bits used to write it. This is pseudo-polynomial time. - [Shortest Paths with Negative Weights and Between All Pairs](https://lightmysky.com/learn/computing/shortest-paths-with-negative-weights-and-between-all-pairs-mt_e8szFezaxO): Dijkstra's greedy choice fails once an edge can reduce a cost, so Bellman-Ford relaxes every edge n minus one times instead, and reports a negative cycle if anything still improves. Floyd-Warshall answers every pair at once by asking which intermediate vertices are allowed. - [Union-Find and Minimum Spanning Trees](https://lightmysky.com/learn/computing/union-find-and-minimum-spanning-trees-mt_zOJei4yCtr): Kruskal's method sorts the edges and adds any that joins two separate pieces, which needs a structure that answers whether two vertices are already connected. Union-find answers it in almost constant time using a forest with path compression. - [Network Flow and the Max-Flow Min-Cut Theorem](https://lightmysky.com/learn/computing/network-flow-and-the-max-flow-min-cut-theorem-mt_momRV9lK1n): Flow pushes as much as possible from a source to a sink without exceeding any edge's capacity. Augmenting paths in a residual graph find the maximum, and the theorem says that maximum equals the cheapest set of edges whose removal disconnects the two. - [Reductions: Solving One Problem by Turning It into Another](https://lightmysky.com/learn/computing/reductions-solving-one-problem-by-turning-it-into-another-mt_PAwby3ZyAr): A reduction converts inputs of one problem into inputs of another while preserving their answers. Polynomial-time reductions support algorithm reuse and conditional hardness arguments. The conversion, target solver and any solution recovery all contribute to the total cost. - [P, NP and What NP-Complete Means](https://lightmysky.com/learn/computing/p-np-and-what-np-complete-means-mt_wwmNVG_VnB): P contains decision problems solvable in polynomial time. NP contains decision problems whose yes answers have polynomial-length certificates checkable in polynomial time. NP-complete means both in NP and NP-hard. A polynomial algorithm for one NP-complete problem would imply P = NP. - [Living with NP-Hardness: Approximation and Heuristics](https://lightmysky.com/learn/computing/living-with-np-hardness-approximation-and-heuristics-mt_tZ82ty6h2u): A polynomial-time exact solver for an NP-hard optimization problem would imply P=NP, which remains unresolved. Approximation algorithms provide proved quality bounds within their stated domain. Heuristics without such bounds are evaluated through measurements of quality and cost. - [Complexity Beyond NP: Space, Randomness and the Hierarchy](https://lightmysky.com/learn/computing/complexity-beyond-np-space-randomness-and-the-hierarchy-mt_ADfgl9UGpO): Polynomially bounded quantifier blocks give membership bounds in the polynomial hierarchy. Their first quantifier distinguishes Sigma from Pi classes. PSPACE bounds memory. BPP uses polynomial time with bounded error on every input. Whether P = BPP and whether the hierarchy collapses remain open. - [Randomised Algorithms and the Probabilistic Method](https://lightmysky.com/learn/computing/randomised-algorithms-and-the-probabilistic-method-mt_4ShN_WlT0-): An algorithm allowed to flip coins can be simpler and faster than any deterministic one known, at the price of a guarantee about expectation rather than about every run. The same idea proves objects exist by showing a random one works with positive probability. - [SAT Solvers and What Makes Search Practical](https://lightmysky.com/learn/computing/sat-solvers-and-what-makes-search-practical-mt_d46m2LD443): SAT asks whether a Boolean formula has a satisfying assignment. Conflict-driven clause learning derives clauses implied by the formula to rule out conflicting assignments. It can help practical search, but supplies no general polynomial-time guarantee for this NP-complete problem. - [Concentration Bounds and a High-Probability Guarantee](https://lightmysky.com/learn/computing/concentration-bounds-and-a-high-probability-guarantee-mt_WIltjK12oW): An expectation says nothing about how often the answer lands far from it. Markov, Chebyshev and the Chernoff bound each buy a sharper statement for a stronger assumption, and they are what turn an average-case claim into one that holds on nearly every run. - [Approximation Ratios and How One Is Proved](https://lightmysky.com/learn/computing/approximation-ratios-and-how-one-is-proved-mt_8pmBztDkFD): An approximation algorithm comes with a proved bound on how far its answer can sit from the best one, and the proof almost never mentions the optimum directly. It bounds the optimum from one side with something computable, then bounds the algorithm against that. - [Linear Programming, Duality and Rounding](https://lightmysky.com/learn/computing/linear-programming-duality-and-rounding-mt_rsj6G8iydV): Relaxing integer decisions to fractions gives a problem that can be solved, and its optimum bounds the integer one. Duality supplies the certificate that a solution is optimal, and rounding turns the fractional answer back into a real one at a cost that can be bounded. ## Computer Systems 45 topics, ages 14 to 24. https://lightmysky.com/learn/computing/areas/computer-systems - [Relational Databases: Tables, Keys and Relationships](https://lightmysky.com/learn/computing/relational-databases-tables-keys-and-relationships-mt_i7pZV6H902): Data held as tables of rows, with a primary key that identifies one row and a foreign key that points at a row in another table. The relationships between tables are the design, not an afterthought. - [Normalisation to Third Normal Form](https://lightmysky.com/learn/computing/normalisation-to-third-normal-form-mt_cbRXVW6KxX): Splitting tables until every field depends on the key, the whole key, and nothing but the key. Each step removes a way the data could contradict itself after an update. - [Binary Numbers and Place Value](https://lightmysky.com/learn/computing/binary-numbers-and-place-value-mt_t67akIKBmI): Counting with two digits, where each column is worth twice the column to its right. Converting both ways between binary and decimal. - [Adding Binary Numbers and Overflow](https://lightmysky.com/learn/computing/adding-binary-numbers-and-overflow-mt_dBS2OoQscq): Adding binary numbers column by column with a carry, and what happens when the answer needs more bits than the space it has. - [Hexadecimal as Binary Shorthand](https://lightmysky.com/learn/computing/hexadecimal-as-binary-shorthand-mt_OV6PHdnU6N): Writing four bits as one of sixteen digits, so long binary values can be read and typed by people without anything being lost. - [Character Sets: Storing Text as Numbers](https://lightmysky.com/learn/computing/character-sets-storing-text-as-numbers-mt_839VNNZlp2): Every character has an agreed number, and the text on screen is those numbers drawn by a font. A shared standard is what lets two machines read the same file, and one byte per character stopped being enough. - [Bitmap Images: Pixels, Resolution and Colour Depth](https://lightmysky.com/learn/computing/bitmap-images-pixels-resolution-and-colour-depth-mt_-Tr40QK8sN): A picture stored as a grid of pixels, each one a binary colour value. Resolution and colour depth decide both how it looks and how big the file is. - [Sampling Sound into Numbers](https://lightmysky.com/learn/computing/sampling-sound-into-numbers-mt_yTA4W-yFjy): Recording sound by measuring the wave thousands of times a second and storing each measurement as a binary number. Sample rate and bit depth change the quality and the size together. - [Compression: Lossy and Lossless](https://lightmysky.com/learn/computing/compression-lossy-and-lossless-mt_lx2U-B9CFa): Making a file smaller either by storing the same information in fewer bits, or by dropping detail people are unlikely to miss. Which of the two is safe depends on the file. - [Logic Gates and Truth Tables](https://lightmysky.com/learn/computing/logic-gates-and-truth-tables-mt_o2N0-q3A4Q): The and, or and not circuits that everything else is built from, and the table that fixes what each one outputs for every possible input. - [Inside the CPU: Fetch, Decode, Execute](https://lightmysky.com/learn/computing/inside-the-cpu-fetch-decode-execute-mt_YT-FSWnUKR): The cycle a processor repeats: fetch the next instruction from memory, work out what it means, carry it out. Clock speed, cores and cache each change how fast that goes. - [Memory and Storage: RAM, ROM and the Backing Store](https://lightmysky.com/learn/computing/memory-and-storage-ram-rom-and-the-backing-store-mt_AiXGJioO_S): Ordinary RAM holds working instructions and data and loses them without power. ROM retains firmware. Secondary storage keeps saved files between runs, but devices can fail. Compare capacity, access time, cost and physical risks for a stated use. - [Packets and Protocols on a Network](https://lightmysky.com/learn/computing/packets-and-protocols-on-a-network-mt_IffXVDtfLX): Network data travels in packets carrying data and delivery information. Packets can be lost, damaged, duplicated or received out of order. Protocols define communication rules. TCP provides reliable ordered transport; UDP does not provide built-in retries or message ordering. - [How a Web Page Reaches Your Screen](https://lightmysky.com/learn/computing/how-a-web-page-reaches-your-screen-mt_8JveAW2Mg7): A browser finds an address for a hostname, requests content and processes the server's response to display a page. Saved addresses and cached resources can be reused. Servers can return stored files or generate responses. - [Cyber Threats and How Systems Defend](https://lightmysky.com/learn/computing/cyber-threats-and-how-systems-defend-mt_zMJzhIdEWd): The usual ways systems are attacked, from tricking a person into handing over a password to feeding a program input it trusted too far, and the defence that answers each one. - [Boolean Algebra and Simplifying Logic Expressions](https://lightmysky.com/learn/computing/boolean-algebra-and-simplifying-logic-expressions-mt_9MrE1N63D5): Writing a circuit as an algebraic expression and rearranging it with the laws of Boolean algebra, including De Morgan's, to reach a shorter expression with the same truth table. Fewer gates means less silicon and less energy, and less delay when the gate path gets shorter. - [Logic Circuits That Add and Remember](https://lightmysky.com/learn/computing/logic-circuits-that-add-and-remember-mt_zPgkt6zf-i): Half adders and full adders perform binary addition with carries. A static flip-flop stores one bit while powered, using internal feedback to retain its state between updates. - [Assembly Language and the Instruction Set](https://lightmysky.com/learn/computing/assembly-language-and-the-instruction-set-mt_bzmsfvdzwp): Assembly uses readable names for operations in a processor's instruction set. Trace registers, memory and branch decisions in a stated instruction model, and compare a high-level statement with its possible machine instructions. - [Registers, Buses and the Fetch-Execute Cycle in Detail](https://lightmysky.com/learn/computing/registers-buses-and-the-fetch-execute-cycle-in-detail-mt_yjy3eSStzH): Trace an instruction through a stated accumulator-machine model, naming registers and the address, data and control buses. A taken branch writes its target into the program counter; a branch that is not taken leaves the next sequential address in place. - [Network Layers and the Protocol Stack](https://lightmysky.com/learn/computing/network-layers-and-the-protocol-stack-mt_O3Ew6c2ynD): A network is split into layers, each with one job and each talking only to the layer above and below: application, transport, internet, link. A message gains a header at each layer on the way down and loses it on the way up. - [IP Addressing and How Routers Choose a Path](https://lightmysky.com/learn/computing/ip-addressing-and-how-routers-choose-a-path-mt_l0dRGocXGw): How an address splits into a network part and a host part, and how a router uses its forwarding table to pick the next hop without knowing the whole route. No single machine holds a map of the internet. - [Instruction Set Architecture as a Contract](https://lightmysky.com/learn/computing/instruction-set-architecture-as-a-contract-mt_pbwHRePY5M): An instruction set architecture specifies instruction encodings and behaviour, visible registers and addressing rules. Different implementations can preserve that interface while changing scheduling, pipelines, caches or internal registers. Running an application also requires its software environment. - [The Memory Hierarchy and Why Caching Works](https://lightmysky.com/learn/computing/the-memory-hierarchy-and-why-caching-works-mt_0f5ArFPlxP): A typical memory hierarchy combines small, fast registers and caches with larger main memory and storage. Temporal locality reuses recent locations; spatial locality accesses nearby locations. Cache performance depends on access order, data layout and cache capacity. - [Pipelining and the Cost of a Hazard](https://lightmysky.com/learn/computing/pipelining-and-the-cost-of-a-hazard-mt_GI_fPY9d6s): Pipelining overlaps instruction stages to increase throughput. In an ideal five-stage model with the same clock, overlap does not shorten an instruction's five-cycle latency. Data hazards may require stalls; forwarding can avoid some waits. Branch mispredictions discard younger wrong-path instructions. - [Many Cores and the Limit on Speedup](https://lightmysky.com/learn/computing/many-cores-and-the-limit-on-speedup-mt_dy3-K9dV19): For a fixed workload with unchanged serial time, Amdahl's ideal model gives speedup 1 / (s + (1 - s) / N), where s is the serial fraction and N is the core count. For positive s, 1 / s is the limiting bound. Coordination and resource contention can reduce gains. - [What an Operating System Is: Privilege and System Calls](https://lightmysky.com/learn/computing/what-an-operating-system-is-privilege-and-system-calls-mt_0kMavEKxpX): An operating system manages resources and provides services. In the user/kernel protection model studied here, user code cannot execute restricted hardware-control instructions. System calls enter the kernel for checked services. CPU privilege, permission to request a service, and ordinary library calls are distinct. - [Processes, Context Switches and What They Cost](https://lightmysky.com/learn/computing/processes-context-switches-and-what-they-cost-mt_oiOwHKUoXG): A process is an active program instance with execution state and OS-managed resources. It may be ready, running or blocked. A process switch saves and restores CPU execution state and selects the next process's existing address-space context. Memory mappings and open-file records remain stored, rather than being copied into saved CPU state. Context handling takes time; added cache costs depend on hardware and workload. - [Scheduling: Deciding Which Process Runs Next](https://lightmysky.com/learn/computing/scheduling-deciding-which-process-runs-next-mt_QZYzfVIcP6): A scheduler chooses from the ready processes, and every rule it could use favours something: throughput, response time, or fairness. Round robin, shortest job first and priority with ageing balance those goals differently. - [Virtual Memory and Address Translation](https://lightmysky.com/learn/computing/virtual-memory-and-address-translation-mt_B-PiAyderj): A process normally uses virtual addresses. Hardware translates them using page mappings and permissions, often cached in a TLB. The OS controls isolation and intentional sharing. With backing storage, valid pages need not all occupy RAM at once. - [Paging, Page Faults and Replacement Policies](https://lightmysky.com/learn/computing/paging-page-faults-and-replacement-policies-mt_nEEuGL89Ze): Accessing a valid nonresident page can cause a recoverable fault. The OS supplies the page and may reclaim a frame. FIFO and LRU choose different victims. Repeated faults and page transfers can leave little time for execution when actively used pages do not fit in available RAM. - [File Systems: Names, Blocks and Metadata](https://lightmysky.com/learn/computing/file-systems-names-blocks-and-metadata-mt_jN4u3idvF3): In an inode-based, block-backed file system, directories map names to records. Records hold metadata and information locating file bytes. Paths follow these mappings; hard links share a record. Removing a name differs from copying bytes or immediately reclaiming storage. - [Crash Consistency and the Journal](https://lightmysky.com/learn/computing/crash-consistency-and-the-journal-mt_I9DT0TUmiu): A crash during a multi-block update can leave only part persistent. In the physical redo metadata-journal model taught here, durable redo records and a durable commit precede home metadata writes. Recovery replays valid committed transactions and ignores incomplete ones. Other journal designs can differ. - [Threads and Shared Memory](https://lightmysky.com/learn/computing/threads-and-shared-memory-mt_N4EGNbN6Xh): Threads in one process share its address space and resources. Each has its own execution state and normally its own stack, but those stacks are not separate protected address spaces. Threads can overlap work and waiting; conflicting accesses to shared data need coordination. - [Race Conditions and Mutual Exclusion](https://lightmysky.com/learn/computing/race-conditions-and-mutual-exclusion-mt_hygT74jJDE): Conflicting shared-data accesses can produce results that depend on their order. A non-atomic read-change-write sequence can lose an update. Mutual exclusion uses a shared lock to protect the required region; threads contending for that lock may have to wait. - [Deadlock and the Four Conditions](https://lightmysky.com/learn/computing/deadlock-and-the-four-conditions-mt_CsMOA4sBb1): Resource deadlock requires mutual exclusion, hold and wait, no preemption, and circular wait. For blocking locks with one holder each, a wait-for cycle identifies deadlock. A shared acquisition order prevents circular wait among those locks; it does not release an existing deadlock. - [Lexing and Parsing: From Text to a Syntax Tree](https://lightmysky.com/learn/computing/lexing-and-parsing-from-text-to-a-syntax-tree-mt_-ZlCxZ3SOh): In a common compiler front end, a lexer groups characters into tokens and a parser uses grammar rules to build a syntax tree. Finite-state methods recognise many token patterns. The tree records operator grouping under precedence and associativity rules. - [Message Passing and Asynchronous Work](https://lightmysky.com/learn/computing/message-passing-and-asynchronous-work-mt_twcpO-945r): A message-passing counter can have one owner that applies queued updates one at a time. This removes shared-counter races, but queue capacity, overload, ordering and blocking still need design. Asynchronous requests let callers continue before a result is ready. - [Semantic Analysis and the Intermediate Representation](https://lightmysky.com/learn/computing/semantic-analysis-and-the-intermediate-representation-mt_f2z_WQxfiw): Syntactically valid code can fail a language's name, type or argument-count rules. Semantic analysis uses declaration and scope information to check those rules. A shared intermediate representation can connect language front ends to multiple target back ends. - [Code Generation and What an Optimiser May Change](https://lightmysky.com/learn/computing/code-generation-and-what-an-optimiser-may-change-mt__ZSPwP4hfA): The back end translates an intermediate representation into target instructions and assigns registers. Optimisations preserve behaviour required by the language and platform. Data dependencies, arithmetic rules and required device effects constrain which changes are valid. - [The Impacts of Computing: Law, Ethics and the Environment](https://lightmysky.com/learn/computing/the-impacts-of-computing-law-ethics-and-the-environment-mt_veX-psjipc): What computing does beyond the machine: the rules on holding people's data, the choices behind who a system serves well, and the energy and materials a device costs. - [SQL: Selecting, Filtering and Ordering Rows](https://lightmysky.com/learn/computing/sql-selecting-filtering-and-ordering-rows-mt_lDVVG2AKzs): Asking a database for the rows and columns you want with SELECT, WHERE and ORDER BY. The query says what is wanted, and the database decides how to fetch it. - [SQL: Joining Tables and Summarising Groups](https://lightmysky.com/learn/computing/sql-joining-tables-and-summarising-groups-mt_0QPZDE2KuS): Pulling rows from two tables together on a matching key, and collapsing many rows into one answer with COUNT, SUM and GROUP BY. This is the payoff for having split the tables in the first place. - [Cloud-Native Architecture: Containers, Schedulers and the Control Loop](https://lightmysky.com/learn/computing/cloud-native-architecture-containers-schedulers-and-the-control-loop-mt_nV1LgSRsh_): A deployment is described as a desired state and a controller works continuously to close the gap. Containers make a process portable, a scheduler decides where it runs, and the control loop is what turns a crashed replica into a replaced one with nobody being paged. - [Observability and Tail Latency Across Services](https://lightmysky.com/learn/computing/observability-and-tail-latency-across-services-mt_NT5tmumdfA): Once a request touches a dozen services, an average tells nobody anything. Traces follow one request across process boundaries, percentiles expose the slow tail, and a request that fans out inherits the worst of everything it waited on. - [Type Soundness: Progress and Preservation](https://lightmysky.com/learn/computing/type-soundness-progress-and-preservation-mt_nAAHVPNaVJ): Small-step rules define one evaluation step. For a basic expression language, progress says a closed well-typed expression is a value or can step; preservation says a step retains its type. Together they exclude reachable stuck expressions under the stated semantics. They do not promise termination or freedom from every runtime failure. ## Machine Learning 34 topics, ages 18 to 24. https://lightmysky.com/learn/computing/areas/machine-learning - [Joint, Marginal and Conditional Probability](https://lightmysky.com/learn/computing/joint-marginal-and-conditional-probability-mt__Rj-hOSMEw): Learning from data means reasoning about several uncertain quantities at once. The joint distribution holds everything, the marginal sums out what is not of interest, and the conditional is what remains once something is known. - [Data as a Matrix: Rows, Features and the Target](https://lightmysky.com/learn/computing/data-as-a-matrix-rows-features-and-the-target-mt_KEN-TU1Gpn): Almost every method takes the same shape of input: one row per example, one column per feature, and a separate target column. Getting real data into that shape means encoding categories, scaling columns onto comparable ranges, and deciding what one row is. - [Likelihood and the Maximum Likelihood Estimate](https://lightmysky.com/learn/computing/likelihood-and-the-maximum-likelihood-estimate-mt_crcBnSqkTE): Given data and a family of models, the likelihood is how probable the data would be under each candidate. Choosing the candidate that maximises it is where most fitting procedures come from, including the least squares line. - [Linear Regression by Least Squares](https://lightmysky.com/learn/computing/linear-regression-by-least-squares-mt_QRRkpIrwWs): Fit a straight relationship by choosing coefficients that make the sum of squared residuals as small as possible. With several features the same idea gives a plane or hyperplane, and each coefficient reads as the effect of one feature with the others held fixed. - [Bayes' Rule and Updating a Belief](https://lightmysky.com/learn/computing/bayes-rule-and-updating-a-belief-mt_A4p5--f7Io): Bayes' rule turns the probability of evidence given a cause into the probability of the cause given the evidence. It explains why a test that is right almost always can still be wrong most of the time it fires, when what it looks for is rare. - [Training Across Many Devices: Data, Model and Pipeline Parallelism](https://lightmysky.com/learn/computing/training-across-many-devices-data-model-and-pipeline-parallelism-mt__e-JwIxHek): A run stops fitting on one device well before the interesting model sizes. Data parallelism copies the model and splits the batch, model parallelism splits the tensors, and pipeline parallelism splits the layers, each paying a different communication bill. - [Serving a Model: Batching, the Key-Value Cache and Quantisation](https://lightmysky.com/learn/computing/serving-a-model-batching-the-key-value-cache-and-quantisation-mt_Nv1-WLGIO4): Generation is memory-bandwidth bound and runs one token at a time, so serving is a different problem from training. Batching amortises the weight reads, a key-value cache stops the model recomputing the past, and lower-precision weights buy throughput against a small accuracy loss. - [Gradient Descent: Following the Slope Downhill](https://lightmysky.com/learn/computing/gradient-descent-following-the-slope-downhill-mt_EjfIT1WgMX): When no formula gives the best parameters, start somewhere and repeatedly step against the slope of the error. The step size decides whether the search creeps, oscillates or diverges, and this one procedure trains almost everything that follows. - [Logistic Regression and the Decision Boundary](https://lightmysky.com/learn/computing/logistic-regression-and-the-decision-boundary-mt_FaVIaT7xl2): For a yes-or-no target, squeeze a linear score through a function that returns a probability, and fit by maximising likelihood. Where that probability crosses a chosen threshold is the decision boundary, and moving the threshold trades one kind of mistake for the other. - [Overfitting and the Bias-Variance Trade-off](https://lightmysky.com/learn/computing/overfitting-and-the-bias-variance-trade-off-mt_xznyNxeNNw): Overfitting can occur when a model follows training-sample noise and predicts poorly on new data. Bias is the difference between its average prediction across training samples and the true mean response. Variance measures prediction changes across samples. For squared prediction error, expected error includes squared bias, variance and irreducible noise. - [Regularisation: Charging for Complexity](https://lightmysky.com/learn/computing/regularisation-charging-for-complexity-mt_RVgsDP0XzP): Add a penalty on the size of the coefficients to the thing being minimised, and the fit pulls back from chasing noise. A squared penalty shrinks everything smoothly, an absolute one can drive some coefficients exactly to zero and selects features that way. - [Cross-Validation and Honest Model Selection](https://lightmysky.com/learn/computing/cross-validation-and-honest-model-selection-mt_YG7X3HYCrT): Every choice made by looking at a set of data uses that set up, so the score on it stops being an estimate of future performance. Splitting into folds, and holding a final set back untouched, is how a reported number stays believable. - [Beyond Accuracy: Precision, Recall and the Cost of an Error](https://lightmysky.com/learn/computing/beyond-accuracy-precision-recall-and-the-cost-of-an-error-mt_BHGgZM7tak): On imbalanced data a model that always says no can be right almost every time and be useless. The confusion matrix separates the two kinds of mistake, and precision, recall and the curves over thresholds say which model suits which cost. - [Decision Trees and Ensembles](https://lightmysky.com/learn/computing/decision-trees-and-ensembles-mt_xo9EEd4R1i): A tree splits the data one question at a time, choosing each split to make the resulting groups purer. One tree is easy to read and unstable; averaging many trees grown on resampled data usually trades that readability for accuracy. - [Clustering: Structure Without Labels](https://lightmysky.com/learn/computing/clustering-structure-without-labels-mt_BAMGOlWgRY): With no target column, the question becomes which examples resemble each other. K-means alternates assigning points to the nearest centre and moving the centres, and the awkward parts are choosing k, choosing a distance, and deciding whether the groups mean anything. - [Principal Components and Dimensionality Reduction](https://lightmysky.com/learn/computing/principal-components-and-dimensionality-reduction-mt_l-9XHg_ChZ): When features are many and correlated, much of the variation often lies along a few directions. Principal component analysis finds those directions from the covariance structure and re-expresses each example in far fewer numbers, which makes data visible and models cheaper. - [From Perceptron to Multilayer Network](https://lightmysky.com/learn/computing/from-perceptron-to-multilayer-network-mt_TTa7KN1-IO): A single artificial neuron is a linear score with a threshold, and it cannot separate patterns that are not linearly separable. Stacking layers with a non-linear function between them removes that limit, because the middle layers build features of their own. - [Backpropagation: Assigning Blame for an Error](https://lightmysky.com/learn/computing/backpropagation-assigning-blame-for-an-error-mt_5bwaSWfF96): Training a network means knowing how much each weight contributed to the error, which the chain rule gives by passing derivatives backwards through the layers. Every weight is then nudged by gradient descent, and the whole procedure is one pass forward and one pass back. - [Deep Learning: Convolution, Sequence and Scale](https://lightmysky.com/learn/computing/deep-learning-convolution-sequence-and-scale-mt_karzGN5JnI): Deep networks work because their architecture matches the data: convolution shares weights across positions in an image, and sequence models carry information along a sentence. What changed in practice was scale, in data and in the hardware that could process it. - [Attention as a Learned Lookup](https://lightmysky.com/learn/computing/attention-as-a-learned-lookup-mt_rrdtS1lHvC): Attention scores a query against every key in the sequence, turns the scores into weights, and returns a blend of the matching values. Nothing about distance is fixed in advance, so a position can read from anywhere, and the price is a comparison against everything. - [The Transformer Block: Heads, Residuals and Normalisation](https://lightmysky.com/learn/computing/the-transformer-block-heads-residuals-and-normalisation-mt_eKC2IehaDT): One block stacks multi-head attention and a position-wise network around a residual path, with normalisation holding the scale steady. Attention treats a sequence as a set, so position has to be supplied explicitly or an unmasked block cannot tell an order from a shuffle. - [Tokenisation and What a Model Actually Reads](https://lightmysky.com/learn/computing/tokenisation-and-what-a-model-actually-reads-mt_PW7s8qEiJD): A model never sees letters or words. It sees ids drawn from a vocabulary built by merging frequent pieces of text, and that vocabulary decides what is cheap to express, which spellings are fragile, and why digits and rare names behave badly. - [Pretraining by Predicting the Next Token](https://lightmysky.com/learn/computing/pretraining-by-predicting-the-next-token-mt_D8b2phZJfp): Every position in a corpus is a labelled example asking what comes next, so the text supplies its own supervision. One objective, run over enough text, forces the model to carry grammar, facts and a rough sense of the task being asked of it. - [Scaling Laws and the Compute Budget](https://lightmysky.com/learn/computing/scaling-laws-and-the-compute-budget-mt_tzl0sQblIM): Held-out loss falls as a smooth power of parameters, tokens and compute, which turns a training decision into arithmetic. The same curve shows where a budget is being wasted, usually on a model larger than the data it will ever see. - [Adapting a Pretrained Model: Fine-Tuning and Low-Rank Updates](https://lightmysky.com/learn/computing/adapting-a-pretrained-model-fine-tuning-and-low-rank-updates-mt_NaA2iGtMPc): Most work starts from weights someone else paid for. A full fine-tune moves every parameter and costs a whole copy to store, while a low-rank update trains a small factored correction and leaves the base weights alone. - [Generative Models: Learning a Distribution You Can Sample](https://lightmysky.com/learn/computing/generative-models-learning-a-distribution-you-can-sample-mt_3CHsmpWVX5): A generative model learns the distribution behind the data, and when its job is to produce samples it is judged by what it produces rather than by a label it predicts. Latent-variable models put a simple distribution behind the data and learn a decoder from it, which makes sampling easy and, with a neural decoder, the likelihood awkward. - [Diffusion Models: Learning to Undo Noise](https://lightmysky.com/learn/computing/diffusion-models-learning-to-undo-noise-mt_kZdQJ96iZ3): Training adds noise to a sample in small steps and asks the network to predict the noise mixed into the result. Generation runs that chain backwards from pure noise, so one hard sampling problem becomes a long series of easy denoising ones. - [Benchmarks and the Traps in Them](https://lightmysky.com/learn/computing/benchmarks-and-the-traps-in-them-mt_o9zLZbkaen): A benchmark is a proxy that becomes a target and then stops measuring what it did. Test data leaks into training sets, baselines are tuned less than the proposed method, and a leaderboard everyone reports against is being overfitted by a whole field at once. - [Markov Decision Processes: States, Actions and Return](https://lightmysky.com/learn/computing/markov-decision-processes-states-actions-and-return-mt_bTCO27sgc6): Reinforcement learning begins by writing the problem down: states, actions, a transition rule, a reward and a discount. The return is the quantity being maximised, and the discount is the modelling choice that fixes how far ahead the agent looks. - [Temporal-Difference Learning and Q-Learning](https://lightmysky.com/learn/computing/temporal-difference-learning-and-q-learning-mt_Z78E2llE0C): An agent that cannot see the transition probabilities can still learn a value by bootstrapping: move each estimate towards the reward plus the next estimate. Q-learning does this over state-action pairs and reaches the best policy while behaving by a different one. - [Policy Gradients and the Actor-Critic Split](https://lightmysky.com/learn/computing/policy-gradients-and-the-actor-critic-split-mt_eXm6stg8zj): Instead of learning values and reading a policy off them, the policy can be a parameterised distribution trained directly by gradient ascent on expected return. The gradient is noisy, so a learned value function serves as a baseline to hold the variance down. - [Learning from Human Preferences: Reward Models and Policy Optimisation](https://lightmysky.com/learn/computing/learning-from-human-preferences-reward-models-and-policy-optimisation-mt_yA1ud53Oy_): When the goal cannot be written as a reward, people compare pairs of outputs and a reward model is fitted to those comparisons. The language model is then optimised as a policy against that fitted reward, with a penalty for drifting away from where it started. - [Fairness, Accountability and the Limits of a Model](https://lightmysky.com/learn/computing/fairness-accountability-and-the-limits-of-a-model-mt_tTh4WtAyk5): A model trained on past decisions reproduces the pattern in them, including the parts nobody would defend out loud. Several reasonable definitions of fairness cannot all hold at once, so a team has to choose one, say which, and be able to explain a decision to the person it lands on. - [Interpretability: Probes, Features and Circuits](https://lightmysky.com/learn/computing/interpretability-probes-features-and-circuits-mt_C8POKvRkq6): A trained network is a working artifact that nobody designed in detail. Probes ask whether a property is readable from an activation, feature analysis asks what a direction stands for, and circuit analysis asks which components carry a behaviour. Each answers less than it appears to. ## Networks & Security 21 topics, ages 18 to 24. https://lightmysky.com/learn/computing/areas/networks-and-security - [Layering and Encapsulation in the Protocol Stack](https://lightmysky.com/learn/computing/layering-and-encapsulation-in-the-protocol-stack-mt_D33SEBslXH): Each layer wraps the layer above in a header and hands it down, so a message crossing the network is a set of nested envelopes. The arrangement means a change in how a link carries bits does not reach the application, and it also means a failure at one layer is reported in that layer's terms. - [Reliable Delivery over an Unreliable Network](https://lightmysky.com/learn/computing/reliable-delivery-over-an-unreliable-network-mt_kCM411CSac): The network below may drop, duplicate, delay and reorder. A reliable transport rebuilds order and completeness on top of it using sequence numbers, acknowledgements, timeouts and retransmission, and a window so the sender need not wait for each reply. - [Congestion Control and Sharing a Link](https://lightmysky.com/learn/computing/congestion-control-and-sharing-a-link-mt_y5hPUrdKyq): In a loss-based congestion-control model, a sender probes for available capacity by raising its rate while packets arrive, then backs off when congestion signals appear. The rule helps senders share a link, while loss remains a signal rather than proof of one cause. - [Naming: DNS and the Resolution Path](https://lightmysky.com/learn/computing/naming-dns-and-the-resolution-path-mt_omttmGkEgW): DNS maps human-readable names to records such as addresses. A recursive resolver can answer from cache or follow delegations from the root through a top-level domain to an authoritative server. TTL values limit how long cached records may be reused. - [Routing: How a Path Is Learned](https://lightmysky.com/learn/computing/routing-how-a-path-is-learned-mt_gyqPDrV6Uo): No router knows the whole network. Inside one organisation routers exchange what they know until their tables agree; between organisations the choice is shaped by policy and business relationships as much as by distance. - [The Web as a Protocol: Requests, State and Caching](https://lightmysky.com/learn/computing/the-web-as-a-protocol-requests-state-and-caching-mt_MDiW4Vt0bo): HTTP uses independent request and response exchanges. Cookies or tokens let an application identify a session across requests, while caching headers tell browsers and shared caches when a response may be reused. - [Clocks, Ordering and Happens-Before](https://lightmysky.com/learn/computing/clocks-ordering-and-happens-before-mt_ratia1eb_2): Separate machines have separate clocks that drift, so a timestamp cannot settle which of two events came first. What can be settled is causality: one event happened before another if a message carried information from the first to the second. - [Symmetric Encryption and What a Cipher Promises](https://lightmysky.com/learn/computing/symmetric-encryption-and-what-a-cipher-promises-mt_egJQEiFWZA): Symmetric encryption uses a shared secret key. A secure scheme, used under its stated conditions, protects message contents against its defined attackers. Encryption alone need not authenticate messages, hide traffic metadata or establish the key. - [Failure Models and Replication](https://lightmysky.com/learn/computing/failure-models-and-replication-mt_aYK210-NIS): A distributed system has to say what kinds of failure it tolerates: a machine that stops, a message that never arrives, a machine that stops and comes back with old state. Replication is the usual answer, and it turns one copy's truth into a question about which copy to believe. - [Consensus and Why Agreement Is Hard](https://lightmysky.com/learn/computing/consensus-and-why-agreement-is-hard-mt_cF-JiM_xRz): Several machines have to agree on one value even though some may fail and messages may be delayed. A majority quorum plus a leader gets there in practice, and the theory says no deterministic protocol can guarantee both safety and progress when delays have no bound and a node may crash. - [Consistency Models and the CAP Trade-off](https://lightmysky.com/learn/computing/consistency-models-and-the-cap-trade-off-mt_j6qtpYPHsr): Replica consistency describes what clients may observe. When network partitions can persist, a store cannot guarantee both linearizable operations and successful responses to every request at a non-failing node. Application requirements guide which guarantees its design must support. - [Impossibility Under Asynchrony: What Consensus Cannot Promise](https://lightmysky.com/learn/computing/impossibility-under-asynchrony-what-consensus-cannot-promise-mt_le54TNOeiR): With no bound on message delay and one process allowed to fail, no deterministic algorithm is guaranteed both to agree and to finish. Real systems live with this by giving up guaranteed termination and leaning on timeouts, which are a failure detector under another name. - [Raft: Leader Election and Log Replication](https://lightmysky.com/learn/computing/raft-leader-election-and-log-replication-mt_JdHtEJSPSP): One consensus algorithm end to end. A term-numbered election picks a single leader, the leader appends entries to its followers, and an entry is committed once a majority holds it. Every rule in the protocol exists to stop one specific bad history. - [Quorums, Leases and Changing the Membership](https://lightmysky.com/learn/computing/quorums-leases-and-changing-the-membership-mt_2uRmRqFutD): A majority is one point on a curve: any read set and write set that intersect will do, and the choice moves cost between reads and writes. A lease buys a leader a bounded window of authority, and changing the member set safely needs a protocol of its own. - [Linearizability and Checking a History](https://lightmysky.com/learn/computing/linearizability-and-checking-a-history-mt_lTaHmlGtuo): Linearizability says every operation appears to take effect at one instant between its call and its return, so a replicated store can be reasoned about as a single object. Whether a recorded history satisfies it is a decidable question, and the check is expensive. - [Public-Key Cryptography and Key Exchange](https://lightmysky.com/learn/computing/public-key-cryptography-and-key-exchange-mt_AHCtrer4eh): A key pair splits the secret: one half can be published, and only the other half undoes what the first did. That solves the problem symmetric ciphers cannot, which is agreeing on a shared key with someone you have never met, over a line somebody is reading. - [Hashes, Signatures and Certificates](https://lightmysky.com/learn/computing/hashes-signatures-and-certificates-mt_qLHm767U87): A cryptographic hash gives a short fingerprint that is impractical to forge a match for, which makes tampering detectable. Signing a hash with a private key proves who produced it, and a certificate is that signature applied to the claim that a key belongs to a name. - [TLS: Putting the Pieces Together](https://lightmysky.com/learn/computing/tls-putting-the-pieces-together-mt_JzIwi-BYG0): A secure connection is assembled from all of it: a certificate proves the server's key, a key exchange produces a fresh shared secret, and a symmetric cipher with an integrity check carries the traffic. Reading the handshake in order is how the pieces stop being separate ideas. - [Threat Modelling: Assets, Adversaries and Trust Boundaries](https://lightmysky.com/learn/computing/threat-modelling-assets-adversaries-and-trust-boundaries-mt_VRXTkrNFvx): Security work starts by naming what is worth protecting, who might want it, and where data crosses from a place you control into one you do not. Without that, defences are chosen by habit, and the effort lands away from where the risk is. - [Authentication, Authorisation and Secure Defaults](https://lightmysky.com/learn/computing/authentication-authorisation-and-secure-defaults-mt_ofIiD4Bbpk): Proving who someone is and deciding what they may do are two questions, and confusing them is a common source of holes. Storing credentials with a slow hash, giving each part the least access it needs, and failing closed are the defaults that hold up when something else goes wrong. - [Cryptographic Security Definitions and Proof by Reduction](https://lightmysky.com/learn/computing/cryptographic-security-definitions-and-proof-by-reduction-mt_qPCwxkqYY2): A security definition specifies a game and requires every efficient adversary to have negligible advantage as the security parameter grows. A reduction-based proof turns a hypothetical attack into a solver for an assumed-hard problem, accounting for running time and success loss. Its conclusion depends on the assumption and model. ## Data & Databases 21 topics, ages 18 to 24. https://lightmysky.com/learn/computing/areas/data-and-databases - [The Relational Model and Relational Algebra](https://lightmysky.com/learn/computing/the-relational-model-and-relational-algebra-mt_unDBd_Ug8T): A table is a set of tuples over named attributes, and queries are built from a handful of operations on those sets: select, project, join, union, difference. Every query language sits on top of this algebra, which is why the same question can be asked several ways and mean one thing. - [Functional Dependencies and Boyce-Codd Normal Form](https://lightmysky.com/learn/computing/functional-dependencies-and-boyce-codd-normal-form-mt_PfWLq1aEQz): A functional dependency says one set of attributes fixes another. Computing the closure of a set of dependencies finds the candidate keys, and Boyce-Codd normal form is the condition that every dependency starts from one of those keys. - [SQL at Depth: Subqueries, Set Operations and Views](https://lightmysky.com/learn/computing/sql-at-depth-subqueries-set-operations-and-views-mt_SLKUlC-7or): A query can use another query as a table, as a value, or as a test of existence, and set operations combine results that share a shape. A view names a query so the rest of the system can treat it as a table. - [Window Functions and Running Calculations](https://lightmysky.com/learn/computing/window-functions-and-running-calculations-mt_aaVxFPjWQv): A window function computes over a set of neighbouring rows while keeping every row in the output, which grouping cannot do. Ranking, running totals and comparisons with the previous row all come from partitioning and ordering the window. - [Indexes: B-Trees and the Cost of a Lookup](https://lightmysky.com/learn/computing/indexes-b-trees-and-the-cost-of-a-lookup-mt_1Z5EQTqooI): An index is a second structure that makes some lookups cheap and every write more expensive. Most are B-trees, whose wide nodes suit a disk that reads a page at a time, and whose ordering also serves ranges and sorts. - [Reading a Query Plan](https://lightmysky.com/learn/computing/reading-a-query-plan-mt_spbbzsCoBB): The database chooses how to run a query: which index to use, which join method, in what order. The plan is that choice written down with estimated row counts, and reading it is how a slow query stops being a mystery. - [Transactions and the ACID Promise](https://lightmysky.com/learn/computing/transactions-and-the-acid-promise-mt_8Egjmafq-L): A transaction groups statements so they take effect together or not at all, keep the database's rules true, do not see each other half-done, and survive a crash once committed. Those four promises are what let application code stay simple. - [Isolation Levels and the Anomalies They Allow](https://lightmysky.com/learn/computing/isolation-levels-and-the-anomalies-they-allow-mt_utxPNgxveB): Full isolation is expensive, so databases offer weaker levels, each defined by which anomalies it permits: dirty reads, non-repeatable reads, phantoms. Choosing a level is choosing which wrong answers the application can tolerate. - [Concurrency Control: Locks and Snapshots](https://lightmysky.com/learn/computing/concurrency-control-locks-and-snapshots-mt_gOd17LRKel): Two-phase locking makes transactions wait for each other and can deadlock. Multi-version concurrency control gives each transaction a consistent snapshot instead, so readers never block writers, at the price of keeping old versions around. - [Crash Recovery and Write-Ahead Logging](https://lightmysky.com/learn/computing/crash-recovery-and-write-ahead-logging-mt_JFPafSWOWF): Durability is achieved by writing the intention to a log before touching the data pages. After a crash the system replays committed work and undoes the rest, which is how a commit can be trusted the moment it returns. - [Key-Value and Document Stores](https://lightmysky.com/learn/computing/key-value-and-document-stores-mt_PfBDSgfeQX): Some workloads want a single key lookup and nothing else, and pay for the freedom by giving up joins and schema checks. A document store keeps whole nested objects together, which suits reading one thing at a time and makes any cross-cutting question harder. - [Wide-Column and Graph Stores](https://lightmysky.com/learn/computing/wide-column-and-graph-stores-mt_4a4yDq83fy): A wide-column store arranges data by the queries it must serve, so the design starts from the access pattern rather than the entities. A graph store makes relationships first-class, which turns a chain of joins into a traversal. - [Partitioning and Replication for Scale](https://lightmysky.com/learn/computing/partitioning-and-replication-for-scale-mt_Xvzz5Hnuvu): Beyond one machine, data is split by key across nodes and copied for safety. The partition key decides which queries stay fast and which become scatter-and-gather, and the replication scheme decides what a read may return after a recent write. - [Data Pipelines: Batch, Streaming and Doing It Twice](https://lightmysky.com/learn/computing/data-pipelines-batch-streaming-and-doing-it-twice-mt_o0zBEPLbmF): Data moves from where it is produced to where it is analysed through stages that extract, transform and load it. Any stage can be retried after a failure, so each one has to be safe to run twice, and late or out-of-order records have to be handled on purpose. - [Distributed Transactions and the Blocking Case of Two-Phase Commit](https://lightmysky.com/learn/computing/distributed-transactions-and-the-blocking-case-of-two-phase-commit-mt_MP_B_a_EwW): A transaction spanning several stores needs one atomic decision. Two-phase commit gets it by making participants promise before the coordinator decides, and its known weakness is that a coordinator failure at the wrong moment leaves participants holding locks with nobody to ask. - [Conflict-Free Replicated Data Types](https://lightmysky.com/learn/computing/conflict-free-replicated-data-types-mt_Bhf1nu-9jz): If every update is commutative and idempotent, replicas that receive the same set of updates in any order end in the same state, and no coordination is needed at write time. The cost is that the merge rule, not the application, decides what concurrent edits mean. - [Log-Structured Storage and Compaction](https://lightmysky.com/learn/computing/log-structured-storage-and-compaction-mt_MDZ7MPNEhO): Writing sequentially to a log and merging sorted runs in the background turns random writes into sequential ones. Reads then have to consult several runs, so the design trades read amplification and background work against write throughput. - [Stream Processing: Windows, Watermarks and Late Events](https://lightmysky.com/learn/computing/stream-processing-windows-watermarks-and-late-events-mt_CfzXL_cL0D): An unbounded stream has no end at which to compute an answer, so results are cut by windows over event time. A watermark is the system's claim that event time has passed a point, and every record arriving after it forces a choice between waiting longer and being wrong. - [The Data Science Workflow](https://lightmysky.com/learn/computing/the-data-science-workflow-mt_99QNfiyQ55): Useful analysis runs in a loop: state the question, find and check the data, build something, look at what it says, then report it in a form someone can act on. Most of the work is in the first two stages, and skipping them is what produces confident nonsense. - [Cleaning Real Data: Missing, Duplicated and Wrong](https://lightmysky.com/learn/computing/cleaning-real-data-missing-duplicated-and-wrong-mt_qIsLXA-7EC): Real datasets have blanks, repeats, impossible values and three spellings of the same city. Every repair is a decision that changes the result, so a cleaning step has to be written down and defended rather than done quietly. - [Exploratory Analysis and an Honest Chart](https://lightmysky.com/learn/computing/exploratory-analysis-and-an-honest-chart-mt_Jpb78Z6Ytu): Before modelling anything, look: distributions, outliers, relationships between pairs. Then the chart that reports it has to make the truth easy to read, which rules out a truncated axis, a misleading area, and a colour scale nobody can order. ## Software Engineering 21 topics, ages 18 to 24. https://lightmysky.com/learn/computing/areas/software-engineering - [Requirements: Turning a Wish into a Testable Statement](https://lightmysky.com/learn/computing/requirements-turning-a-wish-into-a-testable-statement-mt_TFb-YNpvT1): Someone asks for a system that is fast, or fair, or easy. A requirement rewrites that as something with a check attached, separating what the system must do from how well it must do it, and naming what is out of scope. - [Interfaces, Coupling and What a Module Promises](https://lightmysky.com/learn/computing/interfaces-coupling-and-what-a-module-promises-mt_EUZyD26WFk): A module's interface is the set of promises other code may rely on, and everything else is free to change. Coupling measures how much of a neighbour's insides a caller depends on, and it is the quantity that decides how expensive the next change will be. - [Design Patterns: Naming a Solution That Keeps Recurring](https://lightmysky.com/learn/computing/design-patterns-naming-a-solution-that-keeps-recurring-mt_bhUEk8PwBp): Some arrangements of objects appear again and again: swapping behaviour at runtime, telling listeners something happened, hiding the choice of which class to build. Naming them gives a team shared vocabulary, and the risk is reaching for a pattern where a plain function would do. - [Refactoring: Changing Structure Without Changing Behaviour](https://lightmysky.com/learn/computing/refactoring-changing-structure-without-changing-behaviour-mt_HHZufOyTg4): Refactoring changes internal structure while preserving observable behaviour. Small steps, relevant tests and code review help assess that preservation and locate problems. Passing tests support claims about their checks, not every possible input or effect. - [Test Doubles and Testing at a Boundary](https://lightmysky.com/learn/computing/test-doubles-and-testing-at-a-boundary-mt_4ep3SiMYNM): A test double replaces a dependency with a stand-in the test controls. A seam allows that substitution. Checking public results and contract-relevant boundary interactions can reduce dependence on internal structure. - [Test Strategy: Unit, Integration and End to End](https://lightmysky.com/learn/computing/test-strategy-unit-integration-and-end-to-end-mt_fdAvx1MMFE): A test strategy assigns risks to checks with suitable scope, speed and realism. Isolated tests check local logic, integration tests exercise selected real interactions, and end-to-end tests exercise a complete journey. None proves the whole system correct. - [Version Control as a Graph of Commits](https://lightmysky.com/learn/computing/version-control-as-a-graph-of-commits-mt_oKsDRKirMy): A repository is a graph: each commit is a snapshot that points at the one it came from, and a branch is a movable label on a node. Once the shape is clear, most version control commands stop being incantations and become moves on that graph. - [Branching, Merging and Resolving a Conflict](https://lightmysky.com/learn/computing/branching-merging-and-resolving-a-conflict-mt_l3vFbU7L3E): Two branches that changed different lines merge on their own; two that changed the same lines cannot, and a person has to decide. A rebase rewrites the history into a straight line instead, which reads better and throws away what actually happened. - [Code Review: Reading a Change You Did Not Write](https://lightmysky.com/learn/computing/code-review-reading-a-change-you-did-not-write-mt_Hhe1Ou709s): Review reads a diff and asks whether it does what was intended, whether it breaks anything nearby, and whether the next person will understand it. The skill is separating the change that has to happen from the taste that does not. - [Property-Based Testing](https://lightmysky.com/learn/computing/property-based-testing-mt_QqCNKT06IY): Property-based testing states a rule over an allowed input domain and generates cases to check it. A failure is a counterexample. Passing generated cases do not prove the rule for every input. Useful properties include preserving elements during sorting and specified round trips. - [Continuous Integration and the Build Pipeline](https://lightmysky.com/learn/computing/continuous-integration-and-the-build-pipeline-mt_z__G4nfjwh): Continuous integration supports frequent integration of changes through configured automated checks. Pipelines can build projects, run tests and report results on chosen triggers. Failures need investigation, and passing checks do not establish every release requirement. Feedback time can influence how a team works. - [Software Architecture: Layers, Services and Their Trade-offs](https://lightmysky.com/learn/computing/software-architecture-layers-services-and-their-trade-offs-mt_uz_OkFgysJ): Software architecture describes major components, their relationships and where state is owned. Some choices are costly to reverse. Service boundaries can enable separate deployment and scaling when contracts and release processes support them, while adding communication, compatibility and partial-failure concerns. - [Technical debt and the cost of the next change](https://lightmysky.com/learn/computing/technical-debt-and-the-cost-of-the-next-change-mt_iA8-0Qg4ID): Technical debt is a design or implementation problem that can add effort or risk to relevant future work. A shortcut may create it, but not every edit pays a cost and routine maintenance does not automatically reduce it. Deliberate decisions compare benefits, costs and risks and record a cleanup or review plan. - [Working in a Team: Issues, Estimates and Iterations](https://lightmysky.com/learn/computing/working-in-a-team-issues-estimates-and-iterations-mt_HNNnVvADcF): A team splits work into pieces small enough to finish, agrees what done means for each, and looks at what actually happened before planning the next stretch. Estimates are a planning tool rather than a promise, and treating them as promises is what makes teams stop giving honest ones. - [Dependencies, Licences and the Supply Chain](https://lightmysky.com/learn/computing/dependencies-licences-and-the-supply-chain-mt_2kilqPb0aV): Most of a shipped program was written by strangers. Pulling in a library brings its bugs, its updates and its licence terms, so a team has to know what it depends on, what those terms allow, and what happens when a dependency stops being maintained. - [Specifying Correctness: Safety, Liveness and Invariants](https://lightmysky.com/learn/computing/specifying-correctness-safety-liveness-and-invariants-mt_4_KaoDSHZF): Before anything can be proved, the claim has to be written down. A safety property says nothing bad ever happens and is refuted by a finite trace; a liveness property says something good eventually does and is not. An invariant is the safety property a proof actually uses. - [Model Checking and the State-Space Explosion](https://lightmysky.com/learn/computing/model-checking-and-the-state-space-explosion-mt__pgZ0PzEZo): Finite-state model checking decides a stated property over reachable behavior, using explicit or symbolic methods. Component state counts give a product bound on possible global states. A reduction must preserve the behavior relevant to the property; a conservative abstraction can introduce counterexamples that the original system cannot follow. - [Hoare Logic and Proving a Program Meets Its Specification](https://lightmysky.com/learn/computing/hoare-logic-and-proving-a-program-meets-its-specification-mt_bJZnbBrUIP): A partial-correctness Hoare triple promises that execution starting in its precondition satisfies its postcondition if it terminates. Rules compose compatible triples. Loop invariants support initialization, preservation and exit checks; termination needs an additional argument. Tools can generate verification conditions, and some can infer invariants. - [Reading a Systems or Machine-Learning Paper](https://lightmysky.com/learn/computing/reading-a-systems-or-machine-learning-paper-mt_4LsuT0TdxT): A paper is a claim, a method and evidence, in that order of importance. Reading the evaluation before the method shows what is actually being demonstrated, and the related work shows what the authors compared against and what they left out. - [Reproducibility: Seeds, Environments and the Ablation](https://lightmysky.com/learn/computing/reproducibility-seeds-environments-and-the-ablation-mt_Rp__eJ-vjn): A result that cannot be rerun is a claim, not a finding. Fixing seeds, pinning the environment and recording the exact command make a run repeatable, and an ablation is what shows which part of a method the gain came from. - [Scoping and Writing a Thesis-Scale Project](https://lightmysky.com/learn/computing/scoping-and-writing-a-thesis-scale-project-mt_Y46uRENRVf): A year-long project fails on scope more often than on difficulty. A workable one has a question that can be answered either way, a result that stands even if the ambitious part does not land, and a written argument that survives a reader who was not there.