You typed 41, not 14, for your age. Why did the form accept it?

What validation does

• Validation is an automatic check that input is sensible and follows rules before the program uses it.
• Invalid data is rejected, and the user is told why and asked again.
• It stops bad data causing crashes or wrong results later.
• Validation cannot tell whether data is correct: a mistyped value that still follows the rules gets through.

Types of validation check

• Pattern check: the data matches a set pattern, e.g. two letters then four digits.

Writing a validation routine

• Ask for input, test it, and keep asking until it passes.
• A loop does this: the user cannot move on with invalid data.
• This WHILE loop is a range check for 1 to 10.

score = int(input("Score 1 to 10: "))
while score < 1 or score > 10:
    score = int(input("Must be 1 to 10: "))

Authentication

• Authentication confirms the identity of a user before they get access, e.g. with a user ID and password.
• A lookup searches the stored list of IDs and passwords for a matching pair.
• Robust software has few weaknesses; audit trails (logs of who did what) and code reviews (others check the code) help find vulnerabilities.

users = [["sam01", "Tr33house"], ["ali22", "Bl0ckH3ad"]]
userID = input("User ID: ")
password = input("Password: ")
found = False
for user in users:
    if user[0] == userID and user[1] == password:
        found = True
if found:
    print("Access granted")
else:
    print("Access denied")

It passed every test. So why did it fail for an 18-year-old?

Why test?

• Testing checks that a program works as intended and meets its requirements.
• It finds errors so they can be fixed before users meet them.
• A program can run without crashing and still give wrong results.
• Passing a few easy tests proves little: choose test data that could expose errors.

Normal, edge and wrong data

For a program that accepts whole numbers from 1 to 10:

• Normal data: sensible values that should be accepted, e.g. 5.
• Values at the edges of the range, 1 and 10, and just outside them, 0 and 11.
• Data that should be rejected, e.g. ten or 15.

Types of error

• A syntax error breaks the rules of the language, e.g. a missing bracket. The program cannot be translated or run.
• A logic error lets the program run, but it gives the wrong or unexpected result, e.g. > where ≥ was needed.
• A runtime error happens while the program runs and makes it crash, e.g. dividing by zero or using an index past the end of an array.
• Testing with good test data is how you find logic errors.

Code that is easy to maintain

• Other people (and you, later) must be able to read and change code. This is maintainability.
• Meaningful identifiers: totalScore, not t.
• Comments explain what each part of the code does.
• Indentation shows which lines belong inside loops, selection and subprograms.
• White space and a clear layout split code into readable blocks.
• Subprograms break code into named, reusable parts.

Big ideas

• Validation automatically checks input is sensible, e.g. range, length and presence checks, and rejects data that breaks the rules; it cannot check data is correct.
• Authentication confirms who a user is, e.g. by matching a user ID and password.
• Choose test data of every kind: normal, at the edges of the range, and data that should be rejected (values the program should accept, values at the limits and values it should reject).
• Syntax errors stop a program running; logic errors give wrong results; runtime errors crash it while it runs.
• Meaningful names, comments, indentation and subprograms make code easy to maintain.