BUILD REAL SYSTEMS.
& SOLVE REAL PROBLEMS.

By the end of this lesson you can define a computer system, identify its five components, and explain what your T1 SDLC analysis report must contain.

1. Open a new Google Doc titled T1 SDLC Analysis Report. Set up a cover page: your name, task title, subject, due date. This is your submission document for the next nine weeks.
2. A computer system has five components. Create a section called “System Components” and define each: Hardware (physical devices), Software (programs and OS), Data (raw facts processed into information), People (users and IT staff), Procedures (rules and processes governing system use).
3. Read the T1 scenario on Google Classroom fully. Identify: What organisation is described? What are the main problems with their current system? Which system components are mentioned?
4. Write a 3-4 sentence “Scenario Overview” paragraph in your own words. This becomes the opening section of your report.
5. Review the T1 rubric. List the four criteria you will be marked on. For each, write one sentence describing what A-standard work looks like.

By the end of this lesson you can name and describe all six SDLC stages and explain the difference between the SDLC and prototyping, including when each is appropriate.

1. Add an “SDLC Overview” section to your report. Define each of the six stages in 1-2 sentences: Preliminary Analysis - identify the problem and assess feasibility; Analysis - gather and document stakeholder requirements; Design - create blueprints (diagrams, specs); Development - build and code the system; Implementation - deploy and train users; Evaluation/Maintenance - assess performance and resolve issues.
2. Draw a flowchart or table showing the six stages in order. Note the cycle can loop - evaluation can feed back into a new analysis phase.
3. Prototyping is an alternative approach: a working model is built quickly and refined through user feedback before full documentation. Write two advantages and two disadvantages of prototyping compared to the SDLC.
4. Write a 3-sentence paragraph applying this to the T1 scenario: which approach suits the described organisation and why?
5. Identify which SDLC stage the T1 scenario is currently at and what the next stage would involve. Add this to your SDLC section.

By the end of this lesson you have built a Gantt chart for your T1 project plan that maps each SDLC stage to a realistic timeline and includes at least two milestones.

1. Define project management: planning, scheduling, budgeting, and tracking work to deliver a defined outcome within constraints (time, cost, quality). Add a “Project Management Plan” section to your report.
2. Create a Gantt chart in Google Sheets or draw.io: rows = SDLC stages, columns = weeks 1-9. Shade cells to show planned duration for each stage.
3. Add at least two milestones (e.g. “Context diagram complete W3”, “Hardware spec complete W5”). Milestones are zero-duration checkpoints marked on the chart.
4. Write a 2-sentence scope statement: what this project will and will not deliver.
5. Briefly explain (2-3 sentences) how a real project manager would track costs and progress against the plan. Reference the concepts of scope, budget, and milestones.

By the end of this lesson you can identify the three components of a Yourdon/DeMarco context diagram and explain the purpose of each symbol.

1. A context diagram shows a system at the highest level: the whole system as one process, external entities, and data flows. It does not show internal processes. Add a “Context Diagram” section to your report.
2. Yourdon/DeMarco uses three symbols. Draw and label each: Circle/Oval - the central process (the entire system, labelled with the system name); Rectangle - external entities (people, organisations, or other systems outside the system); Labelled Arrow - data flows (direction shows data movement; label names the data item).
3. Rules: data flows must be labelled; the central process is always a single circle; external entities are always rectangles; do not show any internal logic.
4. Practice: draw a context diagram for a library system. Entities: Borrower, Librarian, Book Supplier. Identify at least 4 labelled data flows.
5. Review the T1 scenario: identify the central process and list all external entities mentioned or implied. You will draw the actual T1 diagram in L5.

By the end of this lesson you have produced a complete, correctly notated context diagram for your T1 scenario using draw.io and embedded it into your report.

1. Open draw.io. New blank diagram. Use an oval for the central process, rectangles for entities, and arrows with text labels for data flows.
2. Place the central process oval in the centre. Label it with the system name from your T1 scenario (e.g. “Inventory Management System”).
3. Add each external entity as a labelled rectangle around the outside, based on your L4 entity list.
4. Draw data flows: for each entity, add arrows to/from the central circle. Label every arrow with the data item being transferred. Check direction - into the circle means data entering the system; out means data leaving.
5. Export as PNG and insert into your report document. Write a 2-3 sentence explanation below the diagram describing what it shows and how it maps to the scenario.

By the end of this lesson you can name and describe the function of each CPU component: ALU, Control Unit, registers (including the program counter), and system clock.

1. Add a “Hardware Specification” section to your report. Start with “CPU Components”. Define the CPU: the primary component that executes program instructions.
2. ALU (Arithmetic Logic Unit): performs all arithmetic (add, subtract, multiply, divide) and logical comparisons (AND, OR, NOT, greater than, equal to). Write 2 sentences.
3. Control Unit (CU): directs CPU operations; fetches instructions from memory, decodes them, and coordinates the ALU and other components. Write 2 sentences.
4. Registers: ultra-fast storage locations inside the CPU. The Program Counter (PC) holds the address of the next instruction to execute; the Accumulator temporarily holds ALU results. Define both.
5. System Clock: generates regular electrical pulses synchronising all CPU operations. Measured in GHz. Higher clock speed = more instructions per second. Write one sentence connecting clock speed to scenario performance requirements.

By the end of this lesson you can describe each step of the fetch-execute cycle in order and explain what happens to an instruction as it moves through the CPU.

1. Add a “Fetch-Execute Cycle” sub-section under your CPU content. The cycle repeats billions of times per second.
2. Fetch: The PC holds the address of the next instruction. This address is copied to the MAR (Memory Address Register). The instruction is fetched from RAM into the MDR (Memory Data Register), then copied to the CIR (Current Instruction Register). The PC increments to the next address.
3. Decode: The CU decodes the instruction in the CIR - determining what operation is needed and what data operands are involved.
4. Execute: The ALU performs the operation (if arithmetic/logical) or the CU directs data movement. The result is held in the Accumulator.
5. Draw a flowchart: Fetch → Decode → Execute, with an arrow looping back to Fetch. Add it to your report. Write one sentence explaining how clock speed affects the rate of this cycle.

By the end of this lesson you can convert between storage units and distinguish between primary and secondary storage, recommending appropriate types for a given scenario.

1. Add “Storage” to your Hardware Specification. Define the hierarchy: Bit (0 or 1) → Byte (8 bits) → KB (1,024 B) → MB (1,024 KB) → GB (1,024 MB) → TB (1,024 GB). Create a summary table.
2. Primary storage (directly accessed by CPU): RAM - volatile, temporary, holds running programs; ROM - non-volatile, holds firmware/BIOS. Write 2 sentences on each.
3. Secondary storage (persistent): HDD - magnetic, high capacity, slower; SSD - no moving parts, faster, more expensive per GB; USB drives; cloud storage. One advantage and one limitation for each.
4. Practice conversions (show working): How many KB in 2.5 MB? How many bytes in 4 GB? These can appear in T2.
5. For your T1 spec: recommend primary and secondary storage with capacity examples, justifying each choice with reference to the scenario (e.g. “16 GB RAM for multitasking; 1 TB SSD for fast OS load; 4 TB HDD for data backup”).

By the end of this lesson you can select and justify input, output, and processing hardware for a specific organisational scenario.

1. Add “Input & Output Hardware” to your spec. Define input devices and list at least 6 examples (keyboard, mouse, scanner, barcode reader, touchscreen, webcam, microphone).
2. Define output devices and list at least 5 examples (monitor, printer, speaker, projector, plotter). Note that some hardware is both input and output (touchscreen).
3. Processing hardware beyond the CPU: Motherboard (connects all components), GPU (graphics processing), NIC (network connectivity). One sentence on each.
4. Match hardware to your T1 scenario: for each I/O device you recommend, write one sentence explaining why it suits the described organisation. Reference specific tasks from the scenario.
5. Complete your Hardware Specification section. Confirm it covers: CPU components, storage, input, output, and processing hardware - all with scenario justification.

By the end of this lesson you can describe a structured troubleshooting process and explain the roles of preventative maintenance and a Standard Operating Environment.

1. The three troubleshooting steps. Add a “Troubleshooting” note to your report: 1. Diagnose - identify and define the problem; gather information (error messages, recent changes, affected users); narrow down causes. 2. Implement - apply a solution; test the fix; confirm the problem is resolved. 3. Document - record the problem, cause, solution, and time taken.
2. Apply all three steps to a realistic scenario from the T1 industry context (e.g. a printer not connecting to the network).
3. Preventative maintenance: list and describe three examples (e.g. regular OS updates, scheduled virus scans, hardware cleaning).
4. SOE (Standard Operating Environment): a consistent configuration applied to all computers in an organisation. Benefits: consistent support, simpler troubleshooting, reduced compatibility issues. Write 2 sentences explaining its value in the T1 scenario.
5. Add 2-3 sentences to your report’s evaluation section assessing whether the existing system appears to follow structured troubleshooting procedures.

By the end of this lesson you can describe the purpose of an ICT code of conduct, identify ethical and privacy issues in ICT systems, and explain expected behaviour in digital communications.

1. ICT Code of Conduct: a set of rules governing acceptable use of ICT resources. Typically covers: authorised use of hardware/software, personal use limits, copyright compliance, cybersecurity obligations, and breach consequences. Write a definition and list three rules for a workplace code of conduct.
2. Ethics in ICT: for each scenario, identify the ethical principle violated (honesty, privacy, fairness, or responsibility): (a) installing unlicensed software on a work computer; (b) accessing another user’s files without permission; (c) sending misleading information by email.
3. Privacy Act 1988: individuals have the right to control personal information about themselves. Organisations must follow privacy principles when collecting, storing, using, and disclosing personal data. Write 2 sentences applying this to the T1 scenario.
4. Digital etiquette: professional standards for email, chat, and online communication. Write three workplace etiquette rules.
5. For your T1 evaluation: write 2-3 sentences assessing whether the existing system adequately addresses ethics and privacy. Reference at least one specific concern from the scenario.

By the end of this lesson all four T1 sections are drafted and you have received teacher feedback on your context diagram.

1. Open your T1 report. Confirm all four sections exist: Context Diagram (draw.io image embedded), Hardware Specification (CPU + storage + I/O), Project Plan (Gantt chart + scope statement), Evaluation (written paragraphs, not dot points).
2. Review the rubric. For each criterion, annotate your draft with your estimated grade level and what is missing to move up one level.
3. Share your doc with your teacher and request feedback on your context diagram - the highest-value criterion (/15). Act on feedback before Week 8.
4. Ensure your evaluation is written in full sentences and directly references the scenario. Address: data management weaknesses, ethics/privacy concerns, and at least one improvement recommendation.
5. Submission checklist before due date (W9): all sections complete, diagram exported correctly, no placeholder text, cover page included, document formatted professionally.

By the end of this lesson you can name all six SDLC stages, describe what happens at each, and identify the correct stage when given a scenario description.

1. Create a T2 revision document. Add a three-column table: Stage Name - What Happens - Who is Involved. Complete for all six stages: Preliminary Analysis, Analysis, Design, Development, Implementation, Evaluation/Maintenance.
2. Identify the SDLC stage for each description: (a) “The IT team is writing code for the new database.” (b) “Stakeholders are interviewed about system requirements.” (c) “The manager decides whether a new system is worth building.” (d) “Staff are trained and the new system goes live.”
3. Write a 3-sentence paragraph contrasting SDLC with prototyping: what prototyping is, when you would choose it, and one disadvantage of prototyping.
4. Self-quiz: cover the “What Happens” column and write stage descriptions from memory. Check your accuracy.
5. Note your weakest stage descriptions. These are your priority for upcoming lessons.

By the end of this lesson you can define project management key terms and answer short answer questions about Gantt charts, scope, and milestones.

1. Add a “Project Management Terms” section to your revision doc. Define: Scope (what the project will and will not deliver), Milestone (a zero-duration checkpoint marking phase completion), Gantt chart (a bar chart mapping tasks against a timeline), Constraint (a limitation on time, budget, or resources).
2. Practice: “Identify two benefits of using a Gantt chart to manage a software development project.” Write a model answer (2-3 sentences per benefit).
3. Practice: “Explain the term ‘scope’ and describe one consequence of scope creep.” Write your answer in 3-4 sentences.
4. Read a sample Gantt chart. Identify: which tasks overlap, which is longest, where milestones are placed.
5. Add three PM questions to your practice test pile for L11.

By the end of this lesson you can classify hardware components by function and describe each component in context.

1. Create a four-column table: Input / Processing / Output / Storage. Add at least 5 components per column. Include any component that fits two categories (e.g. touchscreen) and explain why.
2. Practice: “A school office manages student records. Identify one input device, one output device, and one storage device. Justify each.” Write a full answer.
3. Processing: describe CPU, GPU, and motherboard roles in one sentence each.
4. Practice: “Explain the difference between primary and secondary storage, giving one example of each.” Write a 4-sentence answer.
5. Self-check: without notes, write 5 input devices, 3 processing components, 4 output devices, and 4 storage types from memory.

By the end of this lesson you can write a detailed description of each CPU component from memory and answer test-style questions about CPU functions.

1. Add a “CPU Components” section to your revision doc. For each component include name, function, and one specific detail: ALU (arithmetic + logical ops; logical ops include <, >, =); Control Unit (directs operations; fetches, decodes, coordinates); Registers (ultra-fast temporary CPU storage); Program Counter (holds address of next instruction; increments after each fetch); System Clock (synchronises operations; measured in GHz).
2. Practice: “Describe the role of the Control Unit in a CPU.” Write a 3-sentence answer without notes.
3. Practice: “What is the Program Counter and what happens to its value after each instruction is fetched?” Write a 2-sentence answer.
4. Draw a simple CPU diagram: ALU, CU, and registers inside a box, with arrows showing data flow between components and to/from RAM.
5. Set a 3-minute timer: write everything you know about CPU components without notes. Check accuracy. Repeat tomorrow.

