THINK IN CODE.
& BUILD REAL SOLUTIONS.

By the end of this lesson you can write a Python program that uses print(), a variable, and gets input from the user.

1. Go to replit.com and sign in (or create a free account). Create a new Repl and choose Python. Name it T1_Python_Foundations.
2. In main.py, type: print("Hello, World!") then click Run. You should see the message appear in the console. This confirms Python is working.
3. Variables: type name = "Alex" then print(name). Run it. A variable stores a value. The name on the left is the label; the value on the right is what it holds.
4. Data types: try four types in your program. String: greeting = "Hello". Integer: age = 16. Float: score = 9.5. Boolean: is_logged_in = True. Print each one.
5. Input: type user_name = input("What is your name? ") then print("Nice to meet you, " + user_name + "!"). Run it. Type your name when prompted.
6. Add a comment above each section using # this is a comment. Comments explain your code for the reader. Add at least three comments before the end of the lesson.

By the end of this lesson you can write an if/elif/else statement that responds differently based on user input.

1. Open your T1 Replit. Comparison operators: == equal to, != not equal, > greater than, < less than, >= and <=. These return True or False.
2. Write a basic if statement:
   score = int(input("Enter your score: "))
if score >= 50:
    print("Pass")
else:
    print("Not yet")
3. Extend to if/elif/else with three or more branches. Add grades: A (80+), B (60-79), C (50-59), Below (under 50). Test with different inputs.
4. Indentation: Python uses 4 spaces (or 1 tab) to define code blocks. Every line inside an if/elif/else must be indented. Missing indentation is one of the most common Python errors.
5. Build a mini password checker: ask the user to enter a password. If it equals a stored password, print "Access granted". Otherwise, print "Access denied". This models real selection logic.

By the end of this lesson you can write both a for loop and a while loop to repeat a block of code.

1. For loop with range: for i in range(5): print(i) - prints 0 to 4. Try range(1, 6) - prints 1 to 5. Try range(0, 20, 2) - prints even numbers.
2. For loop over a list: scores = [85, 72, 91, 60]
for score in scores:
    print(score)
3. While loop: count = 0
while count < 5:
    print(count)
    count += 1. Important: without count += 1 this runs forever (infinite loop). Always make sure your while condition can become False.
4. Input validation loop: keep asking the user for a number between 1 and 10 until they enter a valid one. Use a while loop with the condition while num < 1 or num > 10:
5. Add a # comment above each loop explaining what it does and why you chose for vs while.

By the end of this lesson you can define and call a function with parameters that returns a calculated value.

1. A function is a named block of reusable code. Define with def:
   def greet(name):
    return "Hello, " + name + "!"
   Call it: print(greet("Alex"))
2. Parameters are the inputs to a function. Return sends a value back to the caller. A function without return gives back None.
3. Write a function calculate_grade(score) that returns "A", "B", "C", or "Below" based on the score. Call it with at least 3 different values.
4. Docstrings: the first line inside a function should be a triple-quoted description:
   def greet(name):
    """Returns a greeting string for the given name."""
    return "Hello, " + name
5. Write a second function get_average(scores) that takes a list and returns the average. Test it with your list from L3.

By the end of this lesson you have designed your T1 program structure and built a working menu loop that stores scores in a list.

1. Program design: your T1 program is a high-score tracker. Plan it first. Write in a comment block at the top: what it does, what inputs it needs, what it outputs, and which functions you will need.
2. Create a new Python file Smith_J_T1_main.py. Start with a list to store scores: scores = []
3. Build a menu with a while loop:
   while True:
    print("1. Add score 2. View scores 3. Quit")
    choice = input("Choose: ")
    if choice == "1":
        pass # we'll add this next
    elif choice == "3":
        break
4. Add score option: prompt for player name and score, validate the score is a number between 0 and 100 (use try/except or if/else), then append to scores list as a tuple: scores.append((name, score))
5. View scores: loop over the list and print each entry clearly. Use an f-string: print(f"{name}: {score}")

By the end of this lesson you can write a Python program that saves data to a file and reads it back correctly.

1. Writing to a file: with open("scores.txt", "w") as f:
    f.write("Alex,95 ")
    f.write("Sam,82 "). The "w" mode creates or overwrites. The "a" mode appends.
2. Reading from a file: with open("scores.txt", "r") as f:
    for line in f:
        print(line.strip()). The with statement automatically closes the file when done.
3. The at the end of each write adds a newline. strip() removes whitespace and newline characters when reading.
4. Integrate into your T1 program: add a save_scores(scores) function that writes all scores to a file, and a load_scores() function that reads them back. Call load_scores() at program start so scores persist between runs.
5. Test: add some scores, quit the program, run it again - the scores should still be there. This is the key requirement for the T1 rubric’s File Handling criterion.

By the end of this lesson you can use try/except to handle input errors so your program doesn’t crash when users enter unexpected data.

1. Problem: if a user types "abc" when you call int(input(...)), Python raises a ValueError and crashes. Try it: score = int(input("Enter score: ")) - type "hello" and watch it crash.
2. Solution - try/except:
   try:
    score = int(input("Enter score: "))
except ValueError:
    print("Please enter a number.")
    score = 0
3. Wrap the score entry in your T1 program with try/except. Also add a while loop so it keeps asking until valid input is received.
4. Add file error handling: wrap your load_scores() in try/except FileNotFoundError so the program handles the case where the file doesn’t exist yet (first run).
5. Add comments explaining what each try/except block protects against and why it’s needed.

By the end of this lesson your T1 program displays statistics (highest score, lowest score, average) and saves results to a file.

1. Extract numeric scores from your list of tuples for statistics:
   nums = [s[1] for s in scores]
2. Write a function show_stats(scores) with docstring that prints: highest score (with name), lowest score (with name), and average. Use max(), min(), sum(), len().
3. Add "Show stats" to your menu (option 3) and "Save and Quit" as option 4. Calling save_scores() before quitting is the key requirement.
4. Test your complete program: add 5+ scores, view them, check stats, save and quit. Rerun - confirm scores reload correctly.
5. Code quality check: every function has a docstring, every section has a comment. Variable names are meaningful (not x, y, a, b).

By the end of this lesson you have tested your program with at least 5 test cases and completed a peer code review.

