Computing Curriculum

Why this course exists

Many schools in Nepal teach computers from the early grades, but CDC’s first computer curriculum is Computer Science for Grades 9–10, an optional subject for the SEE. Below Grade 9, schools choose their own books, and many of these teach a list of software menus that is out of date by the time the book is printed. Even CDC’s Grades 9–10 course gives each idea only a few hours, and much of it is about naming parts and tools.

This course teaches what stays true while the technology changes: how computers work, how they store everything as numbers, how to give them exact instructions, how networks move data, how to find meaning in data, how to stay safe and act fairly, how machines learn, how to make things with a computer for other people, and the everyday skills of using a computer and a phone well. Students in Nepal often have only a phone at home and a shared lab at school, so every grade can be studied on a phone, and every idea in Grades 6–10 can also be taught without a computer.

The course’s aims

The course aims to help students:

• understand the computers, networks and data they use every day well enough to explain them, choose them and fix them;
• think like a programmer: break a problem into parts, write exact instructions, test them and improve them;
• make useful things with a computer for real people, alone and in teams;
• use computers and phones efficiently, safely, honestly and kindly, in English and in Nepali;
• understand AI from the inside, use it critically and judge where it helps and where it harms;
• weigh the effects of computing on people, work, fairness and the environment, in Nepal and the world;
• keep learning new technology on their own after school.

Two stages

• Grades 6–10, the common course, for every student. It starts from nothing and is complete in itself: a student who stops after Grade 10 has met every thread, written real programs, built projects for real users and learned how AI works. It is rounded off in the SEE year.
• Grades 11–12, the senior stage, for students who choose computing. It goes deeper into the same nine threads (objects, recursion, data structures, how a program becomes machine code, modelling, the web’s servers, security, neural networks, algorithms for hard problems, the limits of computing, software engineering, building and judging AI systems, cryptography) at the level of England’s A level and the first year of a university course. It ends with a capstone project.

The course was planned as one series from Grade 6 to Grade 12: each grade starts where the one before stopped, and the senior stage builds on the common course without repeating it.

What it is built from

The course combines these frameworks. Each unit below names the standards it meets.

• CSTA K–12 Computer Science Standards, 2026 (Computer Science Teachers Association, USA): the five concepts Algorithms and Design, Programming, Data and Analysis, Systems and Security, Computing and Society. Codes such as MS-PRO-RD-17 (MS = middle school, Grades 6–8; HS = high school, Grades 9–12) are theirs, as are the codes of their Artificial Intelligence specialty standards (S1-AIN, a first course; S2-AIN, a second), used in Grades 11–12. CSTA’s high school standards are one band for Grades 9–12; Grades 9–10 meet each of them first, and Grades 11–12 meet the same standards again at greater depth.
• England’s Computing programmes of study, Key Stages 3 and 4 (“Eng KS3”, “Eng KS4”), with the order of the National Centre for Computing Education’s units; and for Grades 11–12, England’s A level Computer Science (“Eng A level”: the Department for Education’s subject content, as in the exam boards’ specifications).
• The Australian Curriculum, version 9, Digital Technologies, Years 7–8 and 9–10 (“Aus 7–8”, “Aus 9–10”); and for Grades 11–12, the senior Software Engineering syllabus of New South Wales (NESA, Stage 6, “NSW Software Engineering”).
• AI4K12’s Five Big Ideas in AI (1 Perception, 2 Representation and reasoning, 3 Learning, 4 Natural interaction, 5 Societal impact) and UNESCO’s AI competency framework for students (2024), at its levels understand, apply and create, and in its four dimensions (a human-centred mindset, the ethics of AI, AI techniques and applications, AI system design).
• ISTE Standards for Students and the Digital Inquiry Group’s Civic Online Reasoning (lateral reading, finding the original source), for the practical skills the computer science standards leave out.
• CDC’s Computer Science curriculum, Grades 9–10, for where the two courses meet (“CDC 9 Unit 6 (early)” means that our unit prepares for that CDC unit).

How it relates to CDC’s and NEB’s courses

There are two separate series on the website:

• Computing, Reimagined, Grades 6–12 (this curriculum): our own course, one continuous series, read in order from Grade 6.
• CDC’s Computer Science, Grades 9–10: companion books that follow CDC’s curriculum and order exactly, for students taking the SEE.

Students taking the SEE study CDC’s course with its companion books. Our Grades 9–10 run alongside it and do not replace it. They do not follow CDC’s order or re-teach CDC’s lists. Where the two meet, CDC’s companion teaches the topic as the SEE asks, and our unit goes further (how a CPU is built from gates, rather than its parts; why compression works, rather than file formats). A student who has studied our Grades 6–8 meets most of CDC’s Grade 9 as revision.

Grades 11–12 are likewise independent of NEB’s Computer Science for Grades 11–12: they follow this course’s own threads, not NEB’s order or contents. Companions to NEB’s course may be made later, as for CDC’s.

The shape of the course

• Nine threads run through every grade, each picking up where the grade before stopped: Computer systems · Data and representation · Algorithms and programming · Networks and the internet · Data and analysis · Safety and society · Artificial intelligence · Using computers well · Creating. Section 6 shows each thread grade by grade.
• An AI unit in every grade, climbing from “what AI is” (Grade 6) through “how large language models work” (Grade 10) to building neural networks (Grade 11) and building and judging whole AI systems (Grade 12).
• A “using computers well” unit in every grade: the practical skills of files, typing in English and Nepali, searching and checking, documents, email and online services, fixing problems, automating one’s own work, and learning on one’s own.
• Programs run on the page. Blocks in Grades 6–7, Python from Grade 8, HTML and CSS in Grade 8, JavaScript in Grade 9, SQL in Grade 10, all in the book’s own editors in a web browser, nothing to install. Grades 11–12 add a model CPU’s assembly language, a simulated web server, version control and automatic tests, still in the browser.
• A project in every grade, designed, built and tested for a real user, growing from a picture program in Grade 6 to a team’s capstone in Grade 12.
• Lasting ideas in the text, today’s names in boxes. The names of apps, products, versions, prices and statistics appear only in the book’s “Today” boxes, which are dated and checked every year. The learning outcomes below never depend on a particular product.

2.1 The course’s competencies

The nine competencies match the nine threads. On completing Grade 10 (the common course), students will be able to:

1. Computer systems. Explain how a computing device works, from logic gates and the CPU to the operating system, and choose, set up and look after a device for a given need.
2. Data and representation. Show how numbers, text (including Nepali), pictures and sound are stored as binary, work out storage sizes, and choose a file format and compression for a purpose.
3. Algorithms and programming. Design, write, test and debug programs, first in blocks and then in Python, HTML, CSS and JavaScript, using sequence, selection, repetition, variables, data structures, functions and objects, and compare algorithms for correctness and efficiency.
4. Networks and the internet. Explain how data travels across networks and the internet, and use networks and data plans wisely.
5. Data and analysis. Collect, clean, organize and analyze data with spreadsheets, Python and databases, show it in honest charts, and draw conclusions that the data supports.
6. Safety and society. Protect their own and others’ data and devices, recognize common attacks and scams, act lawfully and kindly online, and judge the effects of computing on people, work, access and the environment, in Nepal and the world.
7. Artificial intelligence. Explain how machines learn from examples, build and test a simple model, use AI tools honestly and critically, and judge where AI helps and where it harms.
8. Using computers well. Use a computer and a phone efficiently and independently: type in English and Nepali, organize and back up files, find and check information, make clear documents, communicate and use online services safely, and fix problems and learn new tools on their own.
9. Creating. Plan, build and improve a digital product (a document, a video, a web page, an app) for real users in a team, giving credit for others’ work and testing it with the people it is for.

Students who go on to Grades 11–12 extend each competency: they design programs from objects and data structures and judge algorithms by their growth and their limits; explain how a program runs as machine instructions; model real systems; build and secure web applications with a server; train and judge neural networks and AI systems; analyze data with honest uncertainty; work as software engineers in a team; and argue technology policy for Nepal.

2.2 Level-wise competencies

Grades 6–8. On completing Grade 8, students will be able to:

1. Describe the parts of a computer and what each does, and the computers hidden in everyday devices; choose a device by its specifications.
2. Convert between binary and decimal, and explain how text, color pictures and sound are stored in bits; choose a file format for a photo, sound or video.
3. Write programs in blocks and then in Python that use sequence, loops, choices, variables and functions; model algorithms in flowcharts and pseudocode; search and sort; test and debug systematically.
4. Explain how a message travels across the internet in packets, and why the internet keeps working when parts fail.
5. Collect data, organize it in a spreadsheet, sort, filter and summarize it, fix messy data, and make charts that tell the truth.
6. Keep accounts and data safe (strong passwords, two-step login, backups), recognize malware, phishing and scams, manage their screen time and digital footprint, and know who to tell.
7. Train a simple model from examples, explain how bias enters through the data, and use generative AI with checks and honesty.
8. Use files, folders, Nepali Unicode typing, search, documents, photos, sound and video confidently on a computer and a phone.
9. Build and test a web page or app for a community user, in a team.

Grades 9–10. On completing Grade 10, students will be able to:

1. Explain how a CPU is built from logic gates and runs instructions, and what an operating system manages; describe sensors, the cloud, GPS and the environmental cost of computing.
2. Do binary arithmetic with negative numbers and hexadecimal, calculate the size of pictures and sound, and explain lossless and lossy compression.
3. Write modular Python programs with lists, strings, dictionaries, functions and modules, and web apps in HTML, CSS and JavaScript; count the steps of an algorithm as the data grows; represent a network of places as a graph and find the fewest steps between two of them.
4. Explain the internet’s protocols and layers (IP, DNS, HTTP) and draw a network.
5. Design and query a database in SQL, clean data and draw conclusions from it with charts and simulations.
6. Explain encryption and password hashing, classify attacks and defenses, and explain Nepal’s laws on electronic transactions, privacy and copyright.
7. Build a machine learning model in Python on real data, test its accuracy, and explain how a large language model works and why it makes mistakes.
8. Write a properly formatted report, use email, online forms, government services and digital payments safely, and troubleshoot problems and learn new software on their own.
9. Build software in a team with a defined workflow and present a project made for a real user.

Grades 11–12. On completing Grade 12, students will be able to:

1. Explain how a program in a high-level language becomes machine instructions, how the operating system runs many programs at once, and how fractional numbers are stored and why they round; simplify logic with Boolean algebra and Karnaugh maps; compare kinds of processor; explain how large services stay up for millions of users and keep their data right (transactions).
2. Choose a representation for a problem (objects, stacks, queues, hash tables, trees, weighted graphs) and justify it by the operations it needs.
3. Design object-oriented and recursive programs, apply searching, shortest path, greedy and dynamic-programming algorithms, express efficiency in big O, describe a language with a grammar, compare ways of programming (procedural, object-oriented, functional, logic), and explain what no program can compute.
4. Explain the internet’s layers, TCP, HTTP and HTTPS in depth, and build a web application with a client, a server and a database designed to third normal form.
5. Model a real system in a simulation, including one that controls itself, and check it against data; analyze data with samples, uncertainty, fitted lines and experiments, and tell correlation from cause.
6. Find and fix common security flaws, explain public-key cryptography and digital signatures with small numbers, and write a technology policy proposal for Nepal.
7. Train a neural network, compare it with other kinds of machine learning (decision trees, clustering, reinforcement learning), measure an AI system properly and for different groups, test it for harm, and plan safeguards for its use.
8. Automate their own work with programs, and keep learning new technology on their own after school.
9. Work as a software engineer in a team (version control, automatic tests, a debugger, code review, documentation, a development method and its plan), guided by a professional code of ethics, and deliver a capstone project for a real user.

How to read this section

• Periods are 45-minute periods. “T” is class teaching (explanation, discussion, unplugged activity, written work); “P” is practical work (on a computer, a phone, or with the book’s on-page programs). A school without computers does the practical periods in the ways given in Section 4.
• Learning outcomes are numbered grade.unit.outcome (7.2.3 is Grade 7, Unit 2, outcome 3), so that the teacher’s guide and the book’s practice can refer to them. Each can be checked on paper or with the book’s on-page programs.
• Scope is the content to teach. Practical work lists the tasks for continuous assessment (Section 5.1).
• Standards are the codes of the frameworks in Section 1. In Grades 11–12 they are the CSTA high school standards met again at greater depth (Section 1), with the senior sources named beside them.

Periods a year

CDC’s Computer Science gives 128 working hours a year (4 credit hours, 4 periods a week over 32 weeks). This course takes 96 periods a year in Grades 6–8 (3 periods a week over 32 weeks) and 128 in Grades 9–12 (4 a week). In every grade the units leave some periods free:

• Grades 6–8: the units take 88; 8 are kept for revision (2), the end-of-year practical task (2; in Grade 8 the final exam’s practical part), project presentations (2) and catch-up (2).
• Grades 9–10: the units take 88, as in Grades 6–8; the fourth period a week gives 40 more, for typing (6), extra time on the year’s project (14), revision and self-marked practice (12), the end-of-year practical task (2; in Grade 10 the final exam’s practical part), project presentations (2) and catch-up (4).
• Grades 11–12: the units go deeper and take 104; 24 are kept for extra time on the year’s project (8), revision and self-marked practice (8), the end-of-year practical task (2; in Grade 12 the final exam’s practical part), project presentations (2) and catch-up (4).

Why 3 periods in Grades 6–8 and 4 in Grades 9–12:

• In Grades 6–8, computing has no fixed place in CDC’s timetable, and schools give it different amounts of time. Three is a load most can meet, and a school that gives four has 32 more periods for typing, projects and revision.
• One shared lab usually serves the whole school. Three periods a week per section is what a lab can give every section of the lower grades.
• From Grade 9, programs and projects grow longer and need more time at the keyboard, and four periods matches CDC’s own Computer Science. The fourth period goes to typing, projects and revision in Grades 9–10, and mostly to the deeper units in Grades 11–12.
• The book carries much of the practice: its programs run on a phone, so students can practice outside class time.