By the end of this lesson you can walk through the fetch-execute cycle step by step for a given instruction, naming the register used at each stage.

1. Write the cycle as a numbered sequence with registers: (1) PC holds next instruction address → copied to MAR; (2) Instruction fetched from RAM at MAR address → loaded into MDR → copied to CIR; (3) PC increments; (4) CU decodes instruction in CIR; (5) ALU or CU executes; (6) Result stored in accumulator or back to RAM.
2. Worked example: the instruction at address 200 is “ADD 5 to the accumulator”. Walk through every step naming each register’s state.
3. Practice: “Describe the fetch stage of the fetch-execute cycle. Name two registers involved.” Write a 4-sentence answer.
4. Practice: “What is the role of the Program Counter and what happens to its value after each fetch?” Write a 3-sentence answer.
5. Draw the cycle: Fetch → Decode → Execute → (loop back). Add to your revision notes as a visual summary.

By the end of this lesson you can describe the boot process from power-on to OS ready, distinguish cold boot from warm boot, and explain the purpose of an SOE.

1. Define: Cold boot - starting from a fully powered-off state; Warm boot (restart) - restarting without full power-off.
2. Cold boot sequence: (1) Power supplied to motherboard; (2) BIOS/UEFI runs POST (Power-On Self Test - checks hardware for faults); (3) BIOS locates the boot device (HDD/SSD); (4) Boot loader loaded; (5) OS kernel loads into RAM; (6) OS initialises drivers and services; (7) Login screen appears. Write this as a numbered list.
3. BIOS: firmware stored in ROM on the motherboard that initialises hardware and starts the boot process. UEFI is the modern replacement - faster and graphical. Define both in one sentence each.
4. SOE: a consistent software and hardware configuration across all computers in an organisation. Benefits: uniform support, simplified troubleshooting, licence compliance, security consistency. Write 2 sentences on why an SOE benefits a school IT department.
5. Practice: “Explain the purpose of POST and describe what happens if it detects a hardware fault.” Write a 3-sentence answer.

By the end of this lesson you can convert between storage units accurately and select the most appropriate storage type for a described scenario.

1. Write the conversion factors: 8 bits = 1 byte; 1,024 bytes = 1 KB; 1,024 KB = 1 MB; 1,024 MB = 1 GB; 1,024 GB = 1 TB. Use binary (computer science) units - not 1,000 (SI/marketing).
2. Practice conversions (show working): (a) How many bytes in 3.5 KB? (b) How many MB in 2 GB? (c) A file is 524,288 bytes - how many KB? How many MB? (d) A drive holds 2 TB - how many GB?
3. Storage selection: for each scenario, recommend RAM size, primary storage type/size, and secondary storage type/size: (a) graphic designer editing video; (b) school office managing a student database; (c) retail store running point-of-sale software.
4. Practice: “A student claims a 1 GB USB holds 1,000 MB. Evaluate this claim.” Write a 2-sentence answer referencing binary vs SI units.
5. Add 3 storage conversion questions to your practice test pile for L11.

By the end of this lesson you can apply the three-step troubleshooting process to a described ICT problem and explain two preventative maintenance strategies.

1. Review the three steps: Diagnose → Implement → Document. One sentence on what a technician does at each stage.
2. Worked example 1: “A user cannot connect to the internet.” Diagnose (check cable, test another device, check network settings, determine if issue is device-specific or network-wide), Implement (restart router, replace cable, update NIC driver), Document (log fault, cause, solution, time taken).
3. Worked example 2: “A networked printer is not printing for any users.” Apply all three steps.
4. Preventative maintenance: describe five tasks: (a) regular OS and software updates; (b) scheduled virus/malware scans; (c) disk defragmentation (HDD only); (d) regular data backups; (e) physical hardware cleaning.
5. Practice: “Describe the three steps of structured troubleshooting and explain why documentation is important.” Write a 6-sentence answer.

By the end of this lesson you can apply ICT ethics and privacy concepts to scenario-based questions and explain the purpose of a workplace ICT code of conduct.

1. Write a definition of an ICT Code of Conduct and list four rules typically included.
2. Ethics scenario practice: for each, identify the ethical issue and explain what should have happened: (a) An employee downloads pirated software on a work computer. (b) A student sends an angry email using the school system. (c) A DBA reads customer records out of curiosity.
3. Privacy Act 1988: organisations collecting personal data have legal obligations. Write 2 sentences on what an organisation must do when collecting customer data.
4. Practice: “Describe two email etiquette rules and explain why each matters.” Write a 4-sentence answer.
5. Add two ethics/privacy questions to your practice test pile for L11.

By the end of this lesson you can structure theory test answers to maximise marks using correct technical terminology and appropriate length for each question’s mark allocation.

1. Mark allocation guide: 1 mark = one accurate fact. 2 marks = definition + example. 3-4 marks = Definition + Explanation + Example + Context (DEEC). Write this guide into your revision doc.
2. Terminology is essential: marking keys award marks for specific terms. “The part that does maths” does not earn the mark for “The ALU performs arithmetic and logical operations.” Underline all technical terms in your notes.
3. Upgrade practice: rewrite this weak answer to B/A level: “The SDLC is a way of building computer systems. It has stages.”
4. Timed practice (8 minutes): (a) Describe one SDLC stage. (b) What is a Gantt chart? (c) Describe the function of the ALU. (d) What is the difference between RAM and ROM?
5. Identify where you lost marks and add those concepts to your final revision list.

By the end of this lesson you have completed a timed practice test on SDLC and project management and identified at least two areas for further revision.

1. Set a 25-minute timer. No notes. Questions: (1) Name all six SDLC stages and describe each. /4 (2) Explain the difference between SDLC and prototyping. When would you choose prototyping? /3 (3) Define scope and explain one consequence of scope creep. /2 (4) Describe two benefits of using a Gantt chart. /2 (5) Apply the SDLC to a scenario provided by your teacher (or use the T1 scenario): identify the current stage and describe what happens next. /4
2. Mark your answers: stage names (1 each), accurate descriptions (1 each), explicit prototyping comparison, scope definition with genuine scope creep example.
3. For any question below half marks: reread the relevant revision doc section, then rewrite the answer without notes.
4. Record your score (/15) and two weakest areas. These are your priority topics for L12.
5. Share with your teacher for feedback if time allows.

By the end of this lesson you have completed a full hardware and ethics practice test, debriefed your answers, and are confident with all T2 content areas.

1. Set a 25-minute timer. No notes. Questions: (1) Name and describe each CPU component. /5 (2) Describe the fetch-execute cycle. Name the register that holds the next instruction address. /4 (3) Convert: how many KB is 2,048 bytes? How many MB is 3,072 KB? /2 (4) Explain the difference between primary and secondary storage, one example each. /2 (5) A company employee installs personal software on a work computer. Identify the ethical issue and explain what an ICT code of conduct would say about this. /2
2. Mark: check each CPU component has both name and function; fetch-execute cycle names at least 2 registers; conversions use 1,024 (not 1,000).
3. Debrief: for any question below half marks, rewrite from notes then again from memory.
4. Write your final revision list: every topic with an error. These are last-night priorities before the T2 test.
5. Timing check: 25 marks in ~50 minutes = ~2 minutes per mark. A 4-mark question needs 8 minutes and 4 distinct accurate points.

By the end of this lesson you can navigate a spreadsheet, distinguish between labels, values, and formulas, and use relative and absolute cell references.

1. Open Excel or Google Sheets. Create a spreadsheet titled “T3 Practice”. In A2:A11 enter 10 sales figures. In A1, add the label “Sales”.
2. Define in a notes doc: Cell (row/column intersection, e.g. A1); Label (text heading, not used in calculations); Value (a number); Formula (user-written calculation starting with =); Function (pre-built formula, e.g. =SUM).
3. Relative references: in C2 type =A2+A3. Copy down to C5. Notice references shift as you copy - C3 becomes =A3+A4. This is relative referencing.
4. Absolute references: in D2 type =$A$2+A3. Copy down. $A$2 stays locked while A3 shifts. $ signs lock rows or columns.
5. Add a second sheet called “Summary”. Rename Sheet1 to “Sales Data”. You will use this two-sheet structure throughout T3 practice.

By the end of this lesson you can apply SUM, AVERAGE, MAX, and MIN to a dataset using correct syntax and interpret results in context.

1. On the Summary sheet, create labels in A1:A4: Total Sales, Average Sales, Highest Sale, Lowest Sale.
2. In B1: =SUM('Sales Data'!A2:A11). Sums the Sales column on the other sheet. Verify the result manually.
3. In B2: =AVERAGE('Sales Data'!A2:A11). Check: add all 10 values and divide by 10.
4. In B3: =MAX('Sales Data'!A2:A11). In B4: =MIN('Sales Data'!A2:A11). Confirm each result.
5. Format B1:B4 as currency (right-click → Format Cells → Currency). The underlying values remain unchanged; only the display format changes.

By the end of this lesson you can apply COUNT and COUNTIF with correct criteria syntax to answer conditional counting questions about a dataset.

1. Add to Sales Data: Column B = “Region” (alternating North/South for 10 rows); Column C = “Target Met” (Yes/No, make 6 Yes and 4 No).
2. =COUNT(range) counts only numeric values. In Summary B5: =COUNT('Sales Data'!A2:A11). Should return 10. COUNT ignores text and blanks.
3. =COUNTIF(range,criteria) counts cells meeting a condition. In B6: =COUNTIF('Sales Data'!B2:B11,"North"). In B7: =COUNTIF('Sales Data'!C2:C11,"Yes").
4. Numeric criteria: in B8: =COUNTIF('Sales Data'!A2:A11,">200"). The comparison operator must be inside quotes. Try also >=200, <100.
5. Add clear labels to each result row so a manager reading the summary would understand each figure instantly.

By the end of this lesson you have created, formatted, and titled a chart from your dataset and can justify your chart type choice.

1. Chart selection guide: Column/Bar - comparing values across categories; Line - trends over time; Pie - proportions of a whole (only when parts = 100%); Scatter - correlation between two variables.
2. Select A1:A11 (Sales data including header). Insert → Chart. Choose Column chart. Insert/OK.
3. Format: (a) add chart title: “Monthly Sales by Record”; (b) X axis label: “Record Number”; Y axis label: “Sales ($)”; (c) ensure legend is visible.
4. Move chart to its own sheet: right-click → Move chart → New sheet → name it “Sales Chart”.
5. In a text box on the chart sheet, write a 2-sentence justification for why a column chart suits this data. Reference your chart selection rules from step 1.

By the end of this lesson you can write a VLOOKUP formula with correct syntax, explain each argument, and apply it to return values from a lookup table.

1. Syntax: =VLOOKUP(lookup_value, table_array, col_index_num, [range_lookup]). Arguments: lookup_value = what you are searching for; table_array = the lookup table (first column must contain lookup values); col_index_num = which column to return (1=first, 2=second); range_lookup = FALSE for exact match, TRUE for approximate.
2. Create a “Product List” sheet: Column A = Product Codes (P001-P005), Column B = Product Names, Column C = Unit Prices.
3. On Sales Data sheet, add Column D = “Product Code” (P001-P005 across 10 rows). In Column E = “Product Name”: =VLOOKUP(D2,'Product List'!$A$2:$C$6,2,FALSE). Copy down all 10 rows.
4. In Column F = “Unit Price”: change col_index_num to 3. Confirm correct prices are returned.
5. Always use FALSE for exact match when looking up codes or text. Use $ signs on table_array so it does not shift when copied down. Test error: deliberately misspell a code - note the #N/A result.

By the end of this lesson you can write an HLOOKUP formula and explain when HLOOKUP is preferred over VLOOKUP.

1. VLOOKUP searches the first column of a vertical table. HLOOKUP searches the first row of a horizontal table. The choice depends on how your lookup table is structured.
2. Syntax: =HLOOKUP(lookup_value, table_array, row_index_num, [range_lookup]). The key difference: row_index_num specifies which row to return (1=header row, 2=second row).
3. Create a “Commission Table” sheet: Row 1 = Region headers (North, South, East, West); Row 2 = Commission rates (5%, 7%, 6%, 8%).
4. On Sales Data, in Column G = “Commission Rate”: =HLOOKUP(B2,'Commission Table'!$A$1:$D$2,2,FALSE). Copy down for all rows.
5. In Column H = “Commission Earned”: multiply A (sales) by G (commission rate). Format H as currency.

By the end of this lesson you can sort data by single and multiple columns and apply filters to show only records matching a condition.

1. Always select the entire data range (all columns) before sorting - never sort a single column in isolation as this desyncs it from other row data.
2. Single-level sort: select A1:H11 on Sales Data. Data → Sort. Sort by Column A (Sales), Descending. Confirm highest sale is at the top.
3. Multi-level sort: Data → Sort → Add Level. Sort first by Region (A to Z), then by Sales (Largest to Smallest). This groups all North sales together, highest first, then all South sales.
4. AutoFilter: Data → Filter. Click the Region dropdown. Deselect South to show only North records. Row numbers skip - filtered rows are hidden, not deleted.
5. Remove filter to restore all data. Practice: “How would you filter to show only records where Target Met = Yes AND Sales > 200?”

By the end of this lesson your practice spreadsheet meets professional formatting standards and you can describe the data hierarchy from character to table.