1. Create a test table (can be in a comment block or separate doc): list each test case, the input, the expected output, and the actual output. Test: valid score, invalid text input, score = 0, score = 100, empty file on load.
2. Debugging: if something doesn’t work, add print() statements to see what values variables hold at each step. This is called print debugging - a valid and widely-used technique.
3. Peer review: swap Replit links with a classmate. Read their code. Write 3 comments: (1) something that works well, (2) something unclear or that could be improved, (3) one specific suggestion. Share feedback in writing.
4. Fix any bugs your peer found or that testing revealed. Keep a note of what you fixed - this feeds directly into your reflection.

By the end of this lesson you have completed the written reflection and your T1 code is submission-ready.

1. Reflection (5-8 sentences): describe at least two specific debugging challenges and how you solved them. Use programming terminology (e.g. ValueError, indentation, scope, loop condition). Explain what you would do differently next time.
2. Final code review: check every function has a docstring. Check every major section has a comment. Check all variable names are meaningful. Check your file is named correctly: Smith_J_T1_main.py.
3. Check the rubric: Python Foundations /15 (variables, data types, input/output, conditionals, loops all present and correct), File Handling /15 (reads and writes, data persists), Code Quality /6 (comments, docstrings, naming), Reflection /4 (specific, uses terminology).
4. Submit: upload your .py file and reflection document to Connect before the due date.

By the end of this lesson Task 1 is submitted to Connect and you understand what Task 2 involves.

1. Download your main.py from Replit (three dots menu → Download). Verify the filename: Smith_J_T1_main.py
2. Submit to Connect: go to your class page, find Task 1 assignment, upload both your .py file and your reflection document.
3. Your teacher introduces Task 2: Algorithms & Data Representation. This is an in-class short answer test scheduled for Term 2 Weeks 1-3. Content: flowcharts, pseudocode, trace tables, binary numbers, data types. Begin noting down any terms you’re unsure of.

By the end of this lesson Task 1 is submitted and you have begun previewing Task 2 algorithm content.

1. If Task 1 is not yet submitted: use this lesson to complete and submit. No further extensions after this lesson.
2. Algorithm intro: an algorithm is a precise step-by-step set of instructions to solve a problem. Your Python programs ARE algorithms. The difference is that algorithms can be written in pseudocode or drawn as flowcharts - language-independent.
3. Flowchart symbols: draw in your notes - oval (start/end), rectangle (process), diamond (decision/branch), parallelogram (input/output), arrows (flow). We’ll use these next term in Task 2.
4. Begin answering from memory: "What are three things a variable must have?" (name, data type, value). Practise using correct terminology - Task 2 tests this.

By the end of this lesson you can draw a correct flowchart for a simple algorithm using proper symbols.

1. Flowchart symbols: draw and label each in your notes. Oval = start/end (terminator). Rectangle = process (action/calculation). Diamond = decision (yes/no question). Parallelogram = input/output. Arrows = flow direction. These are standard across all computing courses.
2. Draw a flowchart for: "Ask user for a number. If number is greater than 0, print POSITIVE. If less than 0, print NEGATIVE. If zero, print ZERO. End." This requires a diamond with three paths - use nested decisions.
3. Rules: every diamond must have exactly two exits labelled YES and NO (or True/False). Every path must reach the terminator (end oval). Arrows must not cross unless you use a connector circle.
4. Draw a second flowchart: a loop that asks the user for a password, and keeps asking until they enter the correct one, then prints "Welcome". This introduces the loop construct in flowcharts.

By the end of this lesson you can write pseudocode for a simple algorithm using standard conventions.

1. Pseudocode conventions: keywords in CAPITALS. INPUT variable. OUTPUT value. IF condition THEN ... ELSE ... ENDIF. WHILE condition DO ... ENDWHILE. FOR i FROM 1 TO 10 DO ... ENDFOR.
2. Convert your flowchart from L1 (positive/negative/zero) to pseudocode. Compare - the logic must be identical.
3. Write pseudocode for a grade calculator: INPUT a score, OUTPUT the grade letter (A/B/C/D). Use IF/ELIF/ELSE structure.
4. Write pseudocode for a loop that reads 5 numbers and outputs their sum. Use a FOR loop and a running total variable.
5. Key difference: pseudocode is language-independent. It shows the logic without Python/Java/C syntax. Use it in your exam answers - it’s what markers expect.

By the end of this lesson you can complete a trace table for a given algorithm by tracking variable values step by step.

1. A trace table tracks the value of each variable at each step of an algorithm. Columns = variable names. Rows = each step/iteration. Fill in each cell as you mentally execute the code.
2. Trace this algorithm with input 5:
   x = INPUT
   total = 0
   FOR i FROM 1 TO x:
       total = total + i
   OUTPUT total
   Create a table with columns: i, total, and fill in each row.
3. Trace a loop with a condition: x = 10, WHILE x > 0: x = x - 3, OUTPUT x. Trace until loop ends. What is the final value of x?
4. Trace tables are your exam technique for algorithm questions. Practice on 3 different algorithms your teacher provides.

By the end of this lesson you can convert between binary and denary (decimal) numbers up to 8 bits.

1. Binary is base-2: only 0s and 1s. Each position represents a power of 2. 8-bit positions (right to left): 128, 64, 32, 16, 8, 4, 2, 1. Draw this header row in your notes.
2. Denary to binary: convert 45 to binary. 45 ÷ 2 = 22 r1, 22 ÷ 2 = 11 r0, 11 ÷ 2 = 5 r1, 5 ÷ 2 = 2 r1, 2 ÷ 2 = 1 r0, 1 ÷ 2 = 0 r1. Read remainders bottom to top: 101101. Pad to 8 bits: 00101101.
3. Binary to denary: convert 10110101. Multiply each bit by its position value and add: 128+0+32+16+0+4+0+1 = 181.
4. Bits and bytes: 1 bit = one binary digit. 8 bits = 1 byte. 1024 bytes = 1 kilobyte. Why binary? Computers use electrical signals that are either ON (1) or OFF (0) - two states are easiest to represent physically.
5. Practise: convert 10 values denary to binary and 10 binary to denary. Use the 8-column header as your working tool.

By the end of this lesson you can identify the correct data type for a given piece of data and explain how it is stored.

1. Data types table in your notes: Integer (whole numbers, stored as binary), Float (decimal numbers, uses floating-point representation), String (text, each character stored using ASCII/Unicode), Boolean (True/False, stored as 1 or 0), Character (single symbol, stored using ASCII code).
2. ASCII: every character has a number. A=65, a=97, 0=48. The number 65 in binary is 01000001. So the letter "A" is stored as 01000001. Use an ASCII table (provided by teacher) to look up 5 characters.
3. For each piece of data below, write the correct data type: age (int), price (float), first name (string), is_logged_in (bool), postcode like "6231" (string - not int because it may have leading zeros), phone number (string).
4. Why does it matter? Using the wrong type causes bugs. If you store a price as int you lose the cents. If you store a postcode as int, 0231 becomes 231.