Typing practice runs as a game in every grade (Section 4.4): the first 5 minutes of every practical period in Grades 6–8, not counted in the periods, and 6 periods of its own in each of Grades 9 and 10.

Grade 6

Students are about 11 years old. Most ideas start unplugged or with something from home, then move to the book’s on-page programs.

Unit 6.1 What Is a Computer? · 8 periods (5 + 3)

Standards: CSTA MS-SYS-HW-31, MS-SOC-HI-38; Eng KS3 hardware and software; Aus 7–8 digital systems.

Learning outcomes:

• 6.1.1 Define a computer as a machine that takes input, processes it, stores it and gives output, following instructions.
• 6.1.2 Sort the parts of a device into input, process, output and storage, for a computer, a phone and an ATM.
• 6.1.3 Distinguish hardware from software, with three examples of each.
• 6.1.4 Identify the computer inside at least five everyday devices (a phone, an ATM, a rice cooker, a traffic light, a washing machine) and say what its input and output are.
• 6.1.5 Describe how computing devices are used in three kinds of work in Nepal (for example a bank, a hospital, a farm).
• 6.1.6 Put the main steps in the history of computing in order, from the abacus to the phone, and name who made one of them.

Scope: input → process → output → storage; hardware and software; computers hidden in devices; computers at work; a short history (abacus, mechanical calculators, the first electronic computers, personal computers, phones).

Practical work: label the parts of a real or pictured computer and phone; list the input and output of five devices at home.

Unit 6.2 Using a Computer Well · 12 periods (3 + 9)

Standards: Eng KS3 “create, reuse, revise”; Aus 7–8 managing; CDC 9 1.7 (early).

Learning outcomes:

• 6.2.1 Explain what an operating system does, and name the operating system of a computer and a phone they use.
• 6.2.2 Create, name, rename, move, copy and delete files and folders, and find a file by searching.
• 6.2.3 Draw a folder tree for a set of files and write the path of a file in it.
• 6.2.4 Type with both hands using the home keys, and use five common shortcuts (copy, cut, paste, undo, save).
• 6.2.5 Type a paragraph in Nepali Unicode with a Romanized or a traditional layout, and explain why text typed in Preeti does not work on other computers and phones.
• 6.2.6 Turn on and use one accessibility feature (a screen reader, magnifier or captions) and voice typing in Nepali or English.
• 6.2.7 List ways to look after a device: charging and the battery, a UPS, surges and voltage swings, heat, dust and water.

Scope: the operating system; files, folders, paths and file names; the keyboard, touch typing and shortcuts; Nepali in Unicode (Romanized and traditional layouts; why not Preeti); voice typing; accessibility features; taking care of devices and power (batteries, UPS, surges).

Practical work: build a folder tree for a school year’s work; a timed typing exercise in English and in Nepali Unicode; type one paragraph by voice and correct it.

Unit 6.3 Algorithms: Step by Step · 8 periods (4 + 4)

Standards: CSTA MS-ALG-PS-01, MS-ALG-PS-03; Eng KS3 algorithms; Aus 7–8 algorithms.

Learning outcomes:

• 6.3.1 Define an algorithm, and explain why a computer needs more precise instructions than a person.
• 6.3.2 Write an algorithm for an everyday task (making chiya, directions from the school gate to a landmark) with steps in the right order.
• 6.3.3 Identify sequence, repetition and choices (“if … then”) in a written algorithm.
• 6.3.4 Follow a written algorithm step by step and say what it produces.
• 6.3.5 Find and correct a bug (a missing, wrong or misplaced step) in an algorithm, and check the correction with given inputs.
• 6.3.6 Use named variables of three kinds (number, text, yes/no) in an algorithm, and trace it for given inputs with a trace table.

Scope: precise instructions; sequence; repetition; choices; variables and trace tables; bugs and debugging; testing an algorithm by following it; all unplugged.

Practical work: a partner follows the student’s directions exactly as written; debug a classmate’s algorithm.

Unit 6.4 Programming with Blocks · 14 periods (4 + 10)

Standards: CSTA MS-PRO-RD-17, MS-PRO-TR-19; Eng KS3 programming.

It teaches with a turtle that draws, not a sprite, and goes on to nested loops, the turning rule for regular shapes, pen up and down, and decomposition.

Learning outcomes:

• 6.4.1 Define program, programming and programming language, and distinguish a block-based from a text-based language with an example of each.
• 6.4.2 Predict and draw on paper what a short block program draws, and say where the turtle ends and which way it faces.
• 6.4.3 Build a block program that draws a given shape, putting blocks in the right sequence.
• 6.4.4 Rewrite a repeated sequence of blocks as a loop, and give two reasons a loop is better.
• 6.4.5 Calculate the turn at each corner of a regular shape (360° ÷ number of sides) and use it in a program.
• 6.4.6 Count how many times the blocks inside a nested loop run.
• 6.4.7 Use pen up and pen down to move without drawing.
• 6.4.8 Write a program with several event blocks that each respond to a different key, and name three events a phone responds to.
• 6.4.9 Debug a program by predicting, running and comparing, and changing one thing at a time, and explain why one change at a time.
• 6.4.10 Break a drawing into parts (decomposition), plan it on paper, and build it part by part.

Scope: program, programming language, block and text languages; the turtle, move and turn, degrees; sequence; loops; the turning rule for regular shapes (and the star, two full turns); nested loops; pen up and pen down; events and event blocks; bugs and debugging; decomposition; a first look at the same program in Python; the story of Logo and Scratch.

Practical work: the unit’s on-page programs (square, triangle, shapes, flower, dashes, steering, star, stairs, house); the project “Design your own picture”.

Unit 6.5 Zeros and Ones · 9 periods (5 + 4)

Standards: Eng KS3 binary; Aus 7–8 data representation; CDC 9 Unit 2 (early).

Learning outcomes:

• 6.5.1 Explain why computers store everything as two states (on and off, 1 and 0), and define bit and byte.
• 6.5.2 Count in binary from 0 to 15.
• 6.5.3 Convert a number from binary to decimal, up to 8 bits.
• 6.5.4 Convert a number from decimal to binary, up to 255.
• 6.5.5 Draw a black-and-white picture from a grid of bits, and write the bits for a given picture.
• 6.5.6 Put the units byte, kilobyte, megabyte, gigabyte and terabyte in order, and choose a sensible unit for a text message, a photo, a film and a phone’s storage.

Scope: two states; bits and bytes; place value in binary; binary ↔ decimal; black-and-white pictures as pixels; units of storage.

Practical work: binary cards (unplugged); the on-page pixel and binary widgets; encode the student’s initial as a pixel grid.

Unit 6.6 Information and Data · 10 periods (4 + 6)

Standards: CSTA MS-DAT-DC-23, MS-DAT-DI-26; Aus 7–8 data.

Learning outcomes:

• 6.6.1 Distinguish data from information with an example.
• 6.6.2 Plan a short survey question with clear answer choices, and collect answers from the class.
• 6.6.3 Enter data in a table with one row per record and one column per field, and enter it in a spreadsheet.
• 6.6.4 Sort a table by a column, and count or add up a column.
• 6.6.5 Make a bar chart and a pie chart from a table, and choose which suits a given question.
• 6.6.6 Spot a misleading chart (an axis not starting at zero, missing labels) and redraw it honestly.

Scope: data and information; collecting data; tables, records and fields; a first spreadsheet (cells, entering data, sorting, simple totals); bar and pie charts; honest charts.

Practical work: a class survey (how students come to school and how far), entered, sorted and charted.

Unit 6.7 Making Things with a Computer · 10 periods (3 + 7)

Standards: CSTA MS-PRO-PD-14; Eng KS3 “create digital artefacts”.

Learning outcomes:

• 6.7.1 Make a one-page document or poster with a heading, body text, a picture and a caption, in English or Nepali.
• 6.7.2 Make a short slideshow with few words per slide and readable text.
• 6.7.3 Apply three rules of clear design (contrast, size, alignment) to improve a given page.
• 6.7.4 Explain copyright in simple terms, and why work by others needs credit and permission.
• 6.7.5 Find a picture under a Creative Commons license and give its credit correctly.

Scope: documents, slides and pictures; clear design; typing Nepali in documents; others’ work, credit and copyright; Creative Commons licenses.

Practical work: a poster about a place in Nepal with a credited picture; a three-slide presentation.

Unit 6.8 The Internet and Staying Safe · 9 periods (5 + 4)

Standards: CSTA MS-SYS-SE-33; Eng KS3 e-safety; CDC 9 Unit 6 (early).

Learning outcomes:

• 6.8.1 Distinguish the internet from the web.
• 6.8.2 Search with well-chosen words, and tell an advertisement from a result.
• 6.8.3 Make a strong password by a rule, and explain why the same password should not be used on two sites.
• 6.8.4 List personal information that should not be shared online.
• 6.8.5 Recognize a scam message (a prize, a fake payment, a request for a code) and say what to do.
• 6.8.6 Describe kind and unkind behavior online, and name the adults to tell when something goes wrong.

Scope: the internet and the web; searching; passwords; privacy; scams common in Nepal; being kind online; who to tell.

Practical work: a search challenge; sort example messages into safe and scam (on paper or on the page).

Unit 6.9 Computers That Learn (AI) · 8 periods (4 + 4)

Standards: CSTA MS-ALG-ML-06, MS-ALG-ML-08, MS-SOC-ET-40; AI4K12 1, 3, 5; UNESCO “understand”.

Learning outcomes:

• 6.9.1 Explain in one sentence what artificial intelligence is, and tell an AI system from an ordinary program.
• 6.9.2 Train a sorter in the browser with examples, and describe how its answers change with more or different examples.
• 6.9.3 Give a reason why a trained model makes a given mistake.
• 6.9.4 Name four places AI is used around them (a phone camera, voice typing, recommendations, translation).
• 6.9.5 Decide, for a given situation, whether an AI answer can be trusted, and how to check it.

Scope: what AI is and isn’t; learning from examples; mistakes; AI in daily life; when to trust it.

Practical work: train the on-page sorter (or a card-sorting game, unplugged) and record its mistakes.

Grade 7

Unit 7.1 Inside the Computer · 8 periods (5 + 3)

Standards: CSTA MS-SYS-HW-30; Eng KS3 hardware; CDC 9 Unit 1 (early).

Learning outcomes:

• 7.1.1 Describe the job of the CPU, memory (RAM), storage, and input and output devices, and draw a block diagram connecting them.
• 7.1.2 Distinguish memory from storage, and say what is lost when the power goes off.
• 7.1.3 Identify common ports (USB, USB-C, HDMI, audio, Ethernet) and what connects to each.
• 7.1.4 List four jobs of the operating system.
• 7.1.5 Compare two phones or laptops from their specifications (processor, RAM, storage, battery) and choose one for a given user and budget, giving reasons.

Scope: CPU, memory, storage, input and output devices, ports; the operating system’s jobs; choosing a phone or laptop.

Practical work: identify parts and ports on a real computer (or photos); compare two devices’ specifications for a family member’s needs.

Unit 7.2 How Computers Store Everything · 10 periods (6 + 4)

Standards: Eng KS3 binary and data representation; Aus 7–8 data representation.

Learning outcomes:

• 7.2.1 Convert between binary and decimal up to 8 bits, both ways.
• 7.2.2 Add two binary numbers up to 8 bits and recognize overflow.
• 7.2.3 Explain that text is stored as numbers, and look up a character’s code in an ASCII or Unicode table.
• 7.2.4 Explain why Nepali typed in Preeti turns into wrong letters on another computer, and convert a Preeti text to Unicode with a tool.
• 7.2.5 Describe how a color is stored as red, green and blue values, and mix a given color from RGB values.
• 7.2.6 Distinguish raster from vector pictures, and say which suits a photo and which a logo.
• 7.2.7 Describe how sound is stored as samples.

Scope: binary ↔ decimal; binary addition; text as numbers (ASCII, Unicode, Devanagari; Preeti and converting old files; fonts; how Nepali search and spell-check work); color (RGB); raster and vector; sound as samples.

Practical work: the on-page binary, RGB and pixel widgets; convert a Preeti paragraph to Unicode.

Unit 7.3 Programming: Variables and Choices · 12 periods (3 + 9)

Standards: CSTA MS-ALG-PS-01, MS-PRO-VD-16; Eng KS3 programming.

Learning outcomes:

• 7.3.1 Define a variable, and create, set and change one in a block program.
• 7.3.2 Use input from the user in a program and store it in a variable.
• 7.3.3 Write a condition with comparison operators (=, <, >), and say whether it is true or false for given values.
• 7.3.4 Write a program that uses if/else to choose between two actions.
• 7.3.5 Trace a program with variables and choices for given inputs and write the value of each variable after each step.
• 7.3.6 Build a quiz game that keeps a score.

Scope: variables (numbers and text); input; conditions; if and if/else; tracing; a quiz game and a scoring game in blocks.

Practical work: a quiz game about a school subject; a scoring game; trace tables on paper.

Unit 7.4 True or False: Logic · 7 periods (4 + 3)

Standards: Eng KS3 Boolean logic; Aus 7–8.

Learning outcomes:

• 7.4.1 Give the result of AND, OR and NOT for any inputs.
• 7.4.2 Complete a truth table for an expression with two inputs.
• 7.4.3 Draw AND, OR and NOT gates, and wire gates to match a given truth table.
• 7.4.4 Write the logic of an everyday rule (for example “the light comes on if it is dark AND someone is near”) as an expression.
• 7.4.5 Use AND, OR and NOT in a search and in a program’s condition.

Scope: true and false; AND, OR, NOT; truth tables; logic gates; logic in search and in programs.

