Programming for non-programmers
Part 2 - Variables
In the previous part I described the use of variables to hold data, but the subject was only touched upon at a very superficial level. Because variables are such an important part of programming I shall take time now to describe the different types and how they are used in more detail.
There are three main type of variable, which are:
The first two, Real and Integer, are used to hold numbers. An alternative name for a Real variable is Floating Point, and this gives a clue to the difference between them. A Real variable can hold a number which has a decimal component, like 2.475. An Integer can only hold whole numbers. If you try to store a number with a decimal part in an Integer variable then the decimal part will be lost. So, if you try to store 2.475 in an Integer variable it will be truncated to 2.
If Integers can only hold whole numbers and Reals can hold either whole numbers of decimals why bother with Integers in Basic? The reasons are speed and accuracy. Computers don't naturally understand decimal fractions, they work only in whole numbers. Quite a bit of 'massaging' has to be done to make them use those strange, human, decimal numbers, so Integers are very much faster. They can also be more accurate as nothing is lost in 'translating' them into a form that the computer can understand, as we shall see later.
It is therefore good programming technique to use Integer variables wherever possible. In fact, experienced programmers use Integers almost exclusively, even when dealing with obvious decimal data like cash.
So, how do we differentiate between Real and Integer variables? In BBC Basic it's very simple. You just add a '%' percentage sign to the end of the variable name.
To clarify: adding a % to the end of an existing Real variable name doesn't change it into an Integer, and leaving the % off the end of an Integer doesn't change it into a Real. The % (or lack of it) is part of the variable name. When it is created basic will allocate the type of storage required for an Integer if it has a % on the end of the name and the space required for a Real if it doesn't. So:
are two different variables.
So that you understand the difference use Edit to create the following short program. The example programs have been included on the disc (in the EXAMPLES directory alongside this file), but it will still be better if you type them in yourself. That way you will continue to gain experience with creating and debugging programs.
REM Illustrate difference between Real and Integer integer% = 1.8 + 2.4 real = 1.8 + 2.4 PRINT integer% PRINT real END
You should be able to predict what will happen when you Run this program. The Integer variable 'rounds down' the number but the Real stores it in full.
By now you should also have realised that we used only Real variables in the VAT calculator program described in the last part, and the reason why.
Everybody needs string
The third type of variable is the String. This is nothing to do with the stuff used to tie up packages, it means 'a string of characters', and it is a way of storing text.
In BBC Basic the maximum permitted length of a string is 255 characters. A string variable is defined and recognised by having a '$' (dollar) terminating character. Strings are always enclosed in double quotes when assigned. For example:
name$ = "Fred Smith" PRINT name$
At this point it is worth spending a little more time to make sure you appreciate the difference between the Real and Integer numerical variables and the string variable. Some people have trouble with this. The former are numbers. They can be added together, subtracted, multiplied, in fact, have all sorts of mathematical functions applied to them. The latter are words or letters. For example:
first% = 42 second% = 64 PRINT first% + second%
would produce the result '106', but:
first$ = "42" second$ = "64" PRINT first$ + second$
would produce the result '4264'.
In the first case the two numbers 4 and 6 are added together, in the second case the two 'words' 42 and 64 are added together. In fact, this 'adding together' of strings is more properly called concatenation. They're joined together, not added together, the '+' sign is just a convenient symbol to use for the action.
In some variants of Basic where the distinction between numerical and string variables is not so clearly defined in their names it is possible for inexperienced programmers to get thoroughly confused. For example, with some types of basic which don't use the '$' you could use:
first = "42"
When you do this these versions of Basic would automatically make 'first' a string variable, but from then on you would have to remember that it was a string variable, it wouldn't be obvious from the variable name. With BBC Basic the '$' suffix always makes the distinction clear, and if you try to assign the wrong sort of data to a variable a 'Type mismatch' error will be produced.
Expressions and string/number conversion
It is part of the 'job description' of Basic that wherever you can use a variable or a constant, you can use an expression. I have mentioned expressions before, and used them in earlier programs, but it's worth repeating what they actually are.
An expression is anything which can be evaluated when the program is run. For example:
first% = 4 + 5
Here '4 + 5' is an expression. When the program is Run the expression '4 + 5' is evaluated and the result (9) is assigned to the variable first%. There's nothing new in this, we've done it before, but from now on things might get a little more complicated and it's a lot easier to understand what's happening with this simple example, though the principle always remains the same.
Although in BBC Basic there are only the three main types of variable mentioned to consider, different languages and variants of Basic may have others. For example, in BBC Basic an integer can be a positive or negative number, with a range of from -2,147,483,648 to +2,147,483,647 (don't worry about why these particular values, we'll get to that later in the series). A cardinal is a type of integer that can be only positive, and so it can hold a bigger number.
Whatever form the variable takes, it will inevitably fall into one of two groups, it will be a numerical variable or a string variable, and all languages will need some way to convert between the two. We've already been doing this, or rather, allowing Basic to do it in the background. Every time a program gets input from the keyboard we type a series of character, and Basic converts these (assuming they are numerical characters) into a number. When the program needs to display the answer to a calculation it must convert the number to a string of characters and display them.
The routines for doing this are called functions. Functions are pieces of code which performs certain actions or calculations and 'return' a result. They may be pieces of code you write in your program to perform a specific task or 'built in' to the language. In BBC Basic we can use a function rather like an expression:
variable = function
What this does is call the function and assign the value returned by it to the variable. 'Call' is the term used when a program leaves the main 'flow' of the program code and branches off to a sub-section, returning to the same place in the main part of the program afterwards. Functions may have parameters passed to them when they are called. Where a function is performing a conversion or calculation this will usually be necessary as we are going to have to give the function the data we want it to use. In fact, a function is a sort of miniature program itself, and should ideally be designed to be almost completely self contained.
The two functions incorporated into Basic which perform conversions between numbers and numeric
number = VAL("142")
will assign the value 142 to the variable number. In a case like this, of course, it would be easier to just use:
number = 142
but things aren't always that simple.
number$ = STR$(142)
You've probably already noticed it yourself, but the parameter passed to VAL is a string, so if it's a literal string, as in the example, it's enclosed in double quotes. The parameter passed to STR$ is a number, so it isn't.
One final point. As with almost everything else in Basic you can pass expressions to functions. For example:
number$ = STR$(64+32)
would make number$ equal to the sum of 64 and 32, or "96".
Basic and line numbers
This might seem like a drastic change of subject, but bear with me, there's a reason for introducing it here. When you write a Basic program, every line is given a sequential number. This is used by Basic to keep track of program execution, but, most of the time, it doesn't matter to you and you don't need to know what these numbers are.
Look at the icon bar menu in Edit and follow 'BASIC options' and you will see that the first item on the sub-menu is 'Strip line numbers'. By default this is 'ticked'. Click on this so it is no longer ticked and load a Basic program into Edit. You will see that each line begins with a number. Depending upon what editor was used to write the program these will either be sequential numbers, or in increments of 10. Now you've seen them you can reset Edit to strip the line numbers. As a programmer they are of no interest to you except for one special purpose.
The reason you need to know about line numbers is because sometimes things go wrong. If you have typed in the programs described in the first article you may already have experienced this when you tried to run them. The error messages probably weren't very helpful because you didn't know where to look for the problem. So far the programs have been fairly short, but as they get bigger you will need a way to find out not only what the problem is, but where to look for it.
So far all the examples I've given have had one Basic statement or instruction on a line. It is possible to put more than one statement on a line, but you can't just join them up, one after the other. Just as in a written language we use a full stop to indicate the end of one sentence and the start of another, so in Basic we use the ':' (colon) character to indicate the end of one statement and the beginning of another. For example:
first% = 24 second% = 56
could be written as:
first% = 24 : second% = 56
As usual, the extra spaces are merely for clarity and are not necessary.
You can put several statements on a single line like this, although there are some potential problems that we'll deal with later.
BBC Basic has its own 'default' error handling routine, which you've probably already seen. If something
is wrong you'll get a message like
Later we will use this to do things like stopping a program from crashing because you've just tried to save hours of work to a disc which doesn't have enough room, but for the moment its main use is going to be to tell us where in our program code the error has occurred so that the inevitable typing mistakes can be easily found and corrected. Which, of course, is why I'm introducing the subject now before you get fed up trying to find out where those 'Mistakes' actually are.
When an error occurs Basic stores the error message, the error number, and the program line where the error occurred respectively in three special variables REPORT$, ERR and ERL. The error number is an individual number assigned to every possible error and is mainly used to trap specific errors. We can't alter or assign values to these variable, but we can 'read' them and so find out what's gone wrong.
The way we 'trap' an error is to use insert a line:
ON ERROR <do something>
where <do something> is whatever we want the program to do when it finds an error.
ON ERROR PRINT REPORT$ + " at line " + STR$(ERL) : END
This looks a bit more complicated than some of the things described so far, but there's nothing new here.
The first part is the
This is actually three separate items, using the '+' symbol to join them up into a single string The first is REPORT$, and this will be the error message from Basic. The next is just a literal string, " at line ". This leads to the third item, which takes the Basic variable ERL which tells us where the error occurred and converts it to a numerical string. So, the line which appears on the screen will be in the form:
<error message> at line <line number>
After this there is a statement delimiter, which signals the end of the
So how does it work in practice? Enter the following program:
REM Test error handler first% = 24 second% = 48 sum% = first% + second% PRINT sum% END
This is pretty simple stuff. It just assigns numbers to two variables, adds them together and puts the sum in a third variable, then prints the result. But what would happen if we had made an error typing the word second% in the 4th line and written:
REM Test error handler first% = 24 second% = 48 sum% = first% + seconf% PRINT sum% END
There obviously won't work, but without error trapping there will just be a message 'Unknown or missing variable' which won't help us to track down where the mistake is.
So, let us introduce our own error trap and see if it's any better.
REM Test error handler ON ERROR PRINT REPORT$ + " at line " + STR$(ERL) : END first% = 24 second% = 48 sum% = first% + seconf% PRINT sum% END
Note that the error handler must be near the start of the program. If not, Basic won't 'know' about it and will just use the default error handler. Now run the program again and you should see:
This is an improvement because it gives us the line where the error occurred, but there's one small difficulty, it tell us the error was in line 50 and the program only has seven lines!
The reason for this is that I used Edit to write the program, and by default Edit numbers Basic lines in increments of 10. If you used something else to write your program where line numbers were incremented in 1's you might have been told that the error occurred at line 5. This isn't much of a problem, because you can just divide the line number by 10 and use the 'Goto line' function of the text editor (in Edit press F5).
The CASE structure
In the first part of this series I described the use of the
CASE <variable> OF WHEN <something> : <do this> WHEN <something> : <do this> WHEN >something> : <do this> ENDCASE
In addition there's another option,
If you do not include the
It is important to note that there must be absolutely nothing on the first line after the word 'OF'. Even a
single space, which might pass unnoticed in your editor, will stop the structure from working correctly.
As soon as a match is found all the other options are ignored, so if <variable> happens to match more than one option, only the first one found will count.
This is a very powerful structure, and is the essential programming tool for multiple-choice selection, so it's worth spending a little more time on it. Type in the following program, and see if you can work out exactly what it's going to do before you try it, and, more important, how it does it.
REM Demonstrate CASE structure ON ERROR PRINT REPORT$ + " at line " + STR$(ERL) : END INPUT "Enter a number " number% CASE number% OF WHEN 1 : PRINT "You entered ONE" WHEN 2 : PRINT "You entered TWO" WHEN 3 : PRINT "You entered THREE" WHEN 4 : PRINT "You entered FOUR" WHEN 5 : PRINT "You entered FIVE" WHEN 6 : PRINT "You entered SIX" WHEN 7 : PRINT "You entered SEVEN" WHEN 8 : PRINT "You entered EIGHT" WHEN 9 : PRINT "You entered NINE" OTHERWISE : PRINT "I don't understand " + STR$(number%) ENDCASE END
You will notice that I've included the error handler line at the start of the program. We can now go back and have another look at the VAT calculator and see if we can improve it. The final program was:
REM Program to add or subtract VAT from a price PRINT "Do you want to -" PRINT " 1. Add VAT to the net price" PRINT " 2. Calculate net price from VAT inclusive price" REPEAT INPUT "Please enter 1 or 2 " choice UNTIL choice = 1 OR choice = 2 INPUT "Enter price " price IF choice=1 THEN result = price * 1.175 ELSE result = price / 1.175 PRINT result END
As this uses a menu selection it could be made more elegant with a CASE structure, and we could also add an option to quit the program.
REM Program to add or subtract VAT from a price ON ERROR PRINT REPORT$ + " at line " + STR$(ERL) : END REPEAT PRINT PRINT "Do you want to -" PRINT " 1. Add VAT to the net price" PRINT " 2. Calculate net price from VAT inclusive price" PRINT " 3. Exit the program" INPUT "Please choose " choice% CASE choice% OF WHEN 1 : INPUT "Enter price " price result = price * 1.175 PRINT "Price with VAT is " result WHEN 2 : INPUT "Enter price " price result = price / 1.175 PRINT "Price without VAT is " result WHEN 3 : END OTHERWISE : PRINT "You must enter 1, 2 or 3" ENDCASE UNTIL choice% = 3 END
Don't worry about the indented lines. The extra spaces are ignored when the program is Run, but they help to make it easier to 'read' and see how the various options operate.
The new program takes what you learned in the first part and adds some of the new things from this session.
Firstly there's the error handler. This will be included in all programs from now on because as they are
getting more complicated typing mistakes are bound to occur. Next the menu now has three items. You can
choose between adding or subtracting VAT or quitting the program. Placing the main section of the program
In the next instalment we'll make a few more improvements to the VAT calculator program and I'll describe another family of variables, the array.