Top 200 Vocabulary for JC 1 H2 Computing | Python, Algorithms, Databases and AI Explained

JC1 H2 Computing vocabulary begins with algorithms, Python, data structures, databases and computational problem-solving. These 200 words are explained simply for Singapore junior college students who need to read code, build working programs and understand the implications of computing in daily life. The guide draws on the 2027 SEAB H2 Computing syllabus 9569, including programming, computer networks, security and emerging technologies.

The 2027 syllabus is revised. Paper 1 is a three-hour written examination worth 60%, and Paper 2 is a three-hour laptop-based laboratory examination worth 40%. The lab uses Python and web technologies including HTML, CSS, SQLite and Flask. The glossary includes concepts from across the two-year course, so a JC1 student should begin with the vocabulary needed in this week’s lesson rather than attempting to memorise all 200 immediately.

Start: algorithms, variables, data types, conditions, loops, functions and debugging.
Next: data structures, searching and sorting, database queries, Flask web applications and network security.
Extend: AI, machine learning, testing, ethics and computing’s consequences for society.
Scope: this is an independently written glossary of 200 useful terms, not a SEAB-endorsed list or evidence of any particular Google search ranking.

How JC1 students should use the 2027 Computing vocabulary

Every new term should be attached to one action: a two-line code example, an algorithm trace, a simple database query, an input validation test or an explanation of a technology in use. Knowing a definition helps you read the question; executing the idea shows whether you understand it. Several concepts listed here are broader context or later-course vocabulary; consult the official 9569 learning outcomes when deciding precise examinable scope.

Quick contents: all 200 H2 Computing words

Computational thinking and problem-solving (words 1–20)
Python syntax, types and expressions (words 21–40)
Control flow, functions and program organisation (words 41–60)
Testing, debugging and software quality (words 61–80)
Data structures and abstraction (words 81–100)
Algorithms, searching, sorting and complexity (words 101–120)
Data, relational databases and SQL (words 121–140)
Web applications, HTML, CSS and Flask (words 141–160)
Networks, cybersecurity and responsible computing (words 161–180)
AI, emerging technologies and social impact (words 181–200)

1. Computational thinking and problem-solving | Words 1–20

The first question in programming is what the task means

Before writing a line of Python, decide what the program will accept, what it should return and how to recognise success. Suppose you need to find the largest exam score in a list. An empty list is an edge case. A negative value might or might not be valid. Establish those conditions before choosing an algorithm. If the data can contain repeated maxima, decide whether your result should return a value or all matching positions. This prevents a superficially successful program from solving the wrong problem.

Computational thinking. A disciplined approach to describing problems so that logical, repeatable computational solutions can be designed and evaluated.
Decomposition. Breaking a difficult task into smaller problems whose solutions can be developed and tested separately.
Abstraction. Focusing on essential features of a problem while temporarily ignoring details that do not affect the solution.
Pattern recognition. Identifying similarities in different cases so a previously useful strategy can be applied or adapted.
Algorithm. A finite, unambiguous sequence of instructions intended to accomplish a clearly specified task.
Pseudocode. A language-independent description of an algorithm using structured, human-readable steps.
Flowchart. A visual representation of a process using symbols for actions, decisions and flow.
Input. Data or signals supplied to a computer program for processing.
Output. Information or actions produced by a computational process.
Precondition. A requirement that must be true before an algorithm or function is executed correctly.
Postcondition. A statement describing what should be true after successful completion of an operation.
Invariant. A property that remains true through specified steps of a program or loop.
Correctness. Whether a program meets its intended requirements for the inputs and conditions specified.
Termination. The property that an algorithm eventually stops rather than running forever.
Efficiency. How economically a solution uses time, memory or other resources.
Scalability. The ability of a system to handle larger workloads without unacceptable deterioration in performance.
Determinism. A property whereby the same program and conditions lead to the same specified result.
State. The values of relevant variables and data structures at a particular moment in execution.
Trace table. A stepwise record of variable values or decisions used to understand an algorithm’s behaviour.
Edge case. An unusual or boundary input that may reveal a defect overlooked by ordinary examples.

Retrieval check: Close this section, define five randomly chosen terms in plain English, and show how at least one changes the correctness or safety of an actual program. For every definition you cannot apply, build one smallest possible example and test its boundaries.

