Assessment | IB - Wyatt's Notes

CS assessment is like a code review — it evaluates not just whether your code works, but how well it’s designed and documented: Effective CS assessment tests understanding of concepts, not just memorization of syntax

Why it matters: Good assessment prepares students for real-world software development, where quality matters as much as functionality

The key insight: Effective CS assessment tests understanding of concepts, not just memorization of syntax

| 4 | Skills usage | n/a | n/a | 9 | 9 | | n/a | Weighting | $0.45$ | $0.25$ | $0.3$ | 1 |

Paper 1 is a 2-hour examination (SL) or 2 hours 15 minutes (HL) that tests knowledge and Understanding of the core syllabus.

• Definitions: Always use the exact IB terminology. For example, define “abstraction” as “hiding unnecessary details to reduce complexity,” not just “simplifying things.”
• Command terms: Pay close attention to the verb at the start of each question. “Describe” requires detail; “Explain” requires a reason; “Compare” requires similarities AND differences; “Evaluate” requires a judgment with supporting evidence.
• Extended responses: Use PEEL (Point, Evidence, Explanation, Link) paragraphs. Aim for 3–4 well-developed points per essay question.

• Writing everything you know about a topic instead of answering the specific question asked.
• Confusing SL and HL content — only use HL material in Paper 1 if you are an HL student and the question targets HL objectives.
• Leaving diagrams unlabeled. Every diagram must have a title and clear labels.

• Spend roughly 1 minute per mark. For a 6-mark extended response, aim for about 6 minutes of writing.
• Read all questions before starting. Answer the questions you are most confident about first to secure easy marks.
• Use the mark allocation as a guide for depth. A 2-mark question needs a brief answer; a 10-mark question needs a structured essay with examples.

Paper 2 is a 1-hour examination (SL) or 1 hour 45 minutes (HL) focused on applying Computational thinking to unseen problems.

• Tracing algorithms: You may be given pseudocode or Python code and asked to determine the output for a given input.
• Writing algorithms: Given a problem description, you must produce a solution in pseudocode or Python.
• Data structures: Be prepared to manipulate arrays, linked lists, stacks, queues, trees, and hash tables (HL).
• Computational thinking: Decomposition, pattern recognition, abstraction, and algorithm design.

Consider the following Python code:

def mystery(data):
    result = 0
    for i in range(len(data)):
        if data[i] > data[i - 1]:
            result += data[i]
    return result

print(mystery([3, 7, 2, 9, 5]))

Trace table:

Output: 16

Exam tip: When i = 0, data[i - 1] accesses the last element (index -1 in Python). Watch for this wrap-around behavior in exam questions.

Question: Write an algorithm that takes a list of integers and returns the two largest distinct Values.

def two_largest(data):
    if len(data) < 2:
        return None
    largest = max(data[0], data[1])
    second = min(data[0], data[1])
    for value in data[2:]:
        if value > largest:
            second = largest
            largest = value
        elif value > second and value != largest:
            second = value
    return largest, second

Exam tip: Always consider edge cases — empty lists, single-element lists, lists with all identical values. State your assumptions .

The IA accounts for 30% of the total grade and consists of a computational solution to a Client-identified problem.

• Identify a defined client and a genuine problem they face.
• The problem must have a computational solution — avoid trivial projects.
• Define the success criteria (at least 3 measurable criteria the solution must meet).
• Justify why the chosen techniques (e.g., programming language, data structures) are appropriate.

• Use appropriate data structures and explain why you chose them.
• Include evidence of iterative development (screenshots of versions, test logs).
• Write well-structured, documented code with meaningful variable names.
• Handle errors and invalid input gracefully.

• Test against your success criteria from Criterion A.
• Include user feedback from your client.
• Discuss limitations of your solution and suggest improvements.
• Be honest — examiners value genuine self-reflection over hollow praise.

• Choosing a project that is too simple (e.g., a basic calculator) or too complex (e.g., a full social network).
• Failing to include meaningful client interaction throughout the process.
• Not testing edge cases or not documenting test results.
• Writing code comments that merely restate the code rather than explaining the purpose.

Understanding command terms is critical for Paper 1 and Paper 2:

Exam tip: Underline or circle the command term in the exam question before you begin writing. This ensures you address the question at the correct cognitive level.

Grade boundaries vary each examination session. As a general guide for a recent session:

Note: These are approximate boundaries and shift each year. Always check the most recent IB subject report for your session.

A recommended approach for the final revision period:

