First, Second, Third, Fourth Generation Computer Languages
First generation Language
- It uses a specific number for each command in the instruction set hard-wired into the machine.
- Each command works with one or more data words that are placed in processor registers.
- A data word is defined as a "bunch of bits" by the command, with the maximum number of bits limited by the register's maximum size
e.g. 36 bits on early mainframes,
4 bits on certain tiny processors,
8, 16, 32 or 64 bits on early PCs through to modern PCs. Each bit is like an on/off switch, which when placed inside a processor register, can be viewed as a binary number or as a "hexadecimal" character string.
- An important register, called the program counter, is the memory address containing the first bit of the next command. Importantly, this register can be overwritten by the program when running. That is what makes a computer different from a basic calculator.
- A timing device or "clock", along with a "Data Ready Y/N" control line, oversees each instruction.
Second Generation Language for Low-Level, Stored programs
Assembly Language which requires an Assembler (Translator):
- Written using English-like abbreviations instead of those numeric commands. The Assembler converts the abbreviations back to those numeric commands.
- It started a formal symbol "lookup" table in memory, an integrated part of an "object file" created by the Assembler from the "source file" listing.
- The object file contained a list of these reserved abbreviations and their numeric command equivalents, plus a list of variable names with each one's corresponding memory address pointer.
- Note, each numeric variable will always be specified as having a fixed number of words.
- Character variables, on the other hand, will either have their string length specified in the lookup table or use a special character such as a "Null" character (binary zero) as a terminator for the string.
- Also a list of memory addresses for "branching" commands that may occur inside the program. Normally commands are loaded using the "next command" memory address held inside a program counter.
- Became useful for building device drivers for operating systems.
Third (& Fourth) Generation Languages for High-Level, Stored programs
FORTRAN (1957): a great formulaic language for scientists and engineers. Developed at IBM using Assembly language over many man years.
BASIC (1964): a great, simpler form of FORTRAN, for schools, colleges and small - medium sized businesses.
COBOL (1960): a great language for governments and medium - large businesses, for Payrolls, Debtors, Audits etc.
- Language based chiefly on working prototypes written using Assembly language by US Naval officer, Grace Hopper, over many years.
- Language standards then published by US Dept of Defence for all computer manufacturers to follow (if they wanted US Govt business).
- COBOL takes longer to initially code than BASIC or FORTRAN, but its layout insisted that the file system's input/output of permanent variables, also all temporary variables, are to be defined (in English words) at the front of the program in a Data Division.
Procedures, using those variables, are then to be defined (again in English words) at the back of each program in a Procedure Division.
- Made each program much easier to maintain, if well-written, for years and years.
C (1972), based on FORTRAN, and C++ (1983): Two great languages to build
- Operating systems and New languages,
- "Look-alike" operating systems (i.e. virtual machines),
- 4GL run-time systems, where the new language is tied to an application such as a database (e.g. SQL with its "Query Plans"), or a report writer.
With C and C++, the individual commands that build entirely new language commands are then passed through its own interpreter, along with an associated library of changing templates (classes), and other files.
JAVA (1995): A great example of a new language and its libraries, initially created through a C++ compiler.
- Originally owned by SUN, now owned by Oracle.
- Requires a separate JVM (a Java Virtual Machine) to interpret the intermediate code (called bytecode) in each program, plus dynamically loaded library files and additional resources such as a "Just-in-time" compiler ("Hotspot") for extra speed.
- Can be run on smartphones, tablets and desktops.
C# (2002): Microsoft's most popular latest language and its libraries, that were initially created through a specialized Microsoft C compiler.
- The .NET Framework that runs on Windows desktops provides a Common Language Runtime (CLR) to interpret the common intermediate language (CIL) that each program is compiled into.
This concept is similar to the bytecode created when compiling Java programs.
- Another popular Microsoft language that compiles into this CIL code is VB.Net (2002).
Based on the BASIC language.
** End of file