By the end of this lesson you can describe three computational problem-solving strategies and apply them to a given problem.

1. Decomposition: break a complex problem into smaller sub-problems. Example: "build a quiz" → get question, display question, get answer, check answer, update score, show result. Each part is a function.
2. Pattern recognition: identify similarities between problems or within a problem. Example: if you’ve solved a grade calculator, a tax calculator uses the same if/elif structure - recognise and reuse the pattern.
3. Abstraction: hide unnecessary detail, focus on essentials. A function is abstraction - you call get_average() without knowing how it works internally. The user interface is abstracted from the file handling.
4. Algorithm efficiency basics: a loop that runs once per item is fine for small lists. If you have two nested loops (loop inside a loop) for a large list, it slows significantly. At General level, note this awareness without formal complexity analysis.
5. Apply all three to this problem: "Build a program that reads a list of student names and scores from a file, finds the top 3 scorers, and writes them to a separate file." Decompose, identify patterns, identify what to abstract.

By the end of this lesson you have completed mixed practice questions covering all T2 content areas.

1. Worked examples: your teacher walks through 2-3 exam-style questions on the board - one flowchart, one trace table, one binary conversion. Copy the method, not just the answer.
2. Timed practice: complete a set of 8 questions independently (10 minutes). Mark your own work. Note which areas need more revision.
3. Binary relay: convert a series of numbers to binary and back. Focus on speed and accuracy - the test will have these questions.
4. Create a revision cheat sheet (1 page, not for test use): all flowchart symbols, pseudocode keywords, binary position values, data type examples. This process of creating it is the revision.

By the end of this lesson you have identified your weakest areas and have a plan for what to review before the test.

1. Class Kahoot: 20 questions covering all T2 content. Pay attention to which ones you get wrong - these are your revision targets.
2. Common errors: forgetting to update the variable in a while loop (infinite loop), putting a terminator in the middle of a flowchart, confusing string "5" with integer 5 in data types, reading binary right-to-left (should be left-to-right for position values).
3. Exam technique: read every question twice. For trace tables, work row by row - do not jump ahead. For pseudocode questions, write keywords in CAPITALS. Show your working for binary conversions (write out the position values).
4. Partner quiz: test each other on definitions. Algorithm, flowchart, pseudocode, trace table, binary, bit, byte, integer, float, string, boolean. Each term in one sentence.

By the end of this lesson you have completed a full practice test and identified specific areas to revise before L11.

1. Practice test (40 min, same format as L11 test): no notes, no devices. Covers flowcharts, pseudocode, trace table, binary conversion, data types, and problem-solving strategy. Work independently.
2. Self-mark with the teacher’s marking guide. Add up your score. Identify which criterion you lost marks in.
3. Targeted revision: spend 10 minutes specifically on your weakest area. If it was binary, do 10 more conversions. If it was trace tables, trace 2 more algorithms.
4. Write a one-line revision plan for L10: "I need to practise _____ because _____."

By the end of this lesson you feel confident and prepared for the Task 2 test in the next lesson.

1. Student-led: any student can request a topic to go over on the board. Teacher will answer up to 5 class questions.
2. Targeted individual revision based on your plan from L9. Use the last 20 minutes to practise your specific weak area.
3. Test conditions reminder: no notes, no devices, no AI. Complete the test on Socrative. Write in full sentences where answers require explanation. Label every diagram clearly.
4. Rest and be ready for L11.

Complete the Task 2 short answer test to the best of your ability.

1. Sit in your assigned seat with your device logged in to Socrative. Clear your desk of everything else.
2. Read all questions before starting. Allocate time roughly proportional to marks.
3. Show all working for binary conversions. Draw flowcharts with correct symbols. Write pseudocode using CAPITALS for keywords.
4. If you finish early, review your answers. Check trace tables row by row.

By the end of this lesson you understand your test results and have been introduced to Task 3.

1. Tests returned. Your teacher walks through the answers for each question. Write correct answers for any you got wrong - this is your corrections document to submit.
2. Identify patterns in your errors: was it binary conversion, trace tables, or pseudocode conventions? Note what to focus on in Module 2 revision.
3. T3 intro: Problem Solving Program. You will design and build a Python program solving a real-world problem of your choice. Options: quiz, calculator, simple game, or data validator. Starts next lesson. Begin thinking about your program idea.

By the end of this lesson you have chosen your T3 program idea and completed a decomposition of the problem into sub-problems.

1. Program options: Quiz (questions + scoring + high score file), Calculator (multi-operation with history file), Simple game (number guess/rock-paper-scissors with win tracker), Data Validator (checks formats, logs results). Any of these works. Your teacher must approve your choice by end of lesson.
2. Decomposition: break your chosen program into 4-6 sub-problems. Each sub-problem becomes a function. Example for Quiz: get_question(), check_answer(), update_score(), show_results(), save_score(), load_scores().
3. Create your T3 design document (Word doc or Google Doc): add a title, your name, the program name, a one-paragraph description, and your decomposition list.
4. User story: write 3 "As a user, I want to..." statements. E.g. "As a user, I want to see my score at the end of the quiz." This defines what your program must do.

By the end of this lesson you have written pseudocode for your main program logic and drawn a flowchart for the most complex part.

1. Pseudocode your main loop: what happens when the program starts? What choices does the user have? What repeats? Write it using standard pseudocode keywords (INPUT, OUTPUT, IF/ENDIF, WHILE/ENDWHILE, CALL function_name).
2. Flowchart: draw the flowchart for the most complex function in your program (e.g. for a quiz: the question-and-answer loop). Use correct symbols.
3. Add pseudocode and flowchart to your design document.
4. Teacher check: show your design document to the teacher for sign-off before you start coding. This is required - no code before approved design.

By the end of this lesson you have a working program skeleton with all functions defined as stubs and a main menu loop running.

1. Create your T3 file in Replit: Smith_J_T3_program.py
2. Write stubs (empty functions) for every function in your decomposition. A stub has a docstring and returns a placeholder value: def get_question():
    """Returns a question string."""
    return "Placeholder"
3. Write a main() function that calls each stub in order. Run it - it should work without errors even with stubs.
4. Implement the simplest function first (e.g. display menu, get choice). Test it works, then move to the next.