1. Weeks 1–2: Review all core topics. Create summary sheets for each topic area.
2. Weeks 3–4: Practice past papers under timed conditions. Focus on understanding mark schemes.
3. Weeks 5–6: Target weak areas identified from practice papers. Revise IA notes and ensure all criteria are fully addressed.
4. Final week: Light review of command terms and key definitions. Practice one full Paper 1 and one Paper 2 under exam conditions.

Understanding which topics carry the most marks helps you prioritize your revision.

Exam tip: Computational Thinking consistently carries the highest mark allocation. Ensure you are comfortable with algorithm design, tracing, and Big-O notation before focusing on other areas.

Question: “Evaluate the impact of cloud computing on data storage and processing in modern Organizations.”

Sample answer structure (using PEEL):

Point: Cloud computing has significantly reduced the cost of data storage for organizations.

Evidence: Instead of purchasing and maintaining expensive on-premises servers, organizations can Rent storage space from providers such as AWS, Google Cloud, or Microsoft Azure on a pay-as-you-go Basis. Small businesses that previously could not afford enterprise-grade infrastructure can now Access the same capabilities.

Explanation: This cost reduction is achieved through economies of scale — cloud providers serve Millions of customers and can spread infrastructure costs across them. Additionally, the cloud model Converts capital expenditure (buying hardware) into operational expenditure (monthly subscription), Improving cash flow.

Link: This demonstrates that cloud computing has democratized access to powerful computing Resources, though it also introduces dependencies on third-party providers and potential security Concerns.

Point: However, cloud computing raises significant data privacy and security concerns.

Evidence: When data is stored on third-party servers, organizations must trust the provider”s Security measures. High-profile breaches (e.g., the Capital One data breach in 2019, which exposed 100 million customer records) illustrate the risks. Additionally, data sovereignty laws (such as GDPR in the EU) restrict where data can be stored and processed.

Explanation: Organizations must carefully evaluate their cloud provider’s compliance with Relevant regulations and implement additional security measures (encryption, access controls). The Shared responsibility model means that while the provider secures the infrastructure, the customer Is responsible for securing their data.

Link: Therefore, while cloud computing offers clear advantages in cost and scalability, Organizations must balance these benefits against the risks of data breaches and regulatory Non-compliance.

Exam tip: For a 10-mark question, aim for 4–5 well-developed points. Each point should include specific evidence and explanation. The conclusion should synthesize your arguments rather than restating them.

• Vague definitions that lack precision (e.g., defining “algorithm” as “a way to solve a problem” without mentioning finiteness or step-by-step nature).
• Confusing related concepts (e.g., confusing “abstraction” with “encapsulation” or “compilation” with “interpretation”).
• Failing to use examples to illustrate definitions.

• Not reading the scenario carefully and missing key details.
• Writing code that is syntactically correct but logically flawed.
• Not testing algorithms with appropriate test data.
• Missing edge cases in algorithm design.

• Choosing a project that lacks a genuine client need.
• Writing a solution overview that is too vague (Criterion B).
• Not including enough evidence of iterative development (Criterion C).
• Providing a superficial evaluation that does not genuinely assess the solution against success criteria (Criterion E).

Use this checklist to track your preparation:

• I can define all key terms from the syllabus
• I can explain the machine instruction cycle (fetch-decode-execute)
• I can trace algorithms using trace tables
• I can write algorithms in pseudocode and Python
• I can implement and explain common data structures (arrays, stacks, queues)
• I can compare sorting and searching algorithms by efficiency
• I understand network topologies, protocols, and security
• I can discuss ethical issues related to computing (privacy, AI bias, digital divide)
• I have completed at least 5 past papers for each paper under timed conditions
• I have reviewed my IA against all criteria and made improvements
• I know the command terms and can identify them in exam questions

1. Forgetting that $O(n \log n)$ average-case for quicksort becomes $O(n^2)$ worst-case on already sorted input.

2. Mixing up Big O, Big $\Omega$, and Big $\Theta$ notation. Big O is an upper bound, not necessarily tight.

3. Writing pseudocode that is too language-specific rather than using standard algorithmic constructs.

4. Misunderstanding the difference between a stack (LIFO) and a queue (FIFO) in data structure applications.

flowchart TD
    A[Assessment] --> B[Key Concepts]
    A --> C[Core Principles]
    A --> D[Practical Applications]
    B --> E[Fundamental definitions]
    C --> F[Design patterns]
    D --> G[Real-world usage]

The key principles covered in this topic are linked in the sub-pages above. Focus on understanding the definitions, applying the formulas or frameworks, and evaluating strengths and limitations of each approach.

Worked examples demonstrating the application of key concepts are covered in the detailed sub-pages linked above.

• IB Computer Science
• Computer Science
• IB CS Flashcards: Algorithms and Data Structures