2.3 Producing Robust Programs

Question 1

What is input validation?

Answer 1

Checking data input by the user meets specific criteria or rules before processing

Question 2

Defensive design considerations: Type check

Answer 2

The input is in the correct data type (e.g. integer, real, string)

Question 3

Defensive design considerations: Range check

Answer 3

The input is within a correct range (e.g. between 1 & 2)

Question 4

Defensive design considerations: Presence check

Answer 4

Some data has been entered (e.g. reject blank inputs)

Question 5

Defensive design considerations: Format check

Answer 5

The input is in the correct format (e.g. dd/mm/yyyy)

Question 6

Defensive design considerations: Length check

Answer 6

The input has the correct (min/max) number of characters (e.g. passwords)

Question 7

What can a programmer make their program by using input validation techniques?

Answer 7

By using input validation techniques, a programmer can make their program:

1) More robust

2) More user friendly

3) Prevent further errors occurring later in the algorithm

Question 8

What does input validation help prevent?

Answer 8

The easiest way for a user to accidentally or intentionally misuse a program is when entering data. This can be prevented using input validation.

Question 9

Anticipating misuse: Division by zero

Answer 9

A programmer should always check that a variable isn’t zero before attempting a division by it to reduce the risk of their program crashing

Question 10

Anticipating misuse: Communication error

Answer 10

Online systems require connections to host servers.
If this connection is dropped, unable to be established, or the system is overloaded, it could potentially cause a program to crash or hang when loading/saving data.

Question 11

Anticipating misuse: Communication error (solution)

Answer 11

A programmer should enable ways for the user to cancel requests or for them to fail gracefully, reporting the connection error.
The program may be able to automatically resume when the connection is available again.

Question 12

Anticipating misuse: Printer and other peripheral errors

Answer 12

If a program outputs a hardcopy, the printer may run out of paper, ink, or have a jam.
The programmer should not assume that an output to a printer was successful and always have options to reprint reports or receipts.

Question 13

Anticipating misuse: What are disk errors?

Answer 13

Programs that read and write to files used to handle many types of exceptions, including:

1) The file/folder not being found

2) The disk being out of space

3) The data in the file being corrupt

4) The end of the file being reached

Question 14

Anticipating misuse: How are disk errors solved?

Answer 14

Robust programs will handle all these situations by checking files and data before attempting to use them for further processing

Question 15

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

Answer 15

1) Force users to use strong passwords and change them regularly

2) Limit the number of failed authentication attempts before access to an account is lost

3) Ask for a random selection of characters from the password on each authentication

Question 16

What is authentication?

Answer 16

Authentication can confirm the identity of a user before they’re allowed to access certain pieces of data or features of the program

Question 17

Data used by systems should be secure. How can this be achieved? (authentication)

Answer 17

1) Username and password to access systems

2) Recovering a password requires clicking on a link within the email that is sent to the registered address

3) Encryption of data files

Question 18

Online bots can submit data automatically to online forms. How can this be protected against?

Answer 18

This can be protected against using software such as reCAPTCHA that verifies the user is human.

Programmers should also be aware of the potential for SQL hacks and other methods used by hackers

Question 19

What does a well-maintained program do?

Answer 19

A well-maintained program makes it easy for other programmers to understand what the code does.

They should 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 20

Maintainability: comments

Answer 20

Use comments to explain the purpose of the program, explain sections of code (typically selections, iterations and procedures), explain unusual approaches that were necessary, visually divide sections of a program

Question 21

Maintainability: white space

Answer 21

Use white space to make sections of a program easier to see

Question 22

Maintainability: indentation

Answer 22

Use indentation for every selection and iteration branch (allows programmers to see the flaw of a program more clearly and pick out the different features)

Question 23

Maintainability: descriptive variable names

Answer 23

Use descriptive variable names, sub programs and parameters and explain their purpose with a comment when declared.

This helps programmers understand what they do and make it easier to keep track of them (e.g. names refer to what they actually are)

Question 24

Maintainability: procedures and/or functions

Answer 24

Use procedures and/or functions to structure the code and eliminate duplicating code (sub programs make it easier to see how different parts of a program work, which help them understand the overall program faster)

