Brief History of Programming

Brief History of Programming

Brief History of Programming

Excerpt from my latest book “UML and Object-Oriented Design Foundations”
Available on Amazon and iTunes.

This Dilbert comic walks us through the history of programming. It’s a bit of an exaggeration, but programming was totally different a couple of decades ago.

Nowadays it is easy to get started with programming. There are various visual tools and sophisticated development environments that make learning fun.

We can program drones and robots, create 3D-games or augmented reality apps. We can achieve all that without having to learn for years. We’re lucky to have all these great tools today.

Initially, computer programs were big, contiguous chunks of code. The unstructured programming was the earliest programming paradigm. The code consisted of sequentially ordered instructions. Each statement would go in a new line. Source code lines were numbered or identified by a label.

Here’s an example written in Sinclair Basic. This simple program converts from Fahrenheit to Celsius degrees:

10 PRINT “Fahrenheit”, “Celsius”


30 INPUT “Enter deg F”, F

40 PRINT F, (F-32)*5/9

50 GO TO 30

As the programs grew in complexity, the drawbacks of this approach had become apparent. Maintaining or even understanding such a code base was challenging. To make any changes or improvements, you had to check the statements line by line.

This task becomes more and more difficult as the number of code lines increases. Non-structured programming was heavily criticized for producing hardly readable, so-called “spaghetti” code.

The term spaghetti code is a pejorative description for complicated, difficult to understand, and impossible to maintain software.

Structured programming emerged in the late 50s. Structured programming languages break down code into logical steps. They rely on subroutines, which contain a set of instructions to be carried out. Here’s an example of a program written in C, which is a procedural language:


int sum(int, int);

int main()
    int x, y;
    int sum;

    printf("Enter the first integer number: ");
    scanf("%d", &x);    
    printf("Enter the second integer number: ");
    scanf("%d", &y);    
    sum = sum(x, y);    

    printf("x: %d, y: %d\n", x, y);
    printf("Sum: %d\n", sum);    

    return 0;

int sum(int x,int y)
    int sum;
    sum = x + y;
    return sum;

The function called main() is the entry point of our program. It calls the sum() function to add the two numbers entered by the user.

We can define additional methods. For example, if we need to calculate the average of the two numbers, we could create a function like this:

float average(float x, float y)
    return (x + y) / 2;

These subroutines operate on variables and data structures. A *variable* represents a value of a given type that can be identified using a name.
int x, y;
float salary;

We use the name of the variable to access the stored value. This lets us modify the value during runtime.

int x = 10 // x has a value of 10
x = 42 // x is now 42
x = x + 1 // x is now 43

A data structure is a way of organizing and storing data in a computer program. Here’s a structure that aggregates the information needed to represent an employee:

struct employee {
    int identifier;
    char name[30];
    float salary;

Structured programming was a significant improvement compared to the monolithic coding practices. Named functions improved the readability of the computer programs. The development time could be reduced substantially.

Even with the improved quality, developers started to face new challenges as the programs got bigger and bigger. Structured programming could not address all the increased complexity.

Object-orientation was the next big step in the evolution of the programming paradigms. Object-oriented languages appeared in the 80s.
The main idea was to split apart the program into self-contained objects. Each object represents a part of the system that gets mapped to a distinct entity. Basically, an object functions as a separate program by itself. It operates on its own data and has a specific role.

The objects that form the system interact with each other. Object-orientation aims to bring the world of programming closer to the real world.

From “UML and Object-Oriented Design Foundations”
Available on Amazon and iTunes.

By | 2018-05-05T07:20:49+00:00 April 28th, 2018|Software development, Uncategorized|0 Comments

About the Author:

Leave A Comment