Practical work: the on-page gate widget; truth tables on paper.

Unit 7.5 Spreadsheets and Data · 10 periods (3 + 7)

Standards: CSTA MS-DAT-DC-21, MS-DAT-DC-23, MS-DAT-DC-24, MS-DAT-DI-25, MS-DAT-DI-27.

Learning outcomes:

• 7.5.1 Write formulas with cell references and the functions SUM, AVERAGE, MIN, MAX and COUNT, and copy a formula down a column.
• 7.5.2 Sort, filter and group data, and summarize each group.
• 7.5.3 Find and fix problems in messy data (spellings, blanks, wrong units, repeats), and choose between options for fixing them.
• 7.5.4 Explain how the precision of collected data (for example ages in years or in groups) changes what can be found out.
• 7.5.5 Make a budget for a family or a small shop, and use it to answer a “what if” question.
• 7.5.6 Write a short summary of a data investigation: the question, the data, what it showed, and its limits.
• 7.5.7 Draw a scatter chart of two columns, describe the relationship it shows, and use a trend line to make a prediction, saying why a prediction outside the data is only a guess and why going together is not the same as causing (added 2026-10-23).

Scope: formulas and functions; sort, filter, group, summarize; messy data and cleaning; precision of data; relationships between columns, trend lines and predictions; a class survey; a budget.

Practical work: a class survey analyzed in a spreadsheet; a budget.

Unit 7.6 Networks and the Internet · 8 periods (5 + 3)

Standards: CSTA MS-SYS-NT-34, MS-SYS-NT-35; Aus 7–8 networks.

Learning outcomes:

• 7.6.1 Model how a message is broken into packets, sent by different routes, and put back together.
• 7.6.2 Explain the jobs of an address and a router.
• 7.6.3 Explain why the internet keeps working when one link or router fails.
• 7.6.4 Describe how the internet reaches Nepal (cables through neighboring countries, fiber, mobile towers, Wi-Fi).
• 7.6.5 Estimate what uses up a data pack, and give three ways to save data.
• 7.6.6 Set up a hotspot, and change a home router’s Wi-Fi password.

Scope: packets, addresses, routers; Wi-Fi and mobile data; how the internet reaches Nepal; resilience; data packs; hotspots; home routers.

Practical work: the on-page packet network (or a packet-passing game with paper notes); check a phone’s data use by app.

Unit 7.7 Finding and Checking Information · 7 periods (3 + 4)

Standards: ISTE 1.3 Knowledge Constructor; Aus 7–8 evaluate data sources; Civic Online Reasoning.

Learning outcomes:

• 7.7.1 Use search operators (quotation marks, minus, site:) and better words to narrow a search.
• 7.7.2 Tell ads and sponsored results from ordinary results.
• 7.7.3 Check who is behind a website by reading other sites about it (lateral reading).
• 7.7.4 Trace a claim or a photo back to its original source, and spot a photo used out of context.
• 7.7.5 Use Wikipedia well: read its references and check a fact in one.
• 7.7.6 Find a PDF, a data table or a textbook online, and cite the source used.

Scope: search operators; reading results and ads; lateral reading; original sources; photos out of context; Wikipedia; finding documents and data; citing.

Practical work: check three claims from social media and report the source of each.

Unit 7.8 Keeping Data Safe · 7 periods (4 + 3)

Standards: CSTA MS-SYS-SE-32, MS-SYS-SE-33; Eng KS3.

Learning outcomes:

• 7.8.1 Explain confidentiality, integrity and availability, and what goes wrong when each is lost.
• 7.8.2 Describe malware and phishing, and how each gets onto a device or into an account.
• 7.8.3 Recognize fake payment and prize messages, and list the signs.
• 7.8.4 Turn on two-step login for an account.
• 7.8.5 Plan a backup for a family’s photos and documents.

Scope: the CIA triad; malware; phishing; fake payment and prize messages; strong passwords; two-step login; backups.

Practical work: sort example messages and links into safe and unsafe; turn on two-step login on an account (the student’s own or a family’s, with permission).

Unit 7.9 You and Your Screen · 6 periods (4 + 2)

Standards: CSTA MS-SOC-HU-43, MS-SOC-ET-41, MS-DAT-IM-28, MS-ALG-IM-10; ISTE 1.2 Digital Citizen; Eng KS3 “safely, respectfully and responsibly”.

Learning outcomes:

• 7.9.1 Describe three ways feeds, short videos, likes and notifications are designed to keep people scrolling.
• 7.9.2 Explain how a recommendation system uses what a person watched to pick what they see next.
• 7.9.3 Set a screen-time limit and turn off notifications on a phone.
• 7.9.4 Give the advice for eyes, posture and sleep.
• 7.9.5 Describe what to do about cyberbullying, and who to tell.
• 7.9.6 Explain what a digital footprint is, and decide whether a photo of someone else may be shared.
• 7.9.7 Give evidence of a helpful and a harmful effect of three algorithms met in daily life (a feed, a spam filter, a map’s route, a ride app’s prices), and say whom each may treat unfairly (added 2026-10-23).

Scope: attention design; recommendation systems; helpful and harmful effects of everyday algorithms; taking back control; health; cyberbullying; sharing others’ photos; digital footprint; who to tell.

Practical work: a week’s screen-time diary, and a plan to change one habit.

Unit 7.10 How Machines Learn (AI) · 7 periods (3 + 4)

Standards: CSTA MS-ALG-ML-07, MS-DAT-IM-29; AI4K12 2, 3, 5; UNESCO “understand” to “apply”.

Learning outcomes:

• 7.10.1 Identify the features and the label in a set of training examples.
• 7.10.2 Explain why a model is tested on examples it was not trained on.
• 7.10.3 Calculate the share of test examples a model got right.
• 7.10.4 Explain how one-sided training examples make a biased model, with an example.
• 7.10.5 Improve a model’s accuracy by changing its training data, and record the result before and after.

Scope: features and labels; training and testing; accuracy; bias from data; improving a model by fixing its data.

Practical work: train and test a model on the page; improve it by changing the data.

Unit 7.11 Computers and People · 6 periods (4 + 2)

Standards: CSTA MS-SOC-HI-38, MS-SOC-HI-39, MS-SOC-CE-44, MS-SOC-CE-45, MS-SYS-IM-37.

Learning outcomes:

• 7.11.1 Put the eras of computing in order, and name a person or group who shaped each.
• 7.11.2 Describe one intended and one unintended effect of a past computing technology.
• 7.11.3 Describe how three kinds of workers use computing to solve problems.
• 7.11.4 Give an example of a job automation has created and one it has replaced.
• 7.11.5 Explain how access to computers differs in Nepal by place, income, age and ability, and suggest one way to design for everyone.

Scope: eras of computing; who shaped them; jobs that use computing; automation; access in Nepal; designing for everyone.

Practical work: interview someone about how they use computers at work.

Grade 8

Python starts in this grade, in the book’s on-page editor.

Unit 8.1 From Blocks to Python · 9 periods (3 + 6)

Standards: CSTA MS-PRO-VD-16; Eng KS3 “a textual language”; Aus 7–8 general-purpose language.

Learning outcomes:

• 8.1.1 Write a Python program that prints text and numbers.
• 8.1.2 Create variables of type int, float, str and bool, and give the type of a given value.
• 8.1.3 Read input, convert it to a number, and use it in a calculation.
• 8.1.4 Write arithmetic expressions with +, −, *, /, //, % and **, and work out their value.
• 8.1.5 Read an error message, name the line and the kind of error (syntax, name, type), and fix it.
• 8.1.6 Rewrite a short block program in Python.

Scope: print; variables and types; input and type conversion; arithmetic; error messages; blocks to text.

Practical work: a bill calculator for a shop; fix five programs with errors.

Unit 8.2 Decisions and Loops in Python · 10 periods (3 + 7)

Standards: CSTA MS-PRO-RD-17.

Learning outcomes:

• 8.2.1 Write if, if/else and if/elif/else statements with comparison and logical operators.
• 8.2.2 Write a for loop with range() and a while loop, and say how many times each runs.
• 8.2.3 Use a loop to count and to add up values.
• 8.2.4 Draw a shape with Python’s turtle using a loop.
• 8.2.5 Explain the role of each loop, condition and variable in a given piece of code, and trace it for given inputs.
• 8.2.6 Find and fix an infinite loop.

Scope: if/elif/else; logical operators; for and range; while; counting and totals; turtle drawings; tracing.

Practical work: a grade calculator; a times table; turtle drawings.

Unit 8.3 Algorithms: Searching and Sorting · 8 periods (4 + 4)

Standards: CSTA MS-ALG-PS-02, MS-ALG-PS-03; Eng KS3 “search and sort”; Aus 7–8.

Learning outcomes:

• 8.3.1 Draw a flowchart and write pseudocode for an algorithm with choices and loops.
• 8.3.2 Carry out a linear search and a binary search by hand, and count the comparisons each makes.
• 8.3.3 Explain why binary search needs sorted data.
• 8.3.4 Sort a short list by hand with a simple sort (bubble or insertion), showing each pass.
• 8.3.5 Compare two sorts on the same list by the number of steps.
• 8.3.6 Choose test inputs (ordinary, edge and wrong) and check an algorithm with them.

Scope: flowcharts and pseudocode; linear and binary search; one or two sorts compared; testing with chosen inputs.

Practical work: sorting games with cards (unplugged); code a linear search in Python.

Unit 8.4 Functions: Building Blocks of Programs · 8 periods (3 + 5)

Standards: CSTA MS-PRO-PD-12, MS-PRO-PD-13; Eng KS3 procedures.

Learning outcomes:

• 8.4.1 Break a problem into parts and write each as a function.
• 8.4.2 Define and call a function with parameters.
• 8.4.3 Reuse a function with different arguments instead of repeating code.
• 8.4.4 Use reference documentation to find out how a function works and use it.
• 8.4.5 Write a function that returns a value, and explain that a function's variables are its own.

Scope: decomposition; functions; parameters and arguments; return values and local variables (a first look; Grade 10 goes into scope in full); reuse; reading documentation.

Practical work: a turtle program built from functions (a house, a tree, a street); look up and use two functions from the documentation.

Unit 8.5 Making Web Pages · 10 periods (3 + 7)

Standards: CSTA MS-ALG-IM-09, MS-PRO-TR-20; CDC 9 Unit 4 (early).

Learning outcomes:

• 8.5.1 Write an HTML page with headings, paragraphs, lists, links, images and a table.
• 8.5.2 Style a page with CSS (colors, fonts, spacing), in a separate style rule rather than on each tag.
• 8.5.3 Make a page readable on a phone.
• 8.5.4 Check a page for accessibility: alt text for images, contrast, headings in order.
• 8.5.5 Evaluate a website against human-centered design principles, and improve a page after feedback from a user.

Scope: HTML structure and tags; CSS; pages for phones; good design for users; accessibility; feedback.

Practical work: a page about the student’s village, town or a festival, in the on-page editor.

Unit 8.6 Photos, Sound and Video · 8 periods (2 + 6)

Standards: CSTA MS-PRO-PD-14; Eng KS3 “create digital artefacts”; Aus 7–8 creating; ISTE 1.6 Creative Communicator.

Learning outcomes:

• 8.6.1 Edit a photo: crop, straighten, adjust light and color, and resize.
• 8.6.2 Choose a file format (JPEG, PNG, WebP, SVG, PDF, MP3, MP4) for a given purpose and say why.
• 8.6.3 Make a photo fit a form’s size limit (for example under 200 KB) without making it unreadable.
• 8.6.4 Record clean sound, and cut a short video with captions and music they are allowed to use.
• 8.6.5 Apply clear layout, type and color to a poster or a video’s title.
• 8.6.6 Choose a Creative Commons license for their own work, and credit others’ work correctly.

Scope: photo editing; recording sound; cutting video; captions; layout, type and color; formats in practice; file size limits; Creative Commons in practice.

Practical work: a one-minute video with captions about a school event; a passport-style photo resized for an online form.

Unit 8.7 Physical Computing · 7 periods (2 + 5)

Standards: Aus 7–8; CDC 9 3.4–3.5 (early).

Learning outcomes:

• 8.7.1 Identify the inputs (buttons, sensors) and outputs (lights, sound) of a small programmable board.
• 8.7.2 Write a program that reacts to a button or a sensor.
• 8.7.3 Describe a device as inputs → program → outputs.
• 8.7.4 Design a simple device for a need at home or school (for example a thermometer, a step counter) and program it in the simulator.

Scope: a micro:bit-style board (simulator); buttons, sensors, lights, sound; inputs → program → outputs.

Practical work: programs on the on-page board simulator (or a real board where the school has one).

Unit 8.8 Organizing Your Digital Life · 7 periods (3 + 4)

Standards: ISTE 1.1d; Eng KS3 “create, reuse, revise and repurpose”; Aus 7–8 managing data.

Learning outcomes:

• 8.8.1 Design a folder structure and file names (with dates and versions) for a year’s work, and find a lost file.
• 8.8.2 Manage a phone’s storage: find what fills it, and free space safely.
• 8.8.3 Check and change an app’s permissions, and install apps only from safe places.
• 8.8.4 Explain the cloud and sync, and apply the 3-2-1 backup rule.
• 8.8.5 Set up a recovery email and recovery codes for an account, and use a password manager.
• 8.8.6 List the steps to take when a phone is lost or an account is hacked, including reporting to Nepal Police’s Cyber Bureau.

Scope: folders and file names; versions; finding files; the phone as a computer (files, storage, permissions, updates); the cloud and sync; 3-2-1 backups; accounts, recovery, password managers; setting up a new device; a lost phone or hacked account.

Practical work: reorganize a messy folder; make a family backup plan; check the permissions of five apps.

Unit 8.9 Data, Privacy and You · 5 periods (3 + 2)

