First-generation programming language
From Wikipedia, the free encyclopedia
A first-generation programming language is a machine-level programming language.
Originally, no translator was used to compile or assemble the first-generation language. The first-generation programming instructions were entered through the front panel switches of the computer system.
The main benefit of programming in a first-generation programming language is that the code a user writes can run very fast and efficiently, since it is directly executed by the CPU. However, machine language is somewhat more difficult to learn than higher generational programming languages, and it is far more difficult to edit if errors occur. In addition, if instructions need to be added into memory at some location, then all the instructions after the insertion point need to be moved down to make room in memory to accommodate the new instructions. Doing so on a front panel with switches can be very difficult. Furthermore, portability is significantly reduced - in order to transfer code to a different computer it needs to be completely rewritten since the machine language for one computer could be significantly different from another computer. Architectural considerations make portability difficult too. For example, the number of registers on one CPU architecture could differ from those of another.
[edit] Current uses
Though 1GL is typically used only with first generation computers, machine level programming still finds a use in several areas of modern programming. All native-code compilers create machine language. This is done without user interaction, usually from a higher-level language such as Fortran, C/C++ or Pascal, often with intermediate byte code or assembly code.
Occasionally, IBM Mainframe software fixes are distributed in the form of ZAPs, which are bare machine code distributed as hexadecimal text. They are applied using a utility program, the latest incarnation is called AMASPZAP though it is still often referred to under its previous name of SUPERZAP.[1] Thus, the creation of a zap is 1st generation programming.
Another use is for so-called virtual machines. In essence, each virtual machine just creates a translation bridge between machine code and byte code. The byte code is the same across all platforms and the translator module of the virtual machine then translates just-in-time each byte to the corresponding native machine instruction.
Computer viruses often inject code in a certain spot in memory. When tracing the logs of a web server, one may find several entries of very long urls. Often, the encoded part of the url is equal to a certain set of machine level instructions which an attacker hopes will be executed on the server. It is notoriously hard to create such pieces of code, unless the coder makes use of assemble and disassemble helper programs.
From the time that personal computers were introduced and continuing until GUI operating systems replaced DOS operating systems in the early to mid 90s, code-injection was sometimes used to extend programming languages like the C programming language or interpreted BASIC and later interpreted QBasic on the IBM-PC.
Interpreted BASIC had no means of inserting assembly code or to link to libraries made by other languages.
One way of extending interpreted BASIC was by using the BLOAD (Binary Load) instruction. One was able to inject machine instructions in memory and then execute them (by using the CALL ABSOLUTE statement in IBM BASIC). The opposite instruction was BSAVE, with which any part of computer memory could be retrieved. These commands were, however, more commonly used for saving and loading graphics in the BSAVE (graphics image format).
Besides being unportable, like any low-level programming of the day in assembly language, this way of coding needed to be done carefully. If the incorrect instruction was typed by a programmer, there was potential for damaging equipment and data.
|
|||||
