Examine individual changes

[ 0 => '{{Refimprove|date=July 2015}}', 1 => 'In [[computer science]], a '''low-level programming language''' is a [[programming language]] that provides little or no [[Abstraction (computer science)|abstraction]] from a computer's [[instruction set architecture]]—commands or functions in the language map closely to processor instructions. Generally this refers to either [[machine code]] or [[assembly language]]. The word "low" refers to the small or nonexistent amount of [[abstraction (computer science)|abstraction]] between the language and machine language; because of this, low-level languages are sometimes described as being "close to the hardware". Programs written in low-level languages tend to be relatively [[Software portability|non-portable]], mainly because of the close relationship between the language and the hardware architecture.', 2 => 'Low-level languages can convert to machine code without a compiler or interpreter— [[second-generation programming language]]s use a simpler processor called an [[Assembly language#Assemble|assembler]]— and the resulting code runs directly on the processor. A program written in a low-level language can be made to run very quickly, with a small [[memory footprint]]. An equivalent program in a [[high-level language]] can be less efficient and use more memory. Low-level languages are simple, but considered difficult to use, due to numerous technical details that the programmer must remember. By comparison, a [[high-level programming language]] isolates execution semantics of a computer architecture from the specification of the program, which simplifies development. ', 3 => false, 4 => 'Low-level programming languages are sometimes divided into two categories: ''first generation'', and ''second generation''.', 5 => false, 6 => '==Machine code==', 7 => '[[File:Digital pdp8-e2.jpg|thumb|Front panel of a PDP-8/E minicomputer. The row of switches at the bottom can be used to toggle in a machine language program]]', 8 => '[[Machine code]] is the only language a computer can process directly without a previous transformation. Currently, programmers almost never write programs directly in machine code, because it requires attention to numerous details that a high-level language handles automatically. Furthermore it requires memorizing or looking up numerical codes for every instruction, and is extremely difficult to modify.', 9 => false, 10 => 'True ''machine code'' is a stream of raw, usually [[Binary code|binary]], data. A programmer coding in "machine code" normally codes instructions and data in a more readable form such as [[decimal]], [[octal]], or [[hexadecimal]] which is translated to internal format by a program called a [[Loader (computing)|loader]] or toggled into the computer's memory from a [[front panel]].', 11 => false, 12 => 'Although few programs are written in machine language, programmers often become adept at reading it through working with [[core dump]]s or debugging from the front panel. ', 13 => false, 14 => 'Example: A function in hexadecimal representation of 32-bit [[x86]] machine code to calculate the ''n''th [[Fibonacci number]]:', 15 => ' 8B542408 83FA0077 06B80000 0000C383', 16 => ' FA027706 B8010000 00C353BB 01000000', 17 => ' B9010000 008D0419 83FA0376 078BD989', 18 => ' C14AEBF1 5BC3', 19 => false, 20 => '==Assembly==', 21 => 'Second-generation languages provide one abstraction level on top of the machine code. In the early days of coding on computers like the [[TX-0]] and [[PDP-1]], the first thing MIT hackers did was write assemblers.<ref>Levy, Stephen (1994). [[Hackers: Heroes of the Computer Revolution]], Penguin Books. p. 32. ISBN 0-14-100051-1</ref>', 22 => '[[Assembly language]] has little [[Semantics (computer science)|semantics]] or formal specification, being only a mapping of human-readable symbols, including symbolic addresses, to [[opcode]]s, [[memory address|addresses]], numeric constants, [[string (computer science)|strings]] and so on. Typically, one [[machine instruction (computing)|machine instruction]] is represented as one line of assembly code. Assemblers produce [[object file]]s that can [[linker (computing)|link]] with other object files or be [[loader (computing)|loaded]] on their own.', 23 => false, 24 => 'Most assemblers provide [[macro (computer science)|macros]] to generate common sequences of instructions.', 25 => false, 26 => 'Example: The same [[Fibonacci number]] calculator as above, but in x86 assembly language using [[MASM]] syntax:', 27 => '<source lang="asm">', 28 => 'fib:', 29 => ' mov edx, [esp+8]', 30 => ' cmp edx, 0', 31 => ' ja @f', 32 => ' mov eax, 0', 33 => ' ret', 34 => ' ', 35 => ' @@:', 36 => ' cmp edx, 2', 37 => ' ja @f', 38 => ' mov eax, 1', 39 => ' ret', 40 => ' ', 41 => ' @@:', 42 => ' push ebx', 43 => ' mov ebx, 1', 44 => ' mov ecx, 1', 45 => ' ', 46 => ' @@:', 47 => ' lea eax, [ebx+ecx]', 48 => ' cmp edx, 3', 49 => ' jbe @f', 50 => ' mov ebx, ecx', 51 => ' mov ecx, eax', 52 => ' dec edx', 53 => ' jmp @b', 54 => ' ', 55 => ' @@:', 56 => ' pop ebx', 57 => ' ret', 58 => '</source>', 59 => false, 60 => 'In this code example, hardware features of the x86 processor (its [[Processor register|registers]]) are named and manipulated directly. The function loads its input from a precise ___location in the [[Call stack|stack]] (8 bytes higher than the ___location stored in the '''ESP''' stack pointer) and performs its calculation by manipulating values in the '''EAX''', '''EBX''', '''ECX''' and '''EDX''' registers until it has finished and returns. Note that in this assembly language, there is no concept of returning a value. The result having been stored in the '''EAX''' register, the '''RET''' command simply moves code processing to the code ___location stored on the stack (usually the instruction immediately after the one that called this function) and it is up to the author of the calling code to know that this function stores its result in '''EAX''' and to retrieve it from there. x86 assembly language imposes no standard for returning values from a function (and so, in fact, has no concept of a function); it is up to the calling code to examine state after the procedure returns if it needs to extract a value.', 61 => false, 62 => 'Compare this with the same function in C:', 63 => false, 64 => '<source lang="c">', 65 => 'unsigned int fib(unsigned int n) {', 66 => ' if (n <= 0)', 67 => ' return 0;', 68 => ' else if (n <= 2)', 69 => ' return 1;', 70 => ' else {', 71 => ' unsigned int a,b,c;', 72 => ' a = 1;', 73 => ' b = 1;', 74 => ' while (1) {', 75 => ' c = a + b;', 76 => ' if (n <= 3) return c;', 77 => ' a = b;', 78 => ' b = c;', 79 => ' n--;', 80 => ' }', 81 => ' }', 82 => '}', 83 => '</source>', 84 => false, 85 => 'This code is very similar in structure to the assembly language example but there are significant differences in terms of abstraction:', 86 => false, 87 => '* While the input (parameter '''n''') is loaded from the stack, its precise position on the stack is not specified. The C compiler calculates this based on the calling conventions of the target architecture. ', 88 => '* The assembly language version loads the input parameter from the stack into a register and in each iteration of the loop decrements the value in the register, never altering the value in the memory ___location on the stack. The C compiler could do the same or could update the value in the stack. Which one it chooses is an implementation decision completely hidden from the code author (and one with no side effects, thanks to C language standards).', 89 => '* The local variables a, b and c are abstractions that do not specify any specific storage ___location on the hardware. The C compiler decides how to actually store them for the target architecture.', 90 => '* The return function specifies the value to return, but does not dictate ''how'' it is returned. The C compiler for any specific architecture implements a '''standard''' mechanism for returning the value. Compilers for the x86 architecture typically (but not always) use the EAX register to return a value, as in the assembly language example (the author of the assembly language example has ''chosen'' to copy the C convention but assembly language does not require this).', 91 => false, 92 => 'These abstractions make the C code compilable without modification on any architecture for which a C compiler has been written. The x86 assembly language code is specific to the x86 architecture.', 93 => false, 94 => '==Low-level programming in high-level languages==', 95 => 'In the late 1960s, high-level languages such as [[IBM PL/S|PL/S]], [[BLISS]], [[BCPL]], extended [[ALGOL]] (for [[Burroughs large systems]]) and [[C (programming language)|C]] included some degree of access to low-level programming functions. One method for this is [[Inline assembly]], in which assembly code is embedded in a high-level language that supports this feature. Some of these languages also allow architecture-dependent [[Optimizing compiler|compiler optimization directives]] to adjust the way a compiler uses the target processor architecture.', 96 => false, 97 => '== Mixed level language ==', 98 => false, 99 => 'Some languages exhibit a mix of low-level and high-level approaches. The [[C++]] and [[Rust programming language]]s give both low level capabilities and high level abstractions via [[Generic programming|generics/templates]]. As such it is difficult to classify these as high or low level.', 100 => false, 101 => '==Instrinsics==', 102 => 'Modern C and [[C++]] compilers often include support for '''[[Intrinsic function|intrinsics]]''' or '''builtins''' for 'reasonably portable' use of low-level functions such as [[cache control instruction]]s or specific [[SIMD]] operations. Software written using intrinsics can be tuned for a specific machine, and the intrinsics (behaving like functions from the programmers perspective) can still be mapped onto the best available combination of instructions on another architecture.', 103 => false, 104 => '==References==', 105 => '{{reflist}}', 106 => false, 107 => '{{Programming language}}', 108 => '{{X86 assembly topics}}', 109 => false, 110 => '{{DEFAULTSORT:Low-Level Programming Language}}', 111 => '[[Category:Programming language classification]]' ]