2. Python syntax, types and expressions | Words 21–40

Code has meaning beyond punctuation

Python distinguishes the comparison operator == from assignment with =. The expression 0.1 + 0.2 may not equal 0.3 exactly because binary floating-point representation is approximate. Indexing begins at zero, whereas a human may count positions from one. When reading unfamiliar code, write a tiny example using concrete inputs rather than guessing what an operator means. The apparent simplicity of syntax can conceal important choices about data types and assumptions.

Source code. Human-readable instructions written in a programming language and processed by software tools.
Interpreter. Software that executes or evaluates program instructions according to a language’s rules.
Identifier. A name used to refer to a variable, function or another program entity.
Variable. A named reference to a value that may change during execution.
Assignment. An operation binding a name or location to a value, such as count = 3 in Python.
Literal. A value written directly in code, such as 42, True or "hello".
Integer. A whole-number data type, represented by int in Python.
Floating-point number. A numerical approximation using a finite binary representation, represented by float in Python.
Boolean. A logical value that is either True or False.
String. An ordered sequence of characters, represented by str in Python.
Type conversion. Changing a value from one data type to another using an appropriate operation.
Expression. A combination of values and operators that evaluates to a result.
Operator precedence. The rules determining which operations are evaluated first when parentheses do not override them.
Comparison operator. An operator such as ==, < or >= that evaluates a relationship between values.
Logical operator. An operator such as and, or or not that combines or negates Boolean expressions.
Floor division. Division producing the mathematical floor of the quotient, written // in Python.
Modulo operation. An operation obtaining the remainder according to Python’s division rule, written %.
Slicing. Selecting a portion of an indexed sequence using positions and optional step sizes.
Index. An integer position used to access an item in a sequence, beginning at zero for Python lists.
Mutability. Whether an object can have its contents altered without creating a replacement object.

3. Control flow, functions and program organisation | Words 41–60

Loops and functions turn ideas into repeatable steps

For a class of student marks, a function could accept a list and return a mean. A loop would visit each mark and an accumulator would maintain their sum. But a truly reusable function should also specify what happens if the list is empty, whether inputs can be strings and whether the original list is changed. Separating calculation from input and display makes testing easier. Trace the first two iterations by hand to check that the intended invariant remains true.

Sequence. Execution of statements in an intended order.
Selection. Choosing between possible paths of execution according to a condition.
Iteration. Repeating instructions until a condition changes or a sequence is exhausted.
Conditional statement. A construct such as if that executes a block only when a condition is satisfied.
Else branch. A block executed when preceding conditions in a selection are not satisfied.
For loop. A loop that iterates over elements of an iterable.
While loop. A loop that repeats while its condition remains true.
Loop counter. A variable tracking iterations, often used to bound repetition or count results.
Accumulator. A variable storing a running total or progressively combined result.
Nested loop. A loop placed inside another loop, potentially repeating the inner work many times.
Function. A reusable block of code invoked by name, usually accepting inputs and optionally returning a result.
Parameter. A named placeholder for an input in a function definition.
Argument. A value or expression passed to a function when it is called.
Return value. The result sent back to a caller by a function.
Local variable. A name whose scope is within a function or another limited context.
Global variable. A name defined in the module-level scope.
Scope. The region of a program in which a name is available.
Recursion. A method in which a function calls itself on smaller or otherwise progressing cases.
Base case. A stopping condition preventing a recursive function from calling itself indefinitely.
Modular programming. Dividing a system into cohesive components with clear responsibilities and interfaces.

4. Testing, debugging and software quality | Words 61–80

Testing is evidence, not a ritual

Imagine a discount function with separate price brackets. Testing only a normal full-price purchase does not establish correctness at a threshold. Try the exact boundaries, a value just below and above, a missing input and any invalid negative price. Specify an expected result before running the code; otherwise the result might appear reasonable merely because the program produced a number. After fixing a bug, rerun previous working cases to detect regressions.