By the end of this lesson your core selection logic (if/elif/else) is implemented and working in at least two functions.

1. Implement the functions that use selection (if/elif/else): e.g. check_answer(), calculate_grade(), validate_input(). Make sure each has a docstring.
2. Test after implementing each function - don’t wait until everything is done to test. Small incremental testing catches bugs early.
3. Add try/except for any user input that could cause a type error.
4. Tick off each function from your decomposition list as you complete it.

By the end of this lesson your program has working loops for the main game/quiz/calculation cycle.

1. Implement the main program loop: either a while True menu loop or a for loop over questions/rounds.
2. Add input validation loops: if a user enters an invalid choice, keep asking until they enter a valid one.
3. Run your program end-to-end. Does it do what your user stories described? If not, debug.

By the end of this lesson you have a completed test table with at least 5 test cases and have fixed the bugs found.

1. Create a formal test table in your design document: columns = Test #, Input, Expected Output, Actual Output, Pass/Fail. Run at least 5 tests: normal case, edge case (0, empty, maximum), invalid input.
2. For each FAIL: identify the bug, fix the code, re-test, and mark the outcome.
3. Your test evidence is submitted alongside your program and is worth marks (Design Process criterion).

By the end of this lesson you have given and received written peer feedback and made at least one improvement to your program based on it.

1. Swap Replit links with your assigned partner. Read their code for 10 minutes. Do not run it - just read it.
2. Write feedback covering: (1) one thing that works well and why, (2) one thing that is unclear or could be improved, (3) one specific suggestion (e.g. "the function get_score() has no docstring - add one").
3. Receive your partner’s feedback. Implement at least one suggestion. Note what you changed and why - this goes in your evaluation.

By the end of this lesson your T3 program is polished and submission-ready.

1. Evaluation section of design doc: "What works well, what doesn’t, what would you improve with more time?" Write 5-8 sentences. Be specific.
2. Final code quality check: every function has a docstring. Every logical section has a comment. All variable names are meaningful. Indentation is consistent throughout.
3. Rubric self-assessment: mark yourself against each criterion using the rubric. Be honest - this helps you know where to focus final effort.
4. Submit: upload your .py file and design document to Connect before the due date.

By the end of this lesson Task 3 is submitted and you understand what Task 4 involves.

1. Final submission: verify your .py file runs without errors. Verify your design document includes problem statement, pseudocode/flowchart, test table, and evaluation. Upload both to Connect.
2. T4 intro: Impacts of Computing in Society. This is a 4-lesson Extended Answer task. You will read a stimulus (article or case study) about how computing affects society and write a structured analytical response (400-500 words). Stimulus provided next lesson.
3. Preview discussion: what are some ways computing has changed society? Think of both positive (medical diagnosis AI, digital communication) and negative (job automation, privacy issues, digital divide) examples.

By the end of this lesson T3 is submitted and you have read the T4 stimulus for the first time.

1. If T3 not yet submitted: this is your last opportunity. Submit today.
2. Read the T4 stimulus document from Connect. First read: no annotations, just read it all the way through to understand what it is about.
3. Second read: annotate. Highlight or circle key claims, statistics, examples, and opinions. Note any computing impacts mentioned.

By the end of this lesson you have seen examples of strong T3 programs and understand the common errors to avoid in future tasks.

1. Volunteer showcase: 2-3 students share their programs with the class. Class provides positive observations only.
2. Teacher debrief: common errors seen across submissions - missing docstrings, cryptic variable names, no error handling, test table not completed. Note these for T7 (Capstone).
3. T3 marks returned (if available). Review feedback and ask questions about any criterion you are unsure about.

By the end of this lesson you are ready to begin T4 with a clear understanding of the task requirements.

1. Catch-up: any outstanding T3 items finalised.
2. T4 framework: your teacher introduces the PEEL paragraph structure (Point, Evidence, Explain, Link) for extended answers. This is the expected writing structure for T4 and T8.
3. Key concepts for T4: automation and employment, data privacy, digital inclusion, accessibility. Add definitions to your notes. You will use these in your response.

By the end of this lesson you have read and annotated the T4 stimulus and identified at least four computing impacts to discuss.

1. Open the Task 4 stimulus on Connect. Read it all the way through without annotating first.
2. Second read: annotate. Circle computing impacts (positive or negative). Underline evidence (statistics, examples, case studies). Note stakeholders affected (workers, consumers, government, community).
3. Key concepts check: automation and employment (jobs replaced or created by technology), data privacy (right to control your personal data), digital inclusion (equal access to technology), accessibility (technology designed for people with disabilities).
4. In your planning document, list at least 4 impacts from the stimulus. For each: who is affected, and how (positive or negative)?

By the end of this lesson you have a dot-point plan for your extended answer with two paragraphs planned in PEEL structure.

1. Select your two strongest impacts to write about - pick ones with clear stimulus evidence you can reference.
2. PEEL structure: Point (your claim about the impact), Evidence (quote/statistic from the stimulus - reference it), Explain (what it means, why it matters), Link (back to the question / broader implication).
3. Write a dot-point PEEL plan for each of your two paragraphs. This planning is submitted alongside your response.
4. Write an introduction sentence: "Computing has significantly impacted society in several ways, including [impact 1] and [impact 2]."

By the end of this lesson you have written a full 400-500 word draft extended answer response.

1. Write your introduction (2-3 sentences), two body PEEL paragraphs, and a conclusion (2 sentences). Aim for 400-500 words.
2. Reference the stimulus at least twice: "According to the article..." or "The stimulus states that..."
3. Use domain vocabulary: automation, algorithm, data privacy, digital divide, accessibility, inclusion, stakeholder, ethical, impact.
4. Peer swap: swap documents with a partner. Read their draft and write one specific improvement suggestion (not a general comment like "good job" - something specific like "your second paragraph needs a stimulus reference").

By the end of this lesson Task 4 is submitted and you have completed Semester 1.

1. Implement peer feedback from L3. Make targeted improvements - do not rewrite everything, just address the specific gaps identified.
2. Final proofread: read every sentence. Fix unclear phrasing. Check that each body paragraph has: a clear point, stimulus evidence, an explanation, and a link back to the question.
3. Submission checklist: (a) extended answer document, (b) annotated stimulus, (c) dot-point planning outline. Submit all components to Connect.
4. Submit all components to Connect. This is the final task of Semester 1 / Module 1. Well done.

By the end of this lesson you can read a CSV file in Python and store its contents in a list.

