Skip to content

Language Evolution

Estimated time to read: 3 minutes

As with many things in our lives, we have to adapt language to meet our needs. Language has evolved over the many years of human existence.

Programming languages evolved in a similar fashion as traditional languages. Each new programming language was developed to provide solutions to problems that previous languages were unable to adequately address. Over the years, ideas used in computer languages have caused a shift in programming paradigms. We needed to change the way in which programs were written in order to address the latest problems more effectively.

COLBOL, FORTRAN and Imperative Paradigms

COBOL and FORTRAN followed an imperative paradigm which broke up large problems into smaller programmes called subroutines, which are like methods in Java.

Global Data

In the 1960s, computer processing time was costly. As a result, it was important to maximise processing performance.

This was accomplished by having global data because they are all located in one place in the computer's memory for a program.

With globally accessible variables, all the subroutines would be able to access them to do their necessary calculations. With global data, it was possible that changes in the data could have side effects on the program. Sometimes, a subroutine would run into cases where the global data was not as expected.

Algol 68, Pascal and the Introduction of Local Variables

The need for better data management led to changes to imperative programming and the rise of languages like Algol 68 and Pascal in the 1970s. The idea of local variables was introduced. Subroutines were called procedures which could contain nested procedures. And each one could have their own variables. Algol 68 and Pascal support the notion of an abstract data type.

Abstract Data Type

Abstract Data Type is a data type that is defined by the programmer and not built into the language. An abstract data type is essentially a grouping of related information that is denoted with a type. It was a a way of organising data in a meaningful way.

By having variables in different scopes, data can be compartmentalised into different procedures. This way, a procedure can be the only one that can modify that piece of data, allowing Ted to put it in the local scope and not have to worry about it being changed by another procedure.

C and Modula-2 as Modular Programming Languages

New languages arose such as C and Modula-2 that provided a means to organise programs and allow developers to more easily create multiple but unique copies of their abstract data types. Programs could now be organised into separate files.

In C, each file contained all the associated data and functions that manipulated it and it declared what could be accessed through a separate file called the Header File.

There are still issues that are not addressed in any of the languages we've looked at so far. These languages do not make it easy for an abstract data type to inherit from another. That means that Ted can define as many data types as he wants but cannot declare that one type is an extension of another type.

The Present - Object-Oriented Design Programming

The goal of object-oriented design is to:

  • Make an abstract data type easier to write
  • Structure a system around abstract data types called classes
  • Introduce the ability for an abstract data type to extend another, by introducing 'inheritance' as a concept

This drives a software system that is made up of entirely abstract data types. The advantage of this is that the system will mimic the structure of the problem, meaning that any object-oriented program is capable of representing real world objects or ideas with more fidelity.

Class files replace the standard files in C and Modula-2. Each class defines a type with associated data and functions. These functions are also known as methods.

A class acts like a factory, making individual objects, all of a specific type.

This allows compartmentalisation of the data and how it can be manipulated in their own separate classes. Object-Oriented Programming is the predominant programming paradigm. Popular modern languages such as Java, C++ and C# are all founded based on objects.