2015 Notes from the Marking Centre – Software Design and Development
Introduction
This document has been produced for the teachers and candidates of the Stage 6 Software Design and Development course. It contains comments on candidate responses to the 2015 Higher School Certificate examination, highlighting their strengths in particular parts of the examination and indicating where candidates need to improve.
This document should be read along with:
- the Software Design and Development Stage 6 Syllabus
- the 2015 Higher School Certificate Software Design and Development examination
- the marking guidelines
- Advice for HSC students about examinations
- other support documents developed by the Board of Studies, Teaching and Educational Standards NSW to assist in the teaching and learning of Software Design and Development in Stage 6.
Section II
Candidates showed strength in these areas:
- identifying reasons for maintaining software (Q21)
- describing a number of testing methods (Q22)
- calling a subroutine with parameters (Q23b)
- recognising the difference between runtime errors and logic errors (Q24)
- providing a range of reasons why updates of software would be provided (Q25)
- demonstrating an understanding of the logic required to achieve the requirements (Q26)
- identifying how hardware advancement affects software development (Q27)
- identifying features of the prototyping and rapid application development approaches (Q28a)
- showing a good understanding of the concept of storyboarding (Q28b)
- understanding the purpose of the Main module (Q29a)
- identifying some uses of stubs (Q29b)
- identifying the subroutines in the algorithm and showing their relationship in a diagram (Q29c)
- demonstrating an understanding of records (Q30a)
- tracing the algorithm through and showing how the values of variables change throughout execution (Q31a)
- identifying errors in the algorithm (Q31b)
- recognising suitable control and data structures for solving the problem (Q32).
Candidates need to improve in these areas:
- distinguishing between algorithm and code testing and the testing appropriate to pre-release (Q22)
- understanding what information about a library routine should be documented (Q23a)
- providing clear examples to show the effects of runtime and logic errors (Q24)
- understanding why software updates may be provided for free (Q25)
- writing pseudocode that avoids language specific syntax (Q26)
- presenting a logical argument using information related to the scenario (Q28a)
- understanding the difference between screen design and storyboards (Q28b)
- explaining the use of stubs as a design and/or testing tool with reference to the scenario (Q29b)
- drawing a structure diagram using correct features and symbols (Q29c)
- justifying the use of an array of records with reference to the scenario (Q30a)
- understanding the benefits and limitations of sorting an array of records (Q30b)
- clearly setting out desk checks, for example, in tables with each column representing a single variable and showing the relevant outputs from the algorithm (Q31a)
- understanding how to modify an algorithm loop (Q31b)
- providing specific test data items, for example #1234#, rather than just providing a description of the required test data (Q31c)
- correctly referencing an array in an algorithm (Q32).
Section III
Candidates showed strength in these areas:
- discussing issues relating to the logic paradigm (Q33a)
- using facts to form a rule in the logic paradigm (Q33ci)
- demonstrating some understanding of inheritance (Q33di)
- showing some understanding of binary multiplication (Q34a)
- identifying a benefit of representing integers using 2’s complement (Q34b)
- showing an understanding of how to interpret the data stream (Q34ci)
- understanding how to construct a data stream (Q34cii)
- identifying the components of the floating point representation (Q34d)
- creating a truth table (Q34ei).
Candidates need to improve in these areas:
- discussing the suitability of the object-oriented paradigm in relation to the scenario (Q33a)
- understand what heuristics are and why they are used (Q33b)
- evaluating rules in the logic paradigm (Q33cii)
- understanding how polymorphism can be used in the scenario (Q33di)
- writing a method in object-oriented code (Q33dii)
- explaining the consequences of the error and understanding how to modify the code to correct the error (Q33e)
- converting from hexadecimal to binary (Q34ci)
- representing a value in floating point notation (Q34d)
- drawing a logic circuit to represent a system (Q34eii).
NSW Government