SDT Student Guide v1.1

LEVEL 4
SOFTWARE DEVELOPMENT TECHNIQUES
Student Guide
SDT Student Guide v1.1

Modification History
Version Date Revision Description

V1.0 June 2011 For release
V1.1 November 2015 Assessment Methodology Updated
© NCC Education Limited, 2011

All Rights Reserved
The copyright in this document is vested in NCC Education Limited. The document must not be
reproduced by any means, in whole or in part, or used for manufacturing purposes, except with the
prior written permission of NCC Education Limited and then only on condition that this notice is
included in any such reproduction.
Published by: NCC Education Limited, The Towers, Towers Business Park, Wilmslow Road,
Didsbury, Manchester M20 2EZ, UK.
Tel: +44 (0) 161 438 6200 Fax: +44 (0) 161 438 6240 Email: info@nccedu.com
http://www.nccedu.com
Page 2 of 60
Title Here
CONTENTS
1. Module Overview and Objectives .............................................................................. 7
2. Learning Outcomes and Assessment Criteria .......................................................... 7
3. Syllabus ....................................................................................................................... 8
4. Related National Occupational Standards .............................................................. 10
5. Teaching and Learning............................................................................................. 10
5.1 Lectures...................................................................................................................... 11
5.2 Tutorials ...................................................................................................................... 11
5.3 Seminars .................................................................................................................... 11
5.4 Private Study .............................................................................................................. 11
6. Assessment .............................................................................................................. 11
7. Further Reading List ................................................................................................. 11
Topic 1: Introduction to the Module and the Software Development Process.................... 13
1.1 Learning Objectives .................................................................................................... 13
1.2 Timings ....................................................................................................................... 13
1.3 Seminar Notes ............................................................................................................ 14
1.4 Private Study Exercises .............................................................................................. 15
1.5 Tutorial Notes ............................................................................................................. 16
Topic 2: Desk-Checking .......................................................................................................... 17
2.2 Timings ....................................................................................................................... 17
2.3 Seminar Notes ............................................................................................................ 18
2.5 Tutorial Notes ............................................................................................................. 20
Topic 3: Data Representation ................................................................................................. 21
3.2 Timings ....................................................................................................................... 21
3.3 Seminar Notes ............................................................................................................ 22
3.5 Tutorial Notes ............................................................................................................. 24
Topic 4: Iteration ..................................................................................................................... 25
4.2 Timings ....................................................................................................................... 25
4.3 Seminar Notes ............................................................................................................ 26
4.5 Tutorial Notes ............................................................................................................. 28
Topic 5: Selection ................................................................................................................... 29
Page 3 of 60
Title Here
5.2 Timings ....................................................................................................................... 29
5.3 Seminar Notes ............................................................................................................ 30
5.5 Tutorial Notes ............................................................................................................. 32
Topic 6: Functions .................................................................................................................. 33
6.2 Timings ....................................................................................................................... 33
6.3 Seminar Notes ............................................................................................................ 34
6.5 Tutorial Notes ............................................................................................................. 36
Topic 7: Testing and Debugging ............................................................................................ 37
7.2 Timings ....................................................................................................................... 37
7.3 Seminar Notes ............................................................................................................ 38
7.5 Tutorial Notes ............................................................................................................. 40
Topic 8: Arrays ........................................................................................................................ 41
8.2 Timings ....................................................................................................................... 41
8.3 Seminar Notes ............................................................................................................ 42
8.5 Tutorial Notes ............................................................................................................. 44
Topic 9: Algorithms................................................................................................................. 45
9.2 Timings ....................................................................................................................... 45
9.3 Seminar Notes ............................................................................................................ 46
9.5 Tutorial Notes ............................................................................................................. 48
Topic 10: Objects and Classes ................................................................................................. 49
10.2 Timings ....................................................................................................................... 49
10.3 Seminar Notes ............................................................................................................ 50
10.5 Tutorial Notes ............................................................................................................. 52
Topic 11: Array Data Structures ............................................................................................... 53
Page 4 of 60
Title Here
11.2 Timings ....................................................................................................................... 53
11.3 Seminar Notes ............................................................................................................ 54
11.5 Tutorial Notes ............................................................................................................. 56
Topic 12: Summary and Recap ................................................................................................ 57
12.2 Timings ....................................................................................................................... 57
12.3 Seminar Notes ............................................................................................................ 58
12.5 Tutorial Notes ............................................................................................................. 60
Page 5 of 60
Title Here
Page 6 of 60
Overview
1. Module Overview and Objectives

