As Level Computer Science Book -2

of 12
2.1 Algorithm design and
problem-solving
2.1.1 Algorithms
What is an Algorithm?
An algorithm is a sequence of steps, which perform a specific task. In computing, algorithms are usually
represented as a program flowchart, or in pseudo-code.
Program flowchart
A program flowchart is a pictorial representation of an algorithm. Program flowcharts use special symbols:

of 12
problem-solving
2.1.1 Algorithms
Example:
Flowchart to output the first five square numbers:

of 12
problem-solving
2.1.1 Algorithms
Pseudo-code
Pseudo-code is a simplified form of programming code that uses common programming keywords, but does
not use the strict syntax rules of a programming language.
An example of a pseudo-code algorithm:
BEGIN
INPUT CardNumber
REPEAT
INPUT PIN
IF PIN is wrong for this CardNumber THEN
OUTPUT “Wrong Pin”
END IF
UNTIL Pin is correct
INPUT Amount
IF there are enough funds THEN
Dispense Cash
Update customer’s balance
ELSE
OUTPUT “Sorry, insufficient funds”
END IF
END

of 12
problem-solving
2.1.1 Algorithms
Meaningful identifier names
Identifiers are used to give names to constants and variables. They are also used to name procedures, functions
and the main program.
Naming conventions
Most of the identifier names must conform to the following rules (different programming languages may have
slightly different rules):
1. they must be unique;
2. spaces must not be used;
3. they must begin with a letter of the alphabet;
4. the rest of the identifier must NOT contain punctuation – it may only consist of a mixture of letters
and digits (A–Z, a–z and 0–9) and the underscore character ‘_’;
5. they must not be a ‘reserved’ word – e.g. Print, Repeat, For, Dim, Loop, etc.
Recommended naming policies
Do not use spaces within identifier names – even with programming languages where they are permitted.
Instead, use the underscore character ‘_’ or, better yet, type names in lowercase except the first letter of each
word, which should be typed in uppercase.
Examples of good identifier names:
FirstName LastName PostCode
TelephoneNumber WeightAtBirth TestScore
AverageHeight
Further clarity can be given to identifier names by including a prefix that identifies the data type.
The above identifiers would be clearer if given the following prefix data types:
strFirstName strLastName strPostCode
strTelephoneNumber sglWeightAtBirth intTestScore
sglAverageHeight

of 12
problem-solving
2.1.1 Algorithms
Algorithm Basic Constructs
Assignment
An assignment is an instruction in a program that places a value into a specified variable.
Some typical assignments are:
TheLength = 20.5
TheUsersName$ = “Charlie”
TheArea = TheWidth * TheLength
TotalCost = LabelledCost + 15
Counter = Counter + 1
Note that the last example is a common method used to increment the value of a variable. It could be read as:
“The new value of Counter is its existing value plus one”
Type Mismatch errors
A type Mismatch error occurs in a program when a variable has been declared as one data type, but it is later
assigned a value that is of an incompatible data type.
The following code will produce a ‘Type Mismatch’ error because “Charlie” is not an integer:
DIM MyCounter AS Integer
MyCounter = “Charlie”
Other Type Mismatches will be produced by the following:
DIM RentalDateAs Date
MemberRentalDate = “September”
DIM ShoeSizeAs Integer
JohnsShoeSize = 10.3
Note that a variable that is declared as a string will never produce a type mismatch error.

of 12
problem-solving
2.1.1 Algorithms
Sequence
Sequence is when the programming statements are executed one after the other, in the order in which they
appear in the program.
Selection
Selection is a control structure in which there is a test to decide if certain instructions are executed.
IF-THEN-ELSE
This selection method is used if there are two possible outcomes to a test:
IF x < 0 THEN
OUTPUT “Sorry, you can’t have negative values”
ELSE
a = x*x
OUTPUT a
END
SELECT-CASE
This selection method is used if there are more than two possible outcomes to a test:
SELECT CASE KeyPress
CASE LeftArrow
Move one character backwards
CASE RightArrow
Move one character forwards
CASE UpArrow
Move one character up
CASE DownArrow
Move one character down
END SELECT

of 12
problem-solving
2.1.1 Algorithms
Nested selection
This is where there is an IF statement within an IF statement.
The following algorithm allows a maximum of four attempts to login to a computer system:
INPUT Password
IF NumberOfTries< 5 THEN
IF Password is correct THEN
OUTPUT “Successful Login”
ELSE
OUTPUT “Password was incorrect”
ENDIF
ELSE
OUTPUT “You have made too many attempts”
ENDIF
Nested iteration
This is where there is a loop within a loop.
A nested iteration is needed to initialize a two-dimensional array:
FOR row = 0 TO 7
FOR column = 0 TO 5
SET MyArray (row, column) = 0
NEXT column
NEXT row
Iteration
Iteration is a control structure in which a group of statements is executed repeatedly – either a set number of
times, or until a specific condition is True.
FOR-NEXT
This is an unconditional loop in which the number of repetitions is set at the beginning.
FOR X = 1 TO 5
Answer = X*3
OUTPUT X, Answer
NEXT
WHILE-ENDWHILE

of 12
problem-solving
2.1.1 Algorithms
This is a conditional loop, which has a test at the start and repeats until the condition is false:
X = 0
WHILE X < 6 DO
X = X + 1
Answer = X*3
OUTPUT X, Answer
ENDWHILE
REPEAT-UNTIL
This is a conditional loop, which has a test at the end and repeats until the condition is true:
X = 0
REPEAT
X = X + 1
Answer = X*3
OUTPUT X, Answer
UNTIL X > 4

of 12
problem-solving
2.1.1 Algorithms
Comparison of the different iterations:
Top down/modular design
Top-down design is when a problem is split into smaller sub-problems, which themselves are split into even
smaller sub-problems until each is just one element of the final program.
Benefits and drawbacks of modular programs:

of 12
problem-solving
2.1.1 Algorithms
Structure diagrams
A structure diagram is a pictorial representation of a modular system.
Stepwise refinement
Stepwise refinement is the process of developing a modular design by splitting a problem into smaller sub-
tasks, which themselves are repeatedly split into even smaller sub-tasks until each is just one element of the
final program.

of 12
problem-solving
2.1.1 Algorithms
Subroutine
A subroutine is a self-contained section of program code that performs a specific task, as part of the main
program.
Procedure
A procedure is a subroutine that performs a specific task without returning a value to the part of the program
from which it was called.
Function
A function is a subroutine that performs a specific task and returns a value to the part of the program from
which it was called.
Note that a function is ‘called’ by writing it on the right hand side of an assignment statement.
Parameter
A parameter is a value that is ‘received’ in a subroutine (procedure or function).
The subroutine uses the value of the parameter within its execution. The action of the subroutine will be
different depending upon the parameters that it is passed.
Parameters are placed in parenthesis after the subroutine name. For example:
Square(5) ‘passes the parameter 5 – returns 25
Square(x) ‘passes the value of the variable x

of 12
problem-solving
2.1.1 Algorithms
Subroutine/sub-program
A subroutine is a self-contained section of program code which performs a specific task and is referenced by a
name.
A subroutine resembles a standard program in that it will contain its own local variables, data types, labels and
constant declarations.
There are two types of subroutine. These are procedures and functions.
Procedures are subroutines that input, output or manipulate data in some way.
Functions are subroutines that return a value to the main program.
A subroutine is executed whenever its name is encountered in the executable part of the main program. The
execution of a subroutine by referencing its name in the main program is termed ‘calling’ the subroutine.
The benefits of using procedures and functions are that:
The same lines of code are re-used whenever they are needed – they do not have to be repeated in
different sections of the program.
A procedure or function can be tested/improved/rewritten independently of other procedures or
functions.
It is easy to share procedures and functions with other programs – they can be incorporated into
library files which are then ‘linked’ to the main program.
A programmer can create their own routines that can be called in the same way as any built-in
command.

of 8
problem-solving
2.1.2 Structure chart
Structure charts
A Structure Chart in software engineering is a chart which shows the breakdown of a system to its lowest
manageable parts. They are used in structured programming to arrange program modules into a tree. Each
module is represented by a box, which contains the module's name. The tree structure visualizes the
relationships between modules, showing data transfer between modules using arrows.

of 8
problem-solving
Structured Charts are an example of a top-down design where a problem (the program) is broken into its
components.
Symbol Name Meaning
Module
Name
Process
Each Box represents a programming module, this might be something that calculates the average of some
figures, or prints out some pay slips
Data
Couple
Data being passed from module to module that needs to be processed.
Flag
[Extension - you don't need to know this for the exam] Check data sent to process to stop or start processes.
For example when the End of a File that is being read is reached, or a flag to say whether data sent was in
the correct format
Let's take a look at a simple example of how this might be executed when representing the following code:
subcalculateAverage()
dimavgasinteger
inputNums()
avg= average(num1, num2)
outputAvg(avg)
endsub
function average(a,b)
return(a + b)/2
endfunction
subinputNums()
dim num1 asinteger
dim num2 asinteger
num1 =console.readline()
endsub
suboutputAvg(x)
console.writeline("average = "& x)
endsub

of 8
problem-solving
Exercise: Structure Charts
Create structure charts for the following code:
sub main()
dim num1 asinteger
dim num2 asinteger
dimavgasinteger
sayHello()
num1 =34
num2 =89
avg= average(num1, num2)
endsub
function average(a,b)
return(a + b)/2
endfunction
subsayHello()
console.writeline("hello")
endsub

of 8
problem-solving
A structure chart for the above code
Answer

of 8
problem-solving
Selection
Structure Chart representation of the selection code
A selection in a Structure Chart is determined by the diamond symbol. This means a condition will be checked
and depending on the result, different modules will be executed.
sub main()
dim num1 asinteger
if num1 =7then
luckyNumber()
else
otherNumber()
endif
endsub

of 8
problem-solving
Iteration
Structure Chart of the code below
Using the semicircular arrows, we can represent iteration in Structure Charts.
The arrow encompasses a link to a module, implying that module is executed multiple times. Let's take a look
at a coded example:
sub main()
dim num1 asinteger
while num1 >0do
num1 =countdown(num1)
endwhile
endsub
sub countdown(a)
return a -1
endsub

of 8
problem-solving
Exercise: Structure Charts, Iteration and Selection
Create structure charts for the following code:
subhowManyThrees()
dim num1, count, total asinteger
num1 =startMsg()
count =0
total =0
while num1 >0do
checkNumber(count, total, num1)
num1 = num1 -1
endwhile
endMsg(count)
endsub
subcheckNumber(byRef c, byRef t, byVal n)
If n MOD3=0Then
c = divBy3(c)
Else
t = add(n, t)
EndIf
endsub
function divBy3(x)
return x +1
endfunction
function add(n, t)
return n + t
endfunction
functionstartMsg()
console.writeline("program started, enter your number")
returnconsole.readline()
endfunction
subendMsg(n)
console.writeline("number of threes : "& n)
endsub

of 8
problem-solving
Answer :

of 4
problem-solving
2.1.3 Corrective maintenance
2.1.4 Adaptive maintenance
Trace table - a technique used to test algorithms to make sure that no logical errors occur.
Hand tracing or 'dry running' allows you to use a trace table to
see what code will do before you have to run it
locate where errors in your code are
Taking a program like the one below we need to keep track (trace) all the variables and outputs.
Dim y asinteger = 3
For x = 1to4
y = y + x
Loop
Console.writeline(y)
To do this we create a trace table:
x y output
1 3
2 4
3 6
4 9
4 13 13
The exam will normally ask you to create a trace table of some sort so you need to be very confident with
them. The exam will usually give you the headings but just in case, there are several steps in making a trace
table,
The first one is to note the table headings, this involves the following:

of 4
problem-solving
1. VARIABLES: note all the variables in the piece of code you are looking at (this includes
arrays). Note each variable as a heading
2. OUTPUTS: note if there is an output and put this as a heading
3. INPUTS: if there are inputs specified, put an inputs column and be prepared to fill it in.
It is very easy to jump right in when filling in trace tables, but you must be careful. The exam will try and
trick you, so trying to predict what a trace table will do isn’t a good idea. In fact, the best idea is to switch
your brain off and tackle the problem line by line, exactly as a computer would. Take a look at the following
example:
Example: Simple trace table
Dimnum() asinteger = {10,8,3,5,6,1,2}
Dim sum asinteger = 0
Dimavgasdecimal
For x = 0to5
sum = sum + num(x)
Loop
avg = sum / (x + 1)
Console.writeline("average ="&avg)
1. note all the variables: num array / sum / avg / x
2. note if there is an output: yes
3. if there are inputs specified: no

of 4
problem-solving
So we should construct the following table:
num
0 1 2 3 4 5 6 sum avg x output
10 8 3 5 6 1 2 0
0
Now looking at the names of the variables you might be tempted to add all the values in the array together to
find the sum, and then find the average number from this calculation “35/7 =5”. However, you'd be wrong,
create a trace table and see if you can find the correct answer:
Answer :
num
0 1 2 3 4 5 6 sum avg x output
10 8 3 5 6 1 2 0
10 0
18 1
21 2
26 3
32 4
33 5.5 5 average =5.5
So what went wrong? If you look at the trace table you can see that we never added the number 2 from the
num array to the sum, it stopped at element 5. To fix this we would adjust the following line:

of 4
problem-solving
“For x = 0 to 6”
Complete the trace table for the following code:
Dimnums()={6,2,8,1,9,2}
Dim n asinteger=0
fori=0to5
ifnums(i)> n
n =nums(i)
endif
loop
Answer:
What function does the above code perform?
Answer:
It finds the highest value in an array of values.
i n nums
0 1 2 3 4 5
0 6 2 8 1 9 2
0 6
1
2 8
3
4 9
5

of 11
2.2 Data representation
2.2.1 Data types
A data type is a method of interpreting a pattern of bits.
Intrinsic data types
Intrinsic data types are the data types that are defined within a particular programming language.
There are numerous different data types. They are used to make the storage and processing of data easier and
more efficient. Different databases and programming systems have their own set of intrinsic data types, but
the main ones are:
Integer
Real
Boolean
String
Character
Date
Container
Integer
An integer is a positive or negative number that does not contain a fractional part. Integers are held in pure
binary for processing and storage. Note that some programming languages differentiate between short and
long integers (more bytes are used to store long integers).
Real
A real is a number that contains a decimal point. In many systems, real numbers are referred to as singles and
doubles, depending upon the number of bytes in which they are stored.
Boolean
A Boolean is a data-type that can store one of only two values – usually these values are “True” or “False”.
Booleans are stored in one byte – True being stored as 11111111 and False as 00000000.
String
A string is a series of alphanumeric characters enclosed in quotation marks. A string is sometimes just referred
to as ‘text’. Any type of alphabetic or numeric data can be stored as a string: “Birmingham City”, “3/10/03”
and “36.85” are all examples of strings. Each character within a string will be stored in one byte using its
ASCII code; modern systems might store each character in two bytes using its Unicode. The maximum length
of a string is limited only by the available memory.

of 11
2.2.1 Data types
Notes:
if dates or numbers are stored as strings then they will not be sorted correctly; they will be sorted
according to the ASCII codes of the characters – “23” will be placed before “9”;
Telephone numbers must be stored as strings or the initial zero will be lost.
Character
A character is any letter, number, punctuation mark or space, which takes up a single unit of storage (usually a
byte).
Dates
In most computer systems dates are stored as a ‘serial’ number that equates to the number of seconds since
January 1st, 1904 (thus they also contain the time). Although the serial numbers are used for processing
purposes, the results are usually presented in one of several ‘standard’ date formats – for example,
dd/mm/yyyy, or ddMonthName, yyyy. Dates usually take 8 bytes of storage.
Comparison of the common data types:

of 11
2.2.1 Data types
Estimating the size of a file:
The basic formula for estimating the size of a file is:
If we consider a file with 200 records, which stores the details of an organization’s customers:
CUSTOMER(RefCode, Name, PostCode, Telephone, DoB, Age)
We can estimate the size of the record as follows:
Thus 200 records would require:
Note that to determine the maximum field length, an extreme case was considered and several bytes added to
play safe.
Character sets

of 11
2.2.1 Data types
ASCII Character sets:
The 104-key PC US English QWERTY keyboard layout evolved from the standard typewriter keyboard, with
extra keys for computing.
ASCII normally uses 8 bits (1 byte) to store each character. However, the 8th bit is used as a check digit,
meaning that only 7 bits are available to store each character. This gives ASCII the ability to store a total of
2^7 = 128 different values.
The 95 printable ASCII characters, numbered from 32 to 126 (decimal)
ASCII values can take many forms:
Numbers
Letters (capitals and lower case are separate)
Punctuation (?/|£$ etc.)
non-printing commands (enter, escape, F1)

of 11
2.2.1 Data types
Take a look at your keyboard and see how many different keys you have. The number should be 104 for
a windows keyboard, or 101 for traditional keyboard. With the shift function values (a, A; b, B etc.) and
recognising that some keys have repeated functionality (two shift keys, the num pad). We roughly have 128
functions that a keyboard can perform.
Binary Dec Hex Abbr
000
0000
0 00 NUL
000
0001
1 01 SOH
000
0010
2 02 STX
000
0011
3 03 ETX
000
0100
4 04 EOT
000
0101
5 05 ENQ
000
0110
6 06 ACK
000
0111
7 07 BEL
000
8 08 BS
Binary Dec Hex Glyph
010
0000
32 20 ?
010
0001
33 21 !
010
0010
34 22 "
010
0011
35 23 #
010
0100
36 24 $
010
0101
37 25 %
010
0110
38 26 &
010
0111
39 27 '
010
40 28 (
100
0000
64 40 @
100
0001
65 41 A
100
0010
66 42 B
100
0011
67 43 C
100
0100
68 44 D
100
0101
69 45 E
100
0110
70 46 F
100
0111
71 47 G
100
72 48 H
110
0000
96 60 `
110
0001
97 61 a
110
0010
98 62 b
110
0011
99 63 c
110
0100
100 64 d
110
0101
101 65 e
110
0110
102 66 f
110
0111
103 67 g
110
104 68 h

of 11
2.2.1 Data types
1000
000
1001
9 09 HT
000
1010
10 0A LF
000
1011
11 0B VT
000
1100
12 0C FF
000
1101
13 0D CR
000
1110
14 0E SO
000
1111
15 0F SI
001
0000
16 10 DLE
001
0001
17 11 DC1
001
0010
18 12 DC2
1000
010
1001
41 29 )
010
1010
42 2A *
010
1011
43 2B +
010
1100
44 2C ,
010
1101
45 2D -
010
1110
46 2E .
010
1111
47 2F /
011
0000
48 30 0
011
0001
49 31 1
011
0010
50 32 2
1000
100
1001
73 49 I
100
1010
74 4A J
100
1011
75 4B K
100
1100
76 4C L
100
1101
77 4D M
100
1110
78 4E N
100
1111
79 4F O
101
0000
80 50 P
101
0001
81 51 Q
101
0010
82 52 R
1000
110
1001
105 69 i
110
1010
106 6A j
110
1011
107 6B k
110
1100
108 6C l
110
1101
109 6D m
110
1110
110 6E n
110
1111
111 6F o
111
0000
112 70 p
111
0001
113 71 q
111
0010
114 72 r

of 11
2.2.1 Data types
001
0011
19 13 DC3
001
0100
20 14 DC4
001
0101
21 15 NAK
001
0110
22 16 SYN
001
0111
23 17 ETB
001
1000
24 18 CAN
001
1001
25 19 EM
001
1010
26 1A SUB
001
1011
27 1B ESC
001
1100
28 1C FS
011
0011
51 33 3
011
0100
52 34 4
011
0101
53 35 5
011
0110
54 36 6
011
0111
55 37 7
011
1000
56 38 8
011
1001
57 39 9
011
1010
58 3A :
011
1011
59 3B ;
011
1100
60 3C <
101
0011
83 53 S
101
0100
84 54 T
101
0101
85 55 U
101
0110
86 56 V
101
0111
87 57 W
101
1000
88 58 X
101
1001
89 59 Y
101
1010
90 5A Z
101
1011
91 5B [
101
1100
92 5C
111
0011
115 73 s
111
0100
116 74 t
111
0101
117 75 u
111
0110
118 76 v
111
0111
119 77 w
111
1000
120 78 x
111
1001
121 79 y
111
1010
122 7A z
111
1011
123 7B {
111
1100
124 7C |

of 11
2.2.1 Data types
001
1101
29 1D GS
001
1110
30 1E RS
001
1111
31 1F US
111
1111
127 7F DEL
011
1101
61 3D =
011
1110
62 3E >
011
1111
63 3F ?
101
1101
93 5D ]
101
1110
94 5E ^
101
1111
95 5F _
111
1101
125 7D }
111
1110
126 7E ~

of 11
2.2.1 Data types
If you look carefully at the ASCII representation of each character you might notice some patterns. For
example:
110 0001 97 61 a
110 0010 98 62 b
110 0011 99 63 c
As you can see, a = 97, b = 98, c = 99. This means that if we are told what value a character is, we can easily
work out the value of subsequent or prior characters.

of 11
2.2.1 Data types
Unicode:
The problem with ASCII is that it only allows you to represent a small number of characters (~128 or 256
for Extended ASCII). This might be OK if you are living in an English speaking country, but what happens if
you live in a country that uses a different character set? For example:
Chinese characters 汉字
Japanese characters 漢字
Cyrillic Кири́ллица
Gujarati ગુજરાતી
Urdu ‫اردو‬
You can see that we quickly run into trouble as ASCII can't possibly store these hundreds of thousands of
extra characters in just 7 bits. What we do instead is use unicode. There are several versions of unicode, each
with using a different number of bits to store data:
Name Descriptions
UTF-8
8-bit is the most common unicode format. Characters can take as little as 8-bits, maximizing
compatibility with ASCII. But it also allows for variable-width encoding expanding to 16, 24, 32, 40
or 48 bits when dealing with larger sets of characters
UTF-
16
16-bit, variable-width encoding, can expand to 32 bits.
UTF-
32
32-bit, fixed-width encoding. Each character takes exactly 32-bits

of 11
2.2.1 Data types
With over a million possible characters we should be able to store every character from every language on the
planet, take a look at these examples:
code point glyph* character UTF-16 code units (hex)
U+007A z LATIN SMALL LETTER Z 007A
U+6C34 水 CJK UNIFIED IDEOGRAPH-6C34 (water) 6C34
U+10000 LINEAR B SYLLABLE B008 A D800, DC00
U+1D11E MUSICAL SYMBOL G CLEF D834, DD1E
A data structure is a collection of different data items that are stored together in a clearly defined way. Two
common data structures are arrays and records.

of 7
2.2.2 Arrays
An array is a data structure, which allows a set of items of identical data type to be stored together using the
same identifier name.
Arrays are declared in a similar way to standard variables, except that the array size and dimensions are
included. For example, the following declares an array that reserves five locations in memory and labels these
as ‘Names’:
DIM Names(4) As String
The five individual locations are Names(0), Names(1), Names(2), Names(3), Names(4).Each data item is
called an “element” of the array. To reference a particular element a programmermust use the appropriate
index. For example, the following statement assigns data to the 5th
element:
Names(4) = “Johal”
Arrays simplify the processing of similar data. An algorithm for getting five names from the user and storing
them in the array Names is shown below:
Dim Names(4) As String
For i=0 to 4
Input Value
Names(i)=Value
Next i
One-dimensional arrays
A one-dimensional array is a data structure in which the array is declared using a single index and can be
visually represented as a list.
The following diagram shows the visual representation of the array Names(4):
Two-dimensional arrays

of 7
2.2.2 Arrays
A two-dimensional array is a data structure in which the array is declared using two indices and can be
visually represented as a table.
The following diagram shows the visual representation of an array Students(4,2):
Each individual element can be referenced by its row and column indices. For example:
Students(0,0) is the data item “JONES”
Students(2,1) is the item “M”
Students(1,2) is the item “LAMBOURNE”
Initializing an array
Initializing an array is a procedure in which every value in the array is set with starter values – this starting
value would typically be “” for a string array, or 0 for a numeric array.
Initialization needs to be done to ensure that the array does not contain results from a previous use, elsewhere
in the program.
Algorithm for initializing a one-dimensional numeric array:
DIM TestScores(9) As Integer
DIM Index As Integer
FOR Index = 0 TO 9
TestScores(Index) = 0
NEXT

of 7
2.2.2 Arrays
Algorithm for initializing a two-dimensional string array:
DIM Students(4,2) As String
DIM RowIndex, ColumnIndexAs Integer
FOR RowIndex = 0 TO 4
FOR ColumnIndex = 0 TO 2
Students(RowIndex,ColumnIndex) = “”
NEXT
NEXT
Serial search on an array
The following pseudo-code can be used to search an array to see if an item X exists:
01 DIM Index As Integer
02 DIM Flag As Boolean
03 Index = 0
04 Flag = False
05 Input X
06 REPEAT
07 IF TheArray(Index) = X THEN
08 Output Index
09 Flag = True
10 END IF
11 Index = Index + 1
12 UNTIL Flag = True OR Index > Maximum Size OfTheArray
Note that the variable Flag (line 04 and 09) is used to indicate when the item has been found and stop the loop
repeating unnecessarily (line 12 ends the loop if Flag has been set to True).
To complete the search algorithm, some lines should be added, after the loop, to detect the times when the
item X was not found in the array:
13 IF Flag = False THEN
14 Show Message “Item not found”
15 END IF

of 7
2.2.2 Arrays
Bubble Sort
A bubble sort, a sorting algorithm that continuously steps through a list, swapping items until they appear in
the correct order.
Bubble sort is a simple sorting algorithm that works by repeatedly stepping through the list to be sorted,
comparing each pair and swapping them if they are in the wrong order. The pass through the list is repeated
until no swaps are needed, which indicates that the list is sorted. The algorithm gets its name from the way
larger elements "bubble" to the top of the list. It is a very slow way of sorting data and rarely used in industry.
There are much faster sorting algorithms out there such as insertion sort and quick sort which you will meet
in A2.
For a step by step animation, visit:
http://en.wikipedia.org/wiki/Bubble_sort#mediaviewer/File:Bubble-sort-example-300px.gif
Step-by-step example
Let us take the array of numbers "5 1 4 2 8", and sort the array from lowest number to greatest number using
bubble sort algorithm. In each step, elements written in bold are being compared.
First Pass:
( 5 1 4 2 8 ) ( 1 5 4 2 8 ), Here, algorithm compares the first two elements, and swaps them since 5 > 1
( 1 5 4 2 8 ) ( 1 4 5 2 8 ), It then compares the second and third items and swaps them since 5 > 4
( 1 4 5 2 8 ) ( 1 4 2 5 8 ), Swap since 5 > 2
( 1 4 2 5 8 ) ( 1 4 2 5 8 ), Now, since these elements are already in order (8 > 5), algorithm does not swap
them.
The algorithm has reached the end of the list of numbers and the largest number, 8, has bubbled to the top. It
now starts again.
Second Pass:
( 1 4 2 5 8 ) ( 1 4 2 5 8 ), no swap needed
( 1 4 2 5 8 ) ( 1 2 4 5 8 ), Swap since 4 > 2
( 1 2 4 5 8 ) ( 1 2 4 5 8 ), no swap needed
( 1 2 4 5 8 ) ( 1 2 4 5 8 ), no swap needed
Now, the array is already sorted, but our algorithm does not know if it is completed. The algorithm needs one
whole pass without any swap to know it is sorted.
Third Pass:

of 7
2.2.2 Arrays
( 1 2 4 5 8 ) ( 1 2 4 5 8 )
( 1 2 4 5 8 ) ( 1 2 4 5 8 )
( 1 2 4 5 8 ) ( 1 2 4 5 8 )
( 1 2 4 5 8 ) ( 1 2 4 5 8 )
Finally, the array is sorted, and the algorithm can terminate.
Pseudocode implementation:
The algorithm can be expressed as:
procedurebubbleSort( A : list of sortable items )
do
swapped = false
for eachiin 1 to length(A) - 1 inclusive do:
if A[i-1] > A[i] then
swap( A[i-1], A[i] )
swapped = true
end if
end for
while swapped
end procedure
Exercise: Bubble Sort
We will now look at an example in Visual Basic using an array of people's heights. The following data set is
being passed:

of 7
2.2.2 Arrays
height
1 98
2 12
3 99
4 54
SubbubbleSort(ByRef height()Asinteger)
Dim swapped AsBoolean
Dim temp Asinteger
'sort the elements
Do
swapped=False
For Count =1ToMaxSize-1
If height(Count +1)< height(Count)Then
temp= height(Count)
height(Count)= height(Count +1)
height(Count +1)= temp
swapped=True
EndIf
Next
Loop Until swapped =False
'Print out the elements
For Count =1ToMaxSize
Console.WriteLine(Count &": "& height(Count))
Next
EndSub
Linear Search
The following pseudo code describes a typical variant of linear search, where the result of the search is
supposed to be either the location of the list item where the desired value was found; or an invalid location -1,
to indicate that the desired element does not occur in the list.

of 7
2.2.2 Arrays
Foreach item in the list:
if that item has the desired value,
stop the search andreturn the item's location.
Return''-1''
dim items()={"h","g","a","d","w","n","o","q","l","b","c"}
dimsearchItemasstring
console.write("What are you searching for: ")
searchItem=console.readline()
For x =0to10
If items(x)=searchItemThen
console.writeline("Found item "&searchItem&" at position "& x)
ExitFor
EndIf
If x =10Then
console.writeline(-1)
EndIf
Next

of 7
2.2.3 Files
Handling data within files
Before a program can use a file, the file needs to be opened. The program needs to specify whether the file is
to be opened for writing, or opened only for reading. After the data has been read or written to the file, it then
needs to be closed.
All algorithms for handling data within files must have the following lines:
OPEN [New/Existing] File in READ/WRITE MODE
…
…
CLOSE All Files
Note that these lines are not necessarily at the beginning and the end of the code, but they must be in place to
make sure that the file(s) is opened and closed correctly.
Adding data
Serial file
Adding data is simple – it is added to the end of the file:
OPEN File in WRITE MODE
GOTO End of File
WRITE NewData
CLOSE File
Sequential file
The addition of data to a sequential file is more complicated than in a serial file, because the record must be
inserted into the correct position – not just at the end of the file.
In practise, when a record is added to a sequential file, it is usual to create a new file and copy all the records
from the old file, but insert the new record in its correct position.

of 7
2.2.3 Files
An algorithm for this is shown below:
OPEN a NewFile in WRITE MODE
OPEN ExistingFile in READ MODE
READ First Record in ExistingFile
REPEAT
IF key of SelectedRecord in ExistingFile< key of NewRecord THEN
COPY SelectedRecord into NewFile
ELSE
COPY NewRecord into NewFile
COPY SelectedRecord into new file
END IF
READ Next Record in ExistingFile
END REPEAT when new record has been copied
COPY ALL remaining records from ExistingFile into NewFile
CLOSE NewFile and ExistingFile

of 7
2.2.3 Files
Random file
Random Access Files – Key Concepts
Used to access files faster as compared to sequential access files
Individual records of a random-access file can be accessed directly without searching other records
Records are accessed by their record number.
Type emprecord
name1 As String * 10
age As Integer
End Type
Dim newempAsemprecord
Open "c:test.dat" For Random As #1 Len = Len(newemp)
Dim recno As Integer
Dim temprecAsemprecord
recno = Val(Trim(Text3.Text))
temprec.name1 = Trim(Text1.Text)
temprec.age = Val(Text2.Text)
Put #1, recno, temprec

of 7
2.2.3 Files
Searching for/retrieving data
Serial file
To retrieve data from a serial file, a program must examine the first record and then all subsequent records
until the desired one is found or until the end of the file has been reached.
The following algorithm does this:
OPEN File in READ MODE
READ First Record
SET Variable Found = False
REPEAT
IF RequiredRecord = SelectedRecord THEN
SET Variable Found = True
ELSE
READ Next Record
END IF
END REPEAT when Found = True OR when EOF is reached
CLOSE File
Note that to be sure that a record does not exist in a serial file, every single record must be examined.
Sequential file

of 7
2.2.3 Files
Searching a sequential file is the same as searching a serial file, except that the search only has to continue
until a record with a higher Key field is reached – this would mean that the data is not in the file.
OPEN File in READ MODE
READ First Record
SET Variables Found = False, Exists = True
REPEAT
IF RequiredRecord = SelectedRecord THEN
SET Variable Found = True
ELSE
READ Next Record
IF Key of RequiredRecord> Key of SelectedRecord THEN
Exists = False
END IF
END IF
END REPEAT when Found = True OR Exists = False OR when EOF is
reached
CLOSE File
Random file
Dim temprecAsemprecord
Get #1, Val(Text3.Text), temprec
Text1.Text = temprec.name1
Text2.Text = temprec.age

of 7
2.2.3 Files
Deleting data
Serial or sequential file
OPEN a NewFile in WRITE MODE
OPEN ExistingFile in READ MODE
READ First Record in ExistingFile
REPEAT
IF Key of SelectedRecord<> Key of RecordToDelete THEN
COPY SelectedRecord into NewFile
ELSE
DO NOT COPY SelectedRecord
END IF
READ Next Record in ExistingFile
END REPEAT when EOF is reached
CLOSE NewFile and ExistingFile
DELETE ExistingFile
RENAME NewFile to Name of ExixtingFile
Random file
Unfortunately, VB6 Random Access files provide no direct mechanism for record deletion, primarily because
deletion leads to a rat's nest of other issues, such as file contraction (filling the empty space), fragmentation
(unused empty space), to name a couple. If you truly need to delete a record, about the only option you have is
to copy all the other records to a temporary file, delete the old file, and rename the temp file to the "original"
name - and, sadly, that's right from Microsoft. This is exactly what we are doing in Sequential and Serial files
above.
One thing you can do, which I'll admit up front isn't ideal, is to add a "deleted" field to your random-access
file, defaulting to 0, but changing to true, 1, or some other relevant value, to indicate that the record is no
longer valid.

of 7
2.2.3 Files
Code example:
Type SampleRecord
UserIDAs Long
lastName As String * 25
firstName As String * 25
Deleted As Boolean
End Type
' This logically deletes a record by setting
' its "Deleted" member to True
Sub DeleteRecord(recordId As Long)
Dim targetRecord As SampleRecord
Dim fileNumber As Integer
fileNumber = FreeFile
Open "SampleFile" For Random As fileNumber Len =
LenB(SampleRecord)
Get fileNumber, recordId, targetRecord
targetRecord.Deleted = True
Put #fileNumber, recordId, targetRecord
Close #fileNumber
End Sub
Sub AddRecord(lastName As String, firstName As String)
Dim newRecord As SampleRecord
Dim fileNumber As Integer
Dim newRecordPosition As Long
newRecord.firstName = firstName
newRecord.lastName = lastName
newRecord.Deleted = False
newRecord.UserID = 123 ' assume an algorithm for assigning this
value
fileNumber = FreeFile
Open "SampleFile" For Random As fileNumber Len =
LenB(SampleRecord)
newRecordPosition = LOF(fileNumber) / LenB(SampleRecord) + 1
Put #fileNumber, newRecordPosition, newRecord
Close #fileNumber
End Sub

of 13
2.3 Programming
2.3.1 Programming basics
Writing Programs
What are good program writing techniques?
Programmers should write code that is self-documenting and split into small sections.
Specifically, the programmers should:
use meaningful identifier names for variables, constants and subroutines;
use declared constants;
annotate code with comments;
indent code within iteration and selection;
split the code into modules when possible;
The need for good program-writing techniques
It is important for a programmer to use good programming techniques when writing code so that the code:
can be easier to understand by other programmers (who are either part of the programming team, or
who will be responsible for the maintenance of the program in the future);
can be understandable by the programmer himself in the future;
is split into smaller blocks which are easier to debug individually and update;
is less prone to errors – because the meaningful variable names and comments make it self-
documenting and easier to read.

of 13
2.3 Programming
Variable
A variable is a value that can change during the execution of a program.
Constant
A constant is a value that is set when the program initializes and does not change during the program’s
execution.
Identifier
Identifier is the name given to a variable, constant or subroutine.
Assigning a variable or constant an identifier name means that it can be easily referenced from any part of the
program within its scope and it helps to make the program more readable.
Reserved word/keyword
Reserved words (occasionally called keywords) are one type of grammatical construct in programming
languages. These words have special meaning within the language and are predefined in the language’s formal
specifications. Typically, reserved words include labels for primitive data types in languages that support a
type system, and identify programming constructs such as loops, blocks, conditionals, and branches.

of 13
2.3 Programming
Declaration
A declaration is a statement in a program that gives the compiler or the interpreter information about a
variable or constant that is to be used within a program.
A declaration ensures that sufficient memory is reserved in which to store the values and also states the
variables’ data type. Reserved words/keywords cannot be used as identifier names as this generates a compiler
error and comes under the category of syntax error.
Declaration of local variables
DIM FirstName, LastName AS String ‘declares two variables
DIM TheLength AS Single
DIM DOB AS Date
DIM OverDueFlag AS Boolean
Intrinsic variable declarations
Some programming languages require intrinsic variable declarations. This means that variables must be
declared before they are used.
The advantage of intrinsic variable declaration is that it cuts out possible errors due to the misspelling of a
variable name – if a variable is used that has not been declared, the programming translator will identify it as
an error.
DIM Number As Integer
Number= Nubmer+1 ‘This will be flagged as an Error!
There are two types of variables used by programmers and they are categorized according to their scope.

of 13
2.3 Programming
Scope
Scope indicates whether a variable can be used by all parts of a program or only within limited sections of the
program – for example, within a subroutine.
Global variable
A global variable is one that is declared at the start of the main program and is visible (useable) everywhere in
the program and exists for the lifetime of the program.
Note that if one procedure changes the value of a global variable, then the next procedure that uses the
variable will be given this changed value – this is a common cause of errors.
Local variable
A local variable is one that is only visible inside the procedure or function in which it is declared.
Note that a local variable cannot be referenced from outside the procedure. In fact a local variable does not
exist until the procedure starts executing and it disappears when the procedure stops executing. Thus any
value that is held by a local variable is only stored temporarily.
The lifetime of a local variable is the lifetime of the procedure in which the local variable is declared.
The advantage of using local variables rather than global variables is that the same variable names can be used
in several different procedures without any chance of values coinciding.
Using declared constants
Constants will be declared at the start of the main program. The following shows the declaration of constants
for Pi and the VAT rate
CONST Pi = 3.142
CONST VatRate = 0.175
Declaring constants at the start of a program means that maintenance is made easier for two reasons:
if the value of a constant changes, it only has to be changed in the one part of the program where it
has been declared, rather than in each part of the program in which it is used;
the code is easier to interpret:
Total=VatRate*CostPrice ‘allows a greater understanding
rather than
Total=0.175*CostPrice

of 13
2.3 Programming
Assignment
An assignment is an instruction in a program that places a value into a specified variable.
Some typical assignments are:
TheLength = 20.5
TheUsersName$ = “Charlie”
TheArea = TheWidth * TheLength
TotalCost = LabelledCost + 15
Counter = Counter + 1
Note that the last example is a common method used to increment the value of a variable. It could be read as:
“The new value of Counter is its existing value plus one”
Type Mismatch errors
A type Mismatch error occurs in a program when a variable has been declared as one data type, but it is later
assigned a value that is of an incompatible data type.
The following code will produce a ‘Type Mismatch’ error because “Charlie” is not an integer:
MyCounter = “Charlie”
Other Type Mismatches will be produced by the following:
DIM RentalDateAs Date
MemberRentalDate = “September”
DIM ShoeSizeAs Integer
JohnsShoeSize = 10.3
Note that a variable that is declared as a string will never produce a type mismatch error.
Arithmetic Operator

of 13
2.3 Programming
Powers
Division
A result of a division such as 17 ÷ 4 can be expressed either as a real (4.25) or as two integers
(4 remainder 1).
The integer method, in most programming languages, uses the operators DIV and MOD.

of 13
2.3 Programming
Relational operators (=, <, <=, >, >= and <>)
Relational operators are used in the format: [Expression] [Operator] [Expression] and will always return a
Boolean (True or False) value.
Relational operators are typically used with the “IF” selection and also within conditional loops
(REPEAT-UNTIL or WHILE-WEND).
In the following table, the variables “a” and “name$” have the following assignments:
a=3+5
name$=“JAMES”

of 13
2.3 Programming
Boolean operators AND, OR and NOT
AND and OR
The AND & OR operators always return a Boolean result and are used in the format:
[Boolean] [Operator] [Boolean]
The following ‘truth’ table summarizes the result of the Boolean operations:
Values Results
NOT
The NOT operator reverses the result of the Boolean expression and is used in the format:
NOT [Boolean]
The following truth table summarizes the NOT operation:

of 13
2.3 Programming
Examples of Boolean ‘logic’
Consider the following algorithm, which is used to monitor a printer and display its output via a LCD display
in the front panel:
IF NOT(PaperTrayEmpty) AND (FilesWaiting> 0) THEN
OUTPUT “PRINTING…”
ELSE
OUTPUT “PLEASE ADD PAPER”
END IF
If the values of the variables are:
PaperTrayEmpty = False
FilesWaiting = 2
Then the output will be “PRINTING…”
The following table shows why:
in whichPaperTrayEmpty = False.
To avoid this incorrect message, the algorithm should be rewritten using a nested IF, as shown on the next
page:
IF PaperTrayEmpty THEN
OUTPUT “PLEASE ADD PAPER”
ELSE
IF FilesWaiting> 0 THEN
OUTPUT “PRINTING…”
ELSE
OUTPUT “STATUS OK”
END IF
END IF

of 13
2.3 Programming
Meaningful identifier names
Identifiers are used to give names to constants and variables. They are also used to name procedures,
functions, and the main program.
Naming conventions
Most of the identifier names must conform to the following rules (different programming languages may have
slightly different rules):
they must be unique;
spaces must not be used;
they must begin with a letter of the alphabet;
the rest of the identifier must not contain punctuation – it may only consist of a mixture of letters and
digits (A–Z, a–z and 0–9) and the underscore character ‘_’;
they must not be a ‘reserved’ word – eg Print, Repeat, For, Dim, Loop, etc.
Recommended naming policies
Do not use spaces within identifier names – even with programming languages where they are permitted.
Instead, use the underscore character ‘_’ or, better yet, type names in lowercase except the first letter of each
word, which should be typed in uppercase.
Examples of good identifier names:
FirstName LastName PostCode
TelephoneNumber WeightAtBirth TestScore
AverageHeight
Further clarity can be given to identifier names by including a prefix that identifies the data type.
The above identifiers would be clearer if given the following prefix data types:
strFirstName strLastName strPostCode
strTelephoneNumber sglWeightAtBirth intTestScore
sglAverageHeight
Initializing a variable means setting it to a starter value. Initialization will usually set the value of an integer to
0 or 1 and a string to Empty (“”).

of 13
2.3 Programming
The following code initializes the variable Counter to zero before it is used in the iteration:
Counter=0 (the variable is initialized)
REPEAT
Counter=Counter+1
…
…
UNTIL Counter=10
Initializing a variable ensures that its value has not be been retained from a previous use of the routine and
that the value has not been accidently set in another part of the program – this helps avoid errors.
Comments/remarks
Comments (originally called remarks) are added to program code to provide useful, or essential,
documentation for the programmer and other people who read the code.
All programs/subroutines should contain comments to indicate:
the details of the person who wrote the code;
the date that the code was written;
the purpose of the code;
how parts of the code work;
the use of certain variables.
Comments can be used anywhere in a program – either as separate lines by themselves or on the same line as
executable code provided they appear to the right of any code that will execute.

of 13
2.3 Programming
Comments are usually indicated by the use of an apostrophe (‘), or two forward slashes (//).
PROCEDURE Arrange(NumberOfScores)
‘Procedure to move the largest element in an array to the end
‘Coded by J Jones, 02/03/09
DIM Ptr, Temp As Integer ‘ptr is the value of the array index
FOR Ptr = 1 TO NumberOfScores‘go through each element
‘test the relative values of the elements
IF Scores(Ptr) < Scores(Ptr + 1) THEN
‘use a temporary store to help swap the elements
Temp = Scores(Ptr)
Scores(Ptr) = Scores(Ptr + 1)
Scores(Ptr + 1) = Temp
END IF
NEXT Ptr‘increment the index to examine the next element
END PROCEDURE
Note that comments are ignored when the program code is compiled and so they are not present within the
stand-alone application.

of 13
2.3 Programming
Indentation should be used within iteration and selection statements so that it is clear which instructions go
together.
Examples:
Original code Indented code
INPUT Number
Total=0
WHILE Number > 0 THEN
Left=Number MOD 10
Right = Number DIV 10
Total=Total+Left
Number=Right
END WHILE
INPUT Number
Total=0
WHILE Number > 0 THEN
Left=Number MOD 10
Right = Number DIV 10
Total=Total+Left
Number=Right
END WHILE
Original code Indented code
FUNCTION TEST(X)
IF X=1 THEN
PRINT 1
RETURN 1
ELSE
Number=X*Test(X-1)
PRINT Number
RETURN Number
END IF
END TEST
FUNCTION TEST(X)
IF X=1 THEN
PRINT 1
RETURN 1
ELSE
Number=X*Test(X-1)
PRINT Number
RETURN Number
END IF
END TEST

of 2
2.3 Programming
2.3.3 Selection
Selection is a control structure in which there is a test to decide if certain instructions are executed.
IF-THEN-ELSE
This selection method is used if there are two possible outcomes to a test:
IF x < 0 THEN
OUTPUT “Sorry, you can’t have negative values”
ELSE
a = x*x
OUTPUT a
END IF
Pseudocode VB Syntax Example
IF <condition>
THEN
<statement(s)>
ENDIF
o or, including an
‘else’ clause:
IF <condition>
THEN
<statement(s)>
ELSE
<statement(s)>
ENDIF
' Multiple-line syntax:
If condition [ Then ]
[ statements ]
[ ElseIfelseifcondition
[ Then ]
[ elseifstatements ]
]
[ Else
[ elsestatements ] ]
End If
' Single-line syntax:
If condition Then [
statements ] [ Else [
elsestatements ] ]
Dim count As Integer = 0
Dim message As String
If count = 0 Then
message = "There are no
items."
ElseIf count = 1 Then
message = "There is 1
item."
Else
message = "There are " &
count & " items."
End If

of 2
2.3 Programming
2.3.3 Selection
SELECT-CASE
This selection method is used if there are more than two possible outcomes to a test:
SELECT CASE KeyPress
CASE LeftArrow
Move one character backwards
CASE RightArrow
Move one character forwards
CASE UpArrow
Move one character up
CASE DownArrow
Move one character down
END SELECT
CASE OF <identifier>
<value 1>: <statement>
<value 2>: <Statement>
...
ENDCASE
or alternatively:
CASE OF <identifier>
<value 1>: <statement>
<value 2>: <Statement>
...
OTHERWISE <statement>
ENDCASE
Select [ Case ]
testexpression
[ Case
expressionlist
[ statements ] ]
[ Case Else
[ elsestatements ] ]
End Select
Dim number As Integer = 8
Select Case number
Case 1 To 5
Debug.WriteLine("Between 1
and 5, inclusive")
Case 6, 7, 8
Debug.WriteLine("Between 6
and 8, inclusive")
Case 9 To 10
Debug.WriteLine("Equal to
9 or 10")
Case Else
Debug.WriteLine("Not
between 1 and 10,
inclusive")
End Select

of 3
2.3 Programming
2.3.4 Iteration
Iteration is a control structure in which a group of statements is executed repeatedly – either a set number of
times or until a specific condition is true.
FOR-NEXT
This is an unconditional loop in which the number of repetitions is set at the beginning.
FOR X = 1 TO 5
Answer = X*3
OUTPUT X, Answer
NEXT
FOR
<identifier>←<value1> TO
<value2>
<statement(s)>
ENDFOR
or alternatively:
FOR
<identifier>←<value1> TO
<value2>
STEP <value3>
<statement(s)>
ENDFOR
For counter
[ As datatype ] = start
To end [ Step step ]
[ statements ]
[ Continue For ]
[ statements ]
[ Exit For ]
[ statements ]
Next [ counter ]
For index As Integer = 1 To
5
Debug.Write(index.ToString&
" ")
Next
Debug.WriteLine("")
' Output: 1 2 3 4 5

of 3
2.3 Programming
2.3.4 Iteration
WHILE-ENDWHILE
This is a conditional loop, which has a test at the start and repeats until the condition is false:
X = 0
WHILE X < 6 DO
X = X + 1
Answer = X*3
OUTPUT X, Answer
ENDWHILE
WHILE <condition>
<statement(s)>
ENDWHILE
While condition
[ statements ]
[ Continue While ]
[ statements ]
[ Exit While ]
[ statements ]
End While
Dim index As Integer = 0
While index <= 10
" ")
index += 1
End While
Debug.WriteLine("")
' Output: 0 1 2 3 4 5 6 7 8
9 10

of 3
2.3 Programming
2.3.4 Iteration
REPEAT-UNTIL
This is a conditional loop, which has a test at the end and repeats until the condition is true:
X = 0
REPEAT
X = X + 1
Answer = X*3
OUTPUT X, Answer
UNTIL X > 4
REPEAT
<statement(s)>
UNTIL <condition>
Do { While | Until }
condition
[ statements ]
[ Continue Do ]
[ statements ]
[ Exit Do ]
[ statements ]
Loop
-or-
Do
[ statements ]
[ Continue Do ]
[ statements ]
[ Exit Do ]
[ statements ]
Loop { While | Until }
condition
Dim index As Integer = 0
Do
" ")
index += 1
Loop Until index > 10
Debug.WriteLine("")
' Output: 0 1 2 3 4 5 6 7 8
9 10

of 6
2.3 Programming
2.3.5 Built-in functions
Location
Many programming languages allow the searching for a short string of characters within a longer string. This
would be similar to searching this book for the word ‘computer’.
Common Key words for finding the location of one string within another are LOCATE, FINDand POSITION
Extraction
At times, a programmer will only want part of a string. Any part of a string can be obtained using the RIGHT,
LEFT and MID functions.
The following string manipulation functions are called by typing:
Result = FunctionName(String [,x,y])

of 6
2.3 Programming
Concatenation
Concatenation is where two or more strings are joined together to make a single string.
Note that when two strings are added together the second string is added to the end of the first:
“Peter” + “Jones” = “PeterJones”
“Peter” + “ “ + “Jones” = “Peter Jones”
“36.85” + “47” = “36.8547”
“47” + “36.85” =“4736.85”
“3/10/03” + “15” = “3/10/0315”
Length
Sometimes a programmer will need to know how many characters there are in a string.
Conversion
Strings and numbers
Strings are a sequence of ASCII characters, even if they contain only numbers such as “241”, and so they
cannot be used within an arithmetic calculation – they need to be ‘evaluated’ first.
Likewise a number such as 27.3 is not stored as ASCII characters and so cannot be used within any of the
string functions (such as Left, Right, Mid).
The function STR converts a number into a string and VAL converts a string into a number:
Characters and ASCII codes

of 6
2.3 Programming
The following two functions are used to either find the ASCII code for a specific character or to find the
character from the ASCII code:
ASCII character codes
Below is a table showing the most common characters and their ASCII codes:
Note the following:
the codes less than 32 are ‘control’ codes that are not used in strings;

of 6
2.3 Programming
‘space’ (code 32) has the lowest code;
next comes most of the punctuation symbols;
then digits 0–9
then uppercase letters
then lowercase letters
all other characters (e.g. é, å, π, etc.) have codes higher than these.
Comparing strings
When comparing strings, the codes of each string are compared, character by character, to decide which string
is greater.
Because it is the ASCII codes that are compared the following applies:
“Computing” <> “computing”
in fact:
“Computing” < “computing”
“10” < “2”
“02” < “1”
“1 120” < “1,120”
“ computing” < “Computing”
Sorting filenames
The following table shows a list of inconsistently names music tracks and the order in which they would be
sorted:
In order to get them sorted into the required order, they must be renamed with consistent use of uppercase
letters, spaces and leading zeros.
Recommended naming would be:
Track 01.mp3, Track 02.mp3, …, Track 10.mp3, Track 11.mp, …
Output data onto screen/file/printer, formatting the data for output as necessary.
Output will be either to the screen, a file or the printer.

of 6
2.3 Programming
Output controls
Output to the screen could be via a dialogue/message box, a text box, a list box or simply direct on the form.
Custom string formatting can be accomplished using specific characters recognized by the Format$ function,
shown in the table below:

of 6
2.3 Programming
To demonstrate custom string formats using combinations of the characters listed above, set up another "Try
It" project, and place the following code in the cmdTryIt_Click event of cmdTryIt button:
Private Sub cmdTryIt_Click()
Dim strName As String
strName = InputBox("Please enter your name:")
Print "Using '>':"; Tab(25); Format$(strName, ">")
Print "Using '<':"; Tab(25); Format$(strName, "<")
Print "Using '@':"; Tab(25); "Hello there, "; Format$(strName,
"@@@@@@@@@@"); ". How are you?"
Print "Using '&':"; Tab(25); "Hello there, "; Format$(strName,
"&&&&&&&&&&"); ". How are you?"
Print "Using '!@':"; Tab(25); "Hello there, "; Format$(strName,
"!@@@@@@@@@@"); ". How are you?"
Print "Using '!&':"; Tab(25); "Hello there, "; Format$(strName,
"!&&&&&&&&&&"); ". How are you?"
Print "Using '':"; Tab(25); Format$(strName, "Hello,
&&&&&&&&&&.")
Print "Using embedded quotes:"; Tab(25); Format$(strName, """Hello,
""&&&&&&&&&&"".""")
End Sub
Run the project and click the "Try It" button. When the input box appears, enter a name in mixed case (in this
example, Bruce was entered). The strings will be displayed as follows:

of 11
2.3 Programming
2.3.6 Structured programming
Procedural programs are ones in which instructions are executed in the order defined by the programmer.
Procedural languages are often referred to as third generation languages and include FORTRAN, ALGOL,
COBOL, BASIC, and PASCAL.
Statement
A statement is a single instruction in a program, which can be converted into machine code and executed.
In most languages a statement is written on a single line, but some languages allow multiple lines for single
statements.
Examples of statements are:
DIM name As String
A=X*X
While x < 10
Subroutine
A subroutine is a self-contained section of program code that performs a specific task, as part of the main
program.
Procedure
A procedure is a subroutine that performs a specific task without returning a value to the part of the program
from which it was called.
Function
A function is a subroutine that performs a specific task and returns a value to the part of the program from
which it was called.
Note that a function is ‘called’ by writing it on the right hand side of an assignment statement.

of 11
2.3 Programming
Parameter
A parameter is a value that is ‘received’ in a subroutine (procedure or function).
The subroutine uses the value of the parameter within its execution. The action of the subroutine will be
different depending upon the parameters that it is passed.
Parameters are placed in parenthesis after the subroutine name. For example:
Square(x) ‘passes the value of the variable x
Use subroutines to modularise the solution to a problem
Subroutine/sub-program
A subroutine is a self-contained section of program code which performs a specific task and is referenced by a
name.
A subroutine resembles a standard program in that it will contain its own local variables, data types, labels and
constant declarations.
There are two types of subroutine. These are procedures and functions.
Procedures are subroutines that input, output or manipulate data in some way.
Functions are subroutines that return a value to the main program.
A subroutine is executed whenever its name is encountered in the executable part of the main program. The
execution of a subroutine by referencing its name in the main program is termed ‘calling’ the subroutine.
The benefits of using procedures and functions are that:

of 11
2.3 Programming
The same lines of code are re-used whenever they are needed – they do not have to be repeated in
different sections of the program.
A procedure or function can be tested/improved/rewritten independently of other procedures or
functions.
It is easy to share procedures and functions with other programs – they can be incorporated into
library files which are then ‘linked’ to the main program.
A programmer can create their own routines that can be called in the same way as any built-in
command.
Sub Procedures (Visual Basic)
A Sub procedure is a series of Visual Basic statements enclosed by the Sub and End Sub statements.
The Sub procedure performs a task and then returns control to the calling code, but it does not return a value
to the calling code.
Each time the procedure is called, its statements are executed, starting with the first executable statement after
the Sub statement and ending with the first End Sub, Exit Sub, or Returnstatement encountered.
You can define a Sub procedure in modules, classes, and structures. By default, it is Public, which means you
can call it from anywhere in your application that has access to the module, class, or structure in which you
defined it. The term, method, describes a Sub or Function procedure that is accessed from outside its defining
module, class, or structure. For more information, see Procedures in Visual Basic.
A Sub procedure can take arguments, such as constants, variables, or expressions, which are passed to it by
the calling code.
Declaration Syntax
The syntax for declaring a Sub procedure is as follows:
[ modifiers ] Sub subname [( parameterlist )]
' Statements of the Sub procedure.
End Sub

of 11
2.3 Programming
The modifiers can specify access level and information about overloading, overriding, sharing, and
shadowing. For more information, see Sub Statement (Visual Basic).
Parameter Declaration
You declare each procedure parameter similarly to how you declare a variable, specifying the parameter name
and data type. You can also specify the passing mechanism, and whether the parameter is optional or a
parameter array.
The syntax for each parameter in the parameter list is as follows:
[Optional] [ByVal | ByRef] [ParamArray] parametername As datatype
If the parameter is optional, you must also supply a default value as part of its declaration. The syntax for
specifying a default value is as follows:
Optional [ByVal | ByRef] parametername As datatype = defaultvalue
Parameters as Local Variables
When control passes to the procedure, each parameter is treated as a local variable. This means that its
lifetime is the same as that of the procedure, and its scope is the whole procedure.
Calling Syntax
You invoke a Sub procedure explicitly with a stand-alone calling statement. You cannot call it by using its
name in an expression. You must provide values for all arguments that are not optional, and you must enclose
the argument list in parentheses. If noarguments are supplied, you can optionally omit the parentheses. The
use of
the Call keyword is optional but not recommended.
The syntax for a call to a Sub procedure is as follows:
[Call] subname [( argumentlist )]
Illustration of Declaration and Call
The following Sub procedure tells the computer operator which task the application is about to perform, and
also displays a time stamp. Instead of duplicating this code at the start of every task, the application just
calls tellOperator from various locations. Each call passes a string in the task argument that identifies the task
being started.

of 11
2.3 Programming
VB
SubtellOperator(ByVal task As String)
Dim stamp As Date
stamp = TimeOfDay()
MsgBox("Starting "& task &" at "&CStr(stamp))
End Sub
The following example shows a typical call to tellOperator.
VB
tellOperator("file update")
Function Procedures (Visual Basic)
A Function procedure is a series of Visual Basic statements enclosed by the Function and End
Function statements. The Function procedure performs a task and then returns control to the calling code.
When it returns control, it also returns a value to the calling code.
Each time the procedure is called, its statements run, starting with the first executable statement after
the Function statement and ending with the first End Function, Exit Function, orReturn statement encountered.
You can define a Function procedure in a module, class, or structure. It is Public by default, which means you
can call it from anywhere in your application that has access to the module, class, or structure in which you
defined it.
A Function procedure can take arguments, such as constants, variables, or expressions, which are passed to it
by the calling code.
Declaration Syntax
The syntax for declaring a Function procedure is as follows:
VB
[Modifiers] FunctionFunctionName [(ParameterList)] AsReturnType
[Statements]
EndFunction

of 11
2.3 Programming
Data Type
Every Function procedure has a data type, just as every variable does. This data type is specified by
the As clause in the Function statement, and it determines the data type of the value the function returns to the
calling code. The following sample declarations illustrate this.
VB
Functionyesterday() AsDate
EndFunction
FunctionfindSqrt(ByVal radicand AsSingle) AsSingle
EndFunction

of 11
2.3 Programming
Returning Values
The value a Function procedure sends back to the calling code is called its return value. The procedure returns
this value in one of two ways:
It uses the Return statement to specify the return value, and returns control immediately to the calling
program. The following example illustrates this.
VB
FunctionFunctionName [(ParameterList)] AsReturnType
' The following statement immediately transfers control back
' to the calling code and returns the value of Expression.
Return Expression
EndFunction
It assigns a value to its own function name in one or more statements of the procedure. Control does
not return to the calling program until an Exit Function or End Functionstatement is executed.
The following example illustrates this.
VB
FunctionFunctionName [(ParameterList)] AsReturnType
‘ The following statement does not transfer control back to the calling
code.
FunctionName = Expression
' When control returns to the calling code, Expression is the return value.
EndFunction
The advantage of assigning the return value to the function name is that control does not return from the
procedure until it encounters an Exit Function or End Function statement. This allows you to assign a
preliminary value and adjust it later if necessary.

of 11
2.3 Programming
Calling Syntax
You invoke a Function procedure by including its name and arguments either on the right side of an
assignment statement or in an expression. You must provide values for all arguments that are not optional, and
you must enclose the argument list in parentheses. If no arguments are supplied, you can optionally omit the
parentheses.
The syntax for a call to a Function procedure is as follows:
lvalue = functionname [( argumentlist )]
If (( functionname [( argumentlist )] / 3) <= expression ) Then
When you call a Function procedure, you do not have to use its return value. If you do not, all the actions of
the function are performed, but the return value is ignored.” MsgBox” is often called in this manner.
Illustration of Declaration and Call
The following Function procedure calculates the longest side, or hypotenuse, of a right triangle, given the
values for the other two sides.
VB
Functionhypotenuse(ByVal side1 As Single, ByVal side2 As Single) As Single
ReturnMath.Sqrt((side1 ^ 2) + (side2 ^ 2))
End Function
The following example shows a typical call to hypotenuse.
VB
DimtestLength, testHypotenuseAs Single
testHypotenuse = hypotenuse(testLength, 10.7)

of 11
2.3 Programming
Passing Arguments by Value and by Reference (Visual Basic)
In Visual Basic, you can pass an argument to a procedure by value or by reference. This is known as the
passing mechanism, and it determines whether the procedure can modify the programming element
underlying the argument in the calling code. The procedure declaration determines the passing mechanism for
each parameter by specifying the ByVal (Visual Basic) or ByRef (Visual Basic) keyword.
Distinctions
When passing an argument to a procedure, be aware of several different distinctions that interact with each
other:
Whether the underlying programming element is modifiable or not
Whether the argument itself is modifiable or not
Whether the argument is being passed by value or by reference
Whether the argument data type is a value type or a reference type
For more information, see Differences Between Modifiable and Nonmodifiable Arguments (Visual Basic) and
Differences Between Passing an Argument By Value and By Reference (Visual Basic).
Choice of Passing Mechanism
You should choose the passing mechanism carefully for each argument.
Protection.
In choosing between the two passing mechanisms, the most important criterion is the exposure of
calling variables to change. The advantage of passing an argument ByRef is that the procedure can
return a value to the calling code through that argument. The advantage of passing an argument ByVal
is that it protects a variable from being changed by the procedure.
Performance.
Although the passing mechanism can affect the performance of your code, the difference is usually
minor. One exception to this is a value type passed ByVal. In this case, Visual Basic copies the entire
data contents of the argument. Therefore, for a large value type such as a structure, it can be more
efficient to pass it ByRef.

of 11
2.3 Programming
Determination of the Passing Mechanism
The procedure declaration specifies the passing mechanism for each parameter. The calling code can't
override a ByVal mechanism.
If a parameter is declared with ByRef, the calling code can force the mechanism to ByVal by enclosing the
argument name in parentheses in the call. For more information, see How to: Force an Argument to Be Passed
by Value (Visual Basic).
The default in Visual Basic is to pass arguments by value.
When to Pass an Argument by Value
If the calling code element underlying the argument is a nonmodifiable element, declare the
corresponding parameter ByVal (Visual Basic). No code can change the value of a non-modifiable
element.
If the underlying element is modifiable, but you do not want the procedure to be able to change its
value, declare the parameter ByVal. Only the calling code can change the value of a modifiable
element passed by value.
When to Pass an Argument by Reference
If the procedure has a genuine need to change the underlying element in the calling code, declare the
corresponding parameter ByRef (Visual Basic).
If the correct execution of the code depends on the procedure changing the underlying element in the
calling code, declare the parameter ByRef. If you pass it by value, or if the calling code overrides the
ByRef passing mechanism by enclosing the argument in parentheses, the procedure call might
produce unexpected results.
Example:
Description:The following example illustrates when to pass arguments by value and when to pass them by
reference. Procedure Calculate has both a ByVal and a ByRef parameter. Given an interest rate, rate, and a
sum of money, debt, the task of the procedure is to calculate a new value for debt that is the result of applying
the interest rate to the original value of debt. Because debt is a ByRef parameter, the new total is reflected in
the value of the argument in the calling code that corresponds to debt. Parameter rate is a ByVal parameter
because Calculate should not change its value.
Code
Module Module1

of 11
2.3 Programming
SubMain()
' Two interest rates are declared, one a constant and one a
' variable.
ConsthighRateAs Double = 12.5
DimlowRate = highRate * 0.6
DiminitialDebt = 4999.99
' Make a copy of the original value of the debt.
DimdebtWithInterest = initialDebt
' Calculate the total debt with the high interest rate applied.
' ArgumenthighRate is a constant, which is appropriate for a
' ByVal parameter. Argument debtWithInterest must be a variable
' because the procedure will change its value to the calculated
' total with interest applied.
Calculate(highRate, debtWithInterest)
' Format the result to represent currency, and display it.
DimdebtString = Format(debtWithInterest, "C")
Console.WriteLine("What I owe with high interest: "&debtString)
' Repeat the process with lowRate. Argument lowRate is not a
' constant, but the ByVal parameter protects it from accidental
' or intentional change by the procedure.
' SetdebtWithInterest back to the original value.
debtWithInterest = initialDebt
Calculate(lowRate, debtWithInterest)
debtString = Format(debtWithInterest, "C")
Console.WriteLine("What I owe with low interest: "&debtString)
End Sub
' Parameter rate is a ByVal parameter because the procedure should
' not change the value of the corresponding argument in the
' calling code.
' The calculated value of the debt parameter, however, should be
' reflected in the value of the corresponding argument in the
' calling code. Therefore, it must be declared ByRef.
SubCalculate(ByVal rate As Double, ByRef debt As Double)
debt = debt + (debt * rate / 100)
End Sub
End Module

of 10
2.4 Software development
2.4.1 Programming
Why Programming?
You may already have used software, perhaps for word processing or spreadsheets to solve problems. Perhaps
now you are curious to learn how programmers write software. A program is a set of step-by-step instructions
that directs the computer to do the tasks you want it to do and produce the results you want.
There are at least three good reasons for learning programming:
Programming helps you understand computers. The computer is only a tool. If you learn how to write
simple programs, you will gain more knowledge about how a computer works.
Writing a few simple programs increases your confidence level. Many people find great personal
satisfaction in creating a set of instructions that solve a problem.
Learning programming lets you find out quickly whether you like programming and whether you
have the analytical turn of mind programmers need. Even if you decide that programming is not for
you, understanding the process certainly will increase your appreciation of what programmers and
computers can do.
A set of rules that provides a way of telling a computer what operations to perform is called a programming
language. There is not, however, just one programming language; there are many. In this chapter you will
learn about controlling a computer through the process of programming. You may even discover that you
might want to become a programmer.
An important point before we proceed: You will not be a programmer when you finish reading this chapter or
even when you finish reading the final chapter. Programming proficiency takes practice and training beyond
the scope of this book. However, you will become acquainted with how programmers develop solutions to a
variety of problems.
What is it that Programmers Do?
In general, the programmer's job is to convert problem solutions into instructions for the computer. That is, the
programmer prepares the instructions of a computer program and runs those instructions on the computer,
tests the program to see if it is working properly, and makes corrections to the program. The programmer also
writes a report on the program. These activities are all done for the purpose of helping a user fill a need, such
as paying employees, billing customers, or admitting students to college.
The programming activities just described could be done, perhaps, as solo activities, but a programmer
typically interacts with a variety of people.
For example, if a program is part of a system of several programs, the programmer coordinates with other
programmers to make sure that the programs fit together well. If you were a programmer, you might also have
coordination meetings with users, managers, systems analysts, and with peers who evaluate your work-just as
you evaluate theirs.
Let us turn to the programming process.

of 10
2.4.1 Programming
The Programming Process
Developing a program involves steps similar to any problem-solving task. There are five main ingredients in
the programming process:
1. Defining the problem
2. Planning the solution
3. Coding the program
4. Testing the program
5. Documenting the program
1. Defining the Problem
Suppose that, as a programmer, you are contacted because your services are needed. You meet with
users from the client organization to analyze the problem, or you meet with a systems analyst who
outlines the project. Specifically, the task of defining the problem consists of identifying what it is
you know (input-given data), and what it is you want to obtain (output-the result). Eventually, you
produce a written agreement that, among other things, specifies the kind of input, processing, and
output required. This is not a simple process.
Two common ways of planning the solution to a problem are to draw a flowchart and to write
pseudocode, or possibly both. Essentially, a flowchart is a pictorial representation of a step-by-step
solution to a problem. It consists of arrows representing the direction the program takes and boxes and
other symbols representing actions. It is a map of what your program is going to do and how it is
going to do it. The American National Standards Institute (ANSI) has developed a standard set of
flowchart symbols. Figure 1 shows the symbols and how they might be used in a simple flowchart of
a common everyday act-preparing a letter for mailing.
Pseudocode is an English-like nonstandard language that lets you state your solution with more
precision than you can in plain English but with less precision than is required when using a formal
programming language. Pseudocode permits you to focus on the program logic without having to be
concerned just yet about the precise syntax of a particular programming language. However,
pseudocode is not executable on the computer. We will illustrate these later in this chapter, when we
focus on language examples.
2. Planning the Solution

of 10
2.4.1 Programming
Flow Chart Symbols and Flow Chart For Mailing Letter

of 10
2.4.1 Programming
3. Coding the Program
As the programmer, your next step is to code the program-that is, to express your solution in a
programming language. You will translate the logic from the flowchart or pseudocode-or some
other tool-to a programming language. As we have already noted, a programming language is a
set of rules that provides a way of instructing the computer what operations to perform. There are
many programming languages: BASIC, COBOL, Pascal, FORTRAN, and C are some examples.
You may find yourself working with one or more of these. We will discuss the different types of
languages in detail later in this chapter.
Although programming languages operate grammatically, somewhat like the English language,
they are much more precise. To get your program to work, you have to follow exactly the rules-
the syntax-of the language you are using. Of course, using the language correctly is no guarantee
that your program will work, any more than speaking grammatically correct English means you
know what you are talking about. The point is that correct use of the language is the required first
step. Then your coded program must be keyed, probably using a terminal or personal computer, in
a form the computer can understand.
One more note here: Programmers usually use a text editor, which is somewhat like a word
processing program, to create a file that contains the program. However, as a beginner, you will
probably want to write your program code on paper first.
4. Testing the Program
some experts insist that a well-designed program can be written correctly the first time. In fact,
they assert that there are mathematical ways to prove that a program is correct. However, the
imperfections of the world are still with us, so most programmers get used to the idea that their
newly written programs probably have a few errors. This is a bit discouraging at first, since
programmers tend to be precise, careful, detail-oriented people who take pride in their work. Still,
there are many opportunities to introduce mistakes into programs, and you, just as those who have
gone before you, will probably find several of them.
Eventually, after coding the program, you must prepare to test it on the computer. This step
involves three phases:
a. Desk-checking. This phase, similar to proofreading, is sometimes avoided by the
programmer who is looking for a shortcut and is eager to run the program on the
computer once it is written. However, with careful desk-checking you may discover
several errors and possibly save yourself time in the long run. In desk-checking you
simply sit down and mentally trace, or check, the logic of the program to attempt to
ensure that it is error-free and workable.
Many organizations take this phase a step further with a walkthrough, a process in which
a group of programmers (your peers) review your program and offer suggestions in a
collegial way.
b. Translating. A translator is a program that (1) checks the syntax of your program to
make sure the programming language was used correctly, giving you all the syntax-error
messages, called diagnostics, and (2) then translates your program into a form the

of 10
2.4.1 Programming
computer can understand. A by-product of the process is that the translator tells you if
you have improperly used the programming language in some way. These types of
mistakes are called syntax errors. The translator produces descriptive error messages. For
instance, if in FORTRAN you mistakenly write N=2 *(I+J))-which has two closing
parentheses instead of one-you will get a message that says, “UNMATCHED
PARENTHESES.” (Different translators may provide different wording for error
messages.) Programs are most commonly translated by a compiler. A compiler translates
your entire program at one time. The translation involves your original program, called a
source module, which is transformed by a compiler into an object module. Prewritten
programs from a system library may be added during the link/load phase, which results in
a load module. The load module can then be executed by the computer.
c. Debugging. A term used extensively in programming, debugging means detecting,
locating, and correcting bugs (mistakes), usually by running the program. These bugs are
logic errors, such as telling a computer to repeat an operation but not telling it how to stop
repeating. In this phase you run the program using test data that you devise. You must
plan the test data carefully to make sure you test every part of the program.
5. Documenting the program
Documenting is an ongoing, necessary process, although, as many programmers are, you may be
eager to pursue more exciting computer-centered activities. Documentation is a written detailed
description of the programming cycle and specific facts about the program. Typical program
documentation materials include the origin and nature of the problem, a brief narrative description of
the program, logic tools such as flowcharts and pseudocode, data-record descriptions, program
listings, and testing results. Comments in the program itself are also considered an essential part of
documentation. Many programmers document as they code. In a broader sense, program
documentation can be part of the documentation for an entire system.
The wise programmer continues to document the program throughout its design, development, and
testing. Documentation is needed to supplement human memory and to help organize program
planning. Also, documentation is critical to communicate with others who have an interest in the
program, especially other programmers who may be part of a programming team. And, since turnover
is high in the computer industry, written documentation is needed so that those who come after you
can make any necessary modifications in the program or track down any errors that you missed.
Program development life cycle (PDLC)
When programmers build software applications, they just do not sit down and start writing code. Instead, they
follow an organized plan, or methodology, that breaks the process into a series of tasks. There are many
application development methodologies just as there are many programming languages. There different
methodologies, however, tend to be variations of what is called the program development life cycle (PDLC).
The program development life cycle (PDLC) is an outline of each of the steps used to build software
applications. Similarly to the way the system development life cycle (SDLC) guides the systems analyst
through development of an information system, the program development life cycle is a tool used to guide
computer programmers through the development of an application. The program development lifecycle
consists of six steps.

of 10
2.4.1 Programming
The Six Steps of PDLC
STEP PROCEDURE DESCRIPTION
1
Analyze the
problem
Precisely define the problem to be solved, and write program
specifications – descriptions of the program’s inputs, processing,
outputs, and user interface.
2
Design the
program
Develop a detailed logic plan using a tool such as pseudocode,
flowcharts, object structure diagrams, or event diagrams to group the
program’s activities into modules; devise a method of solution or

of 10
2.4.1 Programming
algorithm for each module; and test the solution algorithms.
3
Code the
program
Translate the design into an application using a programming language
or application development tool by creating the user interface and
writing code; include internal documentation – comments and remarks
within the code that explain the purpose of code statements.
4
Test and
debug the
program
Test the program, finding and correcting errors (debugging) until it is
error free and contains enough safeguards to ensure the desired results.
5
Formalize the
solution
Review and, if necessary, revise internal documentation; formalize and
complete the end-user (external) documentation.
6
Maintain the
program
Provide education and support to end users; correct any unanticipated
errors that emerge and identify user-requested modifications
(enhancements). Once errors or enhancements are identified, the
program development life cycle begins again at Step 1.

of 10
2.4.1 Programming
How to expose faults in programs, and how to avoid them??
Errors in computer solutions are called bugs. They create two problems. One is that the error needs to be
corrected; this is normally fairly straightforward because most errors are caused by silly mistakes. The second
problem, however, is much more complicated, the errors have to be found before they can be corrected.
Finding where the error is and identifying it, can be very difficult and there are a number of techniques
available for solving such problems.
1. Translator diagnostics. Each of the commands that are in the original program is looked at separately by
the computer translator to execute it. Each command will have a special word which says what sort of
command it is. The translator looks at the special word in the command and then goes to its dictionary to look
it up. The dictionary tells the translator program what the rules are for that particular special word. If the word
has been typed in wrongly, the translator will not be able to find it in the dictionary and will know that
something is wrong. If the word is there, but the rules governing how it should be used have not been
followed properly, the translator will know that there is something wrong. Either way, the translator program
knows that a mistake has been made, it knows where the mistake is and, often, it also knows what mistake has
been made. A message detailing all this can be sent to the programmer to give hints as what to do. These
messages are called translator diagnostics.
2. Debugging tools. Sometimes the program looks alright to the translator, but it still doesn’t work properly.
Debugging tools are part of the software which help the user to identify where the errors are. The techniques
available include:
a) Cross-referencing. This software checks the program that has been written and finds places where
particular variables have been used. This lets the programmer check to make sure that the same variable has
not been used twice for different things.
b) Traces. A trace is where the program is run and the values of all the relevant variables are printed out, as
are the individual instructions, as each instruction is executed. In this way, the values can be checked to see
where they suddenly change or take on an unexpected value.
c) Variable dumps (check/watch). At specified parts of the program, the values of all the variables are
displayed to enable the user to compare them with the expected results.
3. Desk checking is sometimes known as a dry run. The user works through the program instructions
manually, keeping track of the values of the variables. Most computer programs require a very large number
of instructions to be carried out, so it is usual to only dry run small segments of code that the programmer
suspects of containing an error.

of 10
2.4.1 Programming
4. Focus on the top-down design in section 2.1.c we discussed the splitting up of a problem into smaller and
smaller parts, until each part was a manageable size. When the parts were combined they would produce a
solution to the original problem. Because we are starting with a big problem and splitting it into smaller
problems, this was called top-down design. When the program is written, each small program is written
separately, allowing the small programs to be tested thoroughly before being combined. This is called bottom-
up programming. The technique is particularly useful for testing the finished program because it is far easier
to test a lot of small programs than it is to test one large one. One problem can arise, because the small
programs have to be joined together, these joints have to be tested too to make sure that no silly mistakes have
been made like using the same variable name for two different things in two parts of the program (tested by
cross referencing).
5. Test strategies are important to establish before the start of testing to ensure that all the elements of a
solution are tested, and that unnecessary duplication of tests is avoided.
6. (This section is with respect to VB6) If you reach a point in your code that calls another procedure (a
function, subroutine, or the script associated with an object or applet), you can enter (step into) the procedure
or run (step over) it and stop at the next line. At any point, you can jump to the end (step out) of the current
procedure and carry on with the rest of the application.
You may want to step through your code and trace code execution because it may not always be obvious
which statement is executed first. Use these techniques to trace the execution of code:
Break points can be set within program code so that the program stops temporarily to check that it is
operating correctly upto that point.
Step Into: Traces through each line of code and steps into procedures. This allows you to view the
effect of each statement on variables.
Step Over: Executes each procedure as if it were a single statement. Use this instead of Step Into to
step across procedure calls rather than into the called procedure.
Step Out: Executes all remaining code in a procedure as if it were a single statement, and exits to the
next statement in the procedure that caused the procedure to be called initially.
Run to Cursor: Allows you to select a statement in your code where you want execution to stop. This
allows you to "step over" sections of code (for example, large loops).
To trace execution from the current statement
From the Debug menu, choose Step Into, Step Over, Step Out, or Run To Cursor.

of 10
2.4.1 Programming
To trace execution from the beginning of the program
From the Debug menu, choose Step Into, Step Over, Step Out, or Run To Cursor.

As Level Computer Science Book -2

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to As Level Computer Science Book -2 (20)

Recently uploaded (20)

As Level Computer Science Book -2