Syntax error. A violation of a programming language’s grammatical rules that prevents normal interpretation.
Runtime error. An error occurring during execution, such as accessing a nonexistent list position.
Logic error. A defect allowing execution to finish while producing an incorrect or unintended result.
Exception. A signal representing an unusual condition that can interrupt normal execution.
Exception handling. Using structured responses such as try and except to recover from selected failures.
Debugging. Finding and correcting the causes of incorrect program behaviour.
Breakpoint. A designated location where execution pauses for inspection in a debugging tool.
Assertion. An executable check that a condition expected by the programmer is true.
Unit test. A test of a small component, such as a function, in isolation.
Integration test. A test of how components operate together after being connected.
Test case. A specific set of inputs, preconditions and expected outcomes for an evaluation.
Test data. Values supplied to a program to check its responses.
Boundary testing. Testing at and near the ends of permitted input ranges.
Equivalence partition. A group of inputs expected to behave similarly for a specified requirement.
Regression testing. Rechecking previously working behaviour after a change to detect newly introduced defects.
Validation. Checking whether data or a solution meets the needs and constraints of the problem.
Verification. Checking whether an implementation satisfies a stated specification.
Documentation. Written information explaining program use, architecture, decisions or assumptions.
Readability. How easily another programmer can understand the intention and logic of code.
Refactoring. Improving a program’s internal structure while preserving its externally observable behaviour.

5. Data structures and abstraction | Words 81–100

Choose a data structure for the operation you need

A stack is appropriate for undo history because the most recently recorded operation is reversed first. A queue is suitable for processing requests in arrival order. A dictionary can associate unique student IDs with records without searching a list manually. A graph represents MRT stations and connections more naturally than an unrelated collection of strings. No structure is universally best; design follows required access and update patterns.

Data structure. An organised way of storing information to support particular operations efficiently.
List. An ordered mutable Python collection allowing indexed access and duplicate values.
Tuple. An ordered immutable Python collection.
Dictionary. A Python mapping from hashable keys to associated values.
Set. An unordered Python collection of unique hashable elements.
Array. A sequence of elements stored or addressed through indexed positions.
Stack. A last-in-first-out collection with insertion and removal at the same end.
Queue. A first-in-first-out collection where earlier additions are removed first.
Node. A component of a linked structure holding a value and possibly references to others.
Linked list. A linear structure whose nodes connect through links rather than adjacent indices.
Tree. A hierarchical structure with nodes and parent-child relationships.
Binary tree. A tree where each node has at most two children.
Binary search tree. An ordered binary tree supporting comparisons that guide searching.
Graph. A collection of vertices and edges representing relationships.
Vertex. A point or entity in a graph.
Edge. A connection between vertices, which may be directed or carry a weight.
Adjacency list. A representation recording each vertex’s neighbouring vertices.
Hash table. A structure associating keys with storage locations using a hash function.
Collision. A case where different keys produce the same hash-table location.
Abstract data type. A specification of operations and behaviour independent of implementation details.

6. Algorithms, searching, sorting and complexity | Words 101–120

Faster algorithms can require stronger assumptions

Binary search is usually much faster than linear search on a large ordered list, but it only works correctly when the input satisfies the ordering assumption. Merge sort can offer reliable asymptotic performance while using additional memory. Complexity describes how a method scales, not its exact stopwatch time for one computer. For a small class list, readable linear search may be more sensible than additional implementation complexity.

Linear search. Searching entries one by one until a match is found or all entries are exhausted.
Binary search. Searching ordered data by repeatedly eliminating one half of the remaining interval.
Bubble sort. A sorting approach repeatedly swapping adjacent out-of-order items.
Insertion sort. A sorting method placing each new item into its correct location within a sorted prefix.
Selection sort. A method repeatedly choosing the next smallest or largest item for a position.
Merge sort. A divide-and-conquer sort combining recursively sorted portions.
Quicksort. A divide-and-conquer sorting method partitioning values around a pivot.
Divide and conquer. Solving a problem by splitting it into smaller problems and combining the results.
Greedy algorithm. Choosing a locally preferred option at each step without revisiting earlier choices.
Dynamic programming. Solving overlapping subproblems once and reusing their results.
Time complexity. How an algorithm’s computational work grows with input size.
Space complexity. How its memory requirements grow with input size.
Big O notation. An asymptotic upper bound used to describe resource growth.
Constant-time operation. An operation whose cost does not materially grow with the input size under a chosen model.
Logarithmic growth. Resource growth proportional to the number of repeated halvings of a problem.
Linear growth. Resource growth proportional to the number of items processed.
Quadratic growth. Growth proportional to the square of input size.
Worst-case analysis. Examining an algorithm’s maximum resource use within the input conditions.
Best-case analysis. Examining its minimum resource use for allowable inputs.
Algorithmic trade-off. A choice between methods differing in speed, memory, clarity or other constraints.