Standards: CSTA MS-DAT-DC-22, MS-DAT-IM-28, MS-DAT-DI-26.

Learning outcomes:

• 8.9.1 Distinguish data from metadata, and read the metadata of a photo.
• 8.9.2 Explain how data and its metadata can answer a question (for example where and when photos were taken).
• 8.9.3 List who collects personal data from a phone and why, and the benefits and risks of allowing it.
• 8.9.4 Explain who owns personal data, and what consent means.
• 8.9.5 Make two charts of the same data that give different impressions, and say which is honest.

Scope: personal data and metadata; who collects it and why; ownership and consent; misleading charts.

Practical work: check a photo’s location data and turn it off.

Unit 8.10 Generative AI (AI) · 7 periods (4 + 3)

Standards: CSTA MS-ALG-PS-04, MS-ALG-PS-05, MS-PRO-RD-18, MS-SOC-ET-40, MS-SOC-ET-42; AI4K12 4, 5; UNESCO “apply”.

Learning outcomes:

• 8.10.1 Explain how a chatbot produces text by predicting the next word.
• 8.10.2 Write a clear prompt, and improve it after a poor answer.
• 8.10.3 Check an AI answer against a reliable source, and find a mistake in AI-written code.
• 8.10.4 Decide whether a problem is best solved by rules, by a program, by AI from data, or a mix, and justify it.
• 8.10.5 Recognize signs of a deepfake, and explain the energy cost of AI.
• 8.10.6 Describe what translation tools get wrong in Nepali.
• 8.10.7 State when using AI for schoolwork is cheating, and write a note saying how AI was used.
• 8.10.8 Debate how an emerging technology (generative AI, or another such as drones or mobile money) affects social, cultural and environmental issues in their own community, with evidence for each side (added 2026-10-23).

Scope: next-word prediction; image generators; prompts; checking answers and code; when to use AI and when not; deepfakes; energy; translation tools; honest use for schoolwork; an emerging technology in the local community.

Practical work: compare an AI answer with a textbook; find the bug in AI-written Python.

Unit 8.11 A Project for Your Community · 9 periods (1 + 8)

Standards: CSTA MS-ALG-IM-11, MS-PRO-PD-15, MS-SYS-IM-36.

Learning outcomes:

• 8.11.1 Find a problem a real user has, and write what the product must do.
• 8.11.2 Plan, build and test a web page or a Python program for that user in a team, with a role for each member.
• 8.11.3 Improve the product after the user tries it.
• 8.11.4 Credit every source and teammate.
• 8.11.5 Present the product and what changed after testing.

Scope: design, build and test with users; teamwork; credit.

Practical work: the Grade 8 project (Section 4.5).

Grade 9

Unit 9.1 How a Computer Really Works · 9 periods (6 + 3)

Standards: CSTA HS-SYS-HW-29, HS-SYS-HW-30; Eng KS4 architecture; Aus 9–10.

Learning outcomes:

• 9.1.1 Build a half adder from logic gates and complete its truth table.
• 9.1.2 Explain how gates make an adder, an adder makes part of a CPU, and memory holds data and instructions.
• 9.1.3 Describe the fetch–decode–execute cycle, and trace a short program on a simple model CPU.
• 9.1.4 Order the kinds of memory (registers, cache, RAM, storage) by speed and size.
• 9.1.5 Explain what the operating system manages (programs, memory, files, devices) and why it is a special kind of software.
• 9.1.6 Show a limit of a real or simulated computing device on a given task.

Scope: logic gates to an adder to a CPU; fetch–decode–execute; the memory hierarchy; the operating system.

Practical work: the on-page gate and model-CPU widgets.

Unit 9.2 Data in Depth · 9 periods (6 + 3)

Standards: Eng KS4; Aus 9–10 compression.

Learning outcomes:

• 9.2.1 Add binary numbers and represent negative numbers in two’s complement, up to 8 bits.
• 9.2.2 Convert between binary, hexadecimal and decimal, and explain why hexadecimal is used.
• 9.2.3 Explain how Unicode stores characters from every script, and why one Nepali letter can take several bytes.
• 9.2.4 Calculate the file size of a picture from its width, height and color depth, and of sound from its sample rate, bit depth and length.
• 9.2.5 Compress a short text or picture row by run-length encoding, and explain lossless compression.
• 9.2.6 Explain lossy compression (JPEG, MP3) and choose lossless or lossy for a given file.

Scope: binary arithmetic; negative numbers; hexadecimal; characters and Unicode; file sizes of pictures and sound; lossless compression (runs, ZIP, PNG); lossy compression (JPEG, MP3).

Practical work: compress the same photo at different JPEG qualities and compare size and look.

Unit 9.3 Python: Lists, Strings and Dictionaries · 12 periods (4 + 8)

Standards: CSTA HS-ALG-PS-01, HS-PRO-VD-16, HS-PRO-RD-17.

Learning outcomes:

• 9.3.1 Create a list, and read, add, change and remove its items.
• 9.3.2 Loop over a list to count, total, find the largest and filter items.
• 9.3.3 Use string indexing, slicing and methods to process text.
• 9.3.4 Create a dictionary and use it to count or look up values.
• 9.3.5 Choose a list or a dictionary for a given problem, and justify the choice.
• 9.3.6 Read a table of data from text into a list of rows, and answer a question about it.

Scope: lists; loops over lists; strings; dictionaries; choosing a data structure; processing text and tables.

Practical work: a word counter for a Nepali or English paragraph; a class marks table.

Unit 9.4 Algorithms and Efficiency · 8 periods (4 + 4)

Standards: CSTA HS-ALG-PS-02, HS-ALG-PS-03, HS-ALG-PS-04; Eng KS4.

Learning outcomes:

• 9.4.1 Count the steps of linear and binary search and of two sorts as the data doubles, and describe how each grows.
• 9.4.2 Compare two algorithms for the same task for correctness, efficiency and clarity, using test cases.
• 9.4.3 Improve an algorithm by using a function or a better loop.
• 9.4.4 Distinguish a deterministic algorithm from one that uses chance, with an example of each.

Scope: searches and sorts compared; counting steps as data grows; deterministic and random algorithms.

Practical work: time two sorts in Python on growing lists.

Unit 9.5 How the Internet Works · 8 periods (5 + 3)

Standards: CSTA HS-SYS-NT-34, HS-SYS-NT-35; Aus 9–10.

Learning outcomes:

• 9.5.1 Explain what a protocol is, and describe the layers of the internet with a protocol at each.
• 9.5.2 Explain how IP addresses and routing move a packet.
• 9.5.3 Describe how DNS turns a name into an address.
• 9.5.4 Describe what happens, step by step, when a web page is opened (DNS, HTTP, HTTPS).
• 9.5.5 Explain how the internet is a network of networks, and how it differs from a school’s network.
• 9.5.6 Draw a diagram of a home or school network with its devices and connections.

Scope: protocols and layers; IP; DNS; HTTP and HTTPS; a network of networks; network diagrams.

Practical work: draw the school’s network; follow a page load in a browser’s developer tools, where a computer is available.

Unit 9.6 Secrets and Security · 8 periods (5 + 3)

Standards: CSTA HS-SYS-SE-31, HS-SYS-SE-32, HS-SYS-SE-33; Aus 9–10 encryption.

Learning outcomes:

• 9.6.1 Encrypt and decrypt a message with a Caesar cipher, and explain why it is easy to break.
• 9.6.2 Explain the idea of public-key encryption with an analogy, and why it lets strangers communicate securely.
• 9.6.3 Explain why websites store a hash of a password, not the password.
• 9.6.4 Classify attacks (malware, phishing, social engineering, password guessing) by cause and effect on people and organizations.
• 9.6.5 Compare security measures and their trade-offs for users.
• 9.6.6 Propose a fix for a security flaw in a described system.

Scope: ciphers; keys; public-key encryption (the idea); hashing passwords; attacks; social engineering; defenses and trade-offs.

Practical work: the on-page cipher widget; break a Caesar cipher in Python.

Unit 9.7 Documents, Email and Online Services · 10 periods (3 + 7)

Standards: ISTE 1.2 Digital Citizen, 1.7 Global Collaborator; Eng KS4 “responsible, competent, confident” users.

Learning outcomes:

• 9.7.1 Format a report with heading styles, an automatic table of contents, page numbers, captioned tables and figures, and a reference list.
• 9.7.2 Scan a document with a phone, and merge and shrink PDFs.
• 9.7.3 Write an email a teacher or employer takes seriously: subject, greeting, attachment, and the right choice of reply or reply all.
• 9.7.4 Work on a shared document with comments, and join a video call properly.
• 9.7.5 Fill an online form and use a government service, keeping the receipt.
• 9.7.6 Pay by a digital wallet or QR code safely, and list the signs of a fake online shop.

Scope: reports; scanning and PDFs; email; video calls; shared documents; online forms and government services; digital payments; shopping online safely.

Practical work: a formatted report on a computing topic (used again for the project); a formal email with an attachment.

Unit 9.8 Making Web Apps · 10 periods (3 + 7)

Standards: CSTA HS-ALG-IM-09, HS-PRO-TR-19, HS-PRO-TR-20.

Learning outcomes:

• 9.8.1 Add JavaScript to a page that responds to a click or typed input.
• 9.8.2 Use variables, conditions, loops and functions in JavaScript.
• 9.8.3 Change the page’s content from JavaScript.
• 9.8.4 Design an app for a user, and check it against its purpose, correctness and accessibility.
• 9.8.5 Improve the app after testing and user feedback.

Scope: HTML, CSS and JavaScript; events; changing the page; designing for users; accessibility; testing.

Practical work: a small web app (a unit converter, a quiz, a bill splitter) in the on-page editor.

Unit 9.9 Machine Learning (AI) · 9 periods (3 + 6)

Standards: CSTA HS-ALG-ML-06, HS-ALG-ML-07, HS-ALG-ML-08, HS-DAT-IM-27; AI4K12 2, 3; UNESCO “create”.

Learning outcomes:

• 9.9.1 Explain how a nearest-neighbor model classifies a new example.
• 9.9.2 Build a nearest-neighbor model in Python on a real data set from Nepal.
• 9.9.3 Split data into training and test sets, and calculate accuracy.
• 9.9.4 Evaluate a data set’s source, quality, fairness and privacy.
• 9.9.5 Justify the choice of a type of AI for a task.
• 9.9.6 Describe the effects of large-scale data collection for AI on people and the environment.

Scope: nearest-neighbor models; training and test sets; accuracy; where data came from; choosing an AI method; the effects of collecting data at scale.

Practical work: the Python model on the page; its accuracy with different training sets.

Unit 9.10 Computing and the Law · 5 periods (4 + 1)

Standards: CSTA HS-SYS-IM-36, HS-DAT-IM-28, HS-PRO-PD-14, HS-ALG-IM-10, HS-ALG-IM-11.

Learning outcomes:

• 9.10.1 Explain the main offences in Nepal’s Electronic Transactions Act and what they protect.
• 9.10.2 Explain the main rights in Nepal’s privacy law, with an example.
• 9.10.3 Apply copyright and licenses correctly when using others’ work in a program or a project.
• 9.10.4 Explain the reasons behind a law on computing, and argue for or against how well a policy protects people’s data.
• 9.10.5 Compare how two countries or regions regulate AI.
• 9.10.6 Evaluate the ethical implications, effects on society and possible biases of a rule-based and a data-driven algorithm that make the same decision (for example who gets a scholarship) (added 2026-10-23).
• 9.10.7 Name the values built into the design of an algorithmic system (what it counts, what it leaves out, who decided), and show how a different choice changes who gains (added 2026-10-23).

Scope: privacy; Nepal’s Electronic Transactions Act and data laws; copyright and licenses; the values built into algorithms; AI rules around the world.

Practical work: a class debate on a data policy.

Grade 10

The last year of the common course, and the SEE year. Grade 10 rounds off every thread, so that a student who stops here has a complete course; the students who go on meet the same threads again in Grades 11–12.

Re-planned on 2026-10-23, when Grades 11–12 were added: Objects and Classes moved to Grade 11 (11.1), and version control and automatic testing to Grade 12 (12.3); Graphs is new; the team’s workflow and the final project are one unit (10.8); the units were renumbered.

Unit 10.1 Bigger Programs · 9 periods (3 + 6)

Standards: CSTA HS-PRO-PD-12, HS-PRO-PD-13, HS-PRO-RD-17.

Learning outcomes:

• 10.1.1 Write functions that return values, and explain the role of parameters and return values in a given function.
• 10.1.2 Split a program into modules, and import from a module.
• 10.1.3 Use a library from its documentation.
• 10.1.4 Explain what an API is, and get data from one in a program.

Scope: functions that return values; scope; modules; libraries; documentation; APIs.

Practical work: a program built from several functions in two modules; a program that uses a library.

Unit 10.2 Graphs: Maps, Routes and Networks · 10 periods (4 + 6)

Standards: CSTA HS-ALG-PS-01, HS-PRO-VD-16.

Learning outcomes:

• 10.2.1 Represent things joined to things (towns and roads, friends, web pages and links) as a graph of nodes and edges, both as a drawing and in Python as a dictionary of neighbors.
• 10.2.2 Search a graph one step at a time (breadth-first), by hand with a list of places still to visit, and in Python.
• 10.2.3 Find the fewest steps between two places, and the route itself, by breadth-first search.
• 10.2.4 Explain in words how a map app finds a route by trying the nearest places first (routes with distances are worked out in Grade 12).
• 10.2.5 Recognize a tree as a graph without loops (a family tree, a folder tree), and list everything in a folder tree by visiting it.

Scope: graphs, nodes and edges; graphs as dictionaries of neighbors; breadth-first search; the fewest steps and the route; how a map app finds a route (the idea); trees.

Practical work: the bus routes of a city as a graph, and the fewest changes between two stops; the friends-of-friends of a small class network.

