Secondary 3 Information & Communication Technology

A structure storing data as key-value pairs, finding values by key, like a contacts book.

The name used to look up in a dictionary, e.g. "Mary" in {"Mary": "9123 4567"}.

The data a key points to, e.g. the phone number in {"Mary": "9123 4567"}.

The basic unit of a dictionary: one key joined to one value by a colon.

Fetches by key and returns a default when the key is missing, e.g. d.get("x", 0).

Returns all key-value pairs so a for loop can take key and value together.

Checks whether a key is in a dictionary or an item is in a set, giving True or False.

An unordered collection with no duplicates, often used to deduplicate, e.g. set([1, 1, 2]) gives {1, 2}.

Keeping only one copy of each repeated item — the classic use of a set.

Letting a program read and write files so data survives after the program ends.

The function that opens a file, given a filename and a mode, e.g. open("a.txt", "r").

"r" reads only; "w" writes and wipes existing content; "a" appends at the end without destroying old data.

Closes the file automatically when the with block ends — the recommended file pattern.

read() returns the whole content as one string; readlines() returns a list of lines.

The special character meaning 'new line'; add it yourself in write(), strip it off lines you read.

A plain-text data format with comma-separated fields, one record per line, openable in Excel.

Splits a string at commas into a list, e.g. "Mary,85".split(",") gives ["Mary", "85"].

Putting risky code in try and handling named exceptions in except so the program keeps running.

The blueprint defining a kind of object's data and behaviour, e.g. a Student class.

An instance built from a class, holding its own attributes, e.g. Mary's Student object.

Data stored inside an object, e.g. s1.name, s1.cls.

A function belonging to the object, defined inside the class, e.g. introduce().

The special method run automatically when an object is created, setting starting attributes.

The first parameter of every method — the object being called — used to reach its own attributes.

Another word for object: one individual actually produced by a class.

The act of creating an object from a class, e.g. s1 = Student("Mary", "3A").

Keeping data and the methods that use it inside one class, hiding internal details.

The stage deciding what the program must do and for whom, ending with a clear feature list.

Planning the data structure, the split of functions and the interface before coding.

Writing the code function by function following the design, testing as you go.

Verifying the program against requirements with normal and extreme inputs.

An interface listing numbered features for the user to pick, shown repeatedly inside a while loop.

Checking that user input is sensible (e.g. a score must be a number) and asking again when not.

Splitting a program into small functions with single jobs, easy to write, test and change.

The extremes most often overlooked, such as empty lists, zero scores or duplicated names.

Recording what the program does, how to use it and why it was designed that way.

A system storing and managing large amounts of data in an organised way for searching, updating and error prevention.

The two-dimensional structure holding one kind of data, made of rows (records) and columns (fields).

One row of a table — all the data of a single individual, e.g. one student.

One column of a table — a single attribute of the data, e.g. name, class.

The field uniquely identifying each record — never repeated, never empty, e.g. student number.

A database of tables linked by shared fields, e.g. a scores table joining the students table by student number.

The software managing a database — access, permissions and searching — e.g. MySQL, SQLite.

A request made to a database, e.g. 'list all students in 3A', usually written in SQL.

The same data stored in several places, which easily causes inconsistency after updates.

The standard language for talking to databases — querying, inserting, updating and deleting data.

The SQL keyword choosing which fields to return; SELECT * means all fields.

The SQL keyword naming which table the data comes from.

Sets a condition so only matching records return, e.g. WHERE score >= 80.

The symbols compared in WHERE: =, >, <, >=, <=; SQL tests equality with a single =.

Combines conditions: AND requires all to hold; OR requires any one.

Sorts results by a field: DESC high to low, ASC low to high (the default).

Returns only the first few rows, e.g. LIMIT 3 for the top three after sorting.

The star after SELECT, meaning every field of the table.

The SQL statement adding a new record to a table, with VALUES supplying each field.

The part of INSERT giving actual values in field order, e.g. VALUES (2023011, 'Amy', '3A', 88).

The SQL statement changing field values of existing records; SET gives the new value, WHERE limits the scope.

The SQL statement removing records from a table; WHERE decides which — omit it and every record goes.

WHERE decides which records an UPDATE/DELETE touches; leaving it out means all records — very dangerous.

Data staying correct and consistent, guarded by primary keys, field types and range rules.