7. Data, relational databases and SQL | Words 121–140

Relational tables protect meaning

A database storing classes, tutors and student attendance should avoid repeating every tutor’s contact details in every attendance row. Define a tutor table and refer to it through a suitable key where appropriate. That makes updates less error-prone. A JOIN can combine tables for a report, but SQL should filter only the needed records and respect privacy. A database query is not the same as permission to disclose the information returned.

Database. A structured collection of data managed for reliable storage, access and updates.
Database management system. Software that stores, retrieves, secures and manages database information.
Relational database. A database representing information using tables and relationships between them.
Table. A set of rows with defined columns in a relational database.
Record. A row holding related values for one data item or entity.
Field. A column representing one attribute across records.
Primary key. A column or combination uniquely identifying each row in a table.
Foreign key. A column or columns connecting a record to a key in another table.
Entity. A distinguishable object or concept represented within a data model.
Relationship. An association between data entities.
Cardinality. The number pattern of links between entities, such as one-to-many.
Schema. The defined organisation of database tables, attributes and constraints.
Normalisation. Organising tables to reduce redundancy and certain update anomalies.
Data redundancy. Unnecessary duplication of information across storage locations.
Referential integrity. Constraints ensuring referenced records exist and relationships remain consistent.
SQL. The structured language used to define and query relational data.
SELECT statement. An SQL command retrieving specified data from tables.
WHERE clause. An SQL condition filtering which records are considered.
JOIN. An operation combining rows based on a relationship between tables.
SQLite. An embedded relational database engine usable from Python and the computing laboratory.

8. Web applications, HTML, CSS and Flask | Words 141–160

A web form links interface, data and server

A student enters a query in an HTML form. CSS controls its appearance; an HTTP request sends the data; a Flask route processes the request; SQLite may store or retrieve related records; a response displays the result. These layers have different responsibilities. A client-side check improves usability, but server-side validation remains necessary because a request can be sent without using the form. The same principle applies to appointment-booking or school-information services.

Client. A program or device requesting a service from another computer.
Server. A program or system responding to requests and providing resources.
Web application. Software accessed through web protocols and an interactive user interface.
HTTP. The request-response protocol used to exchange web resources.
URL. An address identifying a resource and possibly its query information.
HTML. A markup language describing the structure and meaning of web content.
CSS. A style language controlling the visual presentation of structured web content.
HTML element. A component represented by a tag and its content or attributes.
Attribute. An HTML property supplying additional information to an element.
Form. A web interface collecting user values for submission.
GET request. An HTTP request generally used to retrieve a resource.
POST request. An HTTP request typically carrying data for processing or state changes.
Status code. A numerical HTTP response indicator such as 200, 404 or 500.
Flask. A Python web application framework for routes, requests and responses.
Route. A URL path mapped to a function or handler in a web application.
Template. A reusable page structure that can be filled with dynamic data.
Request. The information a client sends to ask a server to perform an action.
Response. The message a server sends back after processing a request.
Session. A way of preserving selected user state across separate web requests.
Input sanitisation. Reducing unsafe content in supplied data according to its intended destination.

9. Networks, cybersecurity and responsible computing | Words 161–180

Networks create opportunities and risks together

If an application sends personal information over a network, it should use suitable transport protection and access controls. Encryption protects data from certain kinds of interception, but encryption alone does not establish whether the recipient is trustworthy or authorised. A password may authenticate a user, while authorisation determines which records they may view. Teach these distinctions using everyday examples such as class portals rather than vague warnings about hacking.