Unit 10.3 Databases and SQL · 10 periods (3 + 7)

Standards: CSTA HS-DAT-DC-22, HS-DAT-DC-24.

Learning outcomes:

• 10.3.1 Design tables with fields, data types and a primary key for given data.
• 10.3.2 Link two tables with a foreign key, and say what kind of relationship it is.
• 10.3.3 Write SQL queries with SELECT, WHERE, ORDER BY, and aggregate functions with GROUP BY.
• 10.3.4 Join two tables in a query.
• 10.3.5 Write a data dictionary giving each field’s name, type and allowed values.
• 10.3.6 Explain ways of checking that data has the right types, values and ranges.

Scope: tables, keys, relationships; SQL in the browser on a school database; joins; a data dictionary; checking data.

Practical work: query the on-page school database; design a database for a school library.

Unit 10.4 Data Science · 9 periods (3 + 6)

Standards: CSTA HS-DAT-DC-21, HS-DAT-DC-23, HS-DAT-DI-25, HS-DAT-DI-26.

Learning outcomes:

• 10.4.1 Clean a text-based data set with Python (spellings, missing values, types).
• 10.4.2 Make a chart of more than two variables to answer a question.
• 10.4.3 Generate simulated data that fits given limits, and use it in a simulation.
• 10.4.4 Evaluate a chart or simulation: what it answers, and its limits.
• 10.4.5 Write a conclusion the data supports, and say what it can’t show.

Scope: cleaning data; charts of many variables; simulations; honest conclusions.

Practical work: an investigation of an open data set from Nepal (for example rainfall, population or school results).

Unit 10.5 Computers in the World · 7 periods (5 + 2)

Standards: CSTA HS-SYS-HW-30, HS-SYS-IM-37.

Learning outcomes:

• 10.5.1 Describe how sensors and the Internet of Things collect data and act on it, with an example from farming, health or homes.
• 10.5.2 Explain what the cloud is and how large systems stay up when parts fail.
• 10.5.3 Explain how GPS finds a position from satellites’ signals, and how a map app shows where you are on a map (finding the route is Unit 2).
• 10.5.4 Describe the energy use of computing and who is affected by it.
• 10.5.5 Describe what to do with an old phone in Nepal, and why e-waste matters.

Scope: sensors and the Internet of Things; the cloud; reliability; GPS and maps; energy and the environment; e-waste.

Practical work: log a sensor (a phone’s or the simulator’s) and chart it.

Unit 10.6 Fixing Problems and Learning Any New Tool · 7 periods (2 + 5)

Standards: ISTE 1.1d.

Learning outcomes:

• 10.6.1 Troubleshoot a problem step by step: restart, isolate, read the error, search the error, change one thing.
• 10.6.2 Fix a slow phone or a full disk.
• 10.6.3 Install software safely from a trusted source.
• 10.6.4 Use the command line to move between folders, list files, run a program and read its output.
• 10.6.5 Learn a new program from its help, a tutorial and an AI assistant, and check what they said by trying it.

Scope: troubleshooting; slow phones and full disks; installing safely; the command line, a first look; learning a new tool and checking what you learned.

Practical work: troubleshooting challenges (a set of broken settings); learn a new program and teach it to the class in five minutes.

Unit 10.7 How Large Language Models Work (AI) · 8 periods (5 + 3)

Standards: CSTA HS-ALG-PS-05, HS-PRO-RD-18, HS-SOC-HU-44; AI4K12 all; UNESCO “create”.

Learning outcomes:

• 10.7.1 Explain how text is split into tokens and how a model predicts the next token.
• 10.7.2 Describe training and fine-tuning.
• 10.7.3 Explain why a language model can state false things confidently.
• 10.7.4 Test a model’s answers for accuracy and bias with a set of questions, and judge the harm of its errors.
• 10.7.5 Evaluate AI-written code against a program’s requirements.
• 10.7.6 Argue a position on how human and machine intelligence differ.

Scope: tokens; next-token prediction; training and fine-tuning; why models make things up; judging and testing output; human and machine intelligence.

Practical work: build a tiny next-word predictor on the page; test a chatbot with a set of checked questions.

Unit 10.8 A Project in a Team · 20 periods (3 + 17)

Standards: CSTA HS-PRO-PD-15, HS-PRO-TR-19, HS-PRO-TR-20, HS-ALG-IM-09, HS-SOC-ET-42.

Learning outcomes:

• 10.8.1 Find a real user’s problem, and write requirements for a product from their needs.
• 10.8.2 Write a short design document with a role for each team member and a shared plan.
• 10.8.3 Design the product with human-centered design, and build it in stages.
• 10.8.4 Keep dated versions and a change log so that the team can go back, and test after each change with chosen inputs (version control tools in Grade 12).
• 10.8.5 Test the product with its user, improve it from feedback and test results, and check it against its requirements.
• 10.8.6 Weigh the product’s possible benefits and harms.
• 10.8.7 Present it, with what changed and why, and what each member did.

Scope: requirements; design documents and roles; human-centered design; building in stages; versions and a change log; testing; feedback; benefits and harms; presenting.

Practical work: the Grade 10 project (Section 4.5).

Unit 10.9 The Future of Computing · 8 periods (6 + 2)

Standards: CSTA HS-SOC-ET-40, HS-SOC-ET-41, HS-SOC-HI-38, HS-SOC-HI-39, HS-SOC-HU-43, HS-SOC-CE-45, HS-SOC-CE-46.

Learning outcomes:

• 10.9.1 Explain how an emerging technology differs from established ones.
• 10.9.2 Evaluate who gains and who is left out by an emerging technology.
• 10.9.3 Trace the history of one computing technology (the mobile phone, mobile money, the internet in Nepal), and how society and the environment shaped it.
• 10.9.4 Propose a change to an existing law or policy on technology that encourages good new ideas and lowers the risks, and give reasons.
• 10.9.5 Evaluate the risks, benefits and long-term effects of choices people make in using, designing and regulating computing (for example paying in cash or digitally, or keeping or deleting data).
• 10.9.6 Describe careers in computing, and how teams use computing to solve problems.
• 10.9.7 Describe how to work online from Nepal: freelancing, getting paid from abroad through banks, contracts, and avoiding job scams.
• 10.9.8 Write a plan linking their computing skills to their own goals, including whether to take computing in Grades 11–12.

Scope: emerging technologies; who gains and who is left out; the history of one technology; changing a law; the long-term effects of choices in computing; careers; working online from Nepal.

Practical work: a proposal for a change to a law, presented to the class; a career plan.

Grade 11

The senior stage begins. Students are about 16, have written Python for three years, and have chosen computing. Units go deeper and take longer; each starts from where Grades 6–10 stopped.

Unit 11.1 Objects and Classes · 10 periods (3 + 7)

Standards: CSTA HS-PRO-PD-12, HS-PRO-VD-16, HS-PRO-RD-17; Eng A level object-oriented programming; NSW Software Engineering object-oriented paradigm; AP CSA and IB class (static) members; AQA and IB abstract classes.

Builds on: functions and modules (10.1), lists and dictionaries (9.3).

Learning outcomes:

• 11.1.1 Model a real system (a bus route, a library, a cooperative’s savings) as classes, and draw a class diagram with each class’s attributes and methods.
• 11.1.2 Write a class with a constructor, attributes and methods, create several objects from it, and explain the difference between a class and an object, and between an attribute each object has and one the whole class shares (a class attribute: a count of buses made, the interest rate every account uses).
• 11.1.3 Explain encapsulation, mark the attributes only the class itself should touch (Python’s _name, against a public name), and change how a class works inside without changing the code that uses it.
• 11.1.4 Build objects that hold other objects (a library holding books, a route holding stops), and trace a program that passes objects between functions.
• 11.1.5 Write a subclass that inherits from a class and overrides one method, write an abstract class (a Shape or an Account, with Python’s abc) as a promise every subclass must keep, and judge when holding an object (composition) suits better than inheriting from it.
• 11.1.6 Compare the same program written with dictionaries and functions and with classes, for clarity and for how easily it can be changed.

Scope: objects and classes; attributes, methods and constructors; class attributes (a short box in “Classes: one design, many objects”); class diagrams; encapsulation and _name; composition; inheritance and overriding (a little); abstract classes (a short passage in “A kind of: inheritance”); when objects help and when they don’t; a small game or simulation built from objects.

Practical work: a simulation built from classes (a bus route with stops and passengers, or a cooperative’s savings accounts); a board game whose pieces are objects.

Unit 11.2 Recursion · 8 periods (3 + 5)

Standards: CSTA HS-ALG-PS-01, HS-ALG-PS-02, HS-PRO-RD-17; Eng A level recursion.

Builds on: functions (8.4, 10.1), merge sort (9.4), pixel grids (6.5), trees (10.2).

Learning outcomes:

• 11.2.1 Identify the base case and the recursive case of a problem that contains a smaller copy of itself, and state both in words before writing code.
• 11.2.2 Write recursive functions (factorial, the sum of a list, a string reversed, the size of a folder tree) and trace a call for a small input, showing each call waiting on the stack and the value it returns.
• 11.2.3 Explain what happens when the base case is missing or never reached, and read the error Python gives.
• 11.2.4 Solve the Tower of Hanoi recursively, and show that n disks take 2ⁿ − 1 moves.
• 11.2.5 Use recursion to draw a fractal (a tree, the Sierpiński triangle) and to fill a region of a pixel grid (flood fill).
• 11.2.6 Explain merge sort as a recursive algorithm, and decide for a given problem whether a loop or recursion is clearer.

Scope: problems that contain smaller copies of themselves; base and recursive cases; the call stack; missing base cases; Tower of Hanoi; fractals; flood fill; merge sort again (recalled from 9.4 and traced as recursion, not taught afresh); recursion or a loop.

Practical work: the on-page call tracer; a fractal tree with the turtle; a flood-fill paint bucket on a pixel grid.

Unit 11.3 Data Structures · 12 periods (4 + 8)

Standards: CSTA HS-ALG-PS-01, HS-ALG-PS-03, HS-PRO-VD-16; Eng A level data structures and tree traversals; IB and AP CSA selection sort.

Builds on: lists and dictionaries (9.3), counting steps (9.4), graphs and trees (10.2), objects (11.1).

Learning outcomes:

• 11.3.1 Describe a stack and a queue by their operations (push, pop and peek; enqueue and dequeue), and build each as a class.
• 11.3.2 Use a stack to undo actions and to check that the brackets in an expression match, and a queue to serve tokens in the order they were given.
• 11.3.3 Build a linked list from node objects, and compare adding an item at the front of a linked list and of a Python list.
• 11.3.4 Explain how a hash table finds a key in about one step, what a collision is and one way to handle it, and why a dictionary’s keys must not change.
• 11.3.5 Build a binary search tree, insert and search in it, list its items in order (and, in the exercises, in pre-order and post-order), and explain why a lopsided tree is slow.
• 11.3.6 Explain a heap as a priority queue, and use one to always take the most urgent item next.
• 11.3.7 Choose a data structure for a given program from the operations it needs most, and justify the choice by the number of steps each operation takes.

Scope: stacks; queues; linked lists; hash tables and collisions; binary search trees; in-order, pre-order and post-order traversal (the last two as exercises); heaps and priority queues; selection sort as an exercise (heapsort is selection sort with a heap); choosing a structure by its operations.

Practical work: undo in a small text editor; a bracket checker; a hospital’s token queue with emergencies first; a phone book as a list, a tree and a dictionary, timed.

Unit 11.4 From Code to Circuits · 13 periods (7 + 6)

Standards: CSTA HS-SYS-HW-29, HS-SYS-HW-30; Eng A level computer organization and architecture, assembly language, floating point, Boolean algebra and Karnaugh maps, bitwise operations; Cambridge 9618 processors, logic and the operating system; IB scheduling and GPUs.

Builds on: logic gates, truth tables and De Morgan (7.4), the adder, the latch, the model CPU, cache and pipelining (9.1), two’s complement and hexadecimal (9.2), recursion’s call stack (11.2). Why GPUs suit neural networks looks ahead to 11.8.

Learning outcomes:

• 11.4.1 Write and trace short programs in a model CPU’s assembly language (load, store, add, compare, jump), including a loop.
• 11.4.2 Explain how an instruction is stored as a number (opcode and operand), and translate between the model CPU’s assembly language and its machine code.
• 11.4.3 Distinguish a compiler from an interpreter, describe how Python runs a program (bytecode on a virtual machine), and read the bytecode of a short function.
• 11.4.4 Explain how the call stack holds each function call’s variables and how objects are kept on the heap.
• 11.4.5 Explain how the operating system runs many programs at once (processes, time slices, scheduling), what a thread is, and how it handles memory (paging, segmentation, and thrashing when memory runs short) and devices (interrupts, drivers).
• 11.4.6 Store a number with a fraction in a small binary floating-point format (sign, exponent, mantissa), explain why 0.1 + 0.2 is not exactly 0.3, and compare such numbers safely in a program.
• 11.4.7 Show a limit of a real or simulated machine (overflow, rounding, running out of memory) and explain its cause.
• 11.4.8 Simplify a logic expression with the identities of Boolean algebra and De Morgan’s laws, and with a Karnaugh map of three or four inputs, and check that the simpler circuit gives the same truth table.
• 11.4.9 Explain how a D flip-flop keeps one bit from one tick of the clock to the next, and how a row of them makes a register (the one that holds the program counter).
• 11.4.10 Use AND, OR and XOR with a mask, and shifts, to test, set, clear and flip single bits (a device’s status register in the model CPU).
• 11.4.11 Compare scheduling methods (first come first served, shortest job first, shortest remaining time, round robin) on the same jobs by average waiting time and by which jobs may starve.
• 11.4.12 Compare Von Neumann and Harvard designs, and RISC (a phone’s processor) and CISC (a laptop’s), and explain why a GPU, with thousands of simple cores doing the same step on many numbers at once (SIMD), trains a neural network faster than a CPU.

