How do I revise Programming and System Development for WJEC A-Level?

Practice drawing the state of a stack or queue after a series of push/pop or enqueue/dequeue operations.

What exam tips are there for Programming and System Development? (2)

Be prepared to write pseudocode for traversing trees or linked lists.

What exam tips are there for Programming and System Development? (3)

Always link your choice of data structure to the specific performance requirements (e.g., speed of access vs. memory usage) of the scenario provided.

What mistakes should I avoid in Programming and System Development?

Confusing the operational differences between stacks (LIFO) and queues (FIFO).

What are common errors in Programming and System Development exams? (2)

Failing to correctly implement pointer logic when representing linked lists or trees.

Programming and System Development

WJEC

A-Level

This topic covers the description, interpretation, and manipulation of various data structures, including arrays up to three dimensions, records, stacks, queues, trees, linked lists, and hash tables. It requires learners to represent these structures using pointers and arrays, and to select and justify the most appropriate data structure for specific computational problems.

Objectives

Exam Tips

Pitfalls

Key Terms

Mark Points

Subtopics in this area

Programming and System Development

Topic Overview

Programming and System Development is a core component of the WJEC A-Level Computer Science specification, focusing on the principles and practices behind creating reliable, efficient, and maintainable software. This topic covers the entire software development lifecycle, from initial problem analysis and design through to implementation, testing, and maintenance. Students learn to apply computational thinking—decomposition, pattern recognition, abstraction, and algorithmic design—to break down complex problems into manageable parts. Mastery of this area is essential for developing robust programs and understanding how professional software is engineered.

The topic emphasizes both theoretical concepts and practical skills. You will explore different programming paradigms (procedural, object-oriented, and functional), data structures (arrays, lists, stacks, queues, trees, graphs), and algorithms (searching, sorting, recursion). System development methodologies such as the waterfall model, agile, and extreme programming are examined, along with their suitability for different project types. Understanding these methodologies helps you appreciate the importance of planning, documentation, and iterative improvement in real-world software projects.

This knowledge directly supports other A-Level topics like data structures, algorithms, and databases, and is fundamental for any further study or career in computing. By the end of this topic, you should be able to design, implement, test, and evaluate a solution to a given problem, using appropriate tools and techniques. The skills you develop here—logical reasoning, attention to detail, and systematic problem-solving—are highly valued in both academic and professional settings.

What You Need to Demonstrate

Key skills and knowledge for this topic

Correct description and manipulation of arrays (up to 3D), records, stacks, queues, trees, linked lists, and hash tables.
Accurate representation of stacks and queues using pointers and arrays.
Accurate representation of linked lists and trees using pointers and arrays.
Justification of data structure selection based on the requirements of a given situation.
Correct manipulation of records and arrays.
Drawing accurate truth tables for AND, OR, NOT, XOR, NAND, and NOR operations
Correct application of Boolean identities and rules
Successful simplification of Boolean expressions using De Morgan’s laws

Marking Points

Key points examiners look for in your answers

Correct description and manipulation of arrays (up to 3D), records, stacks, queues, trees, linked lists, and hash tables.
Accurate representation of stacks and queues using pointers and arrays.
Accurate representation of linked lists and trees using pointers and arrays.
Justification of data structure selection based on the requirements of a given situation.
Correct manipulation of records and arrays.
Drawing accurate truth tables for AND, OR, NOT, XOR, NAND, and NOR operations
Correct application of Boolean identities and rules
Successful simplification of Boolean expressions using De Morgan’s laws
Demonstrating the application of logical operations in programming contexts like masking and clearing registers
Function of translation programs in making source code executable
Purpose and examples of compilers, interpreters, and assemblers
Distinction between compilers, interpreters, and assemblers
Stages of compilation: lexical analysis, symbol table construction, syntax analysis, semantic analysis, code generation, and optimisation
Distinction between translation and execution errors with examples
Correct use of pseudocode and flowcharts to define algorithms
Application of sequence, selection, and iteration constructs
Correct implementation of sorting algorithms (bubble, insertion, quicksort)
Correct implementation of searching algorithms (linear, binary, shortest-path)
Accurate use of Big O notation for time and space complexity analysis
Effective use of validation and verification techniques
Correct application of mathematical operations like DIV and MOD
Understanding of recursion and parameter passing (by value/reference)
Explanation of programming paradigms (procedural, event-driven, visual, mark-up)
Understanding of object-oriented concepts (object, class, method)
Justification for language standardisation and associated difficulties
Identification of natural language ambiguity and the need for unambiguous syntax
Interpretation and use of syntax diagrams and Backus-Naur form
Comparison of high-level and low-level languages and their appropriate use cases
Description of Waterfall and Agile approaches
Purpose and processes of a feasibility study
Methods of investigation
Use of abstraction and decomposition in problem analysis
Representation of systems using diagrammatic forms
Selection of appropriate hardware and software
Comparison of changeover methods (direct, pilot, phased, parallel)
Distinction between alpha, beta, and acceptance testing
Classification of maintenance (perfective, adaptive, corrective)
Backup and recovery procedures
Documentation requirements (user and maintenance documentation)
Ability to describe types of software tools used to assist the software engineering process.
Explanation of the role of software packages in systems analysis, specification, design, and testing.
Explanation of the role of IDE tools in developing and debugging programs.
Explanation of program version management.
Ability to describe social and economic changes resulting from computing developments
Understanding of the moral, ethical, legal, and cultural consequences of computer use
Knowledge of the role of professional codes of conduct
Analysis of the effects of computers on the nature of employment
Explanation of how legislation impacts security, privacy, data protection, and freedom of information