Computer network. Connected devices exchanging data using agreed communication rules.
Packet. A bounded unit of information transferred across a network.
IP address. A numerical identifier used for network-layer addressing.
Domain name. A human-readable name mapped to network destinations by DNS.
DNS. The system translating domain names into records such as IP addresses.
Router. A device forwarding packets between networks according to routing information.
Switch. A device commonly connecting devices within a local network.
Bandwidth. The maximum data-transfer capacity of a communication channel over time.
Latency. The delay between initiating an operation and receiving a response.
Protocol. A shared specification of how participants communicate.
Encryption. Transformation of readable information into a protected form using cryptographic techniques.
Authentication. Checking the claimed identity of a user, device or service.
Authorisation. Deciding what an authenticated identity may access or perform.
Hashing. Computing a fixed-format digest useful for integrity checking and other purposes.
Malware. Software designed to disrupt, steal, spy or otherwise harm.
Phishing. Deceptive communication intended to trick a person into revealing information or taking harmful action.
Vulnerability. A weakness that can be exploited to compromise a system.
Threat model. A structured account of assets, possible attackers and relevant risks.
Privacy. Protection of information about identifiable people and their choices.
Computing ethics. Reasoned consideration of fairness, harm, rights and responsibility when designing digital systems.

10. AI, emerging technologies and social impact | Words 181–200

AI results require interpretation

Suppose a model classifies messages as spam or not spam. Accuracy alone can mislead if almost every message is legitimate. Precision and recall help reveal different kinds of errors. A system also may behave differently on a new population compared with its training data. The responsible question is not only ‘Does it work?’ but ‘For which users, under which conditions, with what consequences when it fails?’.

Artificial intelligence. Computing methods that perform tasks involving pattern recognition, reasoning or other capabilities associated with intelligence.
Machine learning. Methods that fit models to patterns in data instead of relying entirely on manually written rules.
Training data. Examples used to adjust the parameters of a machine-learning model.
Test set. Held-out examples used to estimate performance on data not used for training.
Feature. A measurable input variable supplied to a model for prediction.
Label. A known target value associated with an example in supervised learning.
Classification. Assigning an input to one of several categories.
Regression model. A model predicting a continuous numerical value.
Overfitting. Learning peculiarities of the training data that do not generalise well.
Underfitting. Using a model too limited to capture important patterns.
Generalisation. The ability of a model to perform usefully on unfamiliar cases.
Accuracy metric. A measure of the proportion of predictions classified correctly.
Confusion matrix. A table comparing predicted and actual classes, displaying correct and incorrect categories.
Precision metric. The proportion of predicted positive cases that are truly positive.
Recall metric. The proportion of actual positive cases identified by the model.
Bias in AI. Systematic distortion in model outcomes, potentially disadvantaging particular people or groups.
Explainability. The extent to which the basis of a model decision can be meaningfully understood.
Human oversight. Meaningful human monitoring and responsibility for decisions involving automated systems.
Automation. Using technology to perform activities with reduced direct manual work.
Digital divide. Unequal access to digital tools, connectivity and the skills needed to use them.

Worked practical 1: correct input validation with a score calculator

Suppose a class tool accepts a student score and classifies it as either in range or invalid. The requirement is not simply to print a message for every number. Scores must be numeric and between zero and one hundred, inclusive. The precondition and postcondition matter. Here is a small illustration, not an entire exam question:

def check_score(value):
    try:
        score = float(value)
    except (TypeError, ValueError):
        return "invalid: enter a number"
    if not 0 <= score <= 100:
        return "invalid: out of range"
    return "valid"

tests = ["0", "100", "-1", "hello"]
for item in tests:
    print(item, check_score(item))

This example demonstrates function, argument, return value, selection, exception handling and boundary testing. It makes no attempt to decide how a school actually awards grades. Notice a remaining question: the code accepts decimal scores; if the task requires integers only, the specification and implementation must change. A program can be internally consistent and still fail the user’s real requirement.

Worked practical 2: explain the difference between linear and binary search

Imagine searching for the name ‘Zara’ among 1,000 sorted names. A linear search examines names in sequence and can require checking the entire list. A binary search compares against the middle name and then searches only the relevant half. If there are 1,024 entries and the list is correctly ordered, at most around eleven such comparisons are needed in the usual exact-match search. But remove the ordering assumption and binary search can miss a present item. Therefore ‘binary search is better’ is incomplete; the correct explanation names the required preconditions, likely workload and implementation cost.