(11.4.8–11.4.12 were added on 2026-10-24 and numbered after the others so that earlier references stay right; Scope gives where each is taught.)

Scope: a short new section, “Fewer gates: Boolean algebra” (Boolean identities and De Morgan used to simplify; Karnaugh maps of three and four inputs; the D flip-flop and the clock); assembly language and machine code, with bit masks and shifts in a box; compilers, interpreters and bytecode; the stack and the heap; processes, threads and scheduling, with scheduling methods compared; memory by pages and by segments, and thrashing (two lines); interrupts and drivers; different processors for different jobs (Von Neumann and Harvard, RISC and CISC, SIMD and GPUs; in “A processor with registers” or a short section of its own); floating point and rounding (“Numbers with fractions” partly reading, to make room); the limits of real machines (“Where every machine runs out” partly moved into the exercises).

Practical work: programs on the on-page model CPU (a countdown, the larger of two numbers, a multiplication by repeated adding, a bit tested with a mask); the bytecode of a Python function; a rounding error found and fixed; an expression simplified with a Karnaugh map and checked on the logic-gate widget; the same jobs run through four schedulers on the page.

Unit 11.5 Modeling and Simulation · 12 periods (3 + 9)

Standards: CSTA HS-DAT-DC-21, HS-DAT-DI-26, HS-ALG-PS-04; Eng A level abstraction; Cambridge 9618 monitoring and control; IB control systems; NSW Software Engineering closed-loop control.

Builds on: simulations and simulated data (10.4), random algorithms (9.4), objects (11.1), floating point (11.4).

Learning outcomes:

• 11.5.1 State what a model of a real system keeps and leaves out (abstraction), and list its assumptions.
• 11.5.2 Write a time-step simulation of a ball thrown with air resistance, and show how the size of the time step changes the answer.
• 11.5.3 Simulate a planet’s orbit, show that the simplest update (Euler’s method) drifts, and fix it with a better one.
• 11.5.4 Build a model of an epidemic (susceptible, infected, recovered), use it to explain herd immunity, and model predator and prey.
• 11.5.5 Estimate a number with random trials (π from random points, the wait in a queue), and explain why more trials give a steadier answer.
• 11.5.6 Check a model’s output against real data from Nepal, and say what the differences show about its assumptions and how far its predictions can be trusted for a decision.
• 11.5.7 Simulate a system that steers itself towards a target (a room heater or a water tank) with a sensor, a controller and an actuator: first an on/off controller (a thermostat), then a proportional one, and explain the overshoot and oscillation each shows.

Scope: models and abstraction; assumptions; time-step simulation; errors from the time step; orbits; epidemics and herd immunity; predator and prey; random (Monte Carlo) simulation; checking a model against data; a model that steers itself (feedback control, on/off and proportional, with the unit’s time-step method; a short section).

Practical work: a thrown ball and an orbit in Python with charts; an epidemic model for a district’s population; π by random points; a heater or a tank held at its target by a controller.

Unit 11.6 Clients, Servers and the Web · 13 periods (5 + 8)

Standards: CSTA HS-SYS-NT-34, HS-SYS-NT-35, HS-PRO-PD-13; Eng A level networking (the TCP/IP stack, client–server, web technologies, CSMA/CA), databases (entity–relationship modeling, normalization) and error checking (parity); Cambridge 9618 database design; IB normal forms and dynamic routing; NSW Software Engineering programming for the web.

Builds on: protocols, DNS and HTTP (9.5), web apps (9.8), APIs (10.1), databases (10.3).

Learning outcomes:

• 11.6.1 Describe the four layers of the TCP/IP model and the job of each, and follow one web request down and up the layers.
• 11.6.2 Explain ports, and how TCP makes delivery reliable over IP (numbered segments, acknowledgements, resending), compared with UDP for a video call.
• 11.6.3 Read an HTTP request and response (method, path, headers, status code, body), and explain GET, POST and the common status codes (200, 301, 404, 500).
• 11.6.4 Explain how HTTPS keeps a connection private and how a certificate tells the browser it reached the right site (the idea; the mathematics in Grade 12).
• 11.6.5 Write and read JSON, and get data from a web API in a program, handling a failed request.
• 11.6.6 Build a small web application whose server part (simulated in the browser) answers requests and keeps data in a database, and draw a diagram of its client, server and database.
• 11.6.7 Decide what must run on the server and what may run in the browser, and explain why a server never trusts data a browser sends.
• 11.6.8 Draw an entity–relationship diagram (crow’s-foot notation) for the database behind a web app, with its entities, attributes, keys and one-to-many and many-to-many relationships.
• 11.6.9 Take a badly designed table (a school fee register that repeats each student’s and class’s details) step by step to first, second and third normal form in SQL, name the problem each step removes (update, insert and delete anomalies), and say when to denormalize on purpose (a report table).
• 11.6.10 Explain how devices on Wi-Fi share the air (CSMA/CA: listen, wait a random time, acknowledge) and why a crowded Wi-Fi is slow, and how routers learn routes from each other (dynamic routing) instead of from a fixed table.
• 11.6.11 Add a parity bit to a byte, find a single flipped bit with it, and explain what it misses (two flipped bits), compared with TCP’s checksum.

(11.6.8–11.6.11 were added on 2026-10-24, numbered after the others.)

Scope: the TCP/IP layers; ports; TCP and UDP; parity bits beside TCP’s checksum (a paragraph and a widget); how Wi-Fi shares the air (CSMA/CA) and dynamic routing (a short passage in “How the internet differs from other networks”); HTTP requests and responses; HTTPS and certificates (the idea); JSON and web APIs; client, server and database; a new section, “Designing the database behind it” (entity–relationship diagrams; first, second and third normal form; denormalizing); what runs where.

Practical work: read real requests in a browser’s developer tools; a notice board or a lost-and-found web app with a server part and a database, its database drawn as an ER diagram; a fee register normalized to third normal form in the browser’s SQL.

Unit 11.7 Cybersecurity in Practice · 10 periods (4 + 6)

Standards: CSTA HS-SYS-SE-31, HS-SYS-SE-32, HS-SYS-SE-33; NSW Software Engineering secure software architecture.

Builds on: attacks and password hashing (9.6), the law (9.10), the web app of 11.6.

Learning outcomes:

• 11.7.1 Write a threat model for a system: what to protect, from whom, how it could be attacked, and what each defence costs its users.
• 11.7.2 Find an SQL injection flaw in a practice login's code, explain what an attacker could do with it, and fix it with parameterized queries.
• 11.7.3 Explain how text a page shows unescaped could run as a script in another user’s browser (cross-site scripting), and fix it by escaping what the page shows.
• 11.7.4 Store passwords with a slow, salted hash, and explain why a fast or unsalted hash is not enough.
• 11.7.5 Find and fix a security flaw in a given small system, and explain the trade-offs of the fix.
• 11.7.6 Classify a real breach (in Nepal or abroad) by its cause, who was harmed, and what would have prevented it.
• 11.7.7 Explain responsible disclosure, and why systems may be tested only with their owner’s permission.

Scope: threat models; injection; cross-site scripting; storing passwords; fixing flaws and their trade-offs; real breaches; responsible disclosure and the law.

