Evaluation

The British Computer Society define evaluation as:

“An objective review of what has been achieved to establish whether it meets the required criteria. The evaluation might also look at the wider context, the user needs and whether there are any undesirable consequences introduced into the solution.”

Burdett, Arnold. BCS Glossary of Computing (Kindle Locations 999-1001). BCS Learning & Development Limited. Kindle Edition. 

There are several criteria that could be used when evaluating your programs: 

• Fitness for purpose

• Efficient use of coding constructs

• Usability

• Maintainability

• Robustness

Fitness for purpose is establishing whether or not your software fulfils all the functional and user requirements detailed in the specification. Any omissions or issues should be described here. 

For example:

• Optional requirements

• Any requirement that is met but there is perhaps a concern/issue or it is “just met”

So when establishing fitness for purpose you need to refer to the requirements and ensure that they have been met.

Efficient use of coding constructs

This aspect of evaluation looks at whether the most appropriate programming constructs or data types have been used:

• Suitable Data Types

• Conditional or Fixed Loops

• Arrays

• Nested Selection Statements

• Procedures/functions with parameter passing

Efficiency does not always mean speed of execution - it could be memory footprint or limiting access to files/databases.

Suitable Data Types and Structures

Have you used appropriate variable types

• • Certain functions can only be carried out on certain variable types - such as concatenation on strings

Have you used arrays/records suitably?

• • Arrays may not be faster at execution but with regards to memory size they can make code more compact

Fixed and Conditional Loops

Where possible have you used a loop?

• • A loop may not always be faster for a small number of iterations but over larger iterations would be more efficient.

If you are using a fixed loop - is that the most efficient option?

• What if you are searching through a list of 100,000 items and you have found an item

• A conditional loop could be more efficient as you could use logic to halt the loop from running unnecessarily, preventing needless iterations through large arrays.

Conditional Statements

Consider the following algorithm, the problem with it is that every IF statement will hsve to be evaluated (even if the first conditional statement was found to be true)

Nested Selection Statements

If you use a combination of nested or else if statements then it is possible that some conditions may never required to be evaluated and checked. This may not be possible in all cases as it may be that the correct option is the last one. The example below takes the grades from above and evaluates them in a more efficient manner.

You can have a functioning product but if it is not usable then it isn't really very useful. You need to test and evaluate the usability of your product.  The usability can be just as important as the functionality - if a product isn't usable then it is less likely to be successful.

You can ask participants to perform specific or routine tasks using your product

• Such as installing the product

• Saving a file etc.

Then the important factor is the observation of the user under controlled conditions and the feedback that is given.

What info can you collect to evaluate?

• Successful Task Rate

• Critical/Non Critical Errors

• Error Free Rate

• Task Times

• Subjective ratings or Likes/Dislikes and recommendations

• Eye Tracking Data

Think Aloud Protocol

Think Aloud Protocol is when a user will be invited to think out loud whilst using a product. They will say what they are thinking and try to describe their thought processes whilst using a piece of software.

• This can provide instant feedback

• Direct Observation

• There is chances for an observer to assist users 

• Can be instant after task dialogue

Usability testing doesn't even need a finished product. It can be conducted with a low or high fidelity prototype. This allows the client to provide feedback at a much earlier stage. When altering an interface will require minimal effort.

How readable is your code?

Meaningful variable names/identifiers assist you (and other developers) to identify the function of programs.

Indentation and the use of white space are also extremely useful

• Remember that Python uses indentation instead of delimiters such as { } or ( ) and end if/next loop etc

Remember that modularity can help maintainability as:

• Local variables can help reduce variable clashes.

• Subprograms can be edited independently of each other.

• Bugs/Errors should be able to located easier.

A piece of software is robust if it can deal with exceptional or incorrect data or unusual situations. Your input validation or file access should be one of your main considerations. You cannot deal with every possible scenario but you should aim to test those that may happen - even if you cannot deal with them as yet.

Your evaluation should:

• Identify any discrepancies between the software specification and the completed software.

• Identify where you’re coding has been efficient.

• Identify features of your software that have enhanced the usability for the user.

• Describe the features in your code that helps with the maintainability of the software.

• Reflect and comment on the testing that was undertaken to meet the specification and demonstrate the robustness of your software.