1. Your teacher provides the T5 dataset: a CSV file with at least 20 rows of real data (e.g. monthly sales figures, temperature readings, or student scores). Download it to your Replit or local machine.
2. Python lists: numbers = [45, 72, 88, 31, 95] - a list stores multiple values. Access by index: numbers[0] = 45. Append: numbers.append(60).
3. Read a CSV: with open("data.csv","r") as f:
    for line in f:
        print(line.strip())
4. Parse into a list: data = []
with open("data.csv","r") as f:
    next(f) # skip header row
    for line in f:
        parts = line.strip().split(",")
        data.append(parts)
5. Print the first 5 rows and count total rows. Check your data looks correct.

By the end of this lesson you can extract a column of numeric data from a CSV file as a list of floats ready for calculation.

1. Problem: CSV files store everything as strings. To calculate, you need numbers. Convert: value = float(parts[1])
2. Write a function load_data(filename) with docstring that reads the CSV and returns a list of tuples: (label, value). E.g. [("January", 4500.0), ("February", 3820.0), ...]
3. Wrap the float() conversion in try/except ValueError to handle any non-numeric rows gracefully.
4. Extract just the values into a separate list: values = [row[1] for row in data]. This is a list comprehension - a concise way to create a list from another list.

By the end of this lesson you have a working calculate_stats() function that returns min, max, average, and count for your dataset.

1. Write calculate_stats(values) with docstring:
   def calculate_stats(values):
    """Returns min, max, average, count for a list of numbers."""
    return min(values), max(values), sum(values)/len(values), len(values)
2. Call it and print results with labels using f-strings:
   lo, hi, avg, count = calculate_stats(values)
print(f"Min: {lo:.2f} Max: {hi:.2f} Avg: {avg:.2f} Count: {count}")
3. Add a find_max_entry() function that returns the label and value of the highest entry in your dataset (not just the number, but which month/item it corresponds to).
4. Test with your full dataset. Check the results make sense visually.

By the end of this lesson you have implemented at least one sorting algorithm and can output your data in sorted order.

1. Bubble sort: repeatedly compare adjacent elements and swap if out of order. Implement it for your values list. Trace through 5 elements manually to see how it works.
2. Python built-in: sorted_data = sorted(data, key=lambda x: x[1]) - sorts your list of tuples by the value column. Note this is NOT the same as implementing your own sort.
3. The rubric requires at least one sort algorithm "implemented and applied to the data." Use bubble sort (or selection sort) as your implementation, but you can also show sorted() as an alternative.
4. Print your data sorted lowest-to-highest and highest-to-lowest. Format output clearly.

By the end of this lesson you can write a linear search function that finds a specific item in your dataset.

1. Linear search: check each item in the list until you find the target (or reach the end). Write find_item(data, target_label) that returns the row matching the label.
2. Binary search concept: only works on sorted data. Divide the list in half, check the middle, go left or right. Much faster than linear search for large datasets. At General level, describe and demonstrate - implementation is optional.
3. Integrate search into your program: prompt the user to enter a label (e.g. a month name) and display that row’s data.

By the end of this lesson your program displays all results clearly with labels, units, and appropriate decimal places.

1. F-strings with formatting: f"{value:.2f}" = 2 decimal places. f"{label:<15}" = left-aligned in 15 chars. f"${value:,.2f}" = currency with comma separator.
2. Write a display_results(data, stats) function that prints a formatted summary: header, all rows in columns, then the statistical summary.
3. Print a separator line between sections: print("-" * 40)
4. Output Quality is worth 8 marks on the rubric. Clear, labelled output is essential.

By the end of this lesson your T5 program has been tested, peer-reviewed, and is code-quality ready.

1. Test table: at least 5 tests - normal data, empty file, non-numeric row, single row, large dataset. Record expected vs actual output.
2. Code quality pass: every function has a docstring. Every major section has a comment. Variable names are meaningful.
3. Peer review: swap with a partner. They check: Does it run? Is the output clear? Are there docstrings? Write one improvement suggestion each.

By the end of this lesson you have written a clear 150-200 word interpretation of your data analysis findings.

1. Look at your program output: what does the data show? Which month/item is highest? Lowest? Is there a trend (increasing over time, seasonal pattern)? Any anomaly (one unusual value)?
2. Write your interpretation (150-200 words): (1) what the data set represents, (2) key statistical findings (highest, lowest, average), (3) any interesting trend or anomaly, (4) a conclusion about what the data tells you.
3. Your interpretation should refer to specific numbers from your program output, not vague statements like "some values were high."

By the end of this lesson Task 5 is submitted to Connect.

1. Run your complete program one final time. Verify all output is correct and clearly formatted.
2. Check filename: Smith_J_T5_main.py and the CSV file included in submission.
3. Submit to Connect: Python file + CSV data file + written interpretation document.
4. T6 preview: Cybersecurity & Digital Systems starts next lesson. This is an in-class test (same format as T2). Content: threats (malware, phishing, social engineering), protections (encryption, firewalls, 2FA), digital systems (networks, cloud). Begin reading your notes from last term if you covered any of this.

By the end of this lesson Task 5 is submitted and you understand Python dictionaries as a data structure.

1. Late submissions: this is the last opportunity for T5. Submit now if not yet done.
2. Dictionaries: person = {"name": "Alex", "age": 16, "score": 88}. Access by key: person["name"]. Add: person["grade"] = "B".
3. Dictionaries vs lists: lists store items by index (position). Dictionaries store items by key (name). Use a dictionary when you want to look something up by name rather than by number.
4. T7 Capstone preview: your Capstone program in T7 will use functions, file I/O, lists, dictionaries, error handling, and a sort/search. Start thinking about what kind of program you’d like to build.

By the end of this lesson you understand variable scope (local vs global) and can design a modular program structure.

1. Scope: a variable defined inside a function is local - it only exists inside that function. A variable defined outside all functions is global - accessible everywhere. Avoid using global variables where possible; pass data as parameters instead.
2. Demonstrate scope: define x = 10 at module level and inside a function. Show they are separate.
3. Modular design principle: each function does ONE thing. If a function is over 20 lines, it probably does too much and should be split. Apply this to your T7 Capstone planning.

By the end of this lesson you understand what T6 covers and have started your cybersecurity notes.