Practical work: the on-page security puzzles (find the flaw in a practice system's code, then fix it; defending only, 2026-10-24); a threat model for the 11.6 web app.

Unit 11.8 Neural Networks (AI) · 10 periods (4 + 6)

Standards: CSTA HS-ALG-ML-06, HS-ALG-ML-07, HS-ALG-ML-08; CSTA AI specialty S1-AIN-DS-06, S1-AIN-HR-09; AI4K12 2, 3; UNESCO “create” (AI techniques and applications).

Builds on: logic gates (7.4), nearest-neighbor models (9.9), how language models are trained (10.7).

Learning outcomes:

• 11.8.1 Work out a neuron’s output from its inputs, weights, bias and activation, and set the weights of a neuron that acts as an AND or an OR gate.
• 11.8.2 Explain why one neuron cannot act as an XOR gate and two layers can.
• 11.8.3 Follow numbers through a small network, layer by layer (the forward pass).
• 11.8.4 Explain learning as changing the weights in small steps that lower the error (gradient descent, seen on a graph, not derived), and the roles of the learning rate and of training rounds (epochs).
• 11.8.5 Train a small network in the browser to recognize handwritten digits, Devanagari digits too, and report its accuracy on examples it never saw.
• 11.8.6 Recognize overfitting from training and test accuracy, and reduce it (more data, a smaller network, stopping early).
• 11.8.7 Examine the examples the network gets wrong, explain what it seems to have learned and where it fails, and compare it with a nearest-neighbor model on the same task.

Scope: the neuron; weights, bias and activation; layers; the forward pass; gradient descent and the learning rate; training and test accuracy; overfitting; what a network learns and where it fails.

Practical work: the on-page network trainer on handwritten digits; a comparison with the Grade 9 nearest-neighbor model.

Unit 11.9 Automate Your Work · 7 periods (2 + 5)

Standards: CSTA HS-DAT-DC-23, HS-PRO-PD-13; ISTE 1.5 Computational Thinker.

Builds on: files and folders (6.2, 8.8), spreadsheets (7.5), the command line (10.6), APIs (10.1).

Learning outcomes:

• 11.9.1 Write a program that renames and sorts many files into folders by a rule, and test it on copies first.
• 11.9.2 Read and write spreadsheet files (CSV) in a program, and clean and combine several of them.
• 11.9.3 Fill letters or certificates from a list (a mail merge in code).
• 11.9.4 Write regular expressions that find and extract patterns in text (phone numbers, dates, amounts in rupees), and test them on text that should and should not match.
• 11.9.5 Collect data from a website or an API responsibly (following its terms, without overloading it).
• 11.9.6 Run a script from the command line with arguments, and decide whether a task is worth automating (the time saved against the time to write and check the program).

Scope: files and folders in code; spreadsheet files; mail merge; regular expressions; collecting data from the web responsibly; scripts on the command line; when automating pays. (7 periods from 2026-10-24: one period went to 11.4, and the practical work is a little shorter.)

Practical work: automate a real chore of the school office or a family shop; certificates for a school event from a list.

Unit 11.10 Building an App People Use · 9 periods (1 + 8)

Standards: CSTA HS-ALG-IM-09, HS-PRO-TR-19, HS-PRO-TR-20; NSW Software Engineering software development.

Builds on: the team project (10.8), web apps with a server (11.6).

Learning outcomes:

• 11.10.1 Interview possible users, and write who the app is for and what they need (user stories).
• 11.10.2 Test a paper or clickable prototype with users before building.
• 11.10.3 Build a working first version, with a server part where it needs one.
• 11.10.4 Measure how well it works for its users (tasks completed, time taken, mistakes made), and check it against its specification, including accessibility.
• 11.10.5 Release a second version improved from feedback and test results, and record what changed and why.

Scope: user research; user stories; prototypes; a first version; measuring usability; a second version.

Practical work: the Grade 11 project (Section 4.5). From 2026-10-24 the unit has 9 periods (two went to the additions in 11.4–11.6); the project still has the 8 periods kept free for it (Section 3, “Periods a year”), so it has 17 in all.

Grade 12

The last year. Students are about 17. The year brings the threads to the level a student meets in a first year at university, and ends with a capstone project.

Unit 12.1 Algorithms for Hard Problems · 12 periods (5 + 7)

Standards: CSTA HS-ALG-PS-01, HS-ALG-PS-02, HS-ALG-PS-03; Eng A level graph traversal and shortest paths.

Builds on: breadth-first search (10.2), heaps (11.3), recursion (11.2).

Learning outcomes:

• 12.1.1 Represent a weighted graph (towns joined by roads with travel times) as a list of neighbors and as a table.
• 12.1.2 Find the shortest route with Dijkstra’s algorithm, by hand on a small graph and in Python with a priority queue.
• 12.1.3 Explain how A* uses an estimate of the distance left to search fewer places, and why the estimate must never be too high.
• 12.1.4 Solve a problem by greedy choices (change from Nepal’s notes), and find a problem where the greedy choice fails.
• 12.1.5 Solve a problem by dynamic programming, storing the answers to smaller problems (making change with any coins; the edit distance between two words, as a spell-checker uses).
• 12.1.6 Explain why some problems (the shortest trek through 20 villages) have no known fast method, and use a heuristic that gives a good answer, measuring how far it is from the best on small cases.

Scope: weighted graphs; Dijkstra’s algorithm; A*; greedy algorithms and when they fail; dynamic programming; problems with no known fast method; heuristics.

Practical work: shortest routes on a map of Nepal’s highways; an edit distance spell-checker for English or Nepali words.

Unit 12.2 The Limits of Computing · 10 periods (6 + 4)

Standards: CSTA HS-ALG-PS-03, HS-ALG-PS-04; Eng A level theory of computation, BNF and syntax diagrams, Reverse Polish notation, space complexity; Cambridge 9618 BNF, syntax diagrams and RPN.

Builds on: counting steps (9.4), big O as 11.3 and 12.1 use it, stacks and the bracket checker (11.3), regular expressions (11.9), the model CPU (11.4), algorithms for hard problems (12.1).

Learning outcomes:

• 12.2.1 Give the growth of an algorithm in big O (O(1), O(log n), O(n), O(n log n), O(n²), O(2ⁿ)) from its loops and calls, as a quick review of the notation 9.4 introduced and 11.3 and 12.1 used, and give the extra memory it needs in the same way (space complexity).
• 12.2.2 Work out from big O how much longer a program takes when its data grows tenfold, and decide whether it will finish in time.
• 12.2.3 Draw a finite state machine (a lift, a vending machine, a ticket gate) as a diagram and as a transition table, and run it on inputs.
• 12.2.4 Show with an example that a regular expression and a finite state machine describe the same patterns.
• 12.2.5 Explain why no regular expression can check that brackets balance (it needs a stack, as in 11.3), and write a grammar in BNF and as a syntax diagram (for a Nepali phone number, then for arithmetic), checking strings against it.
• 12.2.6 Evaluate an expression in Reverse Polish notation with a stack, and turn an ordinary (infix) expression into it with the shunting-yard algorithm, as a calculator or a compiler does.
• 12.2.7 Run a Turing machine on the page, and explain why it can compute anything a computer can.
• 12.2.8 Explain in words why no program can decide, for every program and input, whether it stops (the halting problem).
• 12.2.9 Explain the question P versus NP with 12.1’s trek through 20 villages (a proposed route is quick to check; no fast way to find the best is known), and why the answer matters for cryptography.

Scope: big O, as a quick review, and space complexity; how running time grows; finite state machines; regular expressions as machines; what a regular expression can’t describe: grammars (BNF, syntax diagrams); Reverse Polish notation and the shunting-yard algorithm; Turing machines; the halting problem; P and NP, referring back to 12.1’s trek rather than teaching hardness again.

Practical work: a ticket gate as a state machine in Python; a checker for strings against a small grammar; an RPN calculator with a stack, and infix turned into RPN; programs on the on-page Turing machine.

Unit 12.3 Software Engineering · 14 periods (4 + 10)

Standards: CSTA HS-PRO-PD-14, HS-PRO-PD-15, HS-PRO-RD-18, HS-PRO-TR-19; NSW Software Engineering software engineering project, paradigms and implementation methods; AQA functional programming; Cambridge 9618 programming paradigms, testing and maintenance, development life cycles; OCR paradigms and development methods; IB design patterns.

Builds on: the team project (10.8), objects (11.1), assembly (11.4), the app of 11.10, SQL (10.3), the editor recommended in 10.1.

Learning outcomes:

• 12.3.1 Use version control to commit, compare, branch and merge, resolve a conflict, and write useful commit messages.
• 12.3.2 Write automatic tests for functions with normal, boundary and erroneous data, and run them after every change; and tell white-box from black-box testing, and unit, integration, alpha, beta and acceptance testing.
• 12.3.3 Find a bug with a debugger (a breakpoint, stepping line by line, watching variables), and say when it is quicker than reading the code or printing values.
• 12.3.4 Review a classmate’s code with a checklist, and respond to a review of their own.
• 12.3.5 Write documentation that a newcomer can use: a README, comments where the reason isn’t obvious, and how to run the tests.
• 12.3.6 Write pure functions and explain why code without side effects is easy to test; use lambda, map, filter, reduce and comprehensions; and explain why data that never changes (immutability) is safer to share.
• 12.3.7 Read SQL again as declarative (“say what, not how”), build a small facts-and-rules engine in Python (family relations or a bus timetable) as an example of logic programming, and place every way of programming met in the course (procedural, object-oriented, functional, logic, declarative, assembly) in a table of paradigms with what each suits.
• 12.3.8 Recognize two or three design patterns in real code (an observer for events, a strategy, a facade), and explain the problem each solves.
• 12.3.9 Evaluate AI-written code against the requirements and the tests, and record where AI was used.
• 12.3.10 Choose an open-source license, credit the libraries used, and make a small contribution to an open-source project (a report, a fix or a translation).
• 12.3.11 Compare ways of organizing development (waterfall; agile, with extreme programming and the spiral model as variants), name the four ways to change over to a new system (direct, parallel, phased, pilot: a school changing its fee software) and the three kinds of maintenance (corrective, adaptive, perfective), and plan the capstone in one method with a Gantt chart.

Scope: version control; automatic testing and the testing words exams use; a debugger (the one in the editor 10.1 recommends); code review; documentation; a section “Other ways to program” (pure functions and side effects, lambda, map, filter, reduce, comprehensions, immutability; declarative SQL; facts and rules; a table of paradigms); design patterns in “building software that lasts”; AI-written code; open source and licenses; development methods, changeover and maintenance; a Gantt chart. Most of the exam vocabulary names what students already do, so it takes little new teaching.

Practical work: a team repository with tests and reviews; a bug found with the debugger; a function rewritten without side effects and tested; a bus timetable in facts and rules; a contribution to an open-source project; a Gantt chart for the capstone.

Unit 12.4 Systems at Scale · 9 periods (5 + 4)

Standards: CSTA HS-SYS-NT-35, HS-SYS-IM-37; Eng A level transactions, ACID and record locking (OCR), concurrent access (AQA), Big Data (AQA); IB transactions, NoSQL and data warehouses.

Builds on: the cloud and reliability (10.5), databases and SQL (10.3), clients and servers and database design (11.6).

Learning outcomes:

• 12.4.1 Explain how a service with millions of users spreads its work over many computers (load balancing) and keeps copies of its data.
• 12.4.2 Explain what makes data “big” (volume, velocity, variety), and name the main kinds of NoSQL store (key–value, document, wide-column, graph) and the kind of data each suits, compared with tables.
• 12.4.3 Group changes into a transaction (BEGIN, COMMIT, ROLLBACK) so that a transfer between two wallets that fails half-way changes nothing, explain the four ACID properties, and show how two clerks booking the last bus seat at once lose an update and how locking the record prevents it.
• 12.4.4 Explain the trade-off between keeping copies the same and staying available when a link fails, with an example (a bank balance and a count of likes).
• 12.4.5 Explain caching and content delivery networks, and why a video from abroad may come from a server inside Nepal.
• 12.4.6 Read a real outage report, and describe its cause, how it spread and what was changed.
• 12.4.7 Estimate a data center’s electricity and water use from given figures, and say who is affected by them.

Scope: load balancing; splitting the data, with Big Data’s three Vs and the kinds of NoSQL store named; transactions within one database (ACID, lost updates, record locking), before copies and consistency, which they lead into; copies of data and consistency; caching and content delivery; outages; data centers and their energy and water. The unit keeps its 9 periods: the additions take time from the outage and data-center sections, which are kept short.

Practical work: the on-page simulation of a service under load; a transfer that fails half-way, made safe with a transaction in the browser’s SQL; a summary of a real outage report.

Unit 12.5 Data, Evidence and Decisions · 12 periods (4 + 8)

Standards: CSTA HS-DAT-DI-25, HS-DAT-DI-26, HS-DAT-IM-27, HS-DAT-DC-24; IB linear regression and r²; NSW Software Engineering regression; Cambridge 9618 regression.

Builds on: data science (10.4), simulation (11.5).

Learning outcomes:

• 12.5.1 Explain how a sample stands for a population, and how its size and the way it was chosen change the answer.
• 12.5.2 Work out a range of uncertainty for an average or a share by resampling in a program, and report it with the result.
• 12.5.3 Fit a straight line to data by least squares in Python (altitude against temperature across Nepal’s weather stations), say what its slope and intercept mean in words, measure the fit with r², and show that a high-degree polynomial passes closer to the points and predicts new ones worse (overfitting).
• 12.5.4 Distinguish correlation from cause with an example of a hidden third factor, and explain why a randomized experiment can show cause.
• 12.5.5 Design and analyze a simple A/B test, and work out how big a difference could arise by chance.
• 12.5.6 Find misleading analyses in a given report (a chosen time period, testing many things until one “works”, an average hiding groups).
• 12.5.7 Carry out a full analysis of open data from Nepal: a question, checked and cleaned data, charts of several variables, a fitted line where it helps, the uncertainty, and a written conclusion with its limits.
• 12.5.8 Evaluate the effects of collecting data at large scale on privacy, fairness and the environment.

Scope: samples and populations; uncertainty by resampling; fitting a line (least squares, r², an overfitting polynomial), before correlation and cause; correlation and cause; experiments and A/B tests; misleading analyses; a full analysis written up, using the fitted line where it helps (so the addition shares the analysis’s practical time); the effects of large-scale data.

Practical work: a full analysis of an open data set from Nepal, written up as a short report.

Unit 12.6 Building and Judging AI Systems (AI) · 12 periods (4 + 8)

Standards: CSTA HS-ALG-ML-06, HS-ALG-ML-07, HS-ALG-ML-08, HS-ALG-PS-05, HS-ALG-IM-10, HS-ALG-IM-11; CSTA AI specialty S1-AIN-DD-05, S1-AIN-HR-08, S1-AIN-PP-11, S2-AIN-PP-08; AI4K12 all; UNESCO “create” (AI system design, ethics of AI); Cambridge 9618 supervised, unsupervised and reinforcement learning; IB decision trees, clustering, reinforcement learning, hyperparameters and F1; NSW Software Engineering kinds of machine learning.

Builds on: machine learning (9.9), language models (10.7), neural networks (11.8), data and evidence (12.5).

Learning outcomes:

• 12.6.1 Run three more kinds of machine learning on the page and say what each can and can’t do: a decision tree that can be read as rules (and why that makes it explainable), k-means clustering of Nepal’s districts with no labels (what unsupervised learning finds and what it can’t tell you), and a learner in a small grid world that learns from rewards (states, actions, reward, exploring against exploiting); and name supervised, unsupervised and reinforcement learning.
• 12.6.2 Choose a kind of AI for a task (rules, a classic model such as a decision tree or nearest neighbors, clustering, a neural network, a language model) or no AI at all, and justify the choice by the data, cost, explainability and risk.
• 12.6.3 Measure a classifier properly: a confusion matrix, precision, recall and F1, and why accuracy alone misleads when one class is rare; and tell a model’s hyperparameters (k, a tree’s depth, the learning rate), chosen by the builder on data kept for it, from what the model learns.
• 12.6.4 Measure a model’s performance for different groups (by district, language or gender), find whom it fails, and reduce the gap by changing the data or the threshold.
• 12.6.5 Describe how an AI agent plans steps and calls tools; run an agent on the page whose model is a scripted stand-in (it says so) that follows plans written out in full and calls real Python tools; and analyze its tools, the limits set on what it may do, and how it fails.
• 12.6.6 Test an AI system for wrong, biased and harmful output with written test cases, and record the results.
• 12.6.7 Plan safeguards for putting an AI system into use: a person who reviews important decisions, privacy, a way to appeal, and checks after release.
• 12.6.8 Write a model card for a model they built: its purpose, data, performance for each group, limits and the values built into its design.

Scope: a short tour of machine learning beyond neural networks (decision trees, k-means clustering, reinforcement learning in a grid world), each run on the page; choosing an AI method; confusion matrices, precision, recall and F1; hyperparameters; fairness across groups; AI agents and tools, with a scripted stand-in model on the page (no API key, nothing run on our server; the analysis of tools, limits and failures is the core); testing AI for harm; safeguards and human oversight; model cards. The unit keeps its 12 periods: the agent is studied rather than built against a real model, which leaves room for the tour.

Practical work: build, measure and document a model on data from Nepal; clusters of Nepal’s districts, judged; the on-page agent run on given tasks and its failures recorded; test a chatbot or agent with a written test plan.

Unit 12.7 Cryptography and Trust · 9 periods (5 + 4)

Standards: CSTA HS-SYS-SE-31, HS-SYS-SE-33; Eng A level encryption.

Builds on: ciphers, public keys and hashes (9.6), HTTPS (11.6), P and NP (12.2).

Learning outcomes:

• 12.7.1 Calculate with remainders (modular arithmetic), and explain why multiplying two primes is easy and finding them again is hard.
• 12.7.2 Make an RSA key pair from small primes, and encrypt and decrypt a number with it.
• 12.7.3 Explain how two strangers agree on a secret over an open line (key exchange), with small numbers.
• 12.7.4 Sign a message and check a signature, and explain what a signature proves and what it doesn’t.
• 12.7.5 Explain how a chain of certificates lets a browser trust a site, and what happens when one fails.
• 12.7.6 Explain how hashes chained together make records hard to change unnoticed, what a blockchain adds, and what it doesn’t solve.

Scope: modular arithmetic; RSA with small numbers; key exchange; digital signatures; certificates and trust; hash chains and blockchains.

Practical work: RSA and signatures with small numbers in Python; a hash chain that shows a changed record.

Unit 12.8 Technology, Policy and You · 6 periods (4 + 2)

Standards: CSTA HS-SOC-HU-44, HS-SOC-HI-39, HS-SOC-ET-42, HS-SOC-CE-46; CSTA AI specialty S2-AIN-HR-06, S2-AIN-PP-10; UNESCO human-centred mindset and ethics of AI; Cambridge 9618 professional ethics (BCS, IEEE).

Builds on: the law and AI rules around the world (9.10), human and machine intelligence (10.7), the future of computing and careers (10.9). What those units taught is recalled, not taught again: the unit has 6 periods from 2026-10-24 (it gave two to the rest of Grade 12).

Learning outcomes:

• 12.8.1 Debate whether machines can think or be conscious, and what responsibility people keep for what AI does, giving arguments for both sides.
• 12.8.2 Write a policy proposal for Nepal on a computing issue (AI in schools, data kept by apps, drones), with its reasons, who it affects, and how it would be checked, drawing on how two countries regulate AI and what Nepal could take from each.
• 12.8.3 Read a professional code of ethics (the ACM’s, compared with the IEEE’s and the BCS’s), and use it to judge a real case of a computing professional’s choice.
• 12.8.4 Design, on paper, a solution to a real problem in Nepal using an emerging technology, and weigh its benefits and harms.
• 12.8.5 Plan how to keep learning after school (documentation, courses, open source, a portfolio of their own projects), and link their skills to university courses and careers in Nepal and abroad.

Scope: human and machine intelligence; writing a policy, with AI regulation compared as its evidence; professional codes of ethics; designing with an emerging technology; learning on your own; a portfolio; university and careers.

Practical work: a policy proposal presented to a mock committee; a portfolio of the student’s projects from Grades 8–12.

Unit 12.9 Capstone Project · 20 periods (1 + 19)

Standards: CSTA HS-PRO-PD-15, HS-PRO-TR-20, HS-ALG-IM-09; NSW Software Engineering software engineering project; Eng A level programming project.

Builds on: every unit, and the workflow of 12.3.

Learning outcomes:

• 12.9.1 Agree a substantial problem with a real user, and write a specification with measurable success criteria.
• 12.9.2 Plan the work as a team with roles, a timeline and the workflow of 12.3 (version control, automatic tests, code review).
• 12.9.3 Build and release the product in stages, testing each stage with its users.
• 12.9.4 Evaluate the finished product against the success criteria, including accessibility, security and its effects on its users.
• 12.9.5 Document it for its users and for the next developer, crediting every source, library and AI tool used.
• 12.9.6 Present it, explaining the hardest decision the team made and what each member did.

Scope: specification and success criteria; planning in a team; building and releasing in stages; evaluation; documentation; presentation.

Practical work: the Grade 12 project (Section 4.5).

4.1 How to teach it

• Do first, then name it. Each idea starts from something students know (a bus ticket, a tea shop’s order, a data pack) or from an activity, and the term comes after.
• Predict, run, compare. Before running any program, students say what it will do. The difference between what they predicted and what happened is where learning happens, and it is the habit of debugging.
• Pairs at the keyboard. Two students per computer or phone: one types (the driver), the other reads and checks (the navigator), switching every ten minutes. Girls and boys get equal time at the keyboard.
• Explain in your own words. Every unit ends with written questions: students write answers in full sentences in their notebooks, as they will in the theory papers of Grades 8, 10 and 12.
• Today’s tools in today’s boxes. Teach the idea with whatever program the school has. Students are never marked on a particular program’s menus.

4.2 Three settings, one course

Each unit can be taught in any of these three settings. The teacher’s guide gives every unit’s practical work in all three.

A lab of shared computers. Split the class: half in the lab in pairs, half in the classroom on the unit’s written work or unplugged activity, then swap at the next period. Use the lab for what needs a keyboard and a big screen: typing, files, documents, spreadsheets, web pages, Python. Nothing needs installing: the book’s programs run in any modern browser.

Phones only. The book’s on-page programs (block editor, binary and pixel widgets, gates, packet network, model trainer, Python, HTML, SQL) work on a phone. A teacher’s phone with a projector or a TV can show them to the whole class. Students can save a book to read offline; the Python editor needs an internet connection and downloads several megabytes the first time, so do this on school Wi-Fi. Units on files, permissions, storage, screen time and security are often taught best on a phone.

No devices. Every thread has unplugged activities: binary cards and pixel grids on squared paper (data); a student “turtle” following block cards on the floor, and paper blocks to arrange (programming); sorting a row of students by height with only swaps of neighbors (algorithms); paper notes passed as packets along rows of desks, with some desks “broken” (networks); a paper table of survey answers to sort and chart (data); a card-sorting “model” trained on examples (AI); printed messages to sort into safe and scam (safety). A school without devices teaches the practical periods this way and has students try the on-page programs on any phone they can use at home.

4.3 Grade by grade

• Grades 6–7: short explanations, many unplugged activities and on-page programs; blocks for programming.
• Grade 8: the move to Python; more time at the keyboard; the first team project; the first final exam.
• Grades 9–10: longer programs, reading documentation, working in teams with a defined workflow; students explain and judge, not only use.
• Grades 11–12: fewer, longer units; most of the time at the keyboard, on programs that grow over several lessons; reading real documentation and real reports (outages, breaches, policies); a project each year that real people use. Grades 11–12 need a device for the practical periods (a phone is enough for most units; a computer with a keyboard is better), and their ideas are still explained first on paper.

4.4 Typing

Typing runs through every grade as one shared game in English and in Nepali Unicode, to be built on the website, which every grade’s book links to. In Grades 6–8 it fills the first 5 minutes of every practical period; in Grades 9 and 10 it also has 6 periods of its own; in Grades 11–12 students use it on their own. Speed and accuracy are recorded once a term as part of practical work, but are not a unit of their own.

4.5 A project in every grade

Every grade has one project, done over several weeks, in pairs or teams of up to four, for a real user (a classmate, a younger class, a teacher, a family, a local shop or office). Each has a plan, a product, a test with the user, a record (notes, versions, credits) and a short presentation.

4.6 Using AI in class

From Grade 8, students may use AI tools for schoolwork only as the book teaches: to explain, to check, to get unstuck, never to hand in work they did not do. Any use is stated in a short note with the work. Projects record where AI was used. In Grades 11–12, AI-written code is checked like anyone else’s: against the requirements and the tests (12.3).

Evaluation is continuous in every grade: projects, practical work and self-marked practice, through the year. In Grades 8, 10 and 12, the years of Nepal’s board exams (the BLE, the SEE and NEB’s Grade 12 exam), the result is out of 100, split as CDC splits its own Computer Science course for Grades 9–10: 50 marks given by the school (a practical exam, the project and the year’s work) and 50 marks for a written paper.

5.1 Continuous assessment, in every grade

• Practical work. The practical tasks listed under each unit, marked with a rubric: does it work, is it tested, can the student explain it. A school without computers marks the unplugged and phone versions in the same way. Each student keeps a practical record (a file or portfolio).
• The practical exam (5.3): at the end of the year, each student alone at a computer, before the teacher, with a short viva.
• The project (Section 4.5): carrying it out, its record, a short reflection and the presentation, with a viva (5.5). In a group project each member writes the reflection in their own words on what they did and learned. The head teacher signs the records of the projects.
• Term tests. Two in the year, set like the final written paper (any of the course’s model papers can be used as one).
• Self-marked practice. The book’s questions to tap, its exercises with hidden hints and model answers, and its practice papers. Students mark their own answers against the model answers and correct them; the teacher looks at the practice and uses it to decide what to teach again. It is for learning and carries no marks.
• Participation: attendance, classwork and homework.

In Grades 6, 7, 9 and 11 the year’s result comes from continuous assessment alone; a school may add term tests set from the book’s practice. In Grades 8, 10 and 12 continuous assessment is part of the final result (5.2).

5.2 The final exam in Grades 8, 10 and 12

Each of these years has:

• A theory paper, written, 50 marks in 2 hours. It tests programming and data on paper as well as ideas: predict what a program prints or draws, trace the values of variables, find and fix a bug, complete a truth table, convert numbers, write a short program or SQL query, read a chart, judge a claim or an AI answer, and, in Grade 12, work an algorithm by hand or argue a case.
• A practical exam, marked by the school as part of its 50 marks: programs written and run on a computer, alone, before the teacher, with no internet and no AI, and a short viva (two or three questions about what the student did). Where a school has no computers, the tasks are done on a phone with the book’s on-page programs, with the network off.

The final result adds the school’s 50 marks and the theory paper’s 50. Each exam covers that grade’s units, with each unit’s marks following its share of the periods, as CDC’s specification grids do; earlier grades are not examined as such, though the questions use what they taught (Grade 10’s Python stands on Grades 8 and 9). Questions are set at CDC’s four levels: knowledge, understanding, application and higher ability.

Marks, out of 100:

Why this split. It is CDC’s own split for Computer Science, Grades 9–10, so schools can use it as they are. The practical exam carries the most of the school’s marks because only there does the student work alone, with no help from people or AI. In Grade 12 the capstone replaces the practical record, and half its marks come from the student’s viva (5.5).

Grade 8's specification grid (in full, with each unit's questions by section and level, on the book's papers page). The theory paper covers Units 1–10 (79 periods); Unit 11, the project, is marked in continuous assessment. Each unit's marks are its share of the 79 periods, rounded:

Sections as CDC's Grade 8 grids: A multiple choice 10 × 1 (questions at the four levels 2, 3, 3, 2), B very short 8 × 1 (2, 2, 2, 2), C short 8 × 2 (1, 3, 3, 1), D long 4 × 4 (1, 1, 1, 1). The practical exam (25 marks, 1 hour 30 minutes): a Python program with input, a condition and a loop (8), finding and fixing the error in a given program (4), a small web page with a heading, a list, an image with alt text and one CSS rule (7), and the viva (6), as in 5.3.

Grade 10's specification grid (in full on the book's papers page). The theory paper covers Units 1–7 and 9 (68 periods); Unit 8, the project in a team, is marked in continuous assessment. Each unit's marks are its share of the 68 periods, rounded (the largest remainders round up):