This unit provides you with an introduction to the context of software development and the
description of a method and supporting notations.
2. Learning Outcomes and Assessment Criteria

Learning Outcomes; Assessment Criteria;
The Learner will: The Learner can:
1. Identify and explain the key stages 1.1 Identify and describe the stages in traditional
of software development lifecycles software lifecycle approaches
1.2 Explain why alternative software development
lifecycles have been developed
1.3 Identify and explain the key features of modern
approaches to software development
2. Express, design and evaluate 2.1 Express algorithms in a non-executable code
algorithms 2.2 Develop algorithmic solutions to well-specified
problems using appropriate notation
2.3 Evaluate algorithmic solutions with appropriately
selected test data
3. Identify and use programming 3.1 Select and use variables and constants taking into
language constructs account associated data type requirements
3.2 Select and use appropriate programming structures
(sequence, selection and iteration)
4. Identify and use common data 4.1 Explain and use arrays
structures 4.2 Explain and use common structures such as lists,
queues and stacks
5. Explain and use common algorithms 5.1 Explain and use common algorithms for searching,
sorting, parsing
5.2 Explain the efficiency criteria used to evaluate such
algorithms
6. Explain and use test strategies 6.1 Develop and apply test strategies for well-defined
algorithms
6.2 Identify and explain a range of methods used to test
software
7. Explain how software is modularised 7.1 Explain procedural and object oriented program
structure
7.2 Demonstrate the use of program structures using
non-executable code
Page 7 of 60
Title Here
3. Syllabus
Syllabus
Topic No Title Proportion Content
1 Introduction to 1/12  Introduction to the module
the Module and  Definition and design of simple algorithms
the Software
Development
2 hours of  Introduction to the software development
lectures process
Process
2 hours of  The history of software development
seminars
1 hour of
tutorials
Learning Outcomes: 1 & 2
2 Desk-checking 1/12  Pseudocode Format
 Desk-checking
2 hours of  Commenting
lectures
2 hours of
seminars
1 hour of
tutorials Learning Outcomes: 2 & 6
3 Variables and 1/12  Memory management in a computer system

Data  Data types
Representation
2 hours of  Variable declaration and manipulation
lectures
 Arithmetic operators
2 hours of
seminars
1 hour of
tutorials Learning Outcomes: 3
4 Iteration 1/12  For loops

 While loops
2 hours of  Do-While loops
lectures
 Mathematical algorithms.
2 hours of
seminars
1 hour of
5 Selection 1/12  If
 Else
2 hours of  Switch
lectures
 Input validation
2 hours of
seminars
1 hour of
Page 8 of 60
Title Here
6 Functions 1/12  Parameters
 Return Types
2 hours of  Scope
lectures
2 hours of
seminars
1 hour of
tutorials Learning Outcomes: 3, 4 & 7
7 Testing and 1/12  Black box testing

Debugging  White box testing
2 hours of  Unit testing
lectures
 Integration testing
2 hours of
seminars
1 hour of
tutorials Learning Outcomes: 6
8 Arrays 1/12  Declaration of arrays

 Manipulation of arrays
2 hours of  Application of arrays
lectures
 Two dimensional arrays
2 hours of
seminars
1 hour of
9 Searching and 1/12  Linear search algorithms

Sorting  Big O Notation
2 hours of  Binary search algorithms
lectures
 Bubble Sort Algorithm
2 hours of
 Quick Sort
seminars
1 hour of
10 Objects 1/12  Object design

 Modularity
2 hours of  Methods
lectures
 Constructors
2 hours of
 Accessor Functions
seminars
1 hour of
tutorials Learning Outcomes: 3, 4 & 5
Page 9 of 60
Title Here
11 Data Structures 1/12  Lists
 Stacks
2 hours of  Queues
lectures
 Recursion
2 hours of
seminars
1 hour of
12 Summary and 1/12  Summary of module

Conclusion  Contextualisation of concepts
2 hours of
lectures
2 hours of
seminars
1 hour of
tutorials Learning Outcomes: All
4. Related National Occupational Standards

