Use technical terminology in knowledge-based and extended answer questions.
Expand on explanations and avoid generic descriptions (e.g., don't just say "stack of plates").
Structure responses based on command verbs and mark allocation.
Dry run algorithms quickly to identify their purpose rather than guessing based on variable names.
Utilize past papers and marking schemes for practice and deeper understanding.
Check answers methodically to avoid early errors affecting final answers.
Handwriting must be legible – use word processors if necessary and allowed.
Understand and differentiate between programming paradigms, including procedural, OOP, event-driven, visual, mark-up, functional, and logic.
Provide relevant examples and languages for each paradigm – not just tools like IDEs (e.g., Java for OOP, Haskell for functional).
Explain use cases for different paradigms and how they relate to methodologies like Agile and Waterfall.
Know and explain encapsulation, inheritance, polymorphism, and the use of properties and instance variables.
Be clear on class vs. instance – class is the template, instance is the object created.
Understand that a method only accesses its own object's data.
Distinguish between compilers, interpreters, and assemblers.
Provide examples and discuss advantages/disadvantages of each.
Clarify compiling vs interpreting – a common confusion.
Accurately describe stack and queue operations beyond just saying FILO/FIFO.
Provide technical definitions of operations like push/pop.
Explain linked list vs binary tree clearly.
Understand binary tree traversals and real-world uses (in-order for alphabetical, pre/post for copying/deleting).
Evaluate sorting/search algorithms (e.g., Quicksort = recursive, Insertion = non-recursive).
Know time and space complexity using Big O notation.
Understand and apply logarithmic algorithms like binary search.
Clearly define and use quicksort, merge sort, etc., and identify recursive vs non-recursive.
Understand and explain shortest path algorithms (e.g., Dijkstra's) and weighted cost paths.
Know the features of Agile and Waterfall, particularly their analysis and design stages.
Understand the links between methodologies and programming paradigms.
Be familiar with version control tools like Git/GitHub and their features.
Explain evaluation criteria for computer-based solutions, especially performance (not lag), scalability, usability, and security.
Describe and give examples of natural and immersive interfaces, not just the common ones (e.g., include gesture recognition, force feedback, binaural headphones).
Avoid confusing natural language syntax with natural language interfaces.
Use precise, enriched discussions with a range of interface types.
Apply Boolean identities accurately and consistently through to the final answer.
Understand how to convert truth tables to Boolean expressions.
Clearly identify the most significant bit (MSB) – leftmost, not rightmost.
Be proficient in converting between flowcharts and pseudocode.
Write and interpret pseudocode accurately.
Use syntax diagrams precisely.
Avoid confusing objects with controls in event-driven programming.
Be clear on the semantic analysis stage of compilation.
Know the purpose and features of debugging tools.
Describe hashing properly – e.g., index based on key value.
Understand validation vs verification vs authentication.
Discuss standardisation of languages, including benefits (modularity, security, cross-platform compatibility) and challenges in agreeing on standards.
Know compression ratios and how they're used.
Be able to explain recursion’s demands on stack space and compare to iterative methods.
Use real-world examples for application of theoretical concepts.