Sections as CDC's Grade 10 Computer Science grid: A multiple choice 10 × 1 (questions at the four levels 4, 1, 3, 2), B short 10 × 2 (1, 3, 4, 2), C long 5 × 4 (1, 2, 1, 1). The practical exam (25 marks, 1 hour 30 minutes): a Python program with a function that returns a value, in a module of its own (7), three questions about a given database in SQL (6), the fewest steps between two places in a given graph, with a program (6), and the viva (6).

Grade 12's specification grid (in full on the book's papers page). The theory paper covers Units 1–8 (84 periods); Unit 9, the capstone, is marked by the school. The shares of the 84 periods, rounded, are 7, 6, 8, 6, 7, 7, 5 and 4; each of the two long questions is 8 marks and sits in one unit (an algorithm worked by hand in Unit 1, a case argued in Unit 6), so Units 1 and 6 take 8 and Units 2 and 5 give one each, within CDC's ±2 and with every group's total kept:

Sections: A multiple choice 10 × 1 (questions at the four levels 4, 3, 1, 2), B short 8 × 3 (1, 4, 2, 1), C long 2 × 8 (0, 0, 1, 1). 15% and 25% of 50 are 7.5 and 12.5 marks, so with one level to a question the paper has 7 and 13. The practical exam (20 marks, 1 hour 30 minutes): a program with automatic tests that solves a given problem with a suitable algorithm (7), finding and fixing a failing test or a bug (4), measuring a given model or analysis and reporting one limit (4), and the viva (5). Grade 12 has no Computer systems unit; a one-page “Systems in brief” revision page is planned.

5.3 The practical tasks

At the end of each year, each student alone, 45–90 minutes, with no internet and no AI: in Grades 8 and 10 marked out of 25 and in Grade 12 out of 20, as the practical exam within the school’s 50 marks; in the other grades out of 25, as a practical task within continuous assessment. The tasks are like those below, drawn from the year’s practical work; where the school has no computers, they are done on a phone with the book’s on-page programs, or on paper where the task allows (shown in brackets).

The project is presented and marked separately (5.1, 5.5).

5.4 Keeping the course current

• ”Today” boxes. The names of apps, products, versions, prices and statistics appear only in the books’ dated “Today” boxes, never in the explanations or the learning outcomes.
• Never examined. No exam question asks about anything that is only in a “Today” box (a product’s name, a version, a price, a statistic), as CDC’s curriculum also says for fast-changing technology. Practical tasks can be done with any suitable program; marks are for the idea and the skill, not for a particular program’s menus.
• The yearly review. Each June (Admin → Routines on the website), every “Today” box is checked and updated; the curriculum is checked against new versions of its sources (CSTA, England’s new programme of study and A level, the Australian Curriculum and NSW’s senior syllabus, UNESCO’s framework, CDC’s curriculum). Learning outcomes change only when an idea changes, not when a product does, and any change is recorded with its date at the end of this file, so schools know what changed from one year to the next.

5.5 Marking work that AI could have done

AI can write much of a program or a report, so the marks go mostly to what only the student can show. Students may use AI, and record it in the project’s AI use log.

• The practical exam: alone, with no internet or AI, before the teacher.
• Checkpoints signed when reached: in Grade 12 the signed specification, a demonstration midway and the release.
• The history of the work: the repository (Grade 12) or the project record shows who did what, over weeks.
• A viva with a live change: the student explains a part of their own work, then changes it on the spot (another check, another field). For example: What does this line do? What if the input is empty? Show me the test that would fail if this were wrong. What did the AI suggest, and what did you change? It is marked on understanding, not on speaking well.

Each unit is listed under the thread it mainly belongs to; a unit in brackets also builds that thread.

Grades 6–9

Grades 10–12

How each thread climbs:

• Computer systems: what a computer is → its parts → a programmable board → how gates make a CPU → computers in the world → machine code, compilers, the operating system at work, logic simplified and kinds of processor → systems that serve millions and keep their data right.
• Data and representation: bits and binary → text, color and sound → file formats in practice → hexadecimal, negative numbers and compression → data types in databases → floating point, bit masks and parity.
• Algorithms and programming: algorithms unplugged and blocks → variables and choices in blocks → Python, searching, sorting and functions → data structures and efficiency → modules and graphs → objects, recursion and data structures built by hand → shortest paths, dynamic programming, big O, grammars, the limits of computing and other ways to program.
• Networks and the internet: internet and web → packets and routers → protocols, DNS and HTTP → the cloud and the Internet of Things → TCP, HTTP in depth, clients and servers → systems at scale.
• Data and analysis: tables and charts → spreadsheets, messy data and trends → metadata and privacy → databases and data science → modeling and simulation, database design → samples, uncertainty, fitted lines, experiments and evidence; Big Data and NoSQL.
• Safety and society: passwords and scams → the CIA triad, attention design, everyday algorithms, history and access → privacy and data, an emerging technology in the community → encryption, the law and the values in algorithms → the future, history, policy and careers → attacking and defending real systems → cryptography, trust, technology policy and professional ethics.
• AI: learning from examples → training data and bias → generative AI → a model in Python → large language models → neural networks trained by hand → other kinds of machine learning (trees, clusters, rewards), and building, measuring, testing and governing AI systems.
• Using computers well: files and typing → finding and checking → organizing → documents and online services → troubleshooting and learning any tool → automating one’s own work → learning on one’s own after school.
• Creating: documents, slides and a picture program → (a quiz game) → web pages, media and a community project → web apps → a team project → an app people use → software engineering and a capstone.