Eight Things Programming Languages Can Do

Trevor Gosbell gives us Part 1 of his article on the general concepts of programming — for those keen to enhance their understanding and abilities

When learning computer programming it can be difficult to separate general programming principles from the specific details of one particular language. In some languages the underlying general principles of programming may remain obscured by the sheer volume of information needed just to make a program work. General principles may not emerge until the new programmer has learned two or three other languages.

This article illustrates eight basic programming concepts with examples in five programming languages: Java, Perl, Python, REBOL and Scheme. It will enable the reader to make comparisons and generalisations. Part one addresses the first five ideas: output, variables, expressions, input, and selection. Part two covers lists, subroutines, and repetition.

The five languages were chosen for no other reason than they happened to be installed and working on my computer when I sat down to write this article. I make no claim to expertise in these or any other programming language and I am aware that I have ignored common idioms of the languages in some examples. The five languages are available for all common desktop environments including Windows, Macintosh, and Linux.

For the sake of clarity I have included only the relevant lines of code in the Java examples and omitted the standard header in the REBOL examples. All of the examples, except those for Java are complete programs. The examples are available from my Web page http://member.melbpc.org.au/~tgosbell/ as complete working programs.

1. Output

The vast majority of computer programs provide some information to the outside world - that is, they produce output. Let's face it, a program is not very useful if it doesn't output something. The most common form of output is printing text to the screen (sometimes known as standard output or stdout). This leads us to the simplest computer program in the world - the clichéd "hello world", which prints a simple message (e.g. "hello world") to the standard output.

So, this will be our first example in Listing 1. The output of all of these programs is the text girt by sea printed to the screen followed by a line feed.

Listing 1

Java
   System.out.println("girt by sea");

Perl
   print "girt by sea\n";

Python
   print "girt by sea"

REBOL
   print "girt by sea"

Scheme
   (display "girt by sea\n")

Did you notice that the Perl and Scheme examples include \n at the end of the output? The output commands of the other languages automatically include a line feed in their output, but Perl and Scheme output commands don't, so a line feed must be included explicitly. The character combination \n is recognised as a line feed character and produces a new line in the output.

2. Variables and Assignment

In the first example, the string of characters "girt by sea" is referred to as a constant value, meaning that every time the program runs this text will remain the same. Contrast that with a variable. Think of it as a box that can hold a value that can change as the program executes. Give the "box" a name, and whenever that name appears in the program, the current value stored in its box will be retrieved and used by the program, at that point.

The act of giving a variable a new value is called assignment and it is often represented by the equals sign =. The next example (listing 2) has the same output as the first, but this time the text girt by sea is assigned to a variable which is named message, and the value of that variable is printed to standard output.

Listing 2

Java
   String message = new String("girt by sea" );
   System.out.println( message );

Perl
   $message = "girt by sea\n";
   print $message;

Python
   message = "girt by sea"
   print message

REBOL
   message: "girt by sea"
   print message

Scheme
   (define message "girt by sea\n")
   (display message)

For each of the variations on the "print message" instruction, the output is NOT message; it is the value assigned to the variable message: ie. girt by sea.

In effect, the print instruction is telling the variable "give me your value and I'll print it".

Sometimes limitations are placed on the type of value that can be assigned to a variable. For example look at the assignment statement in the Java example in listing 2, which starts with String message.

This indicates that for the Java example the variable called message can only accept a string of characters between quotation marks (that is, plain text). So, it is not possible to give message a numeric value (such as your age - but a post code is okay) or perform mathematical operations on it.

3. Expressions

This is a concept borrowed from mathematics - values and/or variables are combined with operators to form an expression. When an expression is evaluated a result is produced. For example, the expression
   1 + 2
uses the addition operator (+) on two values (1 and 2), and when evaluated it produces the result
   3
In programming, expressions are not limited to mathematical statements. Let's say we have an operator join that works on strings of characters. The expression
   "this and " join "that"
uses the join operator on the two strings of characters to produce the result
   "this and that"

In programming, the result (output) from an expression is a value that can be handled like any other - it can be assigned to a variable or used as part of another expression.

