C++, like a number of other languages, is powerful enough so one can use it to code any task. But in a lot of cases, it's more convenient to code a task in a language that's specifically designed for that task. The situation is analogous to the automobile world: why doesn't everybody drive the same kind of automobile? Because off-road driving is best handled by a four-wheel-drive vehicle, hauling a team of Little Leaguers is best handled in a minivan, etc.

(9.2.1) - FORTRAN

In the first version of FORTRAN, statements could be assigned numbers (instead of labels) and changes in control flow were performed by the IF and GO TO statements.

    IF(NUMBER) 20, 30, 40

      GO TO 50

    while(Number >= 0)
    {
        .
        .
        .
        cin >> Number ;
    }

10    IF(NUMBER) 20, 5, 5
5     .
      .
      .
      READ(*,*) NUMBER
      GO TO 10
20    ...

Later versions of FORTRAN (FORTRAN II, FORTRAN IV, FORTRAN 77, Fortran 90, and High Performance Fortran) have incorporated more data types and new statements to direct the flow of control.

(9.2.2) - COBOL

    sum = a + b;

    ADD A TO B GIVING SUM.

(9.2.3) - C

Like other high-order languages a C program doesn't need to specify the locations of variables in memory, but this is necessary in some system programs so C also has some low-level constructs.

For example, if Number is a variable in a C program then &Number refers to the memory address of Number. If Number is stored in memory location 1000 and has a value of 234 then Number is 234 and &Number is 1000.

Another low-level construct in C is the pointer data type for variables that contain memory addresses. For example,

    int* intPointer ;

    intPointer = (int*) 800 ;

The memory location that intPointer points to is identified by *intPointer so the assignment statement:

    *intPointer = 3 ;

These low-level constructs were put in C so system programs like UNIX can read/write certain specific memory locations used by I/O devices. They are also a source of bugs in non-system programs - for example, location 800 in the C code above may already have some other purpose in this program or in some other program (like the operating system.)

The C++ language we studied in Chapter 8 is a superset of C that was also developed at AT&T Labs - a C++ programmer doesn't need to use the pointer data type and be concerned with all the bugs it might create.

(9.2.4) - Ada

(9.2.5) - Java

• Applications that are complete stand-alone programs like the ones we looked at in Chapter 8; and
• Applets that are small programs that are embedded in Web pages on central servers - when such a page is read by an Java-enabled browser the code is interpreted/executed by the browser itself.

Portability is achieved by compiling the source program into a low-level language called Java bytecode which is easily translated into the machine language of any computer.

(9.2.6) - C# and .NET

The Microsoft .NET Framework is a very large collection of tools for software development in C# and other programming languages.

(9.3.1) - SQL

    SELECT NAME
    FROM VENDOR
    WHERE ZIP = 95082;

(9.3.2) - HTML

(9.3.3) - JavaScript

(9.4.1) - Functional Programming

Any computer program transforms the values of its input data into the values of its outputs. If it produces more than one output, one can group them into a single list containing all the output values. Thus, one can think of any computer program as a mathematical function transforming the values of its arguments (input data) into a corresponding resulting value (a list of all output values.)

In a functional programming language (like Scheme) certain primitive functions are defined as part of the language and the programmer can use these primitives to build other functions.

For example, the tripling function, f (x ) = 3x transforms its argument into a result with three times the value so f (4) = 12 and f (12) = 36. In Scheme one can define this function and give it the name triple with:

    (define (triple x)
        (* 3 x))

As another example, the squaring function, g (x ) = x² can be defined in Scheme and given the name square with:

    (define (square x)
        (* x x))

    (define (foo x)
        (triple (square x)))

Scheme has four primitives that manipulate lists:

• list can have any number of arguments and groups them together into a single list. For example:

      (list 5 6 7)
  

  creates the 3-element list: (5 6 7)

• car takes a nonempty list as its argument and produces the first element of that list. For example, entering:

      (car (list 5 6 7))
  

  produces 5.

• cdr takes a nonempty list as its argument and produces that list without its first element. For example, entering:

      (cdr (list 5 6 7))
  

  produces (6 7).

• null? takes a single list as its argument and evaluates to true if the list is empty or to false if the list is nonempty.

    (define (adder input-list)
        (cond ((null? input-list) 0)
           (else (+ (car input-list) 
               (adder (cdr input-list))))))

• if (null? input-list) is true then adder returns a 0 value; else

• if (null? input-list) is false then adder returns the value of
  (+ (car input-list) (adder (cdr input-list))).

A program written in a procedural language specifies the exact order in which its steps are performed: a program written in a functional language doesn't specify this order. The only restriction on the order of function evaluations is that a function can't be evaluated until all its arguments have been evaluated.

(9.4.2) - Logic Programming

    president(lincoln, gettysburg_address) .
    president(lincoln, civil_war) .
    president(nixon, first_moon_landing) .
    president(jefferson, lewis_and_clark) .
    president(kennedy, cuban_missile_crisis) .
    president(fdr, world_war_II) .

    before(jefferson, lincoln) .
    before(lincoln, fdr) .
    before(fdr, kennedy) .
    before(kennedy, nixon) .

?-before(lincoln, fdr) .

?-president(lincoln,civil_war),before(lincoln,fdr)

    ?-president(lincoln,X).

    X = gettysburg_address
    X = civil_war

precedes(X,Y) :- before(X,Y) .
precedes(X,Y) :- before(X,Z),precedes(Z,Y) .

One can now define another relation to show the time order of events, earlier:

earlier(X,Y) :- president(R,X),president(S,Y),precedes(R,S) .

    X = first_moon_landing
    X = cuban_missile_crisis

(9.4.3) - Parallel Programming

• S I M D stands for Single Instruction Multiple Data. The machine has a single control unit reading instructions from a single instruction stream controlling thousands of separate processing elements with each processing element using its own ALU to operate on its own data in its own memory. There are also some instructions to transfer data between the processing elements.

  Programs for SIMD machines usually have large data arrays. For example, one might declare three data arrays, A, B, and C, with 1000 elements in each array and the statement A = B + C would perform 1000 additions simultaneously to add elements of array B to elements of array C and stores the sums in elements of array A.

• M I M D stands for Multiple Instruction Multiple Data. The machine has a number of processors with each separate processor using its own control unit to read its own instructions from a separate instruction stream and controlling its own ALU to operate on its own data in its own memory. There are also some instructions that a processor can use to communicate with other processors.

  A program for a MIMD machine usually uses the divide-and-conquer approach to break a task up into a number of subtasks and then assign each subtask to a separate processor.