section 7 - design, testing, IDE's

Question 1

well-maintained programs

Answer 1

When using structured programming, it’s important that your code is well-maintained.
A well-maintained program makes it easy for other programmers to understand what the code does. They should also be able to change parts of the source code without the risk of causing problems elsewhere in the code (e.g. knock on effects).

Question 2

features that improve the maintainability of source code - Comments

Answer 2

useful for explaining what the key features of a program do - well written and clear comments are fundamental for helping other programmers understand your programs.

Question 3

features that improve the maintainability of source code - indentation

Answer 3

used to separate different statements in a program. This allows other programmers to see the flow of the program more clearly and pick out the different features.

Question 4

features that improve the maintainability of source code - naming of Variables, sub programs and parameters

Answer 4

Variables, sub programs and parameters should be named so that they refer to what they actually are. This helps programmers to understand what they do, and makes it easier to keep track of them. It’s also important that they follow the standard naming conventions

Question 5

features that improve the maintainability of source code - use of sub programs

Answer 5

Using sub programs can make it easier for other programmers to see how different parts of a program work, which can help them understand the overall program faster.

Question 6

Defensive Design

Answer 6

When programs are functioning correctly they should never break or produce errors. In practice this is difficult to achieve.

Programmers try to protect their programs through defensive design. They will try to:

• Anticipate how users might misuse their program, then attempt to prevent it from happening.
• Ensure their code is well-maintained
• Reduce the number of errors in the code through testing

Question 7

input validation

Answer 7

Checking if data meets certain criteria before passing it into the program.
E.g. checking that an email address contains an @ symbol and has a suitable ending (.com, .co.uk, etc).

This prevents users from accidentally or intentionally misusing a program when entering data.

Programs can use a mixture of input validation checks to verify that the inputted data has an acceptable format before passing it into the program.

Question 8

types of input validation check you can use

Answer 8

Range check
Presence check
Format check
Look-up table
Length check

Question 9

Range check

Answer 9

Checks the data is within a specified range

Question 10

presence check

Answer 10

Checks the data has actually been entered.

Question 11

format check

Answer 11

Checks the data has the correct format (e.g. a date).

Question 12

look-up table

Answer 12

Checks the data against a table of acceptable values.

Question 13

length check

Answer 13

Checks the data is the correct length.

Question 14

authentication

Answer 14

Authentication can confirm the identity of a user before they’re allowed to access certain pieces of data or features of the program. A common way that programs do this is using passwords - It’s important that programmers get the level of authentication correct - too much authentication can affect a program’s functionality and put people off using it

Question 15

authentication - passwords

Answer 15

Passwords are usually associated with a username. When someone tries to access a protected part of the program, it should ask them for their password to check that they are who they claim to be.

Question 16

common ways to increase the security of a password-based authentication system

Answer 16

• Force users to use strong passwords (see p.46) and get them to change their passwords regularly.
• Limit the number of failed authentication attempts before access to an account is lost.
• Ask for a random selection of characters from the password on each authentication.

Question 17

syntax errors

Answer 17

when the compiler or interpreter doesn’t understand something you’ve typed because it doesn’t follow the rules or grammar of the programming language.

Syntax errors can be diagnosed by compilers and interpreters - they’ll be unable to translate the source code and a syntax error (with its location) will be returned.

Question 18

logic errors

Answer 18

when the compiler or interpreter is able to run the program, but the program does something unexpected.

Logic errors are more difficult to diagnose and track down - compilers and interpreters won’t pick them up. Logic errors are found through general use of the program and by systematically testing it using a test plan.

Question 19

Programming Errors

Answer 19

It’s quite typical for a program to contain errors during its development these errors need to be found and corrected as soon as possible.
The first task is to figure out what type of error has occurred.
Once you have identified the errors in a program, you can then refine your code to fix them.

Question 20

Iterative testing

Answer 20

the program is tested while it is being developed. Often a programmer will test a module, fix any errors they find and then test it again. They will repeat the process until the module is working correctly.

Iterative testing is used to identify and fix small errors, which will help prevent larger (and more difficult to fix) errors from occurring later on in the development process.

Question 21

Final (terminal) testing

Answer 21

the program is tested at the end of the development process. The whole program is tested at the same time to check that it’s working correctly.

Final testing is also important as modules may work perfectly on their own, but errors may occur when the modules interact with each other in the program.

Question 22

Testing

Answer 22

Using a combination of iterative testing and final testing is a good way to help minimise the total number of errors or bugs that a program has when it is released.

Question 23

test plan

Answer 23

outlines exactly what you’re going to test and how you’re going to test it.
It should cover all the possible paths through a program.

A good test plan will anticipate all of the potential issues with the program and select appropriate test data to test for these issues.

Question 24

test data categories:

Answer 24

Normal data
Boundary (extreme) data
invalid data
erroneous data

Question 25

Normal data

Answer 25

things that a user is likely to input into the program.

Question 26

Boundary (extreme) data

Answer 26

values at the limit of what the program should be able to handle.

Question 27

