INFO2222 Computing 2 Usability and Security
INFO2222 Overview
- University of Sydney
- S1 2027
- 12 chapters
- Computer Science
INFO2222 Computing 2 Usability and Security is the University of Sydney's second-year, 6-credit-point unit in the School of Computer Science, and it is deliberately built from two connected halves taught by two examiners.
- Assessed by In-class quiz — Week 2 (early feedback) 0% · Weekly in-class quizzes — Usability (Weeks 3-6) 4% + 5 more
- Key terms Usability goals (the six), User-Centred Design (UCD), CIA triad, Kerckhoff's principle
- How to prepare Treat INFO2222 as two linked subjects rather than one reading unit, and rehearse both every week instead of cramming through STUVAC.
- Most asked Where can I find past exam papers / practice for INFO2222?
How INFO2222 is assessed
| Component | Weight | Format |
|---|---|---|
| In-class quiz — Week 2 (early feedback) | 0% | In-lecture quiz on Weeks 1-2 content |
| Weekly in-class quizzes — Usability (Weeks 3-6) | 4% | In-lecture quizzes; best 2 of 4 count at 2% each |
| Weekly in-class quizzes — Security (Weeks 7-12) | 6% | In-lecture quizzes; best 3 of 6 count at 2% each |
| Project Phase 1 | 5% | Written group-project proposal (due Week 3) |
| Project Phase 2 | 10% (7% + 3%) | Progress report & designs (7%) + tutorial demo/presentation (3%), due Week 6 |
| Project Phase 3 | 25% (15% + 10%) | Final report, source code & designs (15%) + video/tutorial demo & presentation (10%), due Week 11 |
| Final Exam | 50% | Supervised 80-minute closed-book BYOD Canvas quiz, formal exam period |
What INFO2222 covers
INFO2222 runs as two connected halves: Weeks 1-5 build human-computer interaction (usability goals, user-centred design, prototyping, evaluation and human factors), while Weeks 6-12 build computer security and cryptography (symmetric and public-key crypto, authentication, network and software/web security, and professional ethics and privacy).
Every week feeds the final exam, which is worth 50% and tests both halves as 40 multiple-answer questions with negative marking. Continuous in-class quizzes (best 5 of 10 = 10%) and a 40% team project round out the assessment.
Usability and Security: The Two Pillars
usability goals · threat & system model · (Week 1)Week 1 frames the whole unit: professional computing systems must be both usable and secure, and the two goals can pull against each other.
- User interface, usability (Nielsen) and HCI as the field; why a bad UI is costly (Three Mile Island indicator lesson)
- Good vs poor design and affordances — the 'Norman Door' as a canonical bad-signifier example
- The six usability goals: effectiveness, efficiency, safety, utility, learnability, memorability — and that they trade off
- User experience (UX) as the felt quality of use, distinct from (but overlapping) usability
- User-Centred Design at a glance: Requirements → Design → Prototyping → Evaluation, iterating with the user central
- The CIA triad — confidentiality, integrity, availability — as the core security properties
User Experience and User-Centred Design
UX vs usability · UCD principles · requirements · (Week 2)Week 2 distinguishes usability from the broader user experience and teaches User-Centred Design (UCD) as the core method, together with how to gather requirements.
- Usability vs user experience (UX): measurable ease of use vs the subjective felt quality of the whole experience
- User-Centred Design cycle: Requirements → Design alternatives → Prototyping (lo-fi/hi-fi) → Evaluation, iterating with the user central
- Gould & Lewis (1985) UCD principles: early focus on users and tasks; empirical measurement; iterative design
- Why involve users: good functionality, realistic expectation management, and a sense of ownership that aids adoption
- Kinds of requirement: functional, data, environmental (context of use), user (profile), and usability/UX
- User stories: 'As a <role>, I want <behaviour> so that <benefit>'; getting requirements right early is cheapest
Design and Prototyping
low- vs high-fidelity prototypes · design process · (Week 3)Week 3 turns design ideas into testable artefacts: personas and scenarios bring requirements to life, and prototypes let stakeholders interact with a design before it is built.
- Personas (fictional but realistic target users) and scenarios (informal narratives in the user's own vocabulary)
- Two aspects of design: conceptual design (the idea, metaphors, interaction types) vs concrete/physical design (the details)
- Interface metaphors (e.g. the desktop) — advantages (easier to learn) and disadvantages (constrain the design)
- Interaction styles: instructing, conversing, manipulating, exploring, responding — chosen per task
- What a prototype is and why prototype: early feedback, team communication, feasibility, cheap change, reflection
- Fidelity: low-fidelity (paper, Wizard-of-Oz — quick, cheap, changeable) vs high-fidelity (near-final, interactive, slower to change)
Usability Evaluation
testing vs inspection · heuristics · analytics · (Week 4)Week 4 teaches how to check that a design works: evaluating with users (usability testing, controlled experiments, field studies) versus without users (analytical methods — inspection, heuristic evaluation, walkthroughs, analytics).
- Three broad evaluation categories: controlled-with-users (testing/experiments), natural-with-users (field studies), without-users (analytical)
- Analytical methods without users: inspection, heuristic evaluation, walkthroughs, models and analytics
- Evaluation process: determine goals → explore questions → choose approach/methods → evaluate, interpret, present
- Quality criteria: reliability, validity, biases, scope, ethics — and internal vs external validity trade-off
- Experiment design: hypotheses (null H0 vs alternative H1), and the four variable roles
- Independent variable (manipulated, ≥2 levels), dependent variable (measured), control variable (held constant), random variable (allowed to vary)
Human Factors and Accessibility
perception · memory · Fitts' law · inclusive design · (Week 5)Week 5 covers the human capabilities that constrain interface design — perception, memory and motor performance — plus accessibility and inclusive design, and closes the usability half by linking it to security.
- Cognition and attention: making information salient (colour, grouping, spacing) and avoiding clutter
- Perception: foveal (central, in-focus) vs peripheral (blurred, motion-sensitive) vision; pre-attentive 'pop-out' vs attentive serial search
- Memory: recognition is easier than recall — prefer menus/icons over recalled commands; reduce cognitive load
- Fitts' law as a CONCEPT: pointing time falls as targets get larger and closer; edges/corners act as large targets (equation not examined)
- Weber's law: the just-noticeable change is a constant ratio of the baseline stimulus (feedback must scale with baseline)
- Accessibility and colour: ~8% of males and ~0.5% of females are colour-blind — never encode meaning by colour alone
Cryptography Basics and Symmetric Crypto
Kerckhoff · hashing · block/stream ciphers · MAC · AE · (Week 6)Week 6 opens the security half with cryptographic foundations: Kerckhoff's principle, hashing and its properties, and symmetric encryption with its block/stream ciphers, modes, MACs and authenticated encryption.
- Security as science not art: state the exact strength, system model and threat model; the wooden-barrel weakest-link principle
- Kerckhoff's principle vs security through obscurity — secrecy belongs in the key, not the algorithm
- Randomness and entropy: keys need uniform, high-entropy, cryptographically secure randomness (CSPRNG, not Math.random)
- Hash functions and their properties: deterministic, avalanche effect, one-wayness (pre-image), second-pre-image and collision resistance
- Hash applications: password storage with salt, message integrity, proof-of-work; MD5/SHA-1 broken for collision resistance
- Symmetric encryption syntax: K-Gen, C = Enc(K, M), M = Dec(K, C); block ciphers (AES) vs stream ciphers (ChaCha20)
Public-Key Cryptography
PKE · digital signatures · Diffie-Hellman · (Week 7)Week 7 introduces asymmetric cryptography and why it solves the key-distribution problem: public-key encryption, digital signatures, and Diffie-Hellman key exchange, all resting on the hardness of problems like the discrete logarithm.
- Why public-key crypto: the key-distribution problem — symmetric schemes need a shared secret per pair, hard to distribute
- Public-key encryption (PKE): encrypt with the public key pk, decrypt with the private key sk; anyone can encrypt, only sk holder reads
- Digital signatures: sign with sk, verify with pk — providing authenticity and integrity (the mirror of PKE)
- Diffie-Hellman key exchange: public g and prime p; each side derives K = g^(ab) mod p without transmitting the secret
- The Discrete Logarithm Problem: g^x mod p is easy forward, believed hard to reverse — the basis of DH security
- Key agreement (DH, both contribute) vs key transport (PKE, one party picks and encrypts the key); RSA and ECDH
Identification and Authentication
factors · passwords · MFA · attacks & defences · (Weeks 7-8)Weeks 7-8 separate identification ('who are you?') from authentication ('prove it'), teach the factor families and multi-factor authentication, and cover how passwords are attacked and defended.
- Identification vs authentication: a claimed identity (unique, recognisable, persistent) vs verifying that claim
- Authentication requirements: proof of identity, binding, resistance to spoofing, timeliness, and privacy
- The three factors — something you know (password/PIN), have (token/phone), are (biometric) — and multi-factor authentication (MFA)
- Online attacks (guessing/brute force against the live system) vs offline attacks (attacker holds the hash)
- Offline attack tooling: dictionary attacks, lookup tables, and rainbow tables (hash chains storing only start and end)
- Salt (unique per user, defeats precomputation) and pepper (a secret kept off the database)
Network Security: TCP/IP and TLS
IP/TCP · three-way handshake · HTTPS = HTTP + TLS · (Weeks 8-9)Weeks 8-9 build secure communication over an unreliable network: IP packets and TCP's reliable delivery via the three-way handshake, then HTTPS = HTTP + TLS and the confidentiality, integrity and server authentication it delivers.
- IP delivers addressed packets that may arrive out of order, corrupted or lost; UDP is lightweight and unreliable
- TCP gives reliable, ordered, error-checked delivery: sequence and acknowledgement numbers, flags, window size, retransmission
- The three-way handshake (SYN / SYN-ACK / ACK) establishing sequence numbers, and the four-way close (FIN/ACK/FIN/ACK)
- SYN flooding: many half-open connections fill the SYN queue and block legitimate clients (a classic DoS)
- HTTPS = HTTP over TLS, delivering confidentiality (encryption), integrity, and server authentication via certificates
- TLS handshake phases (hello/randoms/cipher suite → certificate/key exchange → client key exchange → change-cipher/finished)
Software and System Security
memory-corruption bugs · static vs dynamic analysis · (Weeks 9-10)Weeks 9-10 explain how software defects become vulnerabilities and how program analysis finds them: static analysis (without running the code), dynamic analysis (running and observing it), and symbolic analysis (exploring paths with a solver).
- Memory-corruption bugs (use-after-free, memory leaks) and why manual testing misses subtle defects
- Static analysis: reason about code without running it via the AST, control-flow graph (CFG) and data-flow analysis
- What static analysis catches (unused imports/variables, potential division-by-zero, obvious logic bugs) and misses (runtime-only issues)
- Dynamic analysis: run the code with instrumentation (sanitizers, fuzzers) to find memory leaks, crashes and runtime errors
- Dynamic analysis needs an oracle (a definition of 'wrong') and good test inputs, and may still miss cases
- Symbolic analysis: treat inputs as symbolic, collect path constraints, and use an SMT solver (e.g. Z3) to find satisfying inputs
Web Application Security
XSS · SQL injection · symbolic execution · sanitisation · (Week 11)Week 11 covers the classic web-application vulnerability classes and their defences: cross-site scripting (XSS), SQL injection, and inference attacks, all rooted in trusting user input.
- The shared root cause: never trust user input — validate and sanitise it, and encode output
- SQL injection: input concatenated into a query (e.g. alice' OR '1'='1) makes the WHERE clause always true → auth bypass
- SQL-injection defences: parameterised/prepared statements (never string concatenation) plus input validation
- Inference attacks: learning hidden data using only allowed queries (e.g. binary-searching a salary threshold)
- Cross-site scripting (XSS): injecting JavaScript that runs in other users' browsers (defacement, cookie/session hijacking)
- Reflected vs stored (persistent) XSS: a stored payload is saved and re-served to every viewer
Ethics, Privacy and Professional Responsibility
ACS Code of Ethics · Privacy Act & APPs · GDPR/CCPA · exam revision · (Week 12)Week 12 closes the unit with the professional and legal frame: the ACS Code of Ethics and how to reason about ethical dilemmas, and data-privacy law from the Australian Privacy Act 1988 to GDPR, CCPA and the UK DPA.
- Ethics as a framework for right/wrong when the choice is not obvious; IT ethics and responsible decision-making
- Ethical dilemmas in emerging tech (autonomous-vehicle / trolley scenarios); responsibility shared across the whole pipeline
- The ACS Code of Ethics — six core values, from the primacy of the public interest to professionalism
- Data privacy as controls on access, use, processing and storage, spanning legal, technical and social dimensions
- Australian Privacy Act 1988: 13 Australian Privacy Principles (APPs), applying to APP entities (turnover > $3M)
- The Privacy and Other Legislation Amendment Act 2024: doxxing offence, automated-decision transparency, a statutory tort
Weeks 1-5 are human-computer interaction and usability — the six usability goals (effectiveness, efficiency, safety, utility, learnability, memorability), user experience, user-centred design, prototyping, usability evaluation and the human factors (perception, memory, Fitts' law, accessibility) that constrain any interface.
Weeks 6-12 are computer security and cryptography — Kerckhoff's principle and hashing, symmetric and public-key cryptography, Diffie-Hellman key exchange, identification and authentication, TCP/IP and TLS, software and web security (XSS, SQL injection, static/dynamic/symbolic analysis), and the professional and legal frame of IT ethics and data-privacy law.
The whole unit of study feeds the final exam, which is worth 50%: a supervised 80-minute (plus 10 minutes reading) closed-book bring-your-own-device Canvas quiz of 40 multiple-answer questions totalling 100 marks (30 questions at 2 marks and 10 at 4 marks), with negative marking, sat in the formal examination period.
Continuous assessment is a set of in-class quizzes worth 10% (only your best 5 of 10 count, at 2% each) and a three-phase group project worth 40% (Phase 1 5%, Phase 2 10%, Phase 3 25%). Two hurdles govern the unit: you must score at least 40% on the final exam and reach an overall mark of at least 50 to pass, and each project has a report hurdle.
Confirm every weight, hurdle and permitted-materials detail on Canvas and the USyd unit outline, since exact dates shift each year; a steady semester here also protects the Weighted Average Mark (WAM) that later computer-science units build on.
Worked example · free
Diffie-Hellman: two parties agree a key over a public channel
- +1Alice's public value A = g^a mod p = 5^8 mod 23. Use exponentiation by squaring: 5^2 = 25 ≡ 2, 5^4 ≡ 2^2 = 4, 5^8 ≡ 4^2 = 16. So A = 16 — this is what Alice sends over the public channel.
- +1Bob's public value B = g^b mod p = 5^5 mod 23 = 5^4 · 5 ≡ 4 · 5 = 20. So B = 20 — this is what Bob sends. Note that a and b themselves are never transmitted; only A and B travel over the wire.
- +1Each party raises the value it RECEIVED to its own secret. Alice computes K = B^a mod p = 20^8 mod 23. Since 20 ≡ −3 (mod 23), 20^8 ≡ (−3)^8 = 3^8; and 3^2 = 9, 3^4 ≡ 12, 3^8 ≡ 12^2 = 144 ≡ 6. So Alice gets K = 6.
- +1Bob independently computes K = A^b mod p = 16^5 mod 23. 16^2 = 256 ≡ 3, 16^4 ≡ 3^2 = 9, 16^5 ≡ 9 · 16 = 144 ≡ 6 — the same K = 6 = g^(ab) mod 23. An eavesdropper sees g, p, A = 16 and B = 20 but would have to recover a from A = g^a mod p, which is the Discrete Logarithm Problem — easy to compute forward, believed hard to reverse for a large prime, and the whole basis of the scheme's security.
Key terms
- Usability goals (the six)
- The measurable qualities that make an interface good to use: effectiveness (does what it should), efficiency (supports the task well), safety (protects the user from dangerous or unwanted states), utility (offers the right functionality), learnability (easy to learn) and memorability (easy to remember once learned). Not all can be maximised at once — designers trade them off.
- User-Centred Design (UCD)
- A design approach that places the user at the centre of every activity. Its three Gould & Lewis (1985) principles are an early focus on users and tasks, empirical measurement of real users with prototypes, and iterative design. The cycle runs Requirements → Design alternatives → Prototyping (lo-fi/hi-fi) → Evaluation, looping back.
- CIA triad
- The three core security properties. Confidentiality — data is accessible only to authorised parties; Integrity — data cannot be altered undetected; Availability — the system stays usable by legitimate users. Cryptography adds authentication and non-repudiation on top.
- Kerckhoff's principle
- A system's security should rest on the secrecy of the key alone, not on the design staying hidden. Algorithms should be public and openly reviewed; only the key is secret. The opposite — hoping attackers never learn the mechanism — is 'security through obscurity' and is unsafe.
- Diffie-Hellman key exchange
- A protocol letting two parties agree a shared secret over a public channel. With public g and prime p, Alice sends A = g^a mod p and Bob sends B = g^b mod p; each derives K = g^(ab) mod p by raising the received value to its own secret. Security rests on the hardness of the Discrete Logarithm Problem; the secret is never transmitted.
- SQL injection
- A web attack where malicious SQL is inserted through user input that is concatenated straight into a query — e.g. entering alice' OR '1'='1 makes the WHERE clause always true and bypasses login. Defended with parameterised (prepared) statements and input validation/sanitisation, never string concatenation.
INFO2222 FAQ
Is INFO2222 hard?
It is broad rather than deeply mathematical. The unit deliberately spans two very different halves — human-computer interaction and usability in Weeks 1-5, then computer security and cryptography in Weeks 6-12 — each taught by a different examiner, so the real challenge is keeping a lot of concepts, methods and mechanisms straight rather than mastering one hard idea.
The teaching team states the exam will not ask you to write out equations (Fitts' law), calculate statistics or recall specific numbers, so marks go to understanding why a method or control matters, its advantages and disadvantages, and applying it in a scenario. The crypto side involves light modular-arithmetic notation (C = Enc(K, M), K = g^(ab) mod p) but no heavy derivations.
Students who keep up with the weekly in-class quizzes and the group project rather than cramming through STUVAC tend to find it manageable, and steady work protects the WAM.
Can AI help me with INFO2222?
Yes, as a step-by-step study aid. Sia is an AI tutor built to mirror how INFO2222 is actually taught and assessed at the University of Sydney: it can walk you through a Diffie-Hellman shared-key computation, explain why only the space of unique salts defeats a rainbow table, trace an SQL-injection payload, or contrast static, dynamic and symbolic analysis one step at a time, and it checks your reasoning as you go.
Bring your own tutorial or practice question and ask Sia to explain each step. It does not do graded assessment for you — no quiz answers, no project work — and the University of Sydney academic-integrity policy still applies. Use it to understand the method, not to produce work you submit.
Where can I find past exam papers / practice for INFO2222?
Start on Canvas, where the unit posts its revision material, the Week 12 exam Q&A session and any practice quizzes that mirror the multiple-answer format, and search the University of Sydney Library's past-exam-paper collection for any released papers. Because the final is a bring-your-own-device Canvas quiz, the weekly in-class quizzes are the closest match to its style and are worth rehearsing.
This guide also includes a re-authored practice exam that mirrors the paper's shape — usability method selection, cryptography, authentication and software-security items — with fresh numbers, and you can ask Sia to generate extra practice in the same style and explain each step. Treat any third-party 'model answers' with caution and confirm what is officially provided on Canvas.
What are the INFO2222 hurdles and assessment rules?
There are two exam-related conditions to pass the unit: you must score at least 40% on the final exam AND achieve an overall mark of at least 50; failing either can cap your final mark at 45 under School of Computer Science policy. The group project adds report hurdles — Phase 2 requires at least 40% on the progress report and Phase 3 at least 40% on the final report (the demo and presentation sub-parts are not the hurdle).
Only your best 5 of the 10 in-class quizzes count (best 2 of 4 usability quizzes plus best 3 of 6 security quizzes, 2% each = 10%); the Week 2 quiz is early feedback at 0%. Confirm the exact weights, hurdles and late-penalty rules on your Canvas Assessments page and the unit outline.
What is on the INFO2222 final exam?
One supervised 80-minute Canvas quiz (plus 10 minutes reading time), worth 50% and sat in the formal examination period. It is closed-book, but you may bring one double-sided A4 sheet of handwritten or typed notes with your SID.
The paper is 40 multiple-answer questions totalling 100 marks — 30 questions worth 2 marks (recall-oriented) and 10 worth 4 marks (apply/reflect) — and it uses negative marking, so blind guessing is penalised, especially on the 4-mark items.
Expect a roughly even spread across both halves: usability goals, UCD, prototyping, evaluation-method selection and human factors from Weeks 1-5, then cryptography, authentication, TLS, software/web security and IT ethics from Weeks 6-12. The revision guidance is to reason and apply rather than memorise numbers.
The exam sits in the University of Sydney Semester 1, 2027 formal exam period (around June 2027) — confirm the exact date, time and permitted materials on Canvas and the USyd exam timetable.
Questions students ask in each INFO2222 chapter
- Why does INFO2222 teach usability and security together?
- Because real systems must be both, and the goals often conflict — a heavily locked-down interface can become unusable, while a friendly one can invite mistakes. The unit's running example is that a secure system must not let a misleading UI cause a person to authorise something harmful (the Bybit incident, where approvers trusted a UI display instead of verifying what they were signing). Learning both halves lets you reason about the trade-off rather than optimising one pillar and breaking the other. Chapter 01 · Usability and Security: The Two Pillars
- What is the difference between usability and user experience?
- Usability is about whether an interface is effective and efficient to use — measurable qualities like task time or error rate. User experience is the subjective, felt side: whether the product is enjoyable, engaging, satisfying, or on the negative side frustrating or patronising. A product can be usable but unpleasant, or delightful but hard to use; good design attends to both. This distinction is a common early-quiz item. Chapter 02 · User Experience and User-Centred Design
- When should I use a low-fidelity versus a high-fidelity prototype?
- Use low-fidelity early, when many questions are open: paper sketches and wireframes are cheap and fast to change, so you can explore and discard alternatives quickly and still get real user feedback. Move to high-fidelity as the open questions shrink and you need to test interaction detail or technical feasibility. High-fidelity is more resource-intensive and slower to modify, and there is a risk that users and management treat it as finished and are reluctant to criticise it. Chapter 03 · Design and Prototyping
- How do I choose an evaluation method?
- Work from the taxonomy and your constraints. If you can involve users in a controlled setting, use usability testing or a controlled experiment; if you want real-world behaviour, run a field study in natural settings; if you cannot recruit users, use analytical methods (inspection, heuristic evaluation, walkthroughs, models/analytics). Then weigh reliability, validity (internal vs external), bias, scope and ethics. Early lo-fi designs favour cheap inspection or think-aloud; near-final products favour comparative usability tests. Chapter 04 · Usability Evaluation
- Do I need to memorise the Fitts' law equation or receptor frequencies?
- No. The revision material is explicit that you will not be asked to write the Fitts' law equation, calculate statistics, or recall specific numbers, angles or frequencies (such as mechanoreceptor ranges). What you do need is the concepts and their design implications — larger, closer targets are faster; recognition beats recall; feedback should scale with the baseline stimulus (Weber's law). Confirm the exact scope in the Week 12 revision on Canvas. Chapter 05 · Human Factors and Accessibility
- Why must encryption keys be uniformly random and high-entropy?
- Because an attacker's job is to guess the key, and any bias or pattern shrinks the search. Uniform means no outcome is more likely than another; high-entropy means many possibilities (128 bits gives 2^128 options, whereas a 6-digit PIN is only about 20 bits and brute-forceable). The randomness must also be cryptographically secure — from a CSPRNG such as crypto.randomBytes() or /dev/urandom, never Math.random() or a timestamp, which are predictable given the seed. Chapter 06 · Cryptography Basics and Symmetric Crypto
- Why do we need public-key cryptography at all?
- Symmetric encryption and MACs require both parties to already share the same secret key, fully protected — but distributing that key, and managing a distinct key for every conversation pair, is a hard problem. Public-key cryptography solves it: you can publish an encryption (public) key so anyone can send you confidential messages, or use Diffie-Hellman so two parties derive a shared secret over an open channel without ever transmitting it. Chapter 07 · Public-Key Cryptography
- What is the difference between identification and authentication?
- Identification is the claim — you assert who you are, e.g. by entering a username, which must be unique, recognisable and persistent. Authentication is the proof — the system verifies the claim, needing proof of identity (something you know/have/are), a secure binding of that proof to the identity, resistance to spoofing, timeliness (recent or session-based), and privacy. Getting authentication right grants the corresponding privilege. Chapter 08 · Identification and Authentication
- How does TCP guarantee ordered, reliable delivery over IP?
- IP alone can lose, duplicate, corrupt or reorder packets. TCP numbers every byte with a sequence number and has the receiver acknowledge the next byte it expects, so the sender knows exactly what arrived and can retransmit anything missing. Out-of-order packets are reassembled by sequence number, corruption is caught by a checksum, and a window controls how much may be in flight before an acknowledgement is required. Chapter 09 · Network Security: TCP/IP and TLS
- When should I use static, dynamic or symbolic analysis?
- Use static analysis for structural and path-visible issues you can find without running the code — unused imports, obvious logic errors, potential division-by-zero — because it is fast and cheap. Use dynamic analysis for defects that only appear at runtime, such as memory leaks and crashes, by executing with instrumentation, but remember it needs good test inputs and an oracle. Use symbolic analysis when you need to reach a specific deep branch or prove a property: it collects path constraints and asks a solver for a witness input, at higher cost. Chapter 10 · Software and System Security
- Why do SQL injection and XSS share the same root cause?
- Both arise from trusting user input and letting it change how something is interpreted. In SQL injection, concatenated input becomes part of the query's structure; in XSS, unescaped input becomes executable markup in a page. The unifying principle is 'don't trust user input': validate it (expect data, not code) and, on output, either bind it as a parameter (SQL) or encode it to inert entities (HTML). Chapter 11 · Web Application Security
- What are the ACS Code of Ethics core values?
- There are six: the Primacy of the Public Interest (public good above personal or business interest), the Enhancement of Quality of Life (improve life for those affected by your work), Honesty (be truthful about your skills, services and products), Competence (work competently and diligently), Professional Development (grow your own and others' competence), and Professionalism (uphold and advance the profession's honour and integrity). Exam items usually describe a situation and ask which single value applies. Chapter 12 · Ethics, Privacy and Professional Responsibility
How to study for the exam
Treat INFO2222 as two linked subjects rather than one reading unit, and rehearse both every week instead of cramming through STUVAC.
For the Weeks 1-5 usability half, learn to apply and select rather than recite: be able to name the six usability goals, choose an evaluation method for a given constraint (with users vs without users; controlled vs natural vs analytical), justify a prototyping-fidelity choice, and reason qualitatively about Fitts' law and accessibility without writing any equation — the exam explicitly rewards understanding over recall.
For the Weeks 6-12 security half, drill the small mechanisms until they are automatic: a Diffie-Hellman shared-key computation, why a unique per-user salt forces per-user work on an attacker, the difference between the hash properties (pre-image, second-pre-image, collision resistance), the TLS and TCP handshakes in order, and how an SQL-injection or XSS payload works and is defended.
Because the final is 40 multiple-answer questions with negative marking, practise deciding when you actually know an option versus when you are guessing — on the 4-mark questions a wrong guess costs you. Build a one-page map linking each week to its examinable ideas and use it as your permitted A4 note sheet.
Keep up with the weekly in-class quizzes (best 5 of 10) and the three project phases, since the report hurdles and the exam hurdle both gate the unit. When a concept won't click, ask Sia to explain that single step a different way and set you a fresh practice question in the same style; it teaches the method and checks your reasoning, and never substitutes for your own graded work.
Confirm the exam date, permitted materials and hurdle rules on Canvas and the University of Sydney exam timetable.
Your AI Computer Science tutor for INFO2222
Stuck on a hard INFO2222 question? Sia is AskSia’s AI Computer Science tutor — ask any INFO2222 Computing 2 Usability and Security question and get a clear, step-by-step explanation grounded in how the course is actually taught and assessed. Read this whole study guide free, then take your hardest questions to Sia.