The UK National Occupational Standards describe the skills that professionals are expected to
demonstrate in their jobs in order to carry them out effectively. They are developed by employers
and this information can be helpful in explaining the practical skills you have covered in this module.
Related National Occupational Standards (NOS)

Sector Subject Area: 6.1 ICT Professional Competence
Related NOS: 4.4.A.1 – Assist with the development for systems analysis activities;
4.4.A.2 – Operate, under supervision, systems analysis activities;
4.4.P.1 – Prepare, under supervision, for a systems analysis assignment;
4.7.A.1 – Follow, under supervision, the organisation’s procedures for informing systems design
activities; 4.7.A.2 – Carry out, under supervision, specified systems design activities;
4.7.A.3 – Document, under supervision, specified information relating to system/solution/service
designs;
5.2.A.1 - Assist with the management of software development activities;
5.2.A.2 - Carry out software development activities under direction;
5.2.P.3 - Control software development activities;
5.3.A.1 - Carry out IT/Technology solution testing activities under direction;
5.3.P.1 - Carry out IT/Technology solution testing
5. Teaching and Learning

Suggested Learning Hours
Lectures: Tutorial: Seminar: Laboratory: Private Study: Total:
24 12 24 - 90 150
The teacher-led time for this module is comprised of lectures, seminars, and tutorials. You will need
to bring this Student Guide to all classes for this module. The breakdown of the hours for each topic
is given in the topic notes below.
Page 10 of 60
Title Here
5.1 Lectures
Your lecturer will be presenting the basic knowledge and the theoretical concepts required for the
unit during this time. He/she will use PowerPoint slides during the lecture time and you will be
expected to take notes.
You will also be encouraged to be active during this time and discuss and/or practice the concepts
covered. Lectures will include question and answer elements to promote participation and to allow
your lecturer to check whether you understand the concepts they are covering.
5.2 Tutorials
These are designed to deal with the questions arising from the lectures and private study sessions.
You should think carefully beforehand about any areas in which you might need additional guidance
and support and use this time to discuss these with your teacher.
5.3 Seminars
These sessions provide tasks to involve group work, investigation and independent learning for
certain topics. The details of these tasks are provided in this guide.
5.4 Private Study

This Student Guide also contains details of the private study exercises. You are expected to
complete these exercises to improve your understanding. Your tutor will set deadlines for the
completion of this work and go over the suggested answers with you. The deadlines will usually be
before the scheduled tutorials for that topic. Some of the private study tasks may require you to work
in a small group so you will need to plan your time carefully and ensure that you can meet with your
group members to complete the work required before the deadline.
You should also use this time to revise the content of lectures to ensure understanding and conduct
extra reading (using the supplementary textbooks or other materials available in the library or
online). You should bring any questions to the tutorial for additional guidance and support.
6. Assessment
This module will be assessed by means of an examination worth 100% of the total mark. These
assessments will cover the learning outcomes and assessment criteria given above.
7. Further Reading List

You will also be expected to undertake further reading to consolidate and extend your knowledge of
the topics covered in this module. Your Accredited Partner Centre’s library will contain a selection of
useful sources of information. The list below also provides suggestions of suitable reference books
you may like to use.
Henney, K. (2010). 97 Things Every Programmer Should Know. O’Reilly Media

ISBN-10: 0596809484
ISBN-13: 978-0596809485
Lopp, M. (2010). Being Geek: The Software Developer’s Career Handbook. O’Reilly Media.
ISBN-10: 0596155409
ISBN-13: 978-0596155407
Page 11 of 60
Title Here
Seibel, P. (2009). Coders at Work: Reflections on the Craft of Programming. APRESS.
ISBN-10: 1430219483
ISBN-13: 978-1430219484
Page 12 of 60
Topic 1
Topic 1: Introduction to the Module and the Software

Development Process
1.1 Learning Objectives

This topic provides an overview of the software development process. On completion of the topic,
you will be able to:
 Explain the history of the software development;

 Define an algorithm;
 Identify pseudocode;
 Write pseudocode.