Worked practical 3: a safe and useful student database

Suppose you are designing a small library-loan system. Make separate tables for books, borrowers and loans. Each book and borrower has an identifier; a loan refers to the appropriate identifiers. A query can list books overdue for return by joining loan records with book titles, without duplicating full details in each row. But a public lookup page should not expose every student’s private borrowing history. Entity relationships, keys, validation and authorisation all matter. Database normalisation helps prevent update anomalies; permissions control who can use stored information.

Worked practical 4: a web request passes through several layers

A request to a school information form begins in the browser. HTML defines the form fields and CSS defines their visual arrangement. The browser makes an HTTP request; Flask receives it through a matching route. The Python function checks submitted data, optionally accesses SQLite and returns a response. If the browser reports a 404 error, check whether the route exists. If the server raises an exception, inspect the code and logs. If the page displays unsafe submitted HTML, review output escaping as well as input validation. These are distinct failure modes. Identifying the correct layer prevents random code changes.

Worked practical 5: applying AI vocabulary to a real decision

A university might use an algorithm to prioritise enquiries requiring quick human attention. A classifier’s accuracy could look high merely because most enquiries are routine. Examine how often urgent cases are missed (recall), how often urgent predictions are correct (precision), and whether errors are distributed unfairly across user groups. Human oversight remains important because the model’s training examples may not resemble new enquiries. Such examples connect AI to ethics, data quality and practical limitations, rather than treating a model output as automatic truth.

A four-week vocabulary and coding programme

Week 1 — trace: Learn 40 terms involving Python, loops, functions and algorithm design. Trace each short program by hand before running it. Annotate what variables contain after every significant step.
Week 2 — test: Learn 40 terms on data structures, searching and program quality. Implement a simple search, add boundary inputs, describe its complexity and improve one confusing variable name or function interface.
Week 3 — build: Learn 40 terms related to SQL and web applications. Design a small database with two related tables, write a safe retrieval query and connect a form to a simple server-side response.
Week 4 — evaluate: Revisit security, networks and AI vocabulary. Take one example of a digital service and identify its data flows, possible failure cases, user risks and ways to test the solution. Record unresolved misunderstandings before the next lesson.

Frequently asked JC1 Computing questions

Is H2 Computing 9569 just about writing Python?

No. The 2027 syllabus assesses algorithms, data, information, networks, security, social implications and emerging technologies alongside programming. The practical paper involves a wider toolset including HTML, CSS, SQLite and Flask.

What is new about the 2027 examination?

The 2027 syllabus is a revised syllabus with six content modules. The official document lists a written paper worth 60% and a laptop-based practical paper worth 40%. Always refer to SEAB’s current technical requirements and school instructions.

Does the glossary mean all 200 terms will be tested?

No. It is a study aid that includes underpinning and extension concepts. Some entries help students understand wider computing practice; use the official syllabus for the examinable learning outcomes.

Can I take H2 Computing without previous programming experience?

Junior colleges set their own subject-offering arrangements and may conduct selection tests. Lack of previous programming is not, by itself, proof of ineligibility, but students should check their intended college and be prepared to learn independently.

How is a coding error different from a misunderstanding of requirements?

A syntax or logic error may be corrected inside the program. A requirements error means the student implemented the wrong task. Good developers test against a written specification, not simply whether a program runs without crashing.

How should parents help a JC1 student who is stuck?

Ask what the program should accept, what result is expected for one simple input, and which line changes the result. Let the student trace and explain their own code. This helps more than copying a finished solution.

Official SEAB syllabus and connected eduKate reading

The 2027 H2 Computing syllabus 9569 and SEAB A-Level syllabuses index are the authorities for assessment scope. Continue with how JC H2 Computing works, whether students can take H2 Computing without programming experience, the Python, Flask and SQLite lab guide, and why students choose H2 Computing.

Teaching checkpoint: make vocabulary observable

For each term, ask students to supply a definition, a shortest working example, a contrasting example and a test case. ‘I know what a loop is’ should become ‘I can explain why this loop terminates and what happens when the input list is empty’. That transition from word recognition to predictable behaviour is the purpose of these 200 terms.