Question 25

Maintainability: constants

Answer 25

Use constants declared at the top of a program

Question 26

What are syntax errors?

Answer 26

Errors which break the grammatical rules of the programming language and stop it from being run/translated

Question 27

Why do syntax errors happen?

Answer 27

1) Variables aren't declared or initialised before use 2) Incompatibility of variable types (e.g. total = "A" (total declared as an integer)) 3) Using assignments incorrectly 4) Keywords misspelt (e.g. prnt("Enter choice: "))

Question 28

What are logic errors?

Answer 28

Errors which produce unexpected output but allow the program to keep running

Question 29

Why do logic errors happen?

Answer 29

1) Conditions and arithmetic operations are wrong 2) Sequence of commands is wrong 3) Division by zero 4) Exceptions (e.g. file not found)

Question 30

What are reasons for testing?

Answer 30

1) To ensure there are no errors (bugs) in the code 2) To check that the program has an acceptable performance and usability 3) To ensure that unauthorised access is prevented 4) To check the program meets the requirements

Question 31

What is iterative testing?

Answer 31

1) Each new module is tested as it is written 2) Program branches are checked for functionality 3) Checking new modules do not introduce new errors in existing code 4) Tests to ensure that the program handles erroneous data and exceptional situations

Question 32

Iterative testing is when program is tested...

Answer 32

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. This process is repeated until the module is working correctly.

Question 33

What is final/terminal testing?

Answer 33

1) Testing that all modules work together (integration testing) 2) Testing the program produces the required results with normal, boundary, invalid, and erroneous data 3) Checking the program meets the requirements with real data 4) A beta test may find more errors

Question 34

Terminal testing is when program is tested....

Answer 34

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

Question 35

How do we prevent errors and bugs?

Answer 35

1) Iterative testing is used to identify and fix small errors, which help prevent larger errors from occurring later on in the development process 2) Final testing is important as modules may work perfectly on their own but errors may occur when the modules interact with each other in the program 3) Using a combination of iterative and final testing is a good way to minimise the total number of bugs or errors that a program has when it is released

Question 36

Suitable test data: normal inputs

Answer 36

Data which should be accepted by a program without causing errors

Question 37

Suitable test data: boundary inputs

Answer 37

Data of the correct type which is on the edge of accepted validation boundaries

Question 38

Suitable test data: invalid inputs

Answer 38

Data of the correct type but outside accepted validation checks so should be rejected by a computer system

Question 39

Suitable test data: erroneous inputs

Answer 39

Data of the incorrect type which should be rejected by a computer system. This includes no input being given when one is expected.

Question 40

What is refining algorithms to make them more robust about:

Answer 40

1) Writing code which anticipates a range of possible inputs 2) Those inputs could be invalid data or erroneous data 3) Making sure "bad" data doesn't crash the program 4) Making sure prompts to the user are descriptive and helpful (e.g. prompt to enter a code, code accepted, code is too short/long/contains non-numeric data) 5) Making sure only data of the correct "data type" are entered 6) Checking and handling missing or blank data

Question 41

What is one option of refining algorithms?

Answer 41

One option is to use simple exception handling commands (available in most programming languages)

Question 42

What should a good test plan have or be?

Answer 42

A test plan should be made before implementation, outline exactly what you're going to test and how you're going to test it. It should cover all possible paths in a program. A good test plan will anticipate all the potential issues with the program and select appropriate test data to test for these issues

Question 43

What programmers try to do through defensive design?

Answer 43

Programmers try to protect their programs through defensive design. They will try to: 1) Anticipate and prevent users from misusing their programs 2) Ensure their code is well-maintained 3) Reduce the number of errors in the code through texting

Question 44

What do structure diagrams and sub programs do?

Answer 44

Structure diagrams show the smaller tasks of a larger program. Simple sub programs can be written to carry out each individual task and the main program can be written from these

Question 45

What are the advantages of structure diagrams?

Answer 45

1) Coding is easier as you're writing code for simple tasks 2) Lots of programmers can work at once as each module is written independently 3) Easier to test as all modules are tested individually 4) Individual sub programs can be fixed/updated without affecting the rest of the program 5) Can reuse sub programs in future programs