Imperative programming

Fortran

Fortran (1958) was unveiled as "The IBM Mathematical FORmula TRANslating system." It was designed for scientific calculations, without string handling facilities. Along with declarations, expressions, and statements, it supported:

• arrays
• subroutines
• "do" loops

It succeeded because:

• programming and debugging costs were below computer running costs
• it was supported by IBM
• applications at the time were scientific.^[3]

However, non-IBM vendors also wrote Fortran compilers, but with a syntax that would likely fail IBM's compiler.^[3] The American National Standards Institute (ANSI) developed the first Fortran standard in 1966. In 1978, Fortran 77 became the standard until 1991. Fortran 90 supports:

• records
• pointers to arrays

COBOL

COBOL (1959) stands for "COmmon Business Oriented Language." Fortran manipulated symbols. It was soon realized that symbols did not need to be numbers, so strings were introduced.^[4] The US Department of Defense influenced COBOL's development, with Grace Hopper being a major contributor. The statements were English-like and verbose. The goal was to design a language so managers could read the programs. However, the lack of structured statements hindered this goal.^[5]

Development of COBOL was tightly controlled, so dialects did not emerge to require ANSI standards. As a consequence, it was not changed for 15 years until 1974. The 1990s version did make consequential changes, like object-oriented programming.^[5]

ALGOL

ALGOL (1960) stands for "ALGOrithmic Language." It had a profound influence on programming language design.^[6] Emerging from a committee of European and American programming language experts, it used standard mathematical notation and had a readable structured design. ALGOL was first to define its syntax using the Backus–Naur form.^[6] This led to syntax-directed compilers. It added features like:

• block structure, where variables were local to their block
• arrays with variable bounds
• "for" loops
• functions
• recursion^[6]

ALGOL's direct descendants include Pascal, Modula-2, Ada, Delphi and Oberon on one branch. On another branch there's C, C++ and Java.^[6]

BASIC

BASIC (1964) stands for "Beginner's All Purpose Symbolic Instruction Code." It was developed at Dartmouth College for all of their students to learn.^[7] If a student did not go on to a more powerful language, the student would still remember BASIC.^[7] A BASIC interpreter was installed in the microcomputers manufactured in the late 1970s. As the microcomputer industry grew, so did the language.^[7]

BASIC pioneered the interactive session.^[7] It offered operating system commands within its environment:

• The 'new' command created an empty slate
• Statements evaluated immediately
• Statements could be programmed by preceding them with a line number
• The 'list' command displayed the program
• The 'run' command executed the program

However, the BASIC syntax was too simple for large programs.^[7] Recent dialects added structure and object-oriented extensions. Microsoft's Visual Basic is still widely used and produces a graphical user interface.^[8]

C

C programming language (1973) got its name because the language BCPL was replaced with B, and AT&T Bell Labs called the next version "C." Its purpose was to write the UNIX operating system.^[9] C is a relatively small language -- making it easy to write compilers. Its growth mirrored the hardware growth in the 1980s.^[9] Its growth also was because it has the facilities of assembly language, but uses a high-level syntax. It added advanced features like:

• inline assembler
• arithmetic on pointers
• pointers to functions
• bit operations
• freely combining complex operators^[9]

C allows the programmer to control in which region of memory data is to be stored. Global variables and static variables require the fewest clock cycles to store. The stack is automatically used for the standard variable declarations. Heap memory is returned to a pointer variable from the malloc() function.