1.2 Timings
Lectures: 2 hours
Seminars: 2 hours
Private Study: 7.5 hours
Tutorials: 1 hour
Page 13 of 60
Title Here
1.3 Seminar Notes
The time allocation for the seminar for this topic is 2 hours.
Activity 1: Group Discussion and Introductions
Work in small groups as directed by your tutor.
Think back to the lecture and discuss the nature of programme. What makes programming difficult?
Activity 2: Giving Instructions
Work with your group to think of a real world task where instructions are difficult to give in a precise,
comprehensive form. Write a list of instructions to complete the task.
e.g. dealing out a hand of cards to four players
You should prepare to present your example to the rest of your class.
Activity 3: First Algorithm Exercises
Work with your group to outline the following tasks as algorithms:
1. Finding the largest number in a list of ten user-specified numbers
2. Finding the smallest number in a list of ten user-specified numbers
Page 14 of 60
Title Here
1.4 Private Study Exercises
You should spend approximately 7.5 hours on the Private Study for this topic. You should use this
time to complete the exercises below as directed by your lecturer and to review the contents of this
topic.
Exercise 1: Pseudocode and Flowcharts
Pseudocode has a close relationship to flowcharts - they are two ways to look at the same thing.
While flowcharts aren't a part of this topic, they are very useful in helping you to explain how you
think a program should work. There are three main symbols in a simple flow chart as discussed on
this website: http://www.mindtools.com/pages/article/newTMC_97.htm
Spend some time researching flowcharts, and convert the pseudocode you developed during the
seminars into a flowchart representation.
This will give you a different method of visualising the way in which an algorithm functions, and
further develop your understanding of the algorithms you have encountered.
Exercise 2: Additional Algorithms
Develop and represent (either in pseudocode or as flowcharts) algorithms for the following tasks:
a. Determine whether a word is a palindrome
b. Calculate the factorial of a number
c. Calculate the power of one number to another
Exercise 3:
Revise the material presented in the lecture, and research these further to ensure a comprehensive
understanding of this and related topics. Use the internet, books and magazines to explore the
following questions:
1. X86 is a common assembly language – what are some others and what microprocessors
were they intended for?
2. What does a simple machine code program look like?
3. Why are algorithms important?
Page 15 of 60
Title Here
1.5 Tutorial Notes
The tutorials for this topic will last for 1 hour. You can expect to spend some of this time discussing
your answers to the Private Study exercises with your lecturer and other students. Your lecturer will
then direct you on completing the tasks below.
Exercise 1: Review of Private Study Exercises
Compare the three algorithms you produced for Private Study Exercise 2 with those produced by
other students. Explain your reasoning.
Page 16 of 60
Topic 2
Topic 2: Desk-Checking

This topic introduces desk-checking. On completion of the topic, you will be able to:
 Develop a program in formal pseudocode;

 Define the need for desk-checking in pseudocode;
 Desk-check pseudocode algorithms.
2.2 Timings
Lectures: 2 hours
Seminars: 2 hours
Tutorials: 1 hour
Page 17 of 60
Title Here
2.3 Seminar Notes
Activity 1:
Develop and desk-check the pseudocode for the following algorithms:
1. A program that asks the user for two numbers. Output the remainder of the first number
divided by the second.
2. A program that asks the user for the radius of a circle and then provides the area (remember,
the area of a circle is given by taking the value of pi, and multiplying it by the square of the
radius)
3. A program that calculates the squared length of the hypotenuse of a right-angled triangle.
The program should ask the user for the length of the other two sides. (use Pythagoras
theorem for this)
Activity 2:
Desk-check, Identify and fix the flaw(s) in the following pseudocode program:
1 data speed as real number
2 data time as real number
3 data distance as real number
4 output "Please value one"
5 input speed
6 output "Please value two"
7 input distance
8 distance = speed / time
9 output "The answer is"
10 output speed
Page 18 of 60
Title Here
topic.
Exercise 1:
Go through all the algorithms you wrote in the seminar, and comment on every line of pseudocode
that you put in place. Use whatever commenting style that you like, but give your explanation of
what you think each line of code is doing.
Exercise 2:
Go through all the algorithms you wrote in the Topic 1 seminar, and comment on every line of
pseudocode that you put in place. You might find this considerably more difficult than with exercise
one, but this highlights the importance of commenting – they’re notes for you (and others) when the
thinking behind the code is no longer fresh in your mind.
Exercise 3:
Review the lecture material and ensure that you are comfortable with everything discussed thus far.
Page 19 of 60
Title Here
2.5 Tutorial Notes
Exercise 1: Trade of Pseudocode
The importance of comments and pseudocode is that they make it possible for people who didn’t
write the algorithm to understand what it does and implement it in a language of their choice.
However, this only works if the logic is documented in a way that makes sense to other people.
During the tutorial, you will work in groups and desk-check each other’s work.
Be constructive in your criticism of the work of others. If you do not understand part of the logic and
the comments do not explain what is happening, ask for clarification. Peer review of code is a
process that is common in industry, and it is valuable to understand where your algorithms cause
other people problems, and where you have problems with the code that others provide to you.
Page 20 of 60
Topic 3
Topic 3: Data Representation