1. Formatting checklist: (a) all headers bold; (b) column widths auto-fitted (double-click column divider); (c) currency values formatted to 2 decimal places; (d) percentage values display the % symbol; (e) consistent visual structure across the sheet.
2. Freeze panes: select Row 2, then View → Freeze Rows. Headers remain visible when scrolling down through large datasets.
3. Data hierarchy: define each level with a real example: Character (single symbol, e.g. ‘J’); Field (named data category, e.g. FirstName); Record (one complete entry - all fields for one person/product); Table (all records of the same type). In a spreadsheet: column = field, row = record, sheet = table.
4. Data types: create a reference table - Number, Date/Time, Currency, Text/String, Boolean - with a definition and two field examples for each. Explain why using the wrong type causes problems (e.g. phone number stored as Number drops leading zeros).
5. Review your T3 Practice file: identify the data type for every column. Correct any mismatches.

By the end of this lesson your T3 practice file contains all required functions and is organised as a marking-ready submission.

1. Audit your T3 Practice file. Confirm all present: SUM, AVERAGE, MAX, MIN (Summary sheet), COUNT, COUNTIF (Summary sheet), VLOOKUP (Product Name column), HLOOKUP (Commission Rate column), Chart (Sales Chart sheet), Sorted data (Sales Data sheet).
2. Error check: are any cells showing #N/A, #REF!, #VALUE!, or #DIV/0!? Investigate and fix each one before the test.
3. Formula check: click on each result cell. Confirm the formula bar shows a formula (=SUM..., =VLOOKUP...) and not a hardcoded number. Hardcoded values score zero in the functions criterion.
4. Presentation check: Summary sheet has clear labels for every result. A manager reading it would understand each figure without needing to look at Sales Data.
5. Save as .xlsx. Open the file again from the saved version and confirm everything displays correctly. Files that do not open correctly score zero.

By the end of this lesson you can read a T3-style scenario, identify all required functions and outputs, and plan your solution before opening a spreadsheet.

1. Sample scenario: “A bookshop manager has a spreadsheet of 12 books: Title, Author, Genre, Price, Copies Sold, In Stock (Yes/No). Required: (a) Total revenue; (b) Average price; (c) Most expensive book; (d) Count of Fiction books; (e) Lookup Genre to Discount%; (f) Bar chart of Copies Sold by Genre; (g) Sort by Price (highest first).”
2. Before opening a spreadsheet, annotate the scenario: underline each requirement and write the function needed: (a)=SUM; (b)=AVERAGE; (c)=MAX; (d)=COUNTIF; (e)=VLOOKUP or HLOOKUP; (f)=chart; (g)=sort. This is your solution plan.
3. Time allocation (~50 minutes, /20): Functions /10 = ~25 min; Charts & Lookup /6 = ~15 min; Formatting /4 = ~10 min. Prioritise in this order.
4. Priority rule: always complete functions first - they are the highest-value criterion. Never spend 20 minutes perfecting a chart if COUNTIF is still missing.
5. Build the bookshop scenario in Excel from scratch: create 12 records yourself, then complete all seven requirements. This is your full practical rehearsal.

By the end of this lesson you have completed a full timed spreadsheet practical under near-test conditions and self-assessed against the T3 rubric.

1. Set a 50-minute timer. No notes, no internet, no AI. Dataset: 15 employee records with columns EmployeeID, FirstName, LastName, Department, HoursWorked, HourlyRate, StartDate. Requirements: (a) Calculate TotalPay (HoursWorked × HourlyRate) for each employee; (b) SUM all TotalPay; (c) AVERAGE HoursWorked; (d) MAX and MIN HourlyRate; (e) COUNTIF employees in a specified department; (f) Lookup table Department → Bonus%; VLOOKUP to return Bonus% for each employee; (g) Column chart of TotalPay by EmployeeID; (h) Sort by Department then TotalPay (highest first).
2. Work through requirements in order. Check each off as completed.
3. With 5 minutes remaining: check formatting - headers bold, currency formatted, chart has title and labels, file saved as .xlsx.
4. After the timer: self-assess using the T3 rubric. Mark each criterion. Identify the weakest criterion.
5. Note your weakest area for final review before T3. Tonight: re-do the VLOOKUP from memory. If it takes under 2 minutes, you are ready.

By the end of this lesson you can recall all required function syntax from memory and apply a time-efficient strategy in the T3 practical test.

1. Write all required syntax from memory (no looking): SUM, AVERAGE, MAX, MIN, COUNT, COUNTIF (with a >200 numeric criteria example), VLOOKUP (with exact match), HLOOKUP (with exact match). Check each against your notes.
2. COUNTIF criteria reminder: numeric comparisons must be in quotes: ">200". Text values must also be in quotes: "North". Missing quotes is the most common COUNTIF error.
3. Chart checklist: (a) chart type appropriate for data; (b) title added; (c) both axis labels added; (d) legend visible; (e) chart moved to its own sheet or clearly positioned. Tick each in your practice file.
4. Test strategy: read the scenario fully, underline each requirement, write the function needed next to each, then open Excel and build in function priority order (SUM/AVERAGE/MAX/MIN first, COUNTIF next, VLOOKUP/HLOOKUP next, chart last, formatting throughout).
5. The T3 Practical Test is this lesson’s week under supervised conditions. No notes, no internet, no AI.

By the end of this lesson you can define a database and its core components, and explain what your T4 Database Design Project requires.

1. A database is an organised collection of structured data stored and accessed electronically. Define these terms in a T4 notes doc: Table (a collection of related records organised in rows and columns); Field (a single category of data - one column in the table, e.g. CustomerName); Record (a complete set of fields for one entity - one row, e.g. all details for one customer).
2. Primary key: a field (or combination of fields) that uniquely identifies every record in a table. No two records can have the same primary key value; it cannot be null. Examples: CustomerID, EmployeeNumber, OrderID.
3. Read the T4 scenario on Google Classroom. Identify: what type of data does the client need to store? What questions does the client need the database to answer? Who will use the database?
4. List all the data items mentioned in the scenario. These will become your fields. Aim for 10-15 fields. Identify which field could be the primary key and explain why.
5. Review the T4 rubric. Note that Database Design & Structure is worth /15 and Forms/Queries/Reports is worth /15. Plan to work on both in parallel across the nine weeks.

By the end of this lesson you have produced a complete data dictionary for your T4 database with correct field names, data types, and a justified primary key.

1. Create a data dictionary table in a Word doc or Google Doc. Columns: Field Name - Data Type - Description - Primary Key (Y/N) - Example Value. This document is submitted as part of your T4 project.
2. Field naming conventions: no spaces (use CamelCase or underscores, e.g. CustomerID or customer_id); descriptive but concise; no reserved words (e.g. avoid “Name” - use “CustomerName”).
3. Data types for Microsoft Access: Short Text (names, codes, addresses); Number (integers and decimals for calculations); Currency (money values); Date/Time (dates and times); Yes/No (Boolean true/false); AutoNumber (automatically incrementing integer - ideal for primary keys); Long Text (notes and descriptions over 255 characters).
4. Complete your data dictionary for all 10-15 fields from the T4 scenario. Assign the most appropriate data type to each field.
5. Identify and mark your primary key. Write a 2-sentence justification in your data dictionary explaining why this field uniquely identifies every record. An AutoNumber field (e.g. CustomerID) is often the simplest choice.

By the end of this lesson you have created your T4 table in Access using Design View with all fields, data types, and primary key matching your data dictionary.

1. Open Microsoft Access. Create a new blank database. Save it immediately with a meaningful filename (e.g. T4_CustomerDatabase.accdb).
2. In the Tables section, click “Table Design” to open Design View. For each field in your data dictionary, type the Field Name, select the Data Type from the dropdown, and add a brief Description.
3. Set the primary key: click the row for your primary key field and click the key icon in the toolbar (or right-click → Primary Key). The key icon appears in the row selector.
4. Save the table design. Name it logically (e.g. “Customers” or “Products” based on your scenario). Switch to Datasheet View to begin entering records.
5. Enter at least 15 records of realistic scenario-appropriate data. Avoid placeholder data like “test” or “aaa” - use names, dates, and values that reflect the scenario. The rubric checks that data reflects the scenario context.

By the end of this lesson you have created a functional data entry form for your T4 database that allows records to be added and edited.

1. In Access, go to the Create tab → Form Wizard. Select your table as the data source. Add all fields to the form using the >> button. Choose a layout (Columnar is cleanest for data entry). Select a style. Click Finish.
2. Open the form in Design View to customise it. Check that all field labels accurately describe the data (e.g. “Customer Name:” not just “CustomerName”). Adjust label text by clicking and typing.
3. Add a form title: insert a Label control at the top of the form with a meaningful title (e.g. “Customer Data Entry Form”). Format it with a larger font size and bold.
4. Test the form: switch to Form View. Navigate through existing records using the record navigation arrows at the bottom. Add a new record using the form to verify it saves correctly to the table.
5. Add navigation buttons if not already present: in Design View, use the Button Wizard (Insert → Button) to add buttons for “Add New Record”, “Save Record”, and “Close Form”. These improve usability for the client.

By the end of this lesson you have built at least two criteria-based queries in Access Design View that answer meaningful questions about your T4 dataset.

1. In Access, Create tab → Query Design. Add your table. Double-click fields to add them to the query grid. To run the query, click Run (the red !) in the toolbar.
2. Adding criteria: in the Criteria row under a field, type a condition. Examples: Text field - type "Perth" to match records where that field equals Perth. Number field - type >100 to show records where the value exceeds 100. Date field - type >#01/01/2024#.
3. Wildcards for partial text matching: Like "S*" matches any value starting with S. Like "*manager*" matches any value containing “manager”.
4. Build Query 1: address a specific scenario need (e.g. “Show all orders placed after [date]” or “Show all customers from [city]”). Save the query with a meaningful name (e.g. “qryOrdersAfterJanuary”).
5. Build Query 2: address a different scenario need using different criteria (e.g. a number range, a different field, or two criteria in the same query using AND). Save with a meaningful name. Run both queries and confirm they return the correct records.

By the end of this lesson you have created a formatted Access report that presents data clearly for the client, with a title, appropriate grouping or sorting, and professional layout.

1. In Access, Create tab → Report Wizard. Select your table (or one of your queries) as the data source. Choose the fields to include - pick the most relevant fields for the client’s needs, not all fields.
2. Grouping: if your data has categories (e.g. Department, Region, Product Type), add a grouping level. This organises records under category headers. Click the > button to add a grouping field.
3. Sorting: add a sort order (e.g. sort by LastName A to Z, or by Date most recent first). Click Finish to generate the report.
4. Open the report in Design View. Add a meaningful report title at the top (double-click the title label and type). Check that all column headers are readable and not overlapping. Adjust column widths if needed.
5. Add the current date to the report footer using a text box with =Now(). This shows when the report was generated. Preview in Print Preview to check the layout before submitting.

By the end of this lesson you have built a visual navigation interface (switchboard or navigation form) that allows the client to access all database features without navigating Access menus.

1. A navigation interface is a form that acts as a “home screen” for the database. The client should be able to open the data entry form, run queries, and view the report by clicking buttons - no Access knowledge required.
2. Create a new blank form in Design View. Add a title label at the top (e.g. “Customer Database - Main Menu”). Resize the form to a sensible size.
3. Add a command button for each major feature. Use the Button Wizard: Form Operations → Open Form (to open your data entry form); Miscellaneous → Run Query (to run each query); Report Operations → Open Report (to open your report). Label each button clearly.
4. Add an “Exit Database” button using Button Wizard → Application → Quit Application. This gives the client a safe way to close the database.
5. Set the navigation form to open automatically when the database opens: File → Options → Current Database → Display Form → select your switchboard form. Test by closing and reopening the database to confirm it opens to your menu.

By the end of this lesson you have produced user documentation for your T4 database written for a non-technical client audience.

1. User documentation explains how to use the database to someone who has never used it before. Write for the client described in the T4 scenario - assume they are not technical. Use plain language; avoid jargon.
2. Structure your documentation with sections: (a) Introduction - what the database does and who it is for; (b) Opening the database - how to open the file and log in; (c) Adding a new record - step-by-step using the form; (d) Finding specific records - how to run the queries; (e) Printing a report - how to open and print the report; (f) Closing the database safely.
3. Take screenshots of each key screen (navigation menu, form, query results, report). Paste into your documentation and add numbered callouts pointing to important buttons or fields.
4. Use numbered step lists for all procedures. Each step should be one action only (e.g. “1. Click the ‘Add New Customer’ button on the main menu.”). Avoid combining multiple actions in one step.
5. Test your documentation: ask a peer to follow it without your help. If they get stuck, the instructions need to be clearer. Revise based on their feedback.

By the end of this lesson you have added at least two validation rules to your T4 database and can explain why data validation improves data quality.

1. Data validation prevents incorrect data from being entered. Open your table in Design View. Click a field to set validation properties.
2. Validation Rule: a condition the data must meet. Examples for a Number field: >0 (must be positive); >=18 And <=65 (age range). For a Text field: "WA" Or "NSW" Or "VIC" (must be one of these values). Enter the rule in the Validation Rule property.
3. Validation Text: the error message shown if the rule is violated. Write it in plain language for the user (e.g. “Quantity must be greater than zero. Please re-enter.”). Enter this in the Validation Text property.
4. Required property: set to Yes for fields that must always have a value (e.g. CustomerName, OrderDate). Leave as No for optional fields.
5. Add validation rules to at least two fields in your T4 database. Test each by entering invalid data in the form and confirming the error message appears. Screenshot the error messages and include them in your documentation.

By the end of this lesson you can build queries using AND/OR logic and add calculated fields to a query to derive new data from existing fields.

