The development of programming languages is closely linked to the machine language of a computer. As the name suggests, this language contains commands that a machine can execute. This means microprocessors that are installed in a computer (CPU, hard disk control, etc.). These processors obey special machine instructions. They are combined into a binary machine program that the computer can execute command by command. Such programs are difficult for people to read and far more difficult to develop.
To facilitate this development, programming languages, text editors and translation programs were invented. The first such programming language appeared in 1948 and is called assembler language. The programmer writes an assembler program in a text editor and saves it as a text file. The computer cannot yet execute this file directly. This requires an auxiliary program called assembler. It translates the complete file, the so-called source code, into a machine program (see the following figure). Only this (binary) machine program can the computer execute.
The assembler source code is easier to understand than a machine program. It consists of a series of small commands. Only a large number of these commands result in a larger program function. A simple Hello World program is therefore significantly longer than one in a high-level language such as Pascal (see the following figure). It takes a long time to write a large assembler program. It is also tied to a specific processor and is more difficult to read compared to high-level languages such as Pascal. These disadvantages are countered by the fact that assembler programs often run faster with good programming and usually require less main and hard disk space.
Despite the undisputed advantages of the assembler language, its disadvantages were poor readability and maintainability, poor developer productivity and, above all, the dependence on one certain Hardware (microprocessor) so blatant that a few years later, second-generation languages developed. These first high-level languages included Fortran and COBOL. Fortran was developed by IBM in 1954 with the aim of creating a powerful, hardware-independent language for scientific purposes. The name says it all: Fortran is the short form of Formula Translation and describes the core idea of the language very well, the translation of formulas.
While assembler programs are translated into a machine program using an assembler, Fortran uses a so-called compiler for this. The changed name already expresses that this translation program clearly exceeds the scope of services of an assembler. A compiler doesn’t just translate the source code of a high-level language into machine code. He optimizes the program for maximum speed and minimum memory requirements.
In other words, the compiler is designed to generate a highly efficient machine program. Why was that important? At the beginning of the 1950s, the computers at that time only had comparatively weak processors and extremely little storage space compared to today’s computers. If the compilers had not been able to generate highly efficient machine programs, the first higher programming languages would probably not have been adopted as quickly.
The basic idea that led to Fortran also inspired the COBOL programming language at the end of the 1950s. Here too the focus was on hardware independence and the technical problem. In contrast to Fortran, this should not be used to develop scientific, but business management programs, hence the name COBOL.
The abbreviation stands for “Common Business Oriented Language”. COBOL is strongly based on natural language and, compared to Fortran, is designed to process large amounts of data. The language soon became one of the most used programming languages after its introduction and is still widely used today.
The two languages Fortran and COBOL initially had a number of deficits that could only be remedied gradually. They often led to poorly structured and difficult to maintain programs. As the applications became more complex over the years, the developers also needed longer and longer to program, which led to the failure of various projects due to the exceeding of the budget.
The increasing number of failed projects triggered the first software crisis in the mid-1960s. There were various approaches to overcoming this crisis. In addition to improved development processes and the introduction of proven programming libraries, other programming languages were also created that should allow the development of more cost-effective programs.
Above all, the programming languages Pascal and C have to be emphasized. Pascal was developed by Niklaus Wirth in 1971 based on the Algol 68 programming language. The language was initially used less for commercial applications. Instead, it spread widely at universities because it was good for learning structured programming.
Another plus from Pascal is the strict typing. This means that variables are already assigned to a fixed data type during compiler translation, which cannot be changed afterwards. The features of Pascal meant that the programs could be structured more cleanly and errors were avoided right from the start. This promotes the development of easily maintainable, robust programs.
Around the same time as Pascal, Dennis Ritchie developed the programming language at Bell Labs with the minimalist name C. It is based on the predecessor, the programming language B, hence its name. C was created for better programming of the Unix operating system and spread quickly in system programming.
Since C is a universal programming language, the language has also established itself for application development. C programs are tailored to portability and efficiency according to their intended use. Thanks to the simple syntax and the sophisticated compiler, they usually run very quickly. The flip side of the coin are some safety-critical functions that do not exactly facilitate the development of easily maintainable, robust programs.