This topic provides an overview of data representation. On completion of the topic, you will be able
to:
 Decide between valid choices of variables;

 Incorporate memory considerations into desk-checking;
 Define issues of scalability in algorithms.
3.2 Timings
Lectures: 2 hours
Seminars: 2 hours
Tutorials: 1 hour
Page 21 of 60
Title Here
3.3 Seminar Notes
Activity 1:
Take the pseudocode and desk-checks that you performed for Activity 1 in the Topic 2 seminar.
Adapt your desk-check to take into account the formal statement of types. Add an additional column
that provides the memory usage of the algorithm at each step for both Java and C++.
Activity 2:
Develop and desk-check pseudocode for the following problems:
1. Ask the user for their forename and their surname, and then output both, separated by a
space, to the user.
2. Ask the user for five characters, and append each to a string. At the end of the user's input,
output the string to the user.
3. Ask the user for four numbers. Display those numbers in a 2 x 2 grid, in the order in which
they were entered.
Page 22 of 60
Title Here
topic.
Exercise 1:
Exercise 2:
As the concepts and desk-checking becomes more complicated each lecture, you should begin
keeping a journal of important notes and concepts. Supplement the material from each lecture with
the results from your own studies. Each week, your guide will contain some topics for you to
research and summarise - these will be your own personal revision and research guides, so make
sure you write them in such a way that you will understand the content. Include examples,
interesting slides and web-pages that you encounter during your research.
For this topic, you should research the following topics:
 The size of data types in different programming languages
 How to choose the right kind of data type when storing data
 How computers represent real numbers in memory
Exercise 3:
Prepare a short, five minute presentation on the results of your research for Exercise 2 above. If
you have found out anything particularly interesting, you should focus on that as a priority.
Exercise 4:
Page 23 of 60
Title Here
3.5 Tutorial Notes
Exercise 1: Reporting Back to the Class
As a result of the research you did during your private study time, you should have a short five
minute presentation ready to give to the rest of the class. There is no need for this to be especially
formal - you are simply reporting on anything interesting that you found during your research, or
pointing out especially useful resources on the topic. Bring your journal along to the class so that
you can make a note of anything especially useful that your classmates have mentioned. This is a
knowledge dissemination exercise; you are not being formally assessed on the style or content of
the presentation.
Page 24 of 60
Topic 4
Topic 4: Iteration

This topic provides an overview of iteration. On completion of the topic, you will be able to:
 Develop algorithms making use of bounded loops;

 Develop algorithms making use of unbounded loops;
 Desk-check algorithms using bounded loops;
 Desk-check algorithms using unbounded loops.
4.2 Timings
Lectures: 2 hours
Seminars: 2 hours
Tutorials: 1 hour
Page 25 of 60
Title Here
4.3 Seminar Notes
The time allocation for seminars in this topic is 2 hours.
Activity 1:
Develop the pseudocode and desk-check algorithms for the following tasks:
1. Calculate the factorial of a number provided by the user
2. Ask the user for a number. Print out a square of stars with sides that length.
3. Ask the user for four numbers. Use those numbers to create a horizontal histogram graph.
Activity 2:
Develop the pseudocode, and condense the desk-check for the following problems:
1. Display the double of every number from one to ten thousand
2. Display every even number from one to ten thousand
Page 26 of 60
Title Here
topic.
Exercise 1:
Exercise 2:
As part of your ongoing journal exercise, you should research the following topics:
 The situations in which a bounded loop is preferable to an unbounded loop
 The situations in which an unbounded loop is preferable to a bounded loop
 Pattern matching in programming.
Exercise 3:
Exercise 4:
Page 27 of 60
Title Here
4.5 Tutorial Notes
the presentation.
Page 28 of 60
Topic 5
Topic 5: Selection

This topic provides an overview of selection and conditionals in pseudocode.
On completion of the topic, you will be able to:
 Use and desk-check selection structures in pseudocode;

 Make use of nested data structures;
 Develop truth tables for compound conditionals.
5.2 Timings
Lectures: 2 hours
Seminars: 2 hours
Tutorials: 1 hour
Page 29 of 60
5.3 Seminar Notes
The time allocation for the seminars for this topic is 2 hours.
Activity 1:
Develop and desk-check the pseudocode for the following problems:
1. Outputting all the numbers from one to twenty, highlighting if they are odd or even
2. Ask the user for a number. Print out a right angled triangle of stars with sides that length.
3. Ask the user for a number. Print out the factorial of all of the numbers up to their number.
4. Ask the user for a number. Print out if that number is a prime number
Activity 2:
Provide truth tables for the following compound conditionals:
1. a OR (b AND c)
2. (a AND b) OR (c AND d)
3. (a OR b) AND (c OR d)
Page 30 of 60
topic.
Exercise 1:
Exercise 2:
 Truth tables
 Boolean rules simplification
 Nesting in programming.
Exercise 3:
Exercise 4:
Page 31 of 60
5.5 Tutorial Notes
the presentation.
Page 32 of 60
Topic 6
Topic 6: Functions

This topic provides an overview of functions. On completion of the topic, you will be able to:
 Use and desk-check functions

 State the benefits that come from the use of functions
 Make use of parameters
 Make use of return types
6.2 Timings
Lectures: 2 hours
Seminars: 2 hours
Tutorials: 1 hour
Page 33 of 60
6.3 Seminar Notes
Activity 1:
For the purposes of these exercises only, your functions can handle output where appropriate.
Develop the pseudocode (using functions) and desk-check for the following:
1. Ask the user for a number. Print out a series of squares of stars in increasing size up to the
number provided by the user.
2. Ask the user for a number. Print out a series of waves in increasing size up to the number
provided by the user.
3. Ask the user for a number, and then for a minimum and maximum. Include a function that
tells whether or not the first number lies between the minimum and maximum.
4. Modify your solution to problem 1 so that it allows the user to specify a symbol instead of a
star.
Example Output for 1: Example Output for 2:
> User enters 5 > User enters 4
* *
** *
** **
*
***
*** *
*** **
***
**** **
**** *
****
**** *
**
***** ***
***** ****
***** ***
***** **
***** *
Page 34 of 60
topic.
Exercise 1:
that you put in place. Use whatever commenting style you like, but give your explanation of what
you think each line of code is doing.
Exercise 2:
 Function design
 Best practise for writing functions
 Variable scope
Exercise 3:
Exercise 4:
Page 35 of 60
6.5 Tutorial Notes
the presentation.
Page 36 of 60
Topic 7
Topic 7: Testing and Debugging

This topic provides an overview of testing. On completion of the topic, you will be able to:
 Develop test cases;

 Make use of black box testing;
 Make use of white box testing;
 Make use of unit testing;
 Make use of integration testing.
7.2 Timings
Lectures: 2 hours
Seminars: 2 hours
Tutorials: 1 hour
Page 37 of 60
7.3 Seminar Notes
Activity 1:
Develop white and black box test sets for the functions you wrote in the Topic 6 seminar. For those
functions that have no return types, track their output for each test case as the 'actual' result.
Activity 2:
Run a desk-check through each of your functions, using the test-sets that you generated.
Activity 3
Develop test cases and unit test the following pseudocode:
Function CheckIsPrime (needs num as whole number)
returning boolean
1 data counter as whole number
2 data isPrime as boolean
3 data tmp as whole number
4 counter = 2
5 isPrime = true
6 repeat until counter is greater than or equal to num
7 tmp = num % counter
8 if tmp is 0 then
9 return false
10 end if
11 counter = counter + 1
12 next loop
13 return true
End Function
Page 38 of 60
topic.
Exercise 1:
Exercise 2:
 Identifying equivalence classes in testing
 Integration testing
 Testing harnesses
 All Pairs Testing
Exercise 3:
Exercise 4:
Page 39 of 60
7.5 Tutorial Notes
the presentation.
Page 40 of 60
Topic 8
Topic 8: Arrays

This topic provides an overview of arrays. On completion of the topic, you will be able to:
 Declare arrays;
 Use arrays in pseudocode;
 Desk-check arrays in pseudocode.
8.2 Timings
Lectures: 2 hours
Seminars: 2 hours
Tutorials: 1 hour
Page 41 of 60
8.3 Seminar Notes
Activity 1:
Develop the pseudocode for, desk-check and test the following programs. As in the lecture slides,
you should allow the user to provide the number of elements, and initialise the array according to
their input. You should use functions where appropriate to ensure modularity.
1. Find the average of a list of numbers.
2. Find the smallest element in a list of numbers
Activity 2:
Making use of a two-dimensional array, write the code that permits two players to play a game of tic-
tac-toe (also known as noughts and crosses). Use 0 to represent an empty square, 1 to represent a
cross, and 2 to represent a nought.
This requires you to implement several algorithms:
1. Asking for the user’s input and placing their symbol.
2. Looping between two different players, alternating the symbol
3. Checking for a win
You should include pseudocode to handle all of these. You should desk-check your solutions to
make sure they work, but formal testing of these is not required during this activity.
Page 42 of 60
topic.
Exercise 1:
Exercise 2:
If you did not complete the second activity in the seminar, complete it during your own private study
time.
Exercise 3:
Increase the robustness of your solution to the second activity in the seminar by making sure users
cannot enter invalid array values (what happens if they enter 10 for X and -20 for Y?).
Exercise 4:
 The sieve of Eratosthenes
 The Game of Life
Spend a time considering how you might represent these two systems using one and two
dimensional arrays.
Exercise 5:
Exercise 6:
Page 43 of 60
8.5 Tutorial Notes
the presentation.
Page 44 of 60
Topic 9
Topic 9: Algorithms

This topic provides an overview of searching and sorting. On completion of the topic, you will be
able to:
 Develop linear and binary searches;

 Develop bubble and quick sorts;
 Apply Big O Notation to algorithm selection.
9.2 Timings
Lectures: 2 hours
Seminars: 2 hours
Tutorials: 1 hour
Page 45 of 60
9.3 Seminar Notes
Activity 1:
Using the lecture slides as a guide, write the pseudocode for performing a binary search on an
ordered array.
Activity 2:
Develop test data and run the desk-checks to ensure the correctness of your binary search
pseudocode outlines above.
Activity 3:
Develop the test-data and run the desk-checks to show the correctness of the bubble sorts and
quick sorts shown in the lecture slides.
Page 46 of 60
topic.
Exercise 1:
Exercise 2:
If you did not complete the desk-checking of the provided lecture algorithms, then develop your test
data and desk-check them.
Exercise 3:
 Big O Notation
 Recursion
 Insertion Sort
 Shell Sort
Exercise 4:
Exercise 5:
Page 47 of 60
9.5 Tutorial Notes
the presentation.
Page 48 of 60
Topic 10
Topic 10: Objects and Classes

This topic provides an overview of objects and classes. On completion of the topic, you will be able
to:
 Use classes and objects within their pseudocode;

 Incorporate objects and classes into their desk-checks;
 Make use of methods, constructors and accessors.
10.2 Timings
Lectures: 2 hours
Seminars: 2 hours
Tutorials: 1 hour
Page 49 of 60
10.3 Seminar Notes
Activity 1:
Design the classes for the following data structures. Classes should have accessor methods for all
data stored within. Provide constructors where appropriate.
1. Cars, including type, engine size, recommended retail price, licence plates, and registered
owner.
2. Books, including name, author (of which there may be more than one), genre and ISBN
3. Albums, including name, artist, and track list (where tracks may be performed by multiple
artists)
Activity 2:
Write a test program that allows users to create new instances of your classes for each of the
exercises above, and then query the results. Assume you need to store a maximum of ten of these
at a time. Desk-check your program with suitable test-data.
Page 50 of 60
topic.
Exercise 1:
Exercise 2:
 Class design
 Accessor methods
 Constructor design
Exercise 3:
Exercise 4:
Page 51 of 60
10.5 Tutorial Notes
the presentation.
Page 52 of 60
Topic 11
Topic 11: Array Data Structures

This topic provides an overview of array based data structures. On completion of the topic, you will
be able to:
 Develop and use queues;

 Develop and use stacks;
 Develop and use lists;
 Make use of recursion;
 Make use of generic data types.
11.2 Timings
Lectures: 2 hours
Seminars: 2 hours
Tutorials: 1 hour
Page 53 of 60
11.3 Seminar Notes
Activity 1:
Develop the pseudocode, input data and desk-checks for generic versions of the following data
structures:
 Queue
 Stack
Activity 2:
Making use of the appropriate data structure from what you created above, create a program that
determines whether or not a given word is a palindrome. Test and desk-check your solution.
Page 54 of 60
topic.
Exercise 1:
Exercise 2:
 Recursion
 The uses of stacks
 The uses of queues
 Other array based data structures (such as hashtables)
Exercise 3:
Exercise 4:
Page 55 of 60
11.5 Tutorial Notes
the presentation.
Page 56 of 60
Topic 12
Topic 12: Summary and Recap

This topic provides an overview of the content covered in the module. On completion of the topic,
you will be able to:
 Recap the material to which you have been introduced.
12.2 Timings
Lectures: 2 hours
Seminars: 2 hours
Tutorials: 1 hour
Page 57 of 60
12.3 Seminar Notes
Activity 1:
Pick four of your pseudocode programs from the past few weeks and convert them into Java code.
Activity 2:
If there are exercises in the Student Guide that you have not yet completed, go back and do so now.
Page 58 of 60
topic.
Exercise 1:
Go through all the code you wrote in the seminar, and comment on every line of Java that you put in
place. Use whatever commenting style that you like, but give your explanation of what you think
each line of code is doing.
Exercise 2:
If there are topics that you are not entirely sure of, make a note of them so they can be discussed
during the tutorial. This exercise is designed to help you with your examination revision.
Page 59 of 60
12.5 Tutorial Notes
Exercise 1: Revision
As a result of your reviewing in your private study, you may have come up with revision questions to
discuss in class. Raise them now with your lecturer.
Page 60 of 60

SDT Student Guide v1.1

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

SDT Student Guide v1.1

Uploaded by

Copyright:

Available Formats

LEVEL 4

SOFTWARE DEVELOPMENT TECHNIQUES

SDT Student Guide v1.1

Version Date Revision Description

© NCC Education Limited, 2011

1. Module Overview and Objectives

2. Learning Outcomes and Assessment Criteria

3 Variables and 1/12  Memory management in a computer system

4 Iteration 1/12  For loops

7 Testing and 1/12  Black box testing

8 Arrays 1/12  Declaration of arrays

9 Searching and 1/12  Linear search algorithms

10 Objects 1/12  Object design

12 Summary and 1/12  Summary of module

4. Related National Occupational Standards

Related National Occupational Standards (NOS)

5. Teaching and Learning

5.4 Private Study

7. Further Reading List

Henney, K. (2010). 97 Things Every Programmer Should Know. O’Reilly Media

Topic 1: Introduction to the Module and the Software

1.1 Learning Objectives

 Explain the history of the software development;

Private Study: 7.5 hours

Activity 1: Group Discussion and Introductions

Work in small groups as directed by your tutor.

Activity 2: Giving Instructions

e.g. dealing out a hand of cards to four players

Activity 3: First Algorithm Exercises

Work with your group to outline the following tasks as algorithms:

1. Finding the largest number in a list of ten user-specified numbers

2. Finding the smallest number in a list of ten user-specified numbers

Exercise 1: Pseudocode and Flowcharts

Exercise 2: Additional Algorithms

a. Determine whether a word is a palindrome

b. Calculate the factorial of a number

c. Calculate the power of one number to another

2. What does a simple machine code program look like?

3. Why are algorithms important?

Exercise 1: Review of Private Study Exercises

2.1 Learning Objectives

 Develop a program in formal pseudocode;

Private Study: 7.5 hours

Develop and desk-check the pseudocode for the following algorithms:

1 data speed as real number

2 data time as real number

3 data distance as real number

4 output "Please value one"

6 output "Please value two"

8 distance = speed / time

9 output "The answer is"

Exercise 1: Trade of Pseudocode

Topic 3: Data Representation

3.1 Learning Objectives

 Decide between valid choices of variables;

Private Study: 7.5 hours

Develop and desk-check pseudocode for the following problems:

For this topic, you should research the following topics:

 The size of data types in different programming languages

 How computers represent real numbers in memory

Exercise 1: Reporting Back to the Class

4.1 Learning Objectives

 Develop algorithms making use of bounded loops;