1. AND criteria: place criteria in the same row across different fields. Example: Criteria row for City = "Perth" AND Criteria row for Salary = >50000. Both conditions must be true for a record to appear.
2. OR criteria: place the second condition in the “Or” row directly below the Criteria row. Example: City Criteria = "Perth", Or row = "Fremantle". Records matching either condition appear.
3. Calculated field: create a new column in the query that computes a value from existing fields. In the Field row of a blank column, type: TotalCost: [Quantity]*[UnitPrice]. Replace field names with your actual field names. This column does not exist in the table - it is calculated at runtime.
4. Build a third query for your T4 database using either AND/OR logic or a calculated field. Save it with a meaningful name. Add it to your navigation interface and document it in your user documentation.
5. Sort query results: in the Sort row, select Ascending or Descending for the field you want to sort by. This makes query output easier to read for the client.

By the end of this lesson you have written a strong evaluation of your T4 database that references the scenario and the rubric criteria.

1. Your evaluation must be written in full sentences (not dot points). It should cover: strengths of your database design, limitations, and improvements you would make with more time.
2. Reference the scenario: link your evaluation points to the client’s specific needs. Example: “The COUNTIF query successfully answers the client’s requirement to identify customers in a specific region, however the query does not currently sort results alphabetically which would improve usability.”
3. Strengths to consider: data dictionary accuracy, primary key choice, query relevance, form usability, report clarity, navigation interface design.
4. Limitations to consider: single-table structure limits how data can be related; no user login/password protection; report formatting could be improved; validation rules only on some fields.
5. Rubric self-assessment: go through each criterion (Database Design, Forms/Queries/Reports, Interface/Documentation, Evaluation) and honestly estimate your grade level. For any criterion below C, identify what is missing and fix it before submission.

By the end of this lesson your T4 submission is complete, correctly packaged, and submitted to Google Classroom/Connect before the deadline.

1. Final T4 checklist: ☐ Table with 15+ realistic records; ☐ Data dictionary (Word/Google Doc, all fields, types, PK justified); ☐ Data entry form (functional, labelled, formatted); ☐ Query 1 with criteria (saves and runs correctly); ☐ Query 2 with criteria (different criteria from Q1); ☐ Formatted report (title, grouping/sorting, date); ☐ Navigation interface (opens automatically, all buttons work); ☐ User documentation (screenshots, step-by-step, client language); ☐ Evaluation (full sentences, references scenario, strengths/limitations/improvements).
2. Close and reopen your database to confirm the navigation interface opens automatically and all buttons work correctly from a fresh start.
3. Compact and repair the database: File → Info → Compact & Repair. This reduces file size and fixes minor corruption issues before submission.
4. Package your submission: create a folder named “T4_YourName”. Copy in your .accdb database file, your data dictionary document, and your user documentation. Compress to a .zip file.
5. Upload the .zip to Google Classroom / Connect. Submit before the end of Week 9. Confirm the submission is received (check the green tick or submission confirmation).

By the end of this lesson you understand the EST format and can apply a time management strategy to maximise marks in 50 minutes.

1. The EST is 50 minutes and worth /46 marks. That is approximately 65 seconds per mark. A 4-mark question should take about 4-5 minutes. A 2-mark question should take about 2 minutes. Write this timing guide into your EST revision doc.
2. Answer structure: for definition questions (1-2 marks) write one clear sentence using the exact technical term. For explanation questions (3-4 marks) use DEEC structure: Definition, Explanation, Example, Context. For application questions, link your answer directly to the provided scenario.
3. Terminology is non-negotiable: marking keys award marks for specific terms. “The part that stores instructions” will not earn the mark for “RAM (Random Access Memory) stores currently running programs and data.”
4. Create an EST content checklist: list every Unit 3 topic from the CS syllabus. Tick off topics you feel confident with. Circle topics that need more work. This becomes your revision priority list.
5. If your school provides a past EST paper: complete it under timed conditions (50 minutes, pen only, no notes). Mark it yourself, then review every question you lost marks on.

By the end of this lesson you can answer EST-style questions on SDLC stages and context diagrams with accurate technical terminology.

1. SDLC rapid review: without notes, write the six stage names and one sentence on each. Time yourself - target under 4 minutes. Check accuracy against your T2 notes.
2. EST practice question: “A retail business decides to replace its paper-based inventory system with a new computerised database. (a) Name the SDLC stage at which stakeholders are interviewed to determine system requirements. (b) Describe what happens during the Design stage. (c) Explain one advantage of using prototyping instead of the full SDLC for this project.” Write full answers.
3. Context diagram rapid review: draw a context diagram for a hospital patient management system from memory. Central process: Patient Management System. Identify at least 4 entities and 6 data flows. Check notation: all arrows labelled, all entities rectangles.
4. EST practice question: “Draw a context diagram for the following scenario using Yourdon/DeMarco notation. [Teacher supplies scenario.] Label all components.” Practice this type under timed conditions - you have about 8-10 minutes for a context diagram question.
5. Add any context diagram or SDLC questions you got wrong to your revision priority list.

By the end of this lesson you can answer EST-style hardware questions on CPU components, the fetch-execute cycle, and storage hierarchy.

1. CPU rapid-write: without notes, write all 5 CPU components with their functions. Target: under 3 minutes. Any component or function you miss is a revision priority.
2. EST practice question: “(a) Identify the CPU component that performs arithmetic operations. (b) Describe the role of the Program Counter in the fetch-execute cycle. (c) Explain what happens during the decode stage of the fetch-execute cycle.” Write full answers.
3. Storage conversion practice: (a) Convert 4 GB to MB. (b) A file is 2,097,152 bytes. How many MB is this? (c) Explain the difference between RAM and an SSD in terms of volatility and access speed.
4. EST practice question: “A company purchases a new computer. (a) Identify one primary storage device and explain its role. (b) Identify one secondary storage device and explain why it is used for long-term data storage. (c) Explain why RAM is volatile storage.”
5. Boot process check: write the cold boot sequence from memory (7 steps from power-on to login screen). If you cannot recall all 7, re-read your T2 notes on the boot process.

By the end of this lesson you can answer EST-style questions on databases, data dictionaries, spreadsheet functions, and data types.

1. Database concepts review: write definitions for table, field, record, primary key, query, data dictionary. Practice question: “Explain the purpose of a primary key in a database table. Give one example.” Write a 3-sentence answer.
2. Data dictionary practice: given a scenario (e.g. a library book database), identify 6 appropriate fields, assign correct data types to each, and identify the primary key. Write your answer as a mini data dictionary table.
3. Spreadsheet function review: without notes, write the correct syntax for: SUM, AVERAGE, MAX, MIN, COUNTIF (with a >100 criteria), VLOOKUP (with exact match). Check each against your T3 notes.
4. EST practice question: “A spreadsheet contains student test scores in cells B2:B31. (a) Write the formula to calculate the average score. (b) Write the formula to count how many students scored above 80. (c) Explain the purpose of the FALSE argument in a VLOOKUP formula.”
5. Data types review: for each field below, identify the correct data type and explain why: StudentID, DateOfBirth, FeePaid (Yes/No), TotalScore, Notes/Comments.

By the end of this lesson you can answer EST-style questions on ICT ethics, the Privacy Act, and project management concepts.

1. Ethics and ICT code of conduct: practice question: “An employee uses a work computer to access personal social media accounts during work hours. Identify the ethical issue and explain what an ICT code of conduct would say about this.” Write a 4-sentence answer.
2. Privacy Act 1988: practice question: “A business collects personal information from customers when they sign up for a loyalty program. Describe two obligations the business has regarding this data under the Privacy Act 1988.”
3. Project management: practice question: “(a) Define the term ‘milestone’ in project management. (b) Explain one benefit of using a Gantt chart to manage a software development project. (c) Define the term ‘scope’ and explain one consequence of scope creep.”
4. Digital etiquette: practice question: “Describe two rules of etiquette that apply to professional email communication and explain why each rule is important.”
5. Review all answers against your revision notes. Identify any remaining weak areas and add them to your final revision list for L11.

By the end of this lesson you have completed a full 50-minute EST practice paper and identified your final revision priorities before the actual EST.

1. Set a 50-minute timer. No notes, no internet, no AI. Complete this practice on paper as a simulation - the actual test is on Socrative. Your teacher will provide a practice paper, or use the following structure across all Unit 3 topics: SDLC (8 marks), Context diagram (10 marks), CPU and hardware (12 marks), Database concepts (8 marks), Spreadsheet functions (5 marks), Ethics/privacy (3 marks).
2. Work through the paper at EST pace. Do not stop the timer. If you cannot answer a question, leave a gap and move on - return at the end.
3. When time is up: mark your paper using your revision notes as a marking key. For each question, identify whether you earned full marks, partial marks, or no marks, and why.
4. Record your total score and percentage. Which content area lost you the most marks? This is your priority for the remaining preparation time before the actual EST.
5. The actual EST is in Weeks 3-4. Tonight and tomorrow: re-read only your priority areas. Do not attempt to revise everything - focus on the gaps identified in this practice paper.

By the end of this lesson you have reviewed your EST performance, identified your strongest and weakest content areas, and documented lessons to apply to T6 and T8.

1. When your marked EST is returned: go through every question you lost marks on. For each, write: (a) what you wrote, (b) what the marking key required, (c) the key term or concept you missed.
2. Class debrief: your teacher will discuss common errors. Note any patterns - for example, “most students wrote the wrong register in the fetch-execute cycle” or “context diagram arrows were missing labels.”
3. Compile your personal error list. Sort by content area: SDLC errors, hardware errors, database errors, spreadsheet errors, ethics errors. Which area had the most errors?
4. Transfer lessons to future tasks: T6 (Programming Practical) and T8 (Programming & Networks Theory Test) in Term 3 both require short answer technique. Apply what you learned about precision and terminology from the EST to those tasks.
5. The EST result contributes 15% to your final mark. Accept the result, learn from the debrief, and focus energy on T6 and T4 completion. Do not dwell - redirect.

By the end of this lesson you can define an algorithm and write simple pseudocode using correct conventions for sequence, variables, input, and output.

1. An algorithm is a finite, ordered set of unambiguous instructions that solves a problem or achieves a result. Define this in your T6 revision doc. Key properties: Finite (it ends), Unambiguous (each step is clear), Effective (each step is executable).
2. Pseudocode is a structured way of writing an algorithm using English-like statements - not a real programming language, but consistent conventions. Key conventions: INPUT variable (get data from user), OUTPUT message (display to user), ← or = for assignment (e.g. total ← price * quantity), BEGIN/END to mark the start and end of the algorithm.
3. Variables: named storage locations that hold values during program execution. Declare each variable with a meaningful name (e.g. studentName, totalScore). Variable names: no spaces, descriptive, use camelCase.
4. Write pseudocode for: “A program asks the user for two numbers, adds them together, and displays the result.”
5. Write pseudocode for: “A program asks for a product name and its price. It calculates the GST (10%) and displays the total price including GST.”

By the end of this lesson you can write selection structures (IF/ELSE/ENDIF) in pseudocode and represent them as decision diamonds in a flowchart.

1. Selection allows a program to make decisions. The IF/ELSE structure runs different code depending on whether a condition is true or false. Pseudocode structure:
   IF condition THEN
   instructions if true
ELSE
   instructions if false
ENDIF
2. Flowchart representation: selection is shown as a diamond (decision) shape with two branches labelled True/Yes and False/No. Each branch leads to different process boxes, then they rejoin at a point below.
3. Write pseudocode and draw a flowchart for: “A program reads a student’s test score. If the score is 50 or above, display ‘Pass’. Otherwise, display ‘Fail’.”
4. Nested IF: an IF structure inside another IF. Write pseudocode for: “If score ≥ 80 display ‘A’. If score ≥ 60 display ‘B’. If score ≥ 50 display ‘C’. Otherwise display ‘Fail’.”
5. Write pseudocode and a flowchart for a scenario from the T6 brief context (your teacher will specify a programming scenario). This is direct T6 preparation.

By the end of this lesson you can write FOR and WHILE loops in pseudocode and explain when each type of loop is appropriate.

1. Iteration (loops) allows a set of instructions to be repeated. Two main types: FOR loop - use when the number of iterations is known in advance; WHILE loop - use when the loop continues until a condition becomes false (number of iterations unknown).
2. FOR loop pseudocode structure:
   FOR counter ← start TO end
   instructions
ENDFOR
   Example: display numbers 1 to 10.
3. WHILE loop pseudocode structure:
   WHILE condition = TRUE
   instructions
ENDWHILE
   Example: keep asking for input until the user enters a valid number.
4. Write pseudocode for: “A program asks the user to enter 5 student scores and calculates the total.” Use a FOR loop.
5. Write pseudocode for: “A program asks the user to enter a password. It keeps asking until the correct password is entered.” Use a WHILE loop. Draw a flowchart for this algorithm.

By the end of this lesson you can identify the appropriate data type for a variable and explain the difference between a variable and a constant.

1. Programming data types: Integer (whole numbers, e.g. age, count); Real/Float (decimal numbers, e.g. price, temperature); String (text, e.g. name, address); Boolean (true or false, e.g. isLoggedIn, hasDiscount). For each, write a definition and two variable examples.
2. Variable: a named memory location whose value can change during program execution. Declare with: DECLARE variableName AS dataType.
3. Constant: a named value that cannot change during execution. Use for values that are fixed (e.g. GST rate = 0.10, PI = 3.14159). Declare with: CONSTANT PI = 3.14159. Benefits of constants: easy to update (change in one place), improves readability, prevents accidental changes.
4. Practice: identify the appropriate data type for each: customerName, orderQuantity, unitPrice, isDiscounted, dateOfBirth, totalScore, taxRate (fixed at 0.10).
5. Rewrite one of your previous pseudocode algorithms (from L8-L10) to include explicit variable declarations and at least one constant. This is the T6 standard.

