Programming and System Development — Eduqas A-Level Computer Science

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.

• →Computational thinking: Decomposition, pattern recognition, abstraction, and algorithmic design form the foundation of problem-solving in programming.
• →Software development life cycle (SDLC): Understand the phases—analysis, design, implementation, testing, evaluation, and maintenance—and how they apply in different methodologies (waterfall, agile).
• →Programming paradigms: Procedural (sequence, selection, iteration), object-oriented (classes, objects, inheritance, polymorphism, encapsulation), and functional (pure functions, immutability, higher-order functions).
• →Testing strategies: Unit testing, integration testing, system testing, and acceptance testing; black-box vs. white-box testing; and the importance of test data (normal, boundary, erroneous).
• →Error handling and debugging: Types of errors (syntax, runtime, logic) and techniques for debugging (trace tables, breakpoints, print statements).

• 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.

• 💡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.
• 💡When answering questions about the SDLC, always justify your choice of methodology by linking it to project characteristics (e.g., size, risk, changing requirements). For example, agile is suitable for projects with evolving requirements, while waterfall works well for small, well-defined projects.
• 💡In programming questions, show your working—especially for algorithms. Use trace tables or step-by-step explanations to demonstrate how your code handles different inputs. This can earn you method marks even if the final answer is incorrect.
• 💡For testing questions, always specify the type of test (e.g., unit, integration) and give concrete examples of test data (normal, boundary, erroneous). Explain what each test case is checking and the expected outcome.

• 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.
• Misconception: 'Testing is only done at the end of development.' Correction: Testing should be integrated throughout the SDLC, starting with unit tests during implementation and continuing with integration and system tests. Early testing catches bugs sooner, reducing cost and effort.
• Misconception: 'Agile means no documentation.' Correction: Agile emphasizes working software over comprehensive documentation, but some documentation is still necessary—especially user stories, acceptance criteria, and technical notes for maintenance.
• Misconception: 'Object-oriented programming is just about classes and objects.' Correction: OOP also involves key principles like inheritance, polymorphism, encapsulation, and abstraction. Simply using a class does not make a program object-oriented; you must apply these principles correctly.