# assembly language

> any low-level programming language in which there is a very strong correspondence between the instructions in the language and the architecture's machine code instructions

**Wikidata**: [Q165436](https://www.wikidata.org/wiki/Q165436)  
**Wikipedia**: [English](https://en.wikipedia.org/wiki/Assembly_language)  
**Source**: https://4ort.xyz/entity/assembly-language

## Summary  
Assembly language is a low-level programming language with a near one-to-one correspondence between its instructions and a computer's machine code. It provides minimal abstraction from hardware, making it highly specific to processor architectures. Developed in 1949, it remains critical for performance-sensitive and hardware-level programming tasks.

## Key Facts  
- **Inception**: 1949 ([reference](https://en.wikipedia.org/wiki/Assembly_language))  
- **Instance of**: Programming language  
- **Subclass of**: Non-structured programming language, low-level programming language  
- **File extensions**: `.asm`, `.s` ([reference](https://cs.lmu.edu/~ray/notes/x86assembly/))  
- **Programming paradigm**: Non-structured programming  
- **Notable derivatives**: GNU assembler  
- **Aliases**: ASM, assembler language, Maschinensprache, アセンブラ  
- **GND ID**: 4003255-3 ([reference](https://d-nb.info/gnd/4003255-3))  
- **YSO ID**: 7766 ([reference](https://finto.fi/yso/en/page/p7766))  

## FAQs  
### Q: What is the difference between assembly language and machine code?  
A: Assembly language uses human-readable mnemonics (e.g., `MOV`, `ADD`) to represent machine code instructions, which are binary numbers. An assembler translates assembly into executable machine code.  

### Q: Why is assembly language still used today?  
A: It is used for performance-critical tasks (e.g., firmware, device drivers), reverse engineering, and optimizing high-level code where hardware control is essential.  

### Q: Is assembly language portable across different processors?  
A: No, assembly is architecture-specific (e.g., x86, ARM, Z80). Code written for one processor family must be rewritten for another.  

## Why It Matters  
Assembly language bridges the gap between human-readable code and machine-executable instructions, enabling precise hardware control. It is foundational for systems programming, embedded systems, and performance optimization. While high-level languages dominate general-purpose programming, assembly remains indispensable for tasks requiring minimal overhead, such as operating system kernels, real-time systems, and cryptographic algorithms. Its direct mapping to machine code allows developers to exploit hardware features that higher-level abstractions may obscure. Historically, it revolutionized early computing by making machine code more accessible, and it continues to play a vital role in education, security research, and low-resource environments.  

## Notable For  
- **Low-level control**: Offers direct manipulation of CPU registers and memory.  
- **Performance**: Eliminates compiler overhead, enabling optimized execution.  
- **Architecture specificity**: Tailored to processor instruction sets (e.g., x86, ARM).  
- **Historical significance**: Pioneered symbolic programming in the late 1940s.  
- **Educational value**: Teaches fundamental computer architecture concepts.  

## Body  
### History  
- **1949**: First developed as symbolic machine code ([reference](https://en.wikipedia.org/wiki/Assembly_language)).  
- **1966**: ASSIRIS, an early assembly language for Iris 50 and Felix C platforms, emerged.  

### Variants  
- **x86 assembly**: Widely used in Intel/AMD processors ([sitelink count: 21](https://www.wikidata.org/wiki/Q28920085)).  
- **Z80 Assembly**: For Zilog Z80 8-bit CPUs ([sitelink count: 2](https://www.wikidata.org/wiki/Q8068075)).  
- **ARM Assembly**: For ARM architecture processors.  
- **Redcode**: Virtual assembly for Core War game ([sitelink count: 3](https://www.wikidata.org/wiki/Q3427413)).  

### Technical Details  
- **Non-structured**: Lacks high-level control constructs (e.g., loops, functions).  
- **Inline assemblers**: Embedded in high-level languages (e.g., C/C++) ([sitelink count: 11](https://www.wikidata.org/wiki/Q603385)).  

### Modern Use Cases  
- **Firmware**: BIOS, bootloaders.  
- **Reverse engineering**: Analyzing malware or proprietary software.  
- **Optimization**: Hand-tuning critical code sections.  

## Schema Markup  
```json
{
  "@context": "https://schema.org",
  "@type": "Thing",
  "name": "Assembly language",
  "description": "A low-level programming language with strong correspondence to machine code instructions.",
  "sameAs": [
    "https://www.wikidata.org/wiki/Q28920085",
    "https://en.wikipedia.org/wiki/Assembly_language"
  ],
  "additionalType": "ProgrammingLanguage"
}

## References

1. Freebase Data Dumps. 2013
2. Integrated Authority File
3. [Source](https://cs.lmu.edu/~ray/notes/x86assembly/)
4. YSO-Wikidata mapping project
5. Quora
6. National Library of Israel
7. [OpenAlex](https://docs.openalex.org/download-snapshot/snapshot-data-format)