Examiner Tips

Expert advice for maximising your marks

💡Practice drawing the state of a stack or queue after a series of push/pop or enqueue/dequeue operations.
💡Be prepared to write pseudocode for traversing trees or linked lists.
💡Always link your choice of data structure to the specific performance requirements (e.g., speed of access vs. memory usage) of the scenario provided.
💡Ensure you can distinguish between static and dynamic data structures.
💡Practice drawing truth tables for all six specified logic gates until it becomes second nature
💡Always show your working when simplifying Boolean expressions to gain method marks
💡Remember that De Morgan’s laws are essential for simplifying complex logic circuits
💡Ensure you can relate logical operations to real-world programming tasks like data encryption and bit manipulation
💡Be prepared to define and explain each stage of the compilation process in order
💡Use specific examples when asked to distinguish between translation and execution errors
💡Ensure you can explain why a specific translator might be chosen for a given scenario
💡Practice dry-running algorithms with test data to identify logical errors
💡Ensure you can convert between flowcharts and pseudocode fluently
💡Memorize the Big O complexity for standard sorting and searching algorithms
💡Always justify your choice of data structure or algorithm when asked
💡Use self-documenting identifiers and annotations in your code examples
💡Be prepared to interpret syntax diagrams and BNF expressions provided in the exam paper
💡Ensure you can clearly distinguish between the roles of different paradigms
💡Practice justifying language choices based on specific problem constraints
💡Focus on the 'why' behind standardisation rather than just the 'what'
💡Ensure you can explain the relative merits of Waterfall versus Agile in different contexts
💡Be prepared to justify why a specific changeover method is most suitable for a given business scenario
💡Remember that maintenance documentation must include annotated listings and variable lists
💡Focus on the distinction between validation and verification in the context of system design
💡Ensure you can distinguish between the roles of different software tools at various stages of the software development lifecycle.
💡Be prepared to explain why version management is critical in collaborative software engineering environments.
💡Ensure you can link specific legislation (e.g., Data Protection Act) to its practical impact on data security and privacy.
💡Be prepared to discuss both the positive and negative impacts of technology on employment and society.
💡Use appropriate technical vocabulary when discussing ethical and legal issues.

Common Mistakes

Pitfalls to avoid in your exam answers

Confusing the operational differences between stacks (LIFO) and queues (FIFO).
Failing to correctly implement pointer logic when representing linked lists or trees.
Inability to justify why one data structure is more efficient than another for a specific problem.
Incorrectly handling multi-dimensional array indexing.
Confusing the order of operations in complex Boolean expressions
Incorrectly applying De Morgan’s laws during simplification
Misinterpreting the behavior of XOR, NAND, or NOR gates in truth tables
Failing to correctly apply bitwise logical operations (masking) to specific register bits
Confusing the roles of compilers and interpreters
Incorrectly ordering the stages of the compilation process
Failing to distinguish between translation-time errors (e.g., syntax) and execution-time errors (e.g., runtime errors)
Confusing time complexity with space complexity in Big O notation
Incorrectly identifying the scope and lifetime of variables
Failing to handle edge cases in search and sort algorithms
Misunderstanding the difference between call by value and call by reference
Inaccurate use of DIV and MOD operators
Confusing the specific features of different programming paradigms
Incorrectly applying Backus-Naur form notation
Failing to justify the choice of language type for a specific problem
Misunderstanding the distinction between high-level and low-level language requirements
Confusing the different types of maintenance
Failing to justify the choice of changeover method for a specific scenario
Neglecting to include maintenance documentation components like data dictionaries
Overlooking the importance of feasibility studies in the project lifecycle

Frequently Asked Questions

Common questions students ask about this topic

Likely Command Words

How questions on this topic are typically asked

Describe

Interpret

Manipulate

Represent

Select

Identify

Justify

Draw

Apply

Simplify

Explain

Distinguish

Compare

Calculate

Write

Use

Analyse

Discuss

Ready to test yourself?

Practice questions tailored to this topic

Programming and System Development

Subtopics in this area

Topic Overview

What You Need to Demonstrate

Marking Points

Examiner Tips

Common Mistakes

Frequently Asked Questions

Likely Command Words

Ready to test yourself?

Related Topics in WJEC A-Level Computer Science

Computer Architecture, Data, Communication and Applications

Computer Architecture, Data, Communication and Applications

Computer Architecture, Data, Communication and Applications

Computer Architecture, Data, Communication and Applications

Programming and System Development

Subtopics in this area

Topic Overview

What You Need to Demonstrate

Marking Points

Examiner Tips

Common Mistakes

Frequently Asked Questions

What is the difference between black-box and white-box testing?

How do I choose between waterfall and agile for a project?

What is the purpose of a trace table?

Can you explain polymorphism with an example?

What are the key differences between procedural and object-oriented programming?

How do I handle errors in my program effectively?

Likely Command Words

Ready to test yourself?

Related Topics in WJEC A-Level Computer Science

Computer Architecture, Data, Communication and Applications

Computer Architecture, Data, Communication and Applications

Computer Architecture, Data, Communication and Applications

Computer Architecture, Data, Communication and Applications