The examples in listing 3 evaluate the expression x times y, where the value in x is 101 and the value in y is 22. The result of the expression is assigned to the variable named answer and then the value in answer is printed on the standard output.

Programming languages typically use the symbols * for multiplication and / for division. The characters x and ö aren't available on an ordinary computer keyboard so it's a matter of using what's available.

Listing 3

Java
   int x = 101;
   int y = 22;
   int answer = x * y;
   System.out.println( answer );

Perl
   $x = 101;
   $y = 22;
   $answer = $x * $y;
   print $answer;

Python
   x = 101
   y = 22
   answer = x * y
   print answer

REBOL
   x: 101
   y: 22
   answer: x * y
   print answer

Scheme
   (define x 101)
   (define y 22)
   (define answer (* x y))
   (display answer)

Again notice that the output of each of these programs is the correct answer:
   2222

You will not see anything like
   x * y
or
   101 * 22
or even
   answer

This is because variables are replaced by their current values and expressions are fully evaluated.

There is not a typo in the Scheme example:
   (* x y)
is the correct way to represent "multiply x by y" in Scheme.

4. Input

One way to get different values into a variable is to have the human operator provide the values - to capture what the operator types at the keyboard (sometimes called standard input or stdin) and assign this operator input to a variable.

Listing 4 shows this in action. Each of these programs wait for the operator to type something and then press the enter key. Whatever was just typed is assigned to the my_message variable, which is then printed to the standard output. This is the chance to get your computer to swear at you.

Listing 4

Java
   BufferedReader in = new Buffered Reader(new
                InputStream Reader(System.in));
   String my_message = in.read
   Line();
   System.out.println( my_message );

Perl
   $my_message = <STDIN>;
   print $my_message;

Python
   my_message = raw_input()
   print my_message

REBOL
   my_message: ask []
   print my_message

Scheme
   (define my_message (read))
   (display my_message)

When these programs run they do absolutely nothing - until the operator types something (or nothing) and presses the enter key. Notice that Perl is very literal - it assigns <STDIN> (that is, standard input) to the variable.

5. Selection

Unless told otherwise, computer programs execute each of their instructions in order from start to finish. The ability to alter this order is called control of flow. Selection is the first of three features that provide control over the flow of programs. (We will look at the other two - repetition and subroutines - in part two of this article.)

The usual means of selection is to make a true or false decision based on a comparison expression. The only values produced by a comparison are true and false (the Boolean values). For example, the expression

Is 10 equal to 5 + 5?

produces the value true. On the other hand, the expression

Is x greater than 0?

is only true for values of x that are positive numbers. If x is currently assigned the value -2, then this comparison produces the result false.

The most common way to make a selection based on a Boolean value is with the IF-THEN-ELSE structure. In human language, it works like this:

In the interests of brevity, programming languages use the shorter word ELSE rather than OTHERWISE (that's a 55% saving in typing effort!).

The result is that different segments of code are run depending on the true or false result of the test condition. Either the "instructions for the positive numbers" are run or the "instructions for the negative numbers" - but never both.

The example in listing 5 combines everything covered so far by simulating a simple password check, as follows:

Listing 5

Java
   BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
   String password = in.readLine();
   if ( password.equals( “fish” ) ) {
      System.out.println( “OK, you’re in.” );
}
else {
      System.out.println( “Sorry, that’s wrong.” );
}

Perl
   chomp( $password = <STDIN> );
   if ( $password eq “fish” ) {
      print “OK, you’re in\n”;
   }
   else {
      print “Sorry, that’s wrong\n”;
   }

Python
   password = raw_input()
   if password == “fish”:
      print “OK, you’re in”
   else:
   print “Sorry, that’s wrong”

REBOL
   password: ask[]
   either password == “fish”
      [print “OK, you’re in”]
      [print “Sorry, that’s wrong”]

Scheme
   (define password (read))
   (if (eqv? password ‘fish)
   (display “OK, you’re in\n”)
   (display “Sorry, that’s wrong\n”))

Reprinted from the April 2004 issue of PC Update, the magazine of Melbourne PC User Group, Australia

[ About Melbourne PC User Group ]