• The global and static data region is located just above the program region. (The program region is technically called the text region. It's where machine instructions are stored.)
  • The global and static data region is technically two regions.^[10] One region is called the initialized data segment, where variables declared with default values are stored. The other region is called the block started by segment, where variables declared without default values are stored.
  • Variables stored in the global and static data region have their addresses set at compile-time. They retain their values throughout the life of the process.
  • The global and static region stores the global variables that are declared on top of (outside) the main() function.^[11] Global variables are visible to main() and every other function in the source code.
• On the other hand, variable declarations inside of main(), other functions, or within { } block delimiters are local variables. Local variables also include formal parameter variables. Parameter variables are enclosed within the parenthesis of function definitions.^[12] They provide an interface to the function.
  • Local variables declared using the static prefix are also stored in the global and static data region.^[10] Unlike global variables, static variables are only visible within the function or block. Static variables always retain their value. An example usage would be the function

    int increment_counter() {
        static int counter = 0;
        counter++; 
        return counter;
    }
    

• The stack region is a contiguous block of memory located near the top memory address.^[13] Variables placed in the stack are populated from top to bottom.^[13] A stack pointer is a special-purpose register that keeps track of the last memory address populated.^[13] Variables are placed into the stack via the assembly language PUSH instruction. Therefore, the addresses of these variables are set during runtime. The method for stack variables to lose their scope is via the POP instruction.
  • Local variables declared without the static prefix, including formal parameter variables,^[14] are called automatic variables^[11] and are stored in the stack.^[10] They are visible inside the function or block and lose their scope upon exiting the function or block.
  • The heap region is located below the stack.^[10] It is populated from the bottom to the top. The operating system manages the heap using a heap pointer and a list of allocated memory blocks.^[15] Like the stack, the addresses of heap variables are set during runtime. An out of memory error occurs when the heap pointer and the stack pointer meet.
  • C provides the malloc() library function to allocate heap memory.^[16] Populating the heap with data is an additional copy function. Variables stored in the heap are economically passed to functions using pointers. Without pointers, the entire block of data would have to be passed to the function via the stack.

C++

In the 1970s, software engineers needed language support to break large projects down into modules.^[17] One obvious feature was to decompose large projects physically into separate files. A less obvious feature was to decompose large projects logically into abstract datatypes.^[17] At the time, languages supported concrete (scalar) datatypes like integer numbers, floating-point numbers, and strings of characters. Concrete datatypes have their representation as part of their name.^[18] Abstract datatypes are structures of concrete datatypes — with a new name assigned. For example, a list of integers could be called integer_list.

In object-oriented jargon, abstract datatypes are called classes. However, a class is only a definition; no memory is allocated. When memory is allocated to a class, it's called an object.^[19]

Object-oriented imperative languages developed by combining the need for classes and the need for safe functional programming.^[20] A function, in an object-oriented language, is assigned to a class. An assigned function is then referred to as a method, member function, or operation. Object-oriented programming is executing operations on objects.^[21]

Object-oriented languages support a syntax to model subset/superset relationships. In set theory, an element of a subset inherits all the attributes contained in the superset. For example, a student is a person. Therefore, the set of students is a subset of the set of persons. As a result, students inherit all the attributes common to all persons. Additionally, students have unique attributes that other persons don't have. Object-oriented languages model subset/superset relationships using inheritance.^[22] Object-oriented programming became the dominant language paradigm by the late 1990s.^[17]

C++ (1985) was originally called "C with Classes".^[23] It was designed to expand C's capabilities by adding the object-oriented facilities of the language Simula.^[24]

An object-oriented module is composed of two files. The definitions file is called the header file. Here is a C++ header file for the GRADE class in a simple school application:

// grade.h
// -------

// Used to allow multiple source files to include
// this header file without duplication errors.
// See: https://en.wikipedia.org/wiki/Include_guard
// ----------------------------------------------
#ifndef GRADE_H
#define GRADE_H

class GRADE {
public:
    // This is the constructor operation.
    // ----------------------------------
    GRADE ( const char letter );

    // This is a class variable.
    // -------------------------
    char letter;

    // This is a member operation.
    // ---------------------------
    int grade_numeric( const char letter );

    // This is a class variable.
    // -------------------------
    int numeric;
};
#endif

A constructor operation is a function with the same name as the class name.^[25] It is executed when the calling operation executes the new statement.

A module's other file is the source file. Here is a C++ source file for the GRADE class in a simple school application:

// grade.cpp
// ---------
#include "grade.h"

GRADE::GRADE( const char letter )
{
    // Reference the object using the keyword 'this'.
    // ----------------------------------------------
    this->letter = letter;

    // This is Temporal Cohesion
    // -------------------------
    this->numeric = grade_numeric( letter );
}

int GRADE::grade_numeric( const char letter )
{
    if ( ( letter == 'A' || letter == 'a' ) )
        return 4;
    else
    if ( ( letter == 'B' || letter == 'b' ) )
        return 3;
    else
    if ( ( letter == 'C' || letter == 'c' ) )
        return 2;
    else
    if ( ( letter == 'D' || letter == 'd' ) )
        return 1;
    else
    if ( ( letter == 'F' || letter == 'f' ) )
        return 0;
    else
        return -1;
}

Here is a C++ header file for the PERSON class in a simple school application:

// person.h
// --------
#ifndef PERSON_H
#define PERSON_H

class PERSON {
public:
    PERSON ( const char *name );
    const char *name;
};
#endif

Here is a C++ source file for the PERSON class in a simple school application:

// person.cpp
// ----------
#include "person.h"

PERSON::PERSON ( const char *name )
{
    this->name = name;
}

Here is a C++ header file for the STUDENT class in a simple school application:

// student.h
// ---------
#ifndef STUDENT_H
#define STUDENT_H

#include "person.h"
#include "grade.h"

// A STUDENT is a subset of PERSON.
// --------------------------------
class STUDENT : public PERSON{
public:
    STUDENT ( const char *name );
    ~STUDENT();
    GRADE *grade;
};
#endif

Here is a C++ source file for the STUDENT class in a simple school application:

// student.cpp
// -----------
#include "student.h"
#include "person.h"

STUDENT::STUDENT ( const char *name ):
    // Execute the constructor of the PERSON superclass.
    // -------------------------------------------------
    PERSON( name )
{
    // Nothing else to do.
    // -------------------
}

STUDENT::~STUDENT() 
{
    // deallocate grade's memory
    // to avoid memory leaks.
    // -------------------------------------------------
    delete this->grade;
}

Here is a driver program for demonstration:

// student_dvr.cpp
// ---------------
#include <iostream>
#include "student.h"

int main( void )
{
    STUDENT *student = new STUDENT( "The Student" );
    student->grade = new GRADE( 'a' );

    std::cout 
        // Notice student inherits PERSON's name
        << student->name
        << ": Numeric grade = "
        << student->grade->numeric
        << "\n";

    // deallocate student's memory
    // to avoid memory leaks.
    // -------------------------------------------------
    delete student;

	return 0;
}

Here is a makefile to compile everything:

# makefile
# --------
all: student_dvr

clean:
    rm student_dvr *.o

student_dvr: student_dvr.cpp grade.o student.o person.o
    c++ student_dvr.cpp grade.o student.o person.o -o student_dvr

grade.o: grade.cpp grade.h
    c++ -c grade.cpp

student.o: student.cpp student.h
    c++ -c student.cpp

person.o: person.cpp person.h
    c++ -c person.cpp