Data are the physical symbols that represent information. Inside a computer, both data and instructions are just binary bit patterns. The computer executes an instruction because the address of the instruction is loaded into the program counter and the instruction is then loaded into the instruction register. The same bit pattern that is executed can also represent an integer number, a real number, a character, or a Boolean value. The key is that the computer interprets the bit pattern to be what it expects it to be.

For example, in Pep/9 the instruction for Stop is a byte of all zero bits. When this instruction is loaded into the instruction register, the program halts. A byte of all zero bits can also be interpreted as an 8-bit binary number containing the value 0 (zero). If the location containing all zero bits is added to the contents of a register, the value is interpreted as a number.

Most high-level languages have four distinct data types built into the language: integer numbers, real numbers, characters, and Boolean values.

The integer data type represents a range of integer values, from the smallest to the largest. The range varies depending on how many bytes are assigned to represent an integer value. Some high-level languages provide several integer types of different sizes, which allows the user to choose the one that best fits the data in a particular problem.

The operations that can be applied to integers are the standard arithmetic and relational operators. Addition and subtraction are represented by the standard symbols + and −. Multiplication and division are usually represented by * and /. Depending on the language, integer division may return a real number or the integer quotient. Some languages have two symbols for division: one that returns a real result and one that returns the integer quotient. Most languages also have an operator that returns the integer remainder from division. This operator is called the modulus operator, but it may or may not act as the mathematical modulus operator. The relational operators are represented by the symbols shown in the table in the previous section.

The real data type also represents a range from the smallest to the largest value with a given precision. Like the integer data type, the range varies depending on the number of bytes assigned to represent a real number. Many high-level languages have two sizes of real numbers. The operations that can be applied to real numbers are the same as those that can be applied to integer numbers. However, you must be careful when applying the relational operators to real values, because real numbers are often not exact. For example, 1/3 + 1/3 + 1/3 in computer arithmetic is not necessarily 1.0. In fact, 1/10 * 10 is not 1.0 in computer arithmetic.

In Chapter 3, we said that a mapping of the ASCII character set to code requires only one byte. One commonly used mapping for the Unicode character set uses two bytes. In this mapping, our English alphabet is represented in ASCII, which is a subset of Unicode. Applying arithmetic operations to characters doesn’t make much sense, and many strongly typed languages will not allow you to do so. However, comparing characters does make sense, so the relational operators can be applied to characters. The meanings of “less than” and “greater than,” when applied to characters, are “comes before” and “comes after,” respectively, in the character set. Thus the character ‘A’ is less than ‘B’, ‘B’ is less than ‘C’, and so forth. Likewise, the character ‘1’ (not the number) is less than ‘2’, ‘2’ is less than ‘3’, and so forth. If you want to compare ‘A’ to ‘1’, you must look up the relationship between these two characters in the character set you are using.

As we said in the previous section, the Boolean data type consists of two values: true and false. We can also assign a Boolean expression to a Boolean variable. Here is the pairs program using Boolean variables:

Integers, reals, characters, and Booleans are called simple or atomic data types, because each value is distinct and cannot be subdivided into parts. In the last chapter, we discussed composite data types—that is, data types made up of a collection of values. The string data type has some of the properties of a composite type but is often considered a simple data type.

A string is a sequence of characters that in some languages can be considered as one data value. For example,

“This is a string.”

is a string containing 17 characters: 1 uppercase letter, 12 lowercase letters, 3 blanks, and a period. The operations defined on strings vary from language to language, but often include a concatenation of strings and a comparison of strings in terms of lexicographic order. Other languages provide a complete array of operations, such as taking a substring of a given string or searching a given string for a substring.

Note that we have used single quotes to enclose characters and double quotes to enclose strings. Some high-level languages use the same symbol for both, thus not distinguishing between a character and a string with one character.

A declaration is a language statement that associates an identifier with a variable, an action, or some other entity within the language that can be given a name so that the programmer can refer to that item by name. In this section we discuss how a variable is declared. Later we look at how actions are given names.

These examples illustrate some differences among high-level languages. For example, VB .NET uses a reserved word to signal a declaration. A reserved word is a word in a language that has special meaning; it cannot be used as an identifier. Dim is a reserved word in VB .NET used to declare variables. C++ and Java do not use a reserved word for this purpose.

C++ and Java use the semicolon to end a statement in the language. VB .NET uses the end of the line or the comment symbol to end the statement. Python programs do not require declarations because Python is not a strongly typed language. Python uses the pound sign (#) as the beginning of a comment that extends to the end of the line. Recall that Pep/9 uses a semicolon to signal that what follows is a comment.

C++, Java, Python, and VB .NET are case sensitive, which means that two copies of the same identifier, when capitalized differently, are considered different words. Thus, Integer, INTEGER, InTeGeR, and INTeger are considered four different identifiers in case-sensitive languages. C++, Java, and VB .NET have a collection of type names for various sizes of integer and real numbers. Although Python does not declare identifiers, it does have the reserved words long, int, float, and bool.

Are these differences important? They are if you are writing a program in one of these languages. However, they are just syntactic issues— that is, different ways of doing the same thing. The important concept is that an identifier is associated with a place in memory and may or may not be associated with a data type. In the exercises, we ask you to compare the syntactic differences that surface in these examples.

The use of uppercase and lowercase in identifiers is part of the culture of a language. In our examples, we have tried to stick with the style that is common within the language’s culture. For example, most C++ programmers begin variable names with lowercase and subprograms with uppercase, while VB .NET programmers tend to begin variable names with uppercase letters.

The statements to be executed or skipped in any control statement can be simple statements or blocks (compound statements)—there is no constraint on what these statements can be. In fact, the statement to be skipped or repeated can contain a control structure. Selection statements can be nested within looping structures; looping structures can be nested within selection statements. Selection and looping statements can be nested within subprograms, and subprogram calls can be nested within looping or selection structures.

We have looked at nesting in our algorithms, but the topic is worth another look. Take, for example, the algorithm that counts and sums ten positive numbers in a file:

The selection control structure is embedded within a looping control structure. If we wanted to sum and print weekly rainfall figures for a year, we would have the following nested looping structures:

Control structures within control structures within control structures . . . Theoretically, there is no limit to how deeply control structures can be nested! However, if the nesting becomes too difficult to follow, you should give the nested task a name and make it a subprogram, giving its implementation later. For example, examine the alternative version of the preceding pseudocode algorithm. Which is easier to follow?

You have likely grown up using a graphical user interface (GUI) that relies on the use of a mouse to manipulate multiple window frames on a screen. Clicking has become a major form of input to the computer. In fact, for many applications, filling in boxes and clicking buttons to say the input is ready has become the only form of input.

In traditional stream processing, an input statement is executed in the sequence in which it is encountered. Here are the first four statements in the algorithm shown earlier:

We expect these statements to be executed in sequence. Output is written to a window, a value is read from the input stream, another value is stored, and the while loop is executed. Stream input and output is within the sequential flow of the program.

Mouse clicking, in contrast, does not occur within the sequence of the program. That is, a user can click a mouse at any time during the execution of a program. The program must recognize when a mouse click has occurred, process the mouse click, and then continue. This type of processing is called asynchronous, which means “not at the same time.” The mouse can be clicked at any time; it is not synchronized with any other instructions.

Asynchronous processing is also called event-driven processing. In other words, the processing is under the control of events happening outside the sequence of program instructions.

Asynchronous processing is used frequently in Java and VB .NET but less often in the other languages.