Invalid data

Answer 27

inputs with a correct data type that should be rejected by the program.

Question 28

Erroneous data

Answer 28

inputs with an incorrect data type that should be rejected by the program

Question 29

test plan example

Answer 29

Question 30

high level languages

Answer 30

• One instruction of high-level code represents many instructions of machine code.
• The same code will work for many different machines and processors.
• The programmer can easily store data in lots of different structures (e.g. lists and arrays) without knowing about the memory structure.
• Code is easy to read, understand and modify.
• Must be translated before a computer is able to understand it.
• You don’t have much control over what the CPU actually does so programs will be less memory efficient and slower.
• (e.g. Python, C++)

Question 31

low level languages

Answer 31

• One instruction of assembly code usually only represents one instruction of machine code.
  Usually written for one type of machine or processor and won’t work on any others.
• The programmer needs to know about the internal structure of the CPU (see p.2-3) and how it manages the memory.
• Code is very difficult to read, understand and modify.
• Commands in machine code can be executed directly without the need for a translator.
• You control exactly what the CPU does and how it uses memory so programs will be more memory efficient and faster.

They consist of machine code and assembly languages

Question 32

translators

Answer 32

Computers only understand instructions given to them as machine code, so high level
languages need to be translated before a computer is able to execute the instructions.
There are two types of translator that you need to know about: compilers and interpreters.
The type of translator used will depend on which programming language and IDE you’re using

Question 33

compiler

Answer 33

Translates all of the source code at the same time and creates one executable file.
Only needed once to create the executable file.
Returns a list of errors for the entire program once compiling is complete.
Once compiled the program runs quickly, but compiling can take a long time.

Question 34

interpreter

Answer 34

Translates and runs the source code one instruction at a time, but doesn’t create an executable file.
Needed every time you want to run the program.
The interpreter will return the first error it finds and then stop - this is useful for debugging.
Programs will run more slowly because the code is being translated as the program is running.

Question 35

linker

Answer 35

If the program is stored over multiple source code files then a linker is used to join all of the separate compiled codes into one executable program.

Question 36

IDE

Answer 36

An integrated development environment is a piece of software that provides features to help a programmer to develop their program. Most IDEs will have similar features

Question 37

code editor

Answer 37

The code editor is the main part of an IDE, it’s where the code is written. Most code editors will have line numbering and auto-colour coding for things like strings, functions, variables and comments. Good code editors will also have other automatic features like auto-correct, auto-indentation and auto-complete.

Question 38

run-time environment

Answer 38

A run-time environment allows the code to run quickly within the IDE - this is done using a start or run button. The run-time environment can also help to identify logic errors in the program as the programmer can see which part of the code is running when errors occur.

Question 39

output window

Answer 39

An output window to
show the output from a program when it is run.

Question 40

Error diagnostics and debugging tools

Answer 40

Error diagnostics and debugging tools help to find and fix errors in a program - they’ll tell you the location of the error and often suggest ways to fix it.

Question 41

Breakpoints

Answer 41

Breakpoints are a common debugging tool, they stop the program on certain lines so you can gather information like the value of variables as the program is running.

Question 42

Auto-documentation

Answer 42

Auto-documentation helps with the maintenance of programs. It can extract certain features
of a program, like the names of variables, names of sub programs and comments.
This information is stored in a separate document to give a summary of what the code does.

Question 43

Graphical User Interface (GUI) builder

Answer 43

A Graphical User Interface (GUI) builder helps the programmer design a user interface by building up graphically rather than having to design it using source code. It allows you to drag and drop different objects and customise them, so you can make the interface look exactly how you want it to.

Question 44

structure diagrams

Answer 44

1) Structure (or modular) diagrams show the smaller tasks of a larger program.

2) They are made by decomposing the program that you want to write into manageable modules. Each of those modules is then decomposed even further into smaller modules and eventually into modules that perform individual tasks.

3) Simple sub programs can be written to carry out each individual task. Then the bigger modules and main program can be written using these sub programs.

Question 45

structure diagrams example

Answer 45

For example, to design a program simulating a game of noughts and crosses you might have:

Question 46

Advantages of using Structure Diagrams

Answer 46

Coding is easier because you’re only writing code to carry out very simple tasks.

Lots of programmers can work on one program as each module can be written independently.

It’s easier to test structured programs as each module can be tested individually

Individual sub programs and modules can be fixed and updated without affecting the rest of the program.

You will be able to reuse the sub programs and modules in programs you write in the future.

Question 47

Trace tables

Answer 47

1) Trace tables give a simple way of testing that a piece of code is working correctly.
They keep track of the values that certain variables take as you go through the code.

2) Their main use is to ‘dry run’ a sub program or algorithm to make sure there are no logic errors.

3) The columns of a trace table usually represent variables. Each row of a trace table represents the values that the variables take at a particular point in the algorithm.

4) The columns of a trace table might not always be variables - they could be any information that the programmer is interested in. For example, they might have a column for the length of an array or for the output of the algorithm

Question 48

Trace tables example

Answer 48