The database refusing inserts that duplicate or omit the primary key, keeping every record identifiable.

An advance copy of the data, restorable after a mistake or an incident.

Running SELECT after a write to confirm the result — the last step of the safe routine.

The markup language behind web pages, using tags to describe content's structure and meaning.

A marker in angle brackets, mostly in pairs: opening ＜p＞, closing ＜/p＞.

The whole of an opening tag, its content and the closing tag — ＜p＞Hello＜/p＞ is one paragraph element.

Extra information inside an opening tag, e.g. href on ＜a href="...">, src and alt on ＜img>.

head holds information for the browser (title, encoding); body holds everything shown to visitors.

The link tag whose href gives the destination, e.g. ＜a href="https://...">go＜/a＞.

A single tag: src names the image file, alt carries the description text.

Structure tags declaring purpose: header, nav, main, footer.

Tags inside tags, layer by layer; the first opened closes last, never crossing.

The language describing how pages look — colour, fonts, spacing and layout.

The opening part naming which elements a style hits, e.g. p, .highlight, #title.

Starts with a dot (.highlight) and hits every element carrying that class — reusable anywhere.

Starts with a hash (#title) and hits the single element with that id on the page.

The two halves of a declaration: the property names what changes (color), the value what it becomes (red), ending with a semicolon.

Every element is a box: content, padding, border, margin — four layers inside out.

padding is the space inside, between content and border; margin is the space outside, to other elements.

A six-digit colour code after #, e.g. #f07f2e orange, #ffffff white.

@media (max-width: 600px) { ... } applies styles only under a screen width — the basis of responsive design.

The page list and link plan drawn before building — which pages exist and how they connect.

The site's default front door, loaded automatically when a visitor opens the folder.

The link menu present on every page (usually inside nav), letting visitors reach any page.

A path measured from the current file, e.g. about.html on the same level, images/p1.jpg in a subfolder.

figure wraps the image and figcaption carries its caption, keeping picture and description together.

The shared header, nav, footer and styles across pages, making the site look professional and unified.

Design usable by everyone including blind users: alt text, ordered headings, strong colour contrast.

Practices helping search engines understand and recommend a page: clear titles, meta description, keywords.

A one-line summary in head, often shown directly in search results.

Technology letting machines perform tasks needing human intelligence, e.g. speech, vision and translation.

The mainstream approach to AI: no hard-coded rules — computers derive patterns from mass examples.

A branch of machine learning using brain-like neural networks, strong at images, speech and language.

A layered computing structure imitating brain connections — the building block of deep learning.

The stage teaching a model with mass examples: predict, check, adjust parameters, repeat.

The stage where a trained model answers new inputs.

The trained product: it holds the learned patterns and parameters and judges new inputs.

The batch of examples used in training, e.g. a hundred thousand photos labelled cat or dog.

An AI stating falsehoods in confident prose — it tracks patterns, not truth.

Systematic unfairness in an AI caused by unbalanced training data.

Data identifying an individual, e.g. name, facial image, voice, address, phone number.

Hong Kong's law on collecting and using personal data: state the purpose, collect minimally, access and correct.

AI-generated or altered media that passes as real — swapped faces, imitated voices.

Content that is untrue; AI hallucinations and deepfakes both produce it.

The principle of declaring sources honestly and never passing off others' (or AI's) work as your own.

Voluntary permission after the person knows the use; uploading someone's photo without it breaches their rights.

AI systems should disclose their data sources, workings and limits to users.

When AI causes harm, a clear person or body must answer for it — never 'the AI did it'.

AI that creates new content — text, images, music, video — e.g. chatbots and text-to-image tools.

The text instruction given to generative AI; how specific it is directly shapes the output.

The craft of designing and refining prompts for better outputs — being specific, assigning roles, iterating.

AI tools generating images from text, e.g. 'Lion Rock at dusk, watercolour style'.

Repeated follow-ups and prompt tweaks, nudging the AI output toward the ideal step by step.

Verifying AI's facts and figures against reliable sources such as textbooks and official sites.

Knowing each AI tool's strengths and blind spots and choosing per task.

Treating AI output as a draft: check facts, test logic, watch for hallucinations before adopting.

Never type personal data, passwords or others' private details into AI tools — inputs may be retained.