Design a software program structure DTG 6-6
Achievement Standard 1.45, AS91075
Design a software program focuses on designing the structure of a software program.
Learning objective: DTG 6-6
Students will:
- demonstrate ability to design the structure of a basic software program.
Indicators
Students can:
- specify variables and their data types
- independently construct a flexible and robust plan
- specify a procedural structure that combines well-chosen actions, conditions and control structures that constitutes a well-structured logical solution to the task
- specify a comprehensive set of test cases with expected, boundary and invalid input for testing the program.
Progression
As part of a junior technology programme students should learn some fundamental concepts about computational thinking and problem solving. It is useful if within a junior programme students can get some exposure to programming, and are introduced to ideas from computer science such as commenting on interfaces critically, binary representation, and simple searching or sorting algorithms.
At level 6 students learn to specify variables and their data types, construct flexible and robust plans, and determine structures that combine well-chosen actions, conditions and control structures that provide well-structured logical solution to tasks. They establish sets of test cases with expected, boundary and invalid input for testing programs.
The Teacher Guidance section provides information that supports teachers scaffolding of learning from levels 1-8 of the curriculum. This allows for differentiation of a programme of learning.
The deliberate use of provide, guide, and support in this section signals that as students' capacity for self-management increases, teachers progressively reduce the level of scaffolding provided.
- Provide – the teacher should take full responsibility for introducing and explicitly teaching new knowledge, skills or practices.
- Guide – the students have a level of understanding and competency on which they can draw but the teacher remains primarily responsible for continuing to develop these.
- Support – the students take primary responsibility for their own learning, drawing on all their previous experiences to consolidate and extend their understanding. The teacher is supportive rather than directive.
- The Teacher Guidance also uses the term ensure to indicate when the teacher plays a monitoring role to check that conditions critical for learning are present.
Teacher guidance
To support students to develop an ability to design the structure of a basic software program at level 6, teachers could:
- Guide students on how to specify variables and their data types.
- Guide students to independently construct flexible and robust plans for basic programs that include using actions, conditions and control structures such as: checking input data for validity; correctly handling expected, boundary and invalid inputs; and using constants, variables and derived values in place of literals.
- Guide students to set out program codes clearly and to document programs with comments.
- Guide students on how to specify procedural structures that combine well-chosen actions, conditions and control structures that constitute well-structured logical solution to tasks, which have no unnecessary duplication or repetition.
- Guide students specify comprehensive sets of test cases with expected, boundary and invalid input for testing programs.
TOP
Contexts for teaching and learning
The learning associated with "Design a software program structure - DTG 6-6" (AS91075 Digital Technologies 1.45) and "Construct a software program – DTG 6-7" (AS91076 Digital Technologies 1.46) are strongly interlinked, and normally both should be taught at the same time. Requiring students to finalise their plan (for AS91075) before implementing their program (for AS91076) reflects the "waterfall" model of software development, and is not really appropriate even for small programs or for novice programmers. A more appropriate, and more common approach in industry, is "agile" software development, where an aspect of the design is done and then implemented, and this process is iterated so that each step of the processes informs the next, allowing errors found in implementation and testing to feed back to improve and extend the design. The latter is recommended for teaching these topics as students will learn what is reasonable in a design as they implement it. The key to producing a design is that students take a loose requirement and turn it into an algorithmic description (plan) that is a set of executable steps. The implementation would involve taking the algorithmic description and turning it into a debugged and tested program. It is to be expected that the final design may have been changed from the initial design, but this is not a problem for assessing the standards as long as students are able to express their final design clearly and precisely as an algorithmic description.
Teachers are referred to the detailed notes on the level 1 and 2 programming standards. "Programming Standards Levels 1 & 2 - A discussion of, and example plans & programs for Standards 1.45, 1.46, 2.45, 2.46" By Anthony Robins & Sandy Garner, Computer Science Department, University of Otago
www.cs.otago.ac.nz/staffpriv/anthony/programming-standards-notes.pdf
This resource provides background information and examples.
Teachers are also referred to the "Support for Schools" website (
http://www.cs.otago.ac.nz/schools/) prepared by staff from the Computer Science Department at The University of Otago. This resource is for curriculum level 7 and 8 but is still an important source of reference for curriculum level 6.
- Students should be developing their plan in the context of a target programming language. At this level the programming language can be graphical, drag-and-drop, or text based. Any programming language that is commonly used for beginners is suitable for curriculum level 6; the following are commonly used for this purpose and have good beginner teaching resources available:
- Scratch
- Python
- Javascript
- Java
Almost any language is acceptable; other examples include:
- Alice
- Processing
- Microsoft SmallBasic
- Visual Basic 2010, VB6
- Ruby
- PERL
- C
- C++
- C#
- This learning objective "Demonstrate ability to design the structure of a basic software program" is often done in conjunction with the learning objective DTG 6-7 "Demonstrate ability to construct a basic software program". While it is not an absolute requirement for this objective that students must carry on and code the program they design, the implementation will make the design process more meaningful, and it would be difficult to teach students to design a program when they don’t know how to code it. It is allowable, and pedagogically desirable, for a student to modify their design based on the experience of trying to implement it.
Literacy considerations
Teachers need to ensure students understand the specialist language related to constructing a plan for a basic program such as ‘iteration control structures or "boundary inputs". In addition students must be able to present their plan in a way that is clear to others. Students will need guidance on how to present a coherent document that communicates the structure and function of a computer program.
Resources to support teaching and learning
TOP
Assessment for qualifications
The following achievement standard(s) could assess learning outcomes from this learning objective:
- AS91075 Digital Technologies 1.45: Construct a plan for a basic program for a specified task
Key messages from the standard
- At level 6 the plan must be for a basic computer program. A basic computer program is defined in explanatory note 4. A basic computer program is a program written in a programming language, that uses:
- variables involving at least two types of information (eg numeric, characters, text) and assignment
- sequence, selection and iteration control structures
- predefined actions (eg predefined methods, functions, or procedures)
- input from a user, sensors, or other external source.
- The “sequence, selection and iteration” required by this standard occurs in all general purpose programming languages. Usually “sequence” is the idea that commands occur in the order they appear in a section of a program; selection is usually an “if” or “case/switch” statement, and iteration is a loop, such as a “for”, “while” or “repeat” statement.
- The “predefined actions” will typically be a built-in function that does something like draw on the screen, read user input, do a mathematical calculation, or manipulate a string of text.
- Input would normally be typed text, but it could be the location of a mouse click, or input from external sensors such as a light or sound sensor.
- What a plan is in the context of this standard is defined in explanatory note 3. It must be developed in the context of a target programming language (see notes on suitable programming languages in the section above). The plan can be communicated using a range of tools such as natural language, diagrams, or pseudocode. See explanatory note 3.
- Explanatory note 5 states the requirement that there is a specified task which requires the development of a basic computer program in order to resolve the task. The task can be teacher given or developed in negotiation with the student. Teachers need to ensure that the task is appropriate for students working at curriculum level 6.
- As part of the task students need to specify a set of input cases for testing the program. These need to be clearly set out in writing in the student evidence for this standard. Students need to understand expected input cases, boundary input cases, and invalid input cases. Some of these may become clearer once the program has been implemented, which is an example of how the plan might be informed by the implementation. Refer to the table below:
| Achieved
| Merit
| Excellence
|
| Expected inputs
| Expected and boundary inputs
| Comprehensive set of expected, boundary, and invalid inputs
|
| Expected – input that is expected e.g. if a number between 1 and 10 is expected then you would test the program for input of say 2 or 5.
| Boundary – Input values that are right at the limit of some condition or range of operation. For example, if a system should check for input between 1 and 10, then the values 9, 10 and 11 would be good to test to see if it responds correctly for each of these.
| Invalid – Input values that are invalid for some other reason than being out of range, e.g. using invalid characters, inconsistent sets of values, unexpected key sequences, or text input when numeric is expected. For example, if a system should check for an integer between 1 and 10, it should be tested with input such as alphabetic characters or a number such as 3.5.
|
- Part of the step-up to merit is that students need to construct the plan independently. To make a judgement for independence, the following guidelines might be helpful. The student:
- takes responsibility for achieving a quality outcome
- plans effectively, thinks ahead, is well organised, self starting, self managing
- makes their own decisions
- stores their work carefully
- carries out appropriate checking and testing and takes corrective action as necessary
- recognises and deals with issues promptly
- asks for help only with exceptional problems rather than routinely
- is always able to describe what they are doing and why and where their project is heading.
It does NOT mean that the student:
- is unable to ask for help with technical (for example, faulty equipment or computing environment issues) or safety issues
- is responsible for the consequences of inadequate project storage facilities.
- The merit criteria also requires specifying well-chosen actions, conditions and control structures (see explanatory note 6 and 7). 'Well-chosen' means that the right language features / control structures are used in the appropriate task contexts (e.g. a for-loop is appropriate in some contexts and a while-loop in others), and that the resulting sequence of actions correctly performs the task and has no unintended behaviour or consequences.
- The step-up to excellence is about efficiently constructing a plan for the program. In the context of designing a program, this involves making good design choices so that the design does not have to be redesigned substantially if the program needs to be extended or modified, and that the design can be understood easily and quickly by a later programmer. This involves constructing a flexible and robust plan (see explanatory note 8), and specifying an effective procedural structure that constitutes a well structured logical decomposition of the task (see explanatory note 9). It also involves specifying a comprehensive set of input cases for testing the program so that design and implementation errors can be found quickly.
- Although not a formal requirement of the standard, teachers may wish to show students suitable ways of desk checking an algorithm.
- The evidence for this standard may be part of a larger project or may be from a standalone activity. For example students could be engaged in a project where they have identified their own need or opportunity and are working with stakeholders to establish a brief prior to staring to developing a basic computer program to resolve the brief.
For the most up to date information, teachers should be referring to the latest version of the standards, conditions of assessment and assessment resources on TKI and the moderators reports, clarifications documents and student exemplars on the NZQA website. See links below.
Resources to support student achievement
Last updated June 8, 2018
TOP