1. T5 debrief: your teacher returns T5 marks (if available). Review feedback. Common issues: CSV not reading correctly, stats function missing edge case handling, output not clearly labelled.
2. T6 preview: Cybersecurity & Digital Systems. Content: (1) Threats - malware (virus, ransomware, spyware), phishing, social engineering. (2) Protections - encryption, passwords & 2FA, firewalls, backups. (3) Digital systems - networks (LAN/WAN/cloud), hardware roles.
3. Start your T6 notes file. Create a heading for each content area. Fill in what you already know from prior knowledge. We’ll build on this in T6 lessons.

By the end of this lesson you can define five types of malware and give a real-world example of each.

1. Malware = malicious software. Types table in your notes: Virus (attaches to files, spreads when file opened), Worm (self-replicates across networks, no user action needed), Ransomware (encrypts files, demands payment), Spyware (secretly monitors activity, steals data), Trojan (disguised as legitimate software, opens backdoor).
2. For each type: add a real-world example. Research: WannaCry (ransomware, 2017, NHS), ILOVEYOU (virus, 2000), Pegasus (spyware). Add date, target, and impact to your notes.
3. How malware spreads: email attachments, infected downloads, removable media (USB), compromised websites, network vulnerabilities. Note at least two for each malware type.
4. Impact categories: financial (ransom, theft), operational (systems down), reputational (loss of customer trust), legal (data breach fines under Australian Privacy Act).

By the end of this lesson you can identify social engineering tactics and explain why they are effective.

1. Social engineering exploits human psychology, not technical vulnerabilities. Key types: Phishing (fake email/website to steal credentials), Spear phishing (targeted phishing using personal details), Pretexting (fake scenario to extract information), Baiting (infected USB left in public), Shoulder surfing (watching someone type their password).
2. Phishing red flags: urgent language ("Your account will be closed in 24 hours!"), generic greeting ("Dear Customer"), misspelled domain (paypa1.com), requests for passwords or credit card numbers, suspicious sender address.
3. Analyse three example phishing emails (provided by teacher). For each: identify the red flags, determine the likely target, and describe what would happen if the victim clicked the link.
4. Why it works: attackers exploit urgency, fear, authority (impersonating bosses or banks), and curiosity. No technical skill is needed to be fooled. Note in your answers: "Social engineering is effective because it targets human emotions rather than technical systems."

By the end of this lesson you can explain how strong passwords, multi-factor authentication, and encryption protect against cyberthreats.

1. Strong passwords: minimum 12 characters, mix of uppercase, lowercase, numbers, symbols. Never reuse passwords. Use a passphrase: "Coffee!Sunrise2026" is stronger than "p@ssw0rd". Password managers store unique passwords per site.
2. Multi-Factor Authentication (MFA/2FA): combines something you KNOW (password) + something you HAVE (phone/token) + something you ARE (fingerprint/face). Even if a password is stolen, the attacker still can't log in without the second factor.
3. Encryption: converts readable data (plaintext) to unreadable data (ciphertext) using a key. Symmetric encryption uses the same key to encrypt and decrypt (fast, used for bulk data). Asymmetric uses a public key to encrypt and a private key to decrypt (used for secure communication). HTTPS uses asymmetric to exchange a symmetric key.
4. End-to-end encryption: only sender and recipient can read messages. Even the service provider can't read them. Used by Signal, WhatsApp (in part). Important for privacy.
5. Note the link to T7: your Capstone program might handle user data. What ethical responsibility do you have to protect that data?

By the end of this lesson you can explain how firewalls, antivirus software, and backup strategies protect systems.

1. Firewall: monitors incoming and outgoing network traffic and blocks unauthorised connections based on rules. Hardware firewall (device, protects the whole network) vs software firewall (installed on a device, protects that device only). Analogy: a security guard at the network's door.
2. Antivirus/anti-malware: scans files and memory for known malware signatures, and uses heuristic analysis to detect suspicious behaviour (zero-day threats). Must be kept up to date - outdated antivirus can't detect new malware.
3. Backup strategies: 3-2-1 rule - keep 3 copies of data, on 2 different media types, with 1 offsite. Types: full backup (everything, slow, large), incremental (only changes since last backup, fast), differential (changes since last full backup). Recovery time matters: after ransomware, how quickly can you restore?
4. Scenario: a school is hit by ransomware. Their firewall failed to block the phishing email, antivirus didn't detect the payload, and their last backup is 3 weeks old. Describe the impact and what they should have done differently.

By the end of this lesson you can describe common network types and the hardware used to build them.

1. Network types: LAN (Local Area Network - covers a building or campus), WAN (Wide Area Network - connects geographically separate LANs, the internet is a WAN), Cloud network (services hosted remotely, accessed via internet).
2. Network hardware: Router (directs data between networks, connects LAN to internet), Switch (connects devices within a LAN, smarter than a hub), Access Point (provides Wi-Fi, wireless connection to the network), Modem (converts digital signal to/from the ISP's signal).
3. Wired vs wireless: wired (Ethernet/Cat6) is faster and more secure. Wireless (Wi-Fi 802.11) is more flexible but susceptible to eavesdropping if unencrypted.
4. Draw a simple network diagram for a school: internet → modem → router → switch → wired computers AND access point → student laptops/phones. Label each device and its function.

By the end of this lesson you can explain the three cloud service models and evaluate cloud computing for a given context.

1. Cloud models: SaaS (Software as a Service - use software via browser, e.g. Gmail, GitHub, Replit), PaaS (Platform as a Service - develop and deploy apps without managing infrastructure, e.g. Heroku, Replit), IaaS (Infrastructure as a Service - rent virtual servers and storage, e.g. AWS EC2, Azure VMs).
2. Benefits: no upfront hardware cost, scales up/down on demand, accessible from anywhere, automatic updates, disaster recovery built in.
3. Risks: internet dependency (no internet = no access), data privacy (where is your data stored?), vendor lock-in (hard to migrate), ongoing subscription cost.
4. Data sovereignty: Australian data may be stored on servers overseas. The Privacy Act 1988 has implications for organisations storing personal data overseas. Note this connects to T8 ethics content.

By the end of this lesson you can match cyberthreats to appropriate countermeasures and apply them to real scenarios.

1. Threat/protection table: create a two-column table. Left: each threat type. Right: the best countermeasure(s). E.g. Phishing → security awareness training, email filtering, 2FA. Ransomware → regular backups, antivirus, patched OS.
2. Scenario 1: A hospital employee receives an email saying "Your IT password expires in 2 hours - click here to reset." They click and enter their credentials. Two days later, all patient records are encrypted. Identify: (a) the attack type, (b) how it succeeded, (c) what should have stopped it.
3. Scenario 2: A small business stores all files on a single computer with no backup. Identify three risks and three improvements.
4. Kahoot: 15 questions covering all T6 content so far. Note which answers you got wrong.

By the end of this lesson you can explain how operating system updates and hardware features contribute to system security.

1. Why update software? Security patches fix known vulnerabilities. WannaCry ransomware (2017) exploited a Windows vulnerability Microsoft had already patched - systems that hadn't updated were infected. Unpatched software = known open door for attackers.
2. Operating system security features: user account control (UAC), file permissions, sandboxing (isolating apps), secure boot (only trusted OS loads at startup).
3. Hardware security: biometric authentication (fingerprint, face ID) - harder to steal than a password. Trusted Platform Module (TPM) - a chip that stores encryption keys securely. Physical security: screen locks, cable locks for laptops.
4. Principle of least privilege: users should only have the access they need for their role. A teacher doesn't need admin rights to the school network. Limits the damage if their account is compromised.

By the end of this lesson you have completed a full practice test and know exactly what to revise before L11.

1. Practice test (40 min, same format as L11): no notes, no devices. Covers: malware types, social engineering, protection strategies, networks, cloud, digital system security.
2. Self-mark with teacher's marking guide. Calculate your score for each criterion (Cybersecurity Knowledge /12, Digital Systems /12, Communication /6).
3. Targeted revision: 10 minutes on your weakest area. If you lost marks on Digital Systems, re-read your network and cloud notes. If Communication, practise writing full-sentence answers.

By the end of this lesson you feel confident and ready for the T6 test in L11.

1. Open-floor questions: any student can ask the teacher to clarify a concept. Maximum 5 class questions.
2. Partner quiz: alternate asking each other definitions. Use your revision card. Cover: all malware types, all protection strategies, network hardware, cloud models.
3. Reminder: no notes, no devices, no AI in L11. Write full sentences. Show reasoning. Use technical terminology - it’s worth marks in the Communication criterion.

Complete the Task 6 short answer test to the best of your ability.

1. Sit in your assigned seat. Clear your desk. Pen only.
2. Read all questions before starting. Allocate time proportionally to marks.
3. For definition questions: define + give an example + explain the impact. Three elements for full marks.

By the end of this lesson you understand your test results and have been introduced to Task 7: Capstone Program.

1. Tests returned. Teacher walks through answers. Write corrections for any wrong answers and submit corrections document.
2. Your teacher introduces Task 7: Capstone Program. This is the largest task of Module 2 (20%, /60). You will design and build a complete Python program demonstrating all Unit 2 skills. Think about your program idea before next lesson. Starting next lesson (Task 7, Term 4 Week 4).
3. Capstone ideas: inventory management system, student grade tracker, simple quiz app with topic categories, personal budget calculator, word frequency counter. What problem would YOU like to solve with Python?

By the end of this lesson you have a teacher-approved Capstone program idea and a completed decomposition of its sub-problems.

1. Capstone requirements (non-negotiable): at least three functions with parameters and return values, file I/O reading AND writing a data file (CSV or text), at least one sort or search algorithm, error handling using try/except, and a design document with test evidence.
2. Program options: inventory management system (add/remove/search/sort items, save to CSV), student grade manager (add students, calculate stats, save/load), quiz application with topic categories (load questions from file, score and save results), personal budget tracker (income/expense categories, totals, save to file). Or propose your own - must meet all requirements.
3. Decompose your chosen program into at least 6 sub-problems. Each should map to a function. Add to design document.
4. Teacher sign-off: show your idea and decomposition. No coding until approved.

By the end of this lesson your design document includes pseudocode for the main program, a flowchart for the core logic, and a test plan skeleton.

1. Pseudocode: write the main program flow from start to end. Include: how it starts (load file), main menu loop, what each option calls, how it ends (save file). Use CALL function_name for each sub-task.
2. Flowchart: draw the flowchart for your most complex function (typically the add/search/sort operation). Use correct symbols.
3. Test plan skeleton (fill in before coding): create a table with columns: Test #, What is being tested, Input, Expected Output, Actual Output, Pass/Fail. Add at least 6 rows with the Test # and What is being tested filled in now. You’ll fill Expected and Actual during testing.
4. Design document structure: Title, your name, program description, decomposition list, pseudocode, flowchart, test plan. Submit or show teacher today.

By the end of this lesson you have a working program skeleton with file I/O loading and saving correctly.

1. Create your Capstone file: Smith_J_T7_capstone.py. Add a header comment block with your name, task, and a description.
2. Write all function stubs first. Every function has a docstring and returns a placeholder. Run it - it should work with no errors before you add real logic.
3. Implement load_data(filename) and save_data(data, filename) first - these are the foundation. Wrap both in try/except: load handles FileNotFoundError (first run), save handles IOError.
4. Test file I/O immediately: create some dummy data, save it, reload it, print it. Confirm data survives the save/load cycle before building on top of it.

By the end of this lesson your main menu loop is running and at least two core functions are implemented and tested.

1. Implement the main menu: a while True loop that displays options, gets the user’s choice (with validation), and calls the appropriate function. Break on the quit/save option.
2. Implement your add/create function. Use input validation: check required fields are not empty, check numeric fields are actually numbers (try/except), check ranges where relevant.
3. Implement your display/list function: loop over the data list and print each item using a consistent f-string format.
4. Test after each function - do not wait until all functions are done. Incremental testing catches bugs early when they are easier to fix.

By the end of this lesson your Capstone program has a working sort and search function integrated into the menu.

1. Sort: implement sort_data(data, field) using bubble sort or selection sort (must implement, not just use sorted()). Optionally also offer a sorted() shortcut. Let the user choose ascending or descending.
2. Search: implement search_data(data, query) using linear search. Return all matching rows (not just the first). Print results clearly.
3. Add sort and search as menu options. Test with: normal data, search term that has no match, sort on empty list.
4. Add test cases for sort and search to your test plan and fill in Expected Output.

By the end of this lesson your program handles all foreseeable error conditions gracefully without crashing.

1. Error audit: go through every input() call and every file operation. Ask: what happens if the user enters the wrong type? What if the file doesn’t exist? What if the list is empty? Add try/except for each risk.
2. Empty list guard: before sort, search, or display - check if the list is empty and print a friendly message rather than crashing.
3. Run all your test cases. Record Actual Output. Mark Pass/Fail. Fix any FAILs. Re-test until all pass.
4. Count your try/except blocks - you need at least two: one for file load, one for numeric input.

By the end of this lesson every function has a docstring, every major section has a comment, and all variable names are meaningful.

1. Docstring check: search for "def " in your code. Every occurrence must have a triple-quoted docstring on the next line describing what the function does, its parameters, and what it returns.
2. Comment check: every logical section (file loading, menu, each major function block) should have a # comment above it. Comments explain WHY, not just what. "# load existing data from file, or start with empty list if first run" is a good comment.
3. Variable names: rename any single-letter or cryptic names. x → user_choice. d → inventory_data.
4. Code Quality is worth 12 marks on the T7 rubric. This lesson directly improves your mark.

By the end of this lesson you have given detailed written peer feedback and made at least one improvement based on the feedback you received.

1. Swap Replit links with your assigned partner. Read their full program - run it too if possible.
2. Write feedback (minimum 150 words): (1) what works well and why, (2) something that is unclear or could be improved - be specific (which line or function?), (3) one concrete suggestion. Include at least one comment about code quality (docstrings, naming, comments).
3. Receive feedback. Implement at least one specific suggestion. Document what you changed and why in your reflection section of the design doc.
4. Peer review is worth marks under the Reflection criterion (12 marks). A good response to feedback is as important as the feedback you give.

By the end of this lesson you have written a reflective evaluation of your Capstone program development process.

1. Reflection structure (add to design document): (a) What does your program do? (2-3 sentences), (b) What challenges did you encounter during development and how did you solve them? (Describe at least 2, use technical terminology), (c) What does your program do well? (Link to rubric criteria), (d) What doesn’t work perfectly or is limited? Be honest, (e) What would you add or improve with more time? (At least 2 ideas), (f) How did peer review change your program? (Specific change you made).
2. Minimum 200 words. Use programming terminology: function scope, exception handling, file persistence, data structure, algorithm.
3. Also add a brief evaluation of your design document: did your pseudocode match what you built? What changed from your plan and why?

By the end of this lesson your Capstone is fully tested, your design document is complete, and you are ready to submit.

1. Final run: execute your full program from start to finish - add data, display, sort, search, save, quit. Reload - confirm data persists. This is your final functional test.
2. Complete your test table: fill in all Actual Output fields. Mark all Pass/Fail. Fix any remaining FAILs.
3. Rubric self-assessment: go through each criterion (Design & Planning /18, Program Functionality /18, Code Quality /12, Reflection /12). Give yourself an honest rating. Is there anything you can still improve?
4. File check: Smith_J_T7_capstone.py and design document (PDF or Google Doc link). Submission includes: Python file, any data files needed, design document.

By the end of this lesson Task 7 is submitted and you understand what Task 8 involves.

1. Submit to Connect: upload .py file, design document, and any required data files. Confirm submission received.
2. T8 intro: Ethics in Computing. Same format as T4: 4 lessons, stimulus-based extended answer (400-500 words). Topics: AI bias, intellectual property and open source, data collection practices, responsible technology use. You must connect at least one issue to your T7 Capstone program context.
3. Stimulus preview: read the T8 stimulus from Connect. First read only - no annotation yet. What is the main issue being discussed?

By the end of this lesson you have seen examples of strong Capstone programs and started your T8 stimulus annotation.

1. Volunteer showcase: 2-3 students run their Capstone programs for the class. Class notes one thing they like about each program’s design.
2. Late submissions: if T7 is not yet submitted, this is your last chance. Submit today. No further extensions.
3. T8 annotation: read the stimulus a second time and annotate. Circle computing ethics issues. Underline evidence. Note which issues connect to your T7 Capstone context (e.g. if your program handles user data, data privacy is directly relevant).

By the end of this lesson you have read and annotated the T8 stimulus and identified at least four computing ethics issues.

1. Open the Task 8 stimulus on Connect. Read it all the way through without annotating first.
2. Second read: annotate. Circle ethics issues. Underline evidence. Note which issues connect directly to your T7 Capstone context.
3. Computing ethics framework - key concepts for your notes: Algorithmic bias (AI systems making unfair decisions due to biased training data - e.g. facial recognition failing for dark-skinned faces), Intellectual Property (copyright, open-source licensing - MIT, GPL, Apache), Data collection ethics (informed consent, data minimisation, right to erasure, GDPR/Australian Privacy Act), Responsible technology use (digital addiction, surveillance, environmental impact of computing).
4. In your planning document, list at least 4 ethics issues from the stimulus. For each: (a) what is the issue, (b) who is affected, (c) is it relevant to your T7 program - why or why not?

By the end of this lesson you have a dot-point plan for two PEEL paragraphs and a clear T7 program connection identified.

1. Select your two strongest ethics issues - pick ones where you have stimulus evidence AND can make a T7 connection for at least one.
2. PEEL plan for each paragraph: Point (the ethics issue), Evidence (from stimulus - quote or paraphrase with reference), Explain (why this is an ethical problem, who is harmed, what values are violated), Link (to broader computing context or T7 program).
3. T7 connection example: "My Capstone program stores user data in a CSV file. An ethical concern raised in the stimulus - data minimisation - applies here: I should only collect the data my program needs, not additional fields. Users should also be informed what data is stored."
4. Write your introduction sentence: a clear statement of the two ethics issues you will discuss.

By the end of this lesson you have a complete 400-500 word draft extended answer response.

1. Write your full response: introduction (2-3 sentences), two PEEL body paragraphs, conclusion (2 sentences). Aim for 400-500 words.
2. Reference the stimulus at least twice: "The stimulus highlights..." or "According to the article,..."
3. Connect to T7: at least one reference to your Capstone program. "When developing my T7 inventory management program, I considered..." or "This is relevant to programmers like myself who..."
4. Use ethics vocabulary: algorithmic bias, informed consent, data minimisation, intellectual property, open source, digital rights, privacy, accountability, transparency, stakeholder.
5. Peer swap: swap drafts with a partner. Write one specific improvement suggestion: which paragraph needs a stronger T7 connection? Where is evidence missing?

By the end of this lesson your Task 8 extended answer and planning evidence are submitted, completing Year 11 CS General.

1. Implement peer feedback from L3. Make targeted improvements - address the specific gaps, not a full rewrite.
2. Final proofread: read every sentence. Check each paragraph has: a clear ethics Point, stimulus Evidence referenced, an Explanation, and a Link to computing or T7 context.
3. Submission checklist: (a) extended answer (400-500 words) on Google Doc or Word, (b) annotated stimulus, (c) dot-point planning outline. Submit all to Connect.
4. Submit all components to Connect before the end of this lesson.