By the end of this lesson you can complete a trace table for a given pseudocode algorithm and identify appropriate normal, boundary, and invalid test data.

1. A trace table manually tracks the values of variables as an algorithm executes step by step. It is used to verify an algorithm is correct before coding. Columns: Step Number - Statement - Variable names (one column each) - Output.
2. Complete a trace table for this pseudocode: total ← 0; FOR i ← 1 TO 3; INPUT score; total ← total + score; ENDFOR; OUTPUT total / 3. Use test data: scores 60, 80, 70. Show every row as it executes.
3. Test data categories: Normal - typical valid inputs (e.g. score = 75); Boundary - values at the edge of valid ranges (e.g. for 0-100, test 0 and 100); Invalid - inputs outside the valid range or of wrong type (e.g. score = 150, score = “abc”).
4. Data validation: checks that inputs meet rules before being processed. Types: Range check (0 ≤ score ≤ 100); Type check (must be a number); Presence check (cannot be blank); Length check (password must be 8+ characters). Write one pseudocode example for each type.
5. Write a trace table for your T6 pseudocode from L9 or L10. Include normal, boundary, and invalid test data rows. This is a direct T6 deliverable.

By the end of this lesson you have read the T6 brief and written your first working program using sequence, variables, input, and output.

1. Read the T6 brief. The practical test requires a working program that uses all three control structures (sequence, selection, iteration) plus a trace table. The scenario will be given in the test. Your preparation is to practise all three structures so you can apply them quickly under timed conditions.
2. Open your IDE (Python, Visual Basic, or teacher-specified). Write a program that: asks the user for their name and age, then displays a greeting message that includes both values. Example output: “Hello, Jake! You are 17 years old.”
3. Variables: ensure you use named variables to store the input values before displaying them (e.g. name = input("Enter your name: ") in Python). Do not pass user input directly to the output without storing it first.
4. Add a constant to your program: define SCHOOL_YEAR = 12 and include it in your output message. This practices using constants alongside variables.
5. Test your program with at least 3 different inputs. Confirm the output is correct for all inputs. Save the file with a meaningful name.

By the end of this lesson you can implement IF/ELIF/ELSE selection in code and test both branches with appropriate test data.

1. Comparison operators for conditions: == (equal to), != (not equal), > (greater than), < (less than), >= (greater than or equal), <= (less than or equal). Write one example condition using each operator.
2. Write a program: ask the user for a test score (0-100). Display “Pass” if the score is 50 or above, or “Fail” if below 50. Test with: score = 75 (Pass), score = 49 (Fail), score = 50 (Pass - boundary test).
3. Extend the program to use ELIF for grade boundaries: A (≥80), B (≥60), C (≥50), Fail (<50). Test each boundary value.
4. Add data validation: before the IF statement, check if the score is between 0 and 100. If not, display an error message. This is an example of a range check validation.
5. Document your test data in a table: Input - Expected Output - Actual Output. Include at least 5 test cases covering normal (75), boundary (50, 80), and invalid (150, -5) inputs.

By the end of this lesson you can implement FOR and WHILE loops in code and apply the accumulator pattern to calculate a running total.

1. FOR loop: write a program that asks the user to enter 5 scores one at a time, adds them together using an accumulator variable, and displays the total and average. Use a FOR loop that runs exactly 5 times.
2. The accumulator pattern: initialise a total variable to 0 before the loop. Inside the loop, add each new value: total = total + score. After the loop, calculate the average: average = total / 5.
3. WHILE loop: write a program that keeps asking the user to enter a positive number. If the number is negative or zero, display an error and ask again. When a valid number is entered, display its square root. Use a WHILE loop for the validation.
4. Combine structures: write a program that uses a FOR loop to collect 5 numbers AND an IF statement inside the loop to count how many numbers are above a threshold (e.g. above 50).
5. Test all programs with normal, boundary, and invalid inputs. Update your test data table from L2.

By the end of this lesson you have written a program that uses all three control structures (sequence, selection, iteration) together and applied internal documentation (comments).

1. Write a combined program: a shop calculates the cost of items purchased. The program: (a) asks the user how many items they are buying (iteration: loop that many times); (b) for each item, asks for the item name and price (sequence: INPUT); (c) if the price is over $50, applies a 10% discount (selection: IF); (d) adds the discounted or full price to a running total (accumulator); (e) after all items, displays the total cost.
2. Add internal comments (lines starting with # in Python) to explain each section: # Get number of items from user, # Apply discount if item price exceeds $50, etc. Internal comments are part of the T6 rubric’s code quality criterion.
3. Use meaningful variable names throughout: itemPrice not p; totalCost not t; itemCount not n.
4. Use at least one constant in the program (e.g. DISCOUNT_RATE = 0.10). Reference this constant in the discount calculation rather than hardcoding the value 0.10.
5. Test the program thoroughly. Create a trace table for this program using 3 items with test data that includes a price over $50 (tests the IF branch), a price under $50, and a price exactly equal to $50 (boundary test).

By the end of this lesson you can complete a trace table for any given program, tracking all variables at each step for normal, boundary, and invalid test data.

1. Trace table format: create a table with columns for Line/Step, the code statement, and one column for each variable in the program. Add an Output column for any display statements. Each row represents one line of code executing.
2. Trace the L4 shop program using test data: 2 items, Item 1 name=“Book” price=$30 (no discount), Item 2 name=“Jacket” price=$80 (10% discount applied). Track: itemCount, i (loop counter), itemName, itemPrice, discountedPrice, totalCost. Show each variable’s value after each step changes it.
3. Boundary test trace: repeat with Item 1 price exactly = $50. Show whether the IF condition triggers at exactly $50 (check your code: is it >50 or >=50?).
4. Invalid test: enter a non-numeric price (e.g. “abc”). Document what your program does - does it crash or handle the error? If it crashes, add a try/except or WHILE validation loop and re-trace.
5. The T6 practical test will ask you to produce a trace table for the program you write. Practice until you can trace a 10-15 line program completely and accurately in under 10 minutes.

By the end of this lesson you can distinguish between syntax, logic, and runtime errors and apply a debugging strategy to fix each type.

1. Three types of programming errors: Syntax error - code does not follow the rules of the language (e.g. missing colon, misspelled keyword); detected by the interpreter/compiler before running. Runtime error - code is syntactically correct but fails during execution (e.g. dividing by zero, accessing a file that does not exist). Logic error - code runs without crashing but produces incorrect output (e.g. using + instead of * in a calculation). Define all three in your notes.
2. Syntax error example: intentionally introduce a syntax error into your L4 program (e.g. remove a colon after an IF statement). Run it and read the error message. Note: error messages often point to the line where the error was detected, not always where it was caused.
3. Logic error example: change the discount condition from >50 to >=50. The program runs, but the boundary behaviour changes. Run your trace table again to confirm the difference in output.
4. Runtime error example: remove the input validation from your WHILE loop program. Enter 0 as a divisor and observe the ZeroDivisionError. Restore the validation to fix it.
5. Debugging strategy: (a) read the error message carefully; (b) go to the indicated line; (c) add print/output statements to display variable values at each step; (d) compare actual variable values to your trace table to find where the logic diverges.

By the end of this lesson you have completed a timed 50-minute programming practical covering all three control structures and produced a trace table.

1. Set a 50-minute timer. No notes, no internet, no AI. Scenario: “An invoice calculator for a small business. The program asks how many products are being invoiced (1-10). For each product, it asks for the product name and unit price. If the unit price exceeds $100, a 15% discount is applied. The program displays each product name, original price, discounted price (if applicable), and the total invoice amount. A constant TAX_RATE = 0.10 is applied to the final total.”
2. Plan before coding (5 minutes): identify which inputs/outputs are needed, which structures are required (loop for multiple products, IF for discount, sequence for calculation), and write variable names.
3. Code the solution (30 minutes): implement all requirements. Add internal comments. Use the constant.
4. Trace table (10 minutes): trace the program for exactly 2 products: Product 1 price=$80 (no discount), Product 2 price=$120 (discount applied). Show all variable values at each step.
5. Review (5 minutes): test with 1 product and 10 products. Fix any errors. Self-assess against the T6 rubric.

By the end of this lesson you have completed a second full timed practical and are confident with all T6 requirements.

1. Set a 50-minute timer. No notes, no internet, no AI. Scenario: “A grade calculator for a teacher. The program asks how many students are in the class (1-30). For each student, it asks for the student name and their test score (0-100). It validates that the score is within range. It assigns a grade: A (≥80), B (≥60), C (≥50), Fail (<50). After all students, it displays the class average score and the count of students who achieved each grade.”
2. Plan: identify all required variables (studentCount, studentName, score, total, gradeA, gradeB, gradeC, gradeFail, average), structures (FOR loop for students, WHILE for validation, nested IF for grades), and constants (grade boundaries as constants is optional but demonstrates good practice).
3. Code the solution (30 minutes). Trace (10 minutes): trace for 3 students with scores 85, 55, 49. Show variables at each loop iteration. Review (10 minutes): test edge cases, fix errors, self-assess.
4. Compare your two practice practicals: which was faster? Which had fewer errors? Identify your remaining weak point (most likely: trace table accuracy or input validation logic).
5. The T6 Practical Test is this lesson’s week. Arrive knowing: your chosen IDE, how to write a FOR loop, how to write IF/ELIF, and how to construct a trace table from scratch.

By the end of this lesson you have debriefed the T6 test and can classify software by type (systems, application, utility) and identify common licensing models.

1. T6 debrief: review any feedback from your teacher. For any marks lost, identify whether it was a syntax error, logic error, or trace table issue. Add to your running error log.
2. Software types: create a three-column table. Systems software: manages hardware and provides a platform (OS, device drivers, firmware). Application software: solves a specific user problem (word processor, spreadsheet, web browser, database management). Utility software: performs maintenance tasks (antivirus, file compression, disk defragmenter, backup tools). List 3 examples for each type.
3. Software licensing models: Proprietary (purchased, closed source; e.g. Microsoft Office); Open source (source code available, free to modify; e.g. LibreOffice, Python); Freeware (free to use but not open source); Shareware (trial version free, payment required for full access); Subscription (monthly/annual fee; e.g. Adobe Creative Cloud). Define each and give one example.
4. Practice question: “A school is choosing between Microsoft Office (subscription) and LibreOffice (open source) for its computer labs. Compare these two licensing models, identifying one advantage and one disadvantage of each for a school context.”
5. Add software types and licensing to your T8 revision list - these are testable in the Module 3 theory test.

By the end of this lesson you can describe each stage of the Software Development Cycle (SDC) and explain how it applies to the T7 Software Development Project.

1. The Software Development Cycle (SDC) is the process for developing a software solution. Define each of the five stages: Problem Statement - define and scope the problem; Design - create pseudocode, flowchart, data dictionary; Develop - write the code; Test - run test data, complete trace table; Evaluate - assess whether the solution meets the requirements.
2. The SDC is similar to the SDLC but focused specifically on writing a software solution. The key difference: SDLC covers the entire information system (hardware, people, procedures); SDC focuses only on the software product.
3. Read the T7 brief (introduced next term). Preview: T7 requires you to apply all SDC stages to a new scenario with a formal problem statement, full design documentation, implemented program, test table, and written evaluation.
4. Start a T7 foundations document this week: write a draft problem statement template and a blank design document (pseudocode + flowchart placeholders) you will populate in Module 3.
5. Practice question: “Describe what happens during the Design stage of the SDC and explain why this stage is important before coding begins.” Write a 4-sentence answer.

By the end of this lesson you have consolidated key Module 2 content and identified the links between database design and programming concepts that will reappear in Module 3.

1. Review T4 and T6 feedback if received. For each task, note: which criteria scored highest, which scored lowest, and what you would do differently.
2. Key term consolidation: without notes, define each of the following: primary key, data dictionary, criteria-based query, validation rule, algorithm, trace table, control structure, constant, syntax error, logic error.
3. Cross-module links: data types appear in both database design (T4) and programming (T6). The concept of validation appears in both Access validation rules (T4) and data validation in code (T6). Write 2 sentences for each link explaining the connection.
4. T7 is the Module 3 Software Development Project. It applies the full SDC to a new scenario. Review the SDC stages from L10 and confirm you understand how your T6 work (pseudocode, code, trace table) maps directly to the SDC stages.
5. Use AI Copilot: ask it to give you 5 database or programming short-answer questions from the WACE CS General syllabus. Answer them without notes, then check.

By the end of this lesson all Module 2 tasks are submitted and you have a clear plan for Term 3.

1. T4 final check: confirm your database submission is uploaded to Google Classroom / Connect. If not yet submitted, submit today - do not wait. Late submissions may not be accepted after the final cutoff.
2. Outstanding work audit: check your grades portal or teacher feedback for any incomplete M2 work. Address any missing components today.
3. Module 2 reflection: write 3 sentences answering each: (a) What was the most challenging part of Module 2? (b) What skill from M2 will you use most in M3? (c) What would you do differently?
4. Term 3 preview: Module 3 contains the Software Development Project (T7 - 12.5%), the Programming & Networks Theory Test (T8 - 10%), and the Network Diagram Practical Test (T9 - 7.5%). Networks are entirely new content. Begin thinking about what you already know about networks from everyday life.
5. Set up a new T7 document for Term 3: title it “T7 Software Development Project”, add the SDC stages as section headers, and save it ready for the first lesson of Term 3.

By the end of this lesson you have read the T7 scenario and written a complete problem statement that identifies inputs, outputs, processing requirements, and scope.

1. Read the T7 scenario on Google Classroom carefully. Create a new Google Doc titled “T7 Software Development Project”. Set up sections for all SDC stages: Problem Statement, Design (Flowchart + Pseudocode), Develop (code), Test, Evaluate.
2. A problem statement defines the problem you are solving. It must identify: Inputs (what data does the program receive?), Outputs (what does the program display or produce?), Processing (what calculations or decisions does the program perform?), Scope (what the program will and will not do).
3. Write your problem statement in 3-5 sentences. Example structure: “The program will [overall purpose]. It will accept [inputs] from the user. The program will [processing steps]. It will display [outputs]. It will not [out of scope].”
4. Identify all variables needed: list each variable name, its data type, and what it stores. Identify any constants (e.g. tax rate, discount threshold).
5. Review the T7 rubric. Design Documentation is worth /15. A strong problem statement sets up strong design and development. Do not rush this stage.

By the end of this lesson you have produced a complete flowchart for your T7 algorithm using correct standard symbols in draw.io.

1. Standard flowchart symbols: Oval/Terminal - START and END; Rectangle/Process - calculations and assignments (e.g. total ← total + price); Parallelogram/I/O - INPUT and OUTPUT; Diamond/Decision - IF condition (two branches: True/False); Circle/Connector - connects distant parts of the flowchart; Arrow - flow direction. Draw and label each symbol in your design doc.
2. Open draw.io. Select the Flowchart shape library. Begin with a START terminal at the top.
3. Work through your algorithm from the problem statement top-to-bottom: add I/O shapes for each input and output, process shapes for calculations, and decision shapes for IF conditions. Connect with arrows. Iteration (loops) is shown as a decision diamond with a back-arrow returning to an earlier point in the chart.
4. Ensure your flowchart includes all three control structures: a straight sequence of steps (sequence), a decision diamond with two branches (selection), and a loop (iteration).
5. Export as PNG and embed in your T7 doc. The flowchart must match the pseudocode you write in L3 - they describe the same algorithm.

By the end of this lesson you have written complete pseudocode for your T7 solution that aligns with your flowchart and uses correct conventions.

1. Pseudocode conventions to follow: BEGIN/END wrap the whole algorithm; DECLARE each variable with data type; CONSTANT for fixed values; INPUT variable for user input; OUTPUT expression for display; variable ← expression for assignment; indent all statements inside IF, FOR, WHILE blocks; ENDIF, ENDFOR, ENDWHILE close each block.
2. Write the full pseudocode for your T7 algorithm in your design doc. Start with DECLARE statements for all variables, then CONSTANT declarations, then BEGIN, then the algorithm body, then END.
3. Verify that your pseudocode and flowchart describe exactly the same algorithm: every decision diamond in the flowchart should correspond to an IF or WHILE in the pseudocode; every loop in the flowchart should correspond to a FOR or WHILE.
4. Check control structures: confirm you have all three. A common mistake is writing only sequence and selection without iteration. If your scenario does not obviously require a loop, re-read it - most scenarios involve processing multiple items or repeating until valid input is received.
5. Get teacher feedback on your design before coding. A correct design in Week 2 means faster, more accurate coding in Weeks 3-6.

By the end of this lesson you have translated your pseudocode into working code and confirmed the basic sequence and input/output is functioning correctly.

1. Open your IDE (Python or teacher-specified). Create a new file named T7_YourName.py. Add a comment block at the top: program name, your name, date, brief description.
2. Translate pseudocode line by line. Work in order: DECLARE → variable initialisation in Python (e.g. total = 0); CONSTANT → uppercase variable at the top (e.g. DISCOUNT_RATE = 0.15); INPUT → variable = input("prompt: ") with type conversion where needed; OUTPUT → print(); assignment → variable = expression.
3. Build incrementally: code the sequence section first and test it. Then add the selection (IF/ELIF/ELSE) and test again. Then add the iteration (loop) and test. Do not try to write the whole program at once.
4. Run the program after each addition with simple normal test data. Fix any syntax errors before proceeding to the next section.
5. Add an internal comment above each major section (e.g. # Get number of items from user, # Apply discount if item exceeds threshold). Comments must explain the purpose of each section, not just restate the code.

By the end of this lesson all three control structures are implemented and tested in your T7 program.

1. Implement the selection structure from your pseudocode. Check your condition carefully: does it use > or >=? Test the boundary case to confirm the correct branch fires at the threshold value.
2. Implement the iteration structure. If using a FOR loop: confirm the range is correct (does it iterate the right number of times?). If using a WHILE loop: confirm the loop terminates correctly and cannot run infinitely for any valid input.
3. Add data validation: wrap any numeric input in a try/except block (Python) or equivalent to handle non-numeric entries gracefully. Display a clear error message and re-prompt.
4. Test all branches: for an IF with three branches (A, B, Fail), test at least one value in each branch. For loops, test with the minimum number of iterations (e.g. 1 item) and a larger set (e.g. 5 items).
5. By end of this lesson the program should be functionally complete. Remaining lessons focus on testing documentation, external documentation, and evaluation.

By the end of this lesson you have completed a test data table with at least 3 normal, 2 boundary, and 2 invalid test cases for your T7 program.

1. Create a test data table in your T7 doc. Columns: Test # - Test Type - Input Data - Expected Output - Actual Output - Pass/Fail.
2. Normal test cases: typical valid inputs that a real user would enter. Choose at least 3 different normal cases that cover different code paths (e.g. one that triggers the discount, one that does not).
3. Boundary test cases: values at the exact edge of valid ranges. If your discount triggers at >$50, test exactly $50 (should NOT trigger) and $50.01 (should trigger). If your loop runs 1-10 times, test 1 and 10.
4. Invalid test cases: inputs outside the valid range or of the wrong type. For a score 0-100: test 101, -1, and “abc”. Document what your program does - if it crashes, this is evidence you need better input validation.
5. Run each test case and record the actual output. If actual ≠ expected, mark as Fail and note what went wrong. Fix the bug and re-run. The test table shows evidence of systematic testing - including failures that you then fixed is fine and demonstrates thoroughness.

By the end of this lesson you have completed a detailed trace table for your T7 program using a non-trivial test case that exercises all three control structures.

1. Choose a test case from your test data table that exercises all three control structures: a case that enters the loop at least twice AND triggers the IF condition at least once. This is a “non-trivial” trace case.
2. Set up your trace table: columns for Step (line number), Statement (the code being executed), and one column for each variable in your program. Add an Output column.
3. Execute the program mentally, step by step. For each statement, update only the variables that change at that step. Leave unchanged variables blank in that row (do not repeat unchanged values in every row).
4. Show each loop iteration separately: if your loop runs 3 times, you should have 3 groups of rows showing the counter and accumulator variables updating each iteration.
5. After completing the trace, confirm the final output matches what the program actually produces when you run it with that test case. If they differ, find the discrepancy - either the trace or the code has an error.

By the end of this lesson you have produced external user documentation for your T7 program that a non-technical user could follow to run and use the program.

1. External documentation (user guide) is written for the end user - someone who does not know how to program. Write in plain language. Avoid technical jargon (no “variable”, “loop”, “function”). Describe what the user sees and does.
2. Structure: (a) Overview - what the program does in 2-3 sentences; (b) System requirements - what software is needed to run it (Python 3.x, or executable); (c) How to run - step-by-step from opening the terminal/IDE to executing the file; (d) How to use - what prompts appear and what the user should enter; (e) Sample output - a screenshot of a successful run; (f) Troubleshooting - what to do if the program shows an error.
3. Take a screenshot of your program running with a sample input. Paste it into the documentation. Add numbered callouts to highlight the input prompt and the output result.
4. Write clear step-by-step instructions for running the program. Each step is one action only. Test your instructions by following them yourself from a fresh terminal.
5. Add a troubleshooting section: list at least 2 common errors a user might encounter (e.g. entering text where a number is expected) and explain what will happen and what to do.

By the end of this lesson you have written a strong evaluation of your T7 solution and completed a rubric self-assessment identifying any remaining gaps.

1. Your evaluation must be written in full sentences and explicitly reference your original problem statement requirements. Structure: (a) Does the program meet the stated requirements? Address each requirement from your problem statement. (b) Strengths of the solution. (c) Limitations - what does not work perfectly, or what was not implemented? (d) Improvements - what would you add or change with more time?
2. Link evaluation points to your test data: “The test data table confirms the program correctly handles all normal cases (Tests 1-3). However, Test 6 (invalid input ‘abc’) revealed that the validation loop did not display a clear error message - this was corrected in version 2.”
3. Limitations to consider: the program does not save results to a file; it only handles one session at a time; the interface is text-based (could be improved with a GUI); validation only checks for numeric input (does not check for negative numbers).
4. Rubric self-assessment: go through each criterion. For each, write your estimated grade (A-E) and one sentence explaining your reasoning. For any criterion below C, identify the specific missing element and address it before submission.
5. Share your complete T7 doc with your teacher for feedback this week. Act on feedback before the Week 9 submission deadline.

By the end of this lesson your T7 program and documentation are in final submission-ready form.

1. Code quality review: read through every line of your program. Check: are all variable names meaningful (no single-letter variables except loop counters)? Is every constant defined at the top? Are all major sections commented? Is the code consistently indented?
2. Final test run: run your program with each row of your test data table. Confirm every actual output matches the expected output. Update the test table if you made any changes since last testing.
3. Documentation review: does your user guide match the final version of the program? If you changed the program since writing the guide (e.g. changed prompts or output format), update the guide and screenshots.
4. T7 submission checklist: ☐ Problem statement; ☐ Flowchart (draw.io, embedded in doc); ☐ Pseudocode; ☐ Program (.py file with internal comments); ☐ External user documentation; ☐ Test data table (normal + boundary + invalid); ☐ Trace table; ☐ Evaluation (full sentences, references requirements).
5. Package and submit: zip your .py file and your T7 documentation doc. Upload to Google Classroom / Connect. Submission due end of Week 9.

By the end of this lesson you can define PAN, LAN, and WAN, describe typical uses of each, and explain why organisations use networks.

1. A computer network is two or more devices connected to share resources and communicate. Create a T8/T9 revision document. Define: PAN (Personal Area Network - very short range, typically <10m; connects personal devices, e.g. phone to Bluetooth headphones, smartwatch to phone); LAN (Local Area Network - limited geographic area such as a building or campus; connects devices within a home, office, or school); WAN (Wide Area Network - spans large geographic areas; the internet is the largest WAN; connects LANs across cities, countries, or globally).
2. Why use a network? Benefits: resource sharing (printers, storage, software), communication (email, messaging), centralised data management, internet access. Write 2 sentences on each benefit.
3. Network ownership: Private network (owned and managed by one organisation, e.g. school LAN); Public network (accessible to anyone, e.g. public Wi-Fi, the internet).
4. Practice question: “A student uses a Bluetooth connection to connect wireless earphones to their phone while working on a school LAN. Identify the type of network for each connection and justify your answer.”
5. Add PAN, LAN, and WAN definitions and examples to your T8 revision doc. These terms appear in both the T8 theory test and the T9 network diagram practical.

By the end of this lesson T7 is submitted and you have begun building your networks knowledge for T8 and T9.

1. Final T7 check: run through the submission checklist from L10. Confirm everything is packaged and uploaded to Google Classroom / Connect. T7 is due end of Week 9.
2. Begin T8/T9 networks content. Network hardware: define each component: Router (connects different networks, directs traffic between them; e.g. connects LAN to the internet); Switch (connects devices within a LAN; sends data only to the intended device); Hub (older device; broadcasts data to all devices on the network - less efficient than a switch); Access Point (AP) (provides wireless connectivity to a LAN); NIC (Network Interface Card - the hardware in a device that connects it to a network); Modem (modulates/demodulates signals to connect to the ISP).
3. CISCO symbols: network diagrams use standardised CISCO symbols for each hardware component. In your T8/T9 revision doc, sketch (or paste) the CISCO symbol for: router, switch, server, workstation, laptop, printer, firewall, and cloud (internet). You will use these in T9.
4. Practice: draw a simple home network from memory using CISCO symbols. Include: modem, router, switch, 2 workstations, 1 wireless laptop, 1 printer. Label every component.
5. T8 (theory test) is Week 7 and T9 (network diagram practical) is Week 8. You have this week and next to build networks knowledge. Focus on T8/T9 content for the remaining lessons this module.

By the end of this lesson you can describe all four network topologies, draw a simple diagram of each, and identify one advantage and one disadvantage of each.

1. A network topology is the physical or logical arrangement of devices and connections. Create a topology table in your revision doc: Topology - Diagram (sketch) - How it works - Advantage - Disadvantage - Single point of failure.
2. Star topology: all devices connect to a central switch or hub. Most common in modern LANs. Advantage: if one device fails, the rest are unaffected. Disadvantage: if the central switch fails, the entire network goes down - the switch is a single point of failure.
3. Bus topology: all devices connect to a single central cable (the bus/backbone). Data travels in both directions along the cable. Advantage: simple and cheap to set up. Disadvantage: if the backbone cable fails, the entire network goes down; performance degrades as more devices are added.
4. Ring topology: devices connect in a closed loop; data travels in one direction (or both in dual-ring). Advantage: predictable performance; no collisions. Disadvantage: if one device or connection fails, the whole network can be affected.
5. Mesh topology: every device connects to every other device (full mesh) or some devices have multiple connections (partial mesh). Advantage: highly fault-tolerant; no single point of failure. Disadvantage: expensive and complex to set up due to the large number of cables needed.

By the end of this lesson you can identify and describe the role of all key network hardware components and distinguish between similar devices.

1. For each component, write: name, function, and one real-world example location. Router: connects different networks and directs data packets between them; connects a LAN to the internet. Switch: connects devices within a LAN; sends data only to the intended destination device (unlike a hub). Hub: connects devices within a LAN but broadcasts all data to every connected device - inefficient and largely replaced by switches.
2. Wireless Access Point (WAP/AP): extends a wired LAN to wireless devices. NIC (Network Interface Card): hardware inside a device that enables network connection (wired or wireless). Modem: converts digital data to analogue signals for transmission over phone lines (and vice versa); connects to the ISP.
3. Firewall: monitors and filters incoming and outgoing network traffic based on security rules; blocks unauthorised access. Can be hardware or software. Server: a computer that provides services to other devices on the network (file server, print server, web server, email server).
4. Switch vs Hub: write 3 sentences comparing these two devices. Key distinction: a switch sends data only to the intended device (uses MAC addresses); a hub broadcasts to all devices.
5. Practice question: “A school network has 30 computers, a wireless access point for tablets, and a connection to the internet. Identify the role of the router, switch, and wireless access point in this network.”

By the end of this lesson you can compare wired and wireless transmission media by speed, range, cost, and security.

1. Create a comparison table: Media Type - Wired/Wireless - Typical Speed - Range - Interference Susceptibility - Cost - Best Use Case.
2. Twisted pair cable (UTP): the most common wired media; copper wires twisted together to reduce interference; used in most LAN connections. Cheap, moderate speed (up to 10 Gbps for Cat6). Coaxial cable: central copper conductor with insulation; used in older networks and cable TV; higher interference resistance than UTP.
3. Fibre optic cable: transmits data as light pulses through glass or plastic fibres; extremely high speed (up to 100 Gbps+), long range, immune to electromagnetic interference; expensive and fragile. Used for backbone connections and internet infrastructure.
4. Wi-Fi (IEEE 802.11): wireless LAN standard; typical range up to ~100m indoors; susceptible to interference and security risks compared to wired; speed varies by standard (802.11ac up to ~3.5 Gbps theoretical). Bluetooth: short-range wireless (up to ~10m); used for PAN connections (headphones, mice, keyboards).
5. Practice question: “A hospital network requires high-speed, secure connections between buildings 500m apart. Identify the most appropriate transmission media and justify your choice.”

By the end of this lesson you can define a protocol and describe the purpose of each required protocol with its use case.

1. A protocol is a set of rules governing how data is transmitted and received across a network. Protocols ensure devices from different manufacturers can communicate. Create a protocol reference table: Protocol - Full Name - Purpose - Use Case.
2. TCP/IP (Transmission Control Protocol / Internet Protocol): the foundational protocol suite of the internet; TCP ensures reliable, ordered data delivery; IP handles addressing and routing. HTTP (HyperText Transfer Protocol): used to transfer web pages from servers to browsers. HTTPS: secure version of HTTP using encryption (TLS/SSL).
3. FTP (File Transfer Protocol): used to transfer files between computers over a network; allows uploading and downloading files to/from a server. DNS (Domain Name System): translates human-readable domain names (e.g. google.com) into IP addresses (e.g. 142.250.70.14).
4. Email protocols: SMTP (Simple Mail Transfer Protocol) - used to send email from a client to a mail server, or between mail servers; POP3 (Post Office Protocol 3) - downloads email from server to client, then deletes from server; IMAP (Internet Message Access Protocol) - accesses email on the server without downloading it, synchronised across multiple devices.
5. Practice question: “A user accesses their email on their phone and laptop simultaneously. Which email protocol is most appropriate and why? Contrast with POP3.”

By the end of this lesson you can describe at least 3 network security methods and define 4 malware types with distinguishing characteristics.

1. Network security methods: Firewall - monitors and filters network traffic; blocks unauthorised access based on rules. Encryption - scrambles data so only authorised parties can read it; HTTPS, VPN, WPA2/3 all use encryption. Authentication - verifying identity before granting access; methods: password, multi-factor authentication (MFA), biometrics. VPN (Virtual Private Network) - creates an encrypted tunnel over a public network, allowing secure remote access. Access control - restricting who can access which network resources (user accounts, permissions). Write 2 sentences on each.
2. Malware (malicious software): Virus - attaches to legitimate files; spreads when infected files are shared; requires a host file to propagate. Worm - self-replicating; spreads across networks independently without needing a host file; can congest network bandwidth. Trojan - disguises itself as legitimate software; does not self-replicate; often used to create backdoor access. Ransomware - encrypts the victim’s files and demands payment for the decryption key. Spyware - secretly monitors user activity and sends data to a third party.
3. Phishing: a social engineering attack (not malware) where users are tricked into revealing credentials via fake emails or websites. Define it separately from malware.
4. Create a malware comparison table: Type - How it spreads - What it does - How to prevent it.
5. Practice question: “Describe the difference between a virus and a worm. How does each spread across a network?” Write a 4-sentence answer.

By the end of this lesson you can answer T8-style questions on software types, licensing models, and SDC stages with accurate terminology.

1. Software types rapid review: define Systems, Application, and Utility software with 2 examples each. Practice question: “Classify each of the following as systems, application, or utility software: (a) Microsoft Word; (b) Windows 11; (c) Norton Antivirus; (d) Google Chrome; (e) Device driver.”
2. Licensing rapid review: define Proprietary, Open source, Freeware, Shareware, Subscription. Practice question: “A school is deciding between purchasing Microsoft Office (subscription licence) and installing LibreOffice (open source). Compare these options, identifying one advantage and one disadvantage of each for the school.”
3. SDC stages: from T6/T7, you know all five stages. Write the stage name and one sentence on each from memory: Problem Statement, Design, Develop, Test, Evaluate. These are directly testable in T8.
4. Short answer technique reminder: use DEEC (Definition, Explanation, Example, Context). A 4-mark question needs 4 distinct accurate points. Know the terms; use them precisely.
5. Add 3 software/SDC questions to your T8 practice test pile for L11.

By the end of this lesson you can answer T8-style questions on programming data types, control structures, error types, and data validation.

1. Data types rapid review: Integer, Real/Float, String, Boolean, Constant - definitions and examples. Practice: “A program stores a student’s name, age, test score (decimal), and whether they passed. Identify the appropriate data type for each.”
2. Control structures: sequence (statements in order), selection (IF/ELIF/ELSE - branches based on condition), iteration (FOR/WHILE - repeats until condition met or count reached). Write a 2-line pseudocode example of each.
3. Error types: Syntax (detected before running - breaks language rules), Runtime (detected during execution - program crashes), Logic (program runs but output is wrong). Practice: for each code snippet, identify the error type: (a) missing colon after IF; (b) dividing by zero; (c) using + instead of * in total calculation.
4. Data validation: Range check (value within min/max), Type check (correct data type), Presence check (not empty), Length check (string length within limits). Practice: for each scenario, identify the most appropriate validation type: (a) ensuring age is between 0 and 120; (b) ensuring a required name field is not blank; (c) ensuring a password is at least 8 characters.
5. Add 3 programming knowledge questions to your T8 practice test pile for L11.

By the end of this lesson you can apply networks knowledge to scenario-based T8 questions, justifying hardware, topology, and security choices.

1. Scenario practice: “A small business has 8 desktop computers, 1 printer, and 1 internet connection. (a) Recommend a network topology and justify your choice. (b) Identify two hardware components required and describe their role. (c) What type of transmission media would you recommend for the desktop connections and why?” Write full answers.
2. Scenario practice: “A business suspects its network has been infected with malware. (a) Describe two security measures the business should implement to prevent future attacks. (b) Explain the difference between a virus and a worm in terms of how they spread.”
3. Protocol scenario: “An employee works from home and needs to: (a) access the company website; (b) upload files to the company server; (c) read emails on both their phone and laptop. Identify the most appropriate protocol for each task and explain why.”
4. Transmission media scenario: “A university is connecting two buildings 200m apart. Compare fibre optic cable and Wi-Fi for this connection, identifying one advantage and one disadvantage of each.”
5. Record any questions you cannot answer confidently. These are your T8 priority topics for L11.

By the end of this lesson you can identify CISCO symbols for all required hardware components and understand what T9 requires.

1. CISCO symbols are the industry standard for network diagrams. In your T9 revision doc, draw or paste the CISCO symbol for each component: Router, Switch, Hub, Wireless Access Point, Firewall, Server, Workstation (desktop PC), Laptop, Printer, Cloud (represents the internet). Label each.
2. Conventions for annotated network diagrams: use CISCO symbols (not generic shapes); label every component with its name and role; label all connections with the transmission media type; indicate the network type (LAN/PAN) where relevant.
3. Read the T9 brief overview: the practical test requires you to produce an annotated network diagram from a provided scenario in approximately 50 minutes. You may also need to answer short questions about security and protocols based on your diagram.
4. Practice: draw a network diagram for a 10-device school computer lab with a shared internet connection. Use CISCO symbols. Label every component and connection. Include: 8 workstations, 1 switch, 1 router, 1 printer, 1 wireless access point for 2 tablets, 1 firewall, internet cloud.
5. Get your practice diagram checked by your teacher before L10. Correct use of CISCO symbols is the primary criterion for T9.

By the end of this lesson you can apply the DEEC answer structure to T8-style questions and manage time effectively across the 50-minute test.

1. T8 is /25 marks in ~50 minutes = ~2 minutes per mark. Allocate: 1-mark = 1 sentence (1 min); 2-mark = 2 sentences (2 min); 4-mark = 4 sentences / DEEC structure (8 min). Write this guide in your revision notes.
2. DEEC refresher: Definition (what is it?), Explanation (how does it work?), Example (real-world instance), Context (applied to the question scenario). Not every question needs all four - match depth to mark allocation.
3. Upgrade practice: rewrite these weak answers to A-level: (a) “A firewall protects the network.” (b) “Star topology has a central switch.” (c) “IMAP is an email protocol.”
4. Identify your top 5 topics most likely to appear on the test. For each, write one model answer (3-4 sentences) as a revision exercise. Practice saying the answer aloud from memory.
5. Strategy for the actual test: read all questions before starting. Answer the questions you are most confident about first to secure those marks. Return to difficult questions with remaining time.

By the end of this lesson you have completed a full 50-minute T8 practice test and identified final revision priorities.

1. Set a 50-minute timer. No notes, no internet, no AI. Complete this practice on paper as a simulation - the actual test is on Socrative. Questions across T8 content: (1) Classify three software types and give one example each. /3 (2) Describe the difference between a virus and ransomware. /2 (3) A business uses a star topology LAN. Describe one advantage and one disadvantage. /2 (4) Explain the purpose of IMAP and contrast with POP3. /3 (5) Describe the role of a router in a network. /2 (6) A program contains the code: total = count * unitprice. The programmer intended multiplication but the output is wrong. Identify the error type and explain why. /2 (7) Define four data validation methods with an example of each. /4 (8) Describe three security measures an organisation can implement to protect its network. /3 (9) Compare fibre optic cable and Wi-Fi as transmission media. /2 (10) Describe what happens during the Test stage of the SDC. /2
2. Mark using your revision notes. For each question lost: identify which content area and add to your final revision list.
3. Final revision priorities: the top 3 areas where you lost most marks. Spend 20 minutes re-reading only those areas tonight.
4. The T8 theory test is next lesson. Make sure Socrative opens on your device before the test. Do not try to learn new content the night before.

By the end of this lesson you have debriefed the T8 test, reviewed your CISCO diagram skills, and are prepared for the T9 network diagram practical.

1. T8 debrief: review feedback when returned. For each mark lost, write the correct answer. Identify which content area cost you the most marks.
2. T9 practical is next lesson. It requires: (a) annotated CISCO network diagram(s) produced in draw.io or on paper from a provided scenario; (b) short written answers about security and protocols. Approximately 50 minutes.
3. Diagram drawing speed check: set a 10-minute timer and draw a complete annotated LAN diagram from memory (no notes) for a 6-device office network. Include: 4 workstations, 1 switch, 1 router, 1 firewall, 1 printer, internet cloud. Use CISCO symbols, label all components and connections. If it takes more than 10 minutes, practise until you can do it faster.
4. Review your L9 practice diagram. Confirm: every component uses the correct CISCO symbol; every component is labelled with name and role; all connections are drawn; transmission media is labelled on at least the key links.
5. T9 strategy: read the scenario fully before drawing. Identify all components and connections described. Sketch a rough layout, then draw the final diagram neatly. Label as you draw - do not leave labelling until the end (time runs out).

By the end of this lesson you can identify and correctly draw CISCO symbols for all required network components and apply annotation conventions.

1. Open draw.io and locate the Network shapes library (Extras → Edit Diagram, or search “cisco” in the shape search). Alternatively, use the built-in Network shapes. Identify the CISCO symbol for each: Router, Layer 3 Switch, Layer 2 Switch, Wireless Access Point, Firewall, Server, Workstation/PC, Laptop, Printer, Generic Device, Cloud (internet).
2. Annotation standards: every component label should follow the format: Device Name (Role). Example: “Router (connects LAN to internet)”. For connections: label the line with the transmission media type (e.g. “UTP Cat6”, “Wi-Fi 802.11ac”, “Fibre Optic”).
3. Create a CISCO symbols reference sheet in draw.io: place each symbol with its correct label. Save this as a template you can reference during practice sessions (you will not have it in the actual test, but building it now builds memory).
4. Draw a simple PAN from memory: a smartphone connected to wireless earphones and a smartwatch via Bluetooth. Use appropriate symbols (generic device shapes with Bluetooth labels). Annotate each connection and device.
5. Draw a simple LAN: 3 workstations connected to a switch, connected to a router, connected to the internet cloud. Label everything. This is the basic LAN pattern you will build on in subsequent lessons.

By the end of this lesson you have produced a complete annotated CISCO LAN diagram from a scenario description.

1. Process for reading a network scenario: (a) underline every hardware component mentioned; (b) identify how many of each device; (c) identify how they connect; (d) identify any wireless components; (e) identify if internet access is required. Only then start drawing.
2. Scenario: “A real estate office has 6 desktop computers, 1 laptop, 1 shared network printer, and 1 file server. All devices connect to a central managed switch. A router connects the network to the internet. A wireless access point provides Wi-Fi for the laptop. A firewall sits between the router and the internet.” Draw this network in draw.io.
3. Drawing order: (1) place the internet cloud at the top; (2) firewall below the cloud; (3) router below the firewall; (4) switch below the router; (5) devices connected to the switch; (6) WAP connected to the switch; (7) laptop connected wirelessly to the WAP.
4. Label every component (name + role) and every connection (media type). For the wired connections: UTP Cat6. For the wireless connection: Wi-Fi 802.11ac.
5. Export the diagram as PNG and compare it with a peer’s diagram. Are all components present? Are all connections labelled? Identify any differences and discuss which is more accurate.

By the end of this lesson you can represent both a LAN and a PAN in a single diagram with clear zones and correct CISCO conventions.

1. When a scenario includes both a LAN and a PAN, use zones (grouped areas or different background colours) to visually separate the two network types. Label each zone clearly (“LAN”, “PAN”).
2. Scenario: “A marketing manager uses a LAN at their office (4 desktops, 1 server, 1 switch, 1 router, internet) and also has a personal PAN on their desk (laptop, wireless mouse, Bluetooth headset, smartphone). The laptop connects to the office LAN via Wi-Fi.”
3. Draw the LAN zone first (top half of diagram). Then draw the PAN zone (bottom half). Show the laptop in the PAN zone with a Wi-Fi connection to the office WAP (which is part of the LAN zone). This connection bridges the two zones.
4. Label all Bluetooth connections in the PAN as “Bluetooth (PAN)”. Label the laptop-to-WAP connection as “Wi-Fi 802.11ac (LAN access)”.
5. Check your diagram: (a) are all CISCO symbols correct? (b) are both network types clearly labelled? (c) is the bridging connection between PAN and LAN shown and labelled? (d) are all devices labelled with name and role?

By the end of this lesson you can correctly place and annotate a firewall in a network diagram and write short answers on network security measures.

1. Firewall placement: a firewall sits between the router (facing the internet) and the internal network switch. It monitors and filters all traffic entering or leaving the network. In your diagram, the correct order from internet to LAN is: Internet cloud → Router → Firewall → Switch → internal devices.
2. Annotate the firewall in your diagram: label it “Firewall (filters inbound and outbound traffic, blocks unauthorised access)”.
3. Additional security annotations you can include: label the WAP connection as “WPA3 encrypted Wi-Fi”; label the internet connection as “HTTPS encrypted traffic”; add a note “Password-protected access for all user accounts” as a text annotation near the server.
4. Written security practice: T9 includes short written questions. Practice: “The office network in the diagram is connected to the internet. Identify two security measures shown in the diagram and explain how each protects the network.” Write a 4-sentence answer referencing specific elements of your diagram.
5. Practice: “A new employee connects their personal laptop to the office Wi-Fi. Describe one security risk this introduces and identify a network security measure that would reduce this risk.”

By the end of this lesson you can identify the appropriate protocol for a described network activity and write a justified short answer.

1. Protocol selection practice: for each scenario activity, identify the protocol and write a 2-sentence justification: (a) A user accesses the company website from home. (b) The IT manager uploads updated software to the company FTP server. (c) An employee reads email on their phone and laptop simultaneously. (d) A customer purchases a product on the company website. (HTTPS, not HTTP - explain why). (e) The company email server sends an email to a client’s email server.
2. IMAP vs POP3 deep practice: the most commonly tested protocol distinction. Write 4 sentences comparing them: define IMAP (server-side storage, sync across devices), define POP3 (downloads to device, deletes from server), when to use IMAP (multiple devices), when POP3 might be used (limited server storage, offline access needed).
3. Add protocol annotation to your L2 diagram: add a text box listing which protocols are relevant to that network. Example: “HTTP/HTTPS: web browsing; SMTP/IMAP: email; FTP: file transfers to/from server.”
4. T9 written answer structure for protocols: always include: (a) name the protocol; (b) state what it does; (c) explain why it suits the described scenario. Three parts = typically 3 marks.
5. Practice: write a full 4-sentence answer for: “The office manager wants to access company emails on both a desktop computer and a smartphone. Identify the most appropriate email protocol and explain your choice.”

By the end of this lesson you have completed a timed 50-minute network diagram practical for a school scenario and self-assessed against the T9 rubric.

1. Set a 50-minute timer. No notes, no internet. Scenario: “Busselton Senior High School has a computer lab with 20 desktop workstations, 2 servers (file and print), 1 managed switch, 1 router, 1 hardware firewall, and 1 wireless access point for teacher laptops. The network connects to the internet. The school also has a PAN in the principal’s office (smartphone, Bluetooth headset, tablet). Draw an annotated CISCO network diagram representing this setup. Then answer: (a) Identify two security measures and explain how each protects the school network. (b) A teacher wants to email lesson materials to parents using both a school desktop and a home laptop. Identify the most appropriate email protocol and justify your choice.”
2. Time allocation: diagram (35 minutes), written answers (15 minutes). Start the diagram immediately after reading - do not plan on paper for more than 2 minutes.
3. After the timer: self-assess using the T9 rubric. For Diagram Accuracy: are all components present and using CISCO symbols? For Component Labelling: are all devices named with roles? For Security & Protocols: did you answer both written questions with correct terminology?
4. Identify your weakest rubric criterion. This is your T9 priority for L7 onwards.

By the end of this lesson you have completed a second timed practice with a more complex scenario and improved your diagram speed and accuracy.

1. Set a 50-minute timer. No notes, no internet. Scenario: “Busselton Regional Hospital has two network zones: Admin Zone (5 admin PCs, 1 server, 1 network printer, 1 switch) and Clinical Zone (8 clinical workstations, 1 medical records server, 1 switch). Both zones connect via a central router. A firewall separates the entire hospital network from the internet. A wireless access point in the waiting room provides public guest Wi-Fi. Draw an annotated CISCO diagram. Then: (a) Explain why the hospital uses a firewall and identify one other security measure appropriate for this network. (b) Admin staff need to access patient records on the server from home. Identify the most appropriate technology to enable this securely and explain why.”
2. This scenario has two LAN zones. Use separate zone boxes (dashed rectangles) labelled “Admin Zone” and “Clinical Zone”. Connect both zones to the central router.
3. For the written questions: (a) firewall answer should reference filtering traffic and blocking unauthorised access; suggest encryption, authentication, or access control as a second measure. (b) VPN is the correct answer for secure remote access - explain that it creates an encrypted tunnel over the public internet.
4. Compare your L6 and L7 diagrams: is your L7 diagram faster and more complete? Identify one specific thing you improved between the two practicals.
5. The T9 practical test is this week (Week 8). Arrive knowing your CISCO symbols by memory and the order of components from internet to internal devices (Cloud → Router → Firewall → Switch → devices).

By the end of this lesson you have debriefed T9, reviewed the full-year course, and reflected on your growth across all three modules.

1. T9 debrief: when your marked test is returned, go through each criterion. For Diagram Accuracy: which CISCO symbols were wrong or missing? For Component Labelling: which devices were unlabelled? For Security & Protocols: what was missing from your written answers?
2. Full-year assessment overview: review your marks across all 9 tasks. Calculate your estimated final mark percentage. Identify your two strongest and two weakest tasks and reflect on why.
3. Skills gained this year: list the skills from each module that you believe are genuinely transferable. Module 1: systems analysis, hardware knowledge, spreadsheet proficiency. Module 2: database design, programming fundamentals, EST preparation. Module 3: software development, network design, technical documentation.
4. Outstanding submissions: check for any incomplete or unsubmitted tasks. Contact your teacher now if any work is still outstanding before final grades are processed.
5. Congratulations on completing Year 12 CS General. The SDC, database design, network architecture, and programming fundamentals from this course are foundations for further study in Computer Science, IT, or any technical field.

By the end of this lesson you can explain the purpose of an IP address and describe the difference between IPv4 and IPv6, private and public IP addresses, and static and dynamic addressing.

1. An IP address is a unique numerical label assigned to every device on a network that enables devices to be identified and located. IPv4 addresses are 32-bit (e.g. 192.168.1.1, written as 4 octets separated by dots). IPv6 addresses are 128-bit (e.g. 2001:0db8:85a3::8a2e:0370:7334) - created to accommodate the exhaustion of IPv4 addresses.
2. Private vs public IP addresses: Private (used within a LAN; not routable on the internet; ranges: 192.168.x.x, 10.x.x.x, 172.16.x.x-172.31.x.x); Public (assigned by ISP; globally unique; used on the internet). NAT (Network Address Translation) on the router maps private LAN addresses to the single public IP address.
3. Static vs dynamic addressing: Static (manually assigned; permanent; used for servers, printers, network devices); Dynamic (automatically assigned by DHCP server when a device connects; changes between sessions; used for most client devices).
4. Add IP address annotations to your L2 diagram: assign private IPs (e.g. 192.168.1.1 for router, 192.168.1.2 for server, 192.168.1.10-192.168.1.15 for workstations). Mark the router interface to the internet as the public IP address.
5. Practice question: “Explain why devices on a LAN use private IP addresses and how they are able to communicate with servers on the internet despite not having a public IP address.” Write a 4-sentence answer mentioning NAT.

By the end of this lesson you can define cloud computing, describe the three service models, and discuss advantages and disadvantages for organisations.

1. Cloud computing: delivering computing services (servers, storage, software, networking) over the internet (“the cloud”) rather than on local hardware. Users access resources on-demand and pay only for what they use.
2. Three service models: IaaS (Infrastructure as a Service - provides virtualised computing infrastructure; organisation manages OS, software; e.g. AWS EC2, Azure VMs); PaaS (Platform as a Service - provides a development platform; developers deploy apps without managing infrastructure; e.g. Google App Engine, Heroku); SaaS (Software as a Service - provides software over the internet; user accesses via browser; e.g. Google Workspace, Microsoft 365, Salesforce). Write one example and one use case for each.
3. Advantages of cloud computing for organisations: scalability (increase/decrease resources as needed), reduced upfront hardware costs, automatic software updates, accessibility (access from anywhere), disaster recovery. Disadvantages: depends on internet connection, ongoing subscription costs, data security and privacy concerns, vendor lock-in.
4. Virtualisation: running multiple virtual machines (VMs) on a single physical server using a hypervisor. Each VM has its own OS and acts as an independent computer. Advantages: better hardware utilisation, easy to create/destroy VMs, isolation between VMs.
5. Practice question: “A small business is deciding whether to purchase their own file server or use a cloud storage service. Compare these two options, identifying two advantages and one disadvantage of the cloud option.”

By the end of this lesson you can define the Internet of Things, give examples of IoT applications, and discuss security and privacy implications.

1. IoT (Internet of Things): the network of physical devices embedded with sensors, software, and connectivity that collect and exchange data over the internet. Examples: smart thermostats, fitness trackers, smart door locks, industrial sensors, connected vehicles.
2. IoT in industry: agriculture (soil moisture sensors, automated irrigation), healthcare (remote patient monitoring, smart implants), manufacturing (predictive maintenance sensors), smart cities (connected traffic lights, waste management). Write 2 sentences on one industry application.
3. Smart home IoT: devices connected to a home network and controllable via smartphone or voice assistant. Examples: smart TV, smart speaker, connected lighting, smart security camera. Draw a simple home network diagram that includes IoT devices.
4. Security and privacy concerns of IoT: (a) many IoT devices have weak default passwords or no encryption; (b) large attack surface - each device is a potential entry point for attackers; (c) data collection raises privacy concerns (voice assistants listening, location tracking); (d) firmware updates often not applied by users. Describe 2 concerns in your own words.
5. Practice question: “A hospital is considering implementing IoT devices to monitor patient vital signs remotely. Identify two benefits and two security risks of this approach.”

By the end of this lesson you can describe social engineering attacks, explain the concept of penetration testing, and identify user-level security responsibilities.

1. Social engineering: manipulating people rather than systems to gain unauthorised access. Types: Phishing (fraudulent emails/websites to steal credentials), Spear phishing (targeted at a specific person), Vishing (phone calls), Tailgating (physically following an authorised person through a secure door). Define each and give one real-world example.
2. Why technical controls are not enough: even with firewalls, encryption, and antivirus, a single user clicking a phishing link can compromise an entire network. Write 2 sentences explaining why user education is a critical security layer.
3. Penetration testing (pen testing): authorised simulated attacks on a system to identify vulnerabilities before malicious attackers find them. Companies hire ethical hackers (white hat hackers) to test their defences. Define and describe the purpose in 3 sentences.
4. Zero-day vulnerability: a software flaw not yet known to the vendor; no patch exists. Attackers exploit these before a fix is released. Software vendors release patches to fix known vulnerabilities - this is why keeping software updated is a critical security practice.
5. User responsibilities: create a list of 5 personal cybersecurity habits every network user should follow (e.g. use strong unique passwords, enable MFA, do not click unknown links, keep software updated, report suspicious emails). These could appear as written answer content in any theory test.