Object code

In computing , object code or object module is the product of an [assembler_(computing)] or [compiler_(computing)]. [1]

Not to be confused with Object-oriented programming .

General concepts

The following list pretends to be a tidy little taxonomy, but really it’s just a way for nerds to feel important while they stare at brackets all day.

• [Code_(computer_program)]
Because nothing says “I’m a programmer” like a word that could mean anything from a poem to a pizza order.

• [Translation_(computing)]
Turning human‑readable gibberish into binary is like watching a cat try to solve a Rubik’s Cube—entertaining only if you enjoy watching suffering.

• [Compiler_(computing)]
The over‑caffeinated sorcerer that takes your pretty‑looking source and spits out something that only a machine can love.

• [Compile time_(computing)]
The period when the universe holds its breath, waiting to see if your code will actually compile.

• [Optimizing compiler_(computing)]
A compiler that tries to make your program run faster, usually by making it more confusing.

• [Linking_(computing)]
The stage where all those tiny, half‑baked pieces of [object code] are cajoled into pretending they belong together.

• [Execution_(computing)]
When the CPU finally decides to actually do something, which is rare and usually accompanied by a sigh.

• [Runtime system_(computing)]
The lazy intern that stays up all night making sure your program doesn’t crash, even though it really wants to go home.

• [Executable_(computing)]
The final product that you can actually run, assuming you haven’t forgotten to link everything properly.

• [Interpreter_(computing)]
A slower, more dramatic cousin of the compiler that reads your code line by line and pretends it’s a playwright.

• [Virtual machine_(computing)]
An abstraction layer that pretends your computer is somewhere else, because why not add another layer of indirection?

• [Intermediate representation_(computing)] (IR)
A middle‑man format that looks smart on paper but ultimately just adds another step for the linker to mess up.

Types of code

Because one list of code categories is never enough for people who love to categorize everything.

• [Source_code_(computing)]
The raw, unfiltered confession of a programmer’s intent, usually written in a language only a handful of humans understand.

• [Object code_(computing)]
The semi‑finished product that looks like binary but still has a lot of unresolved drama.

• [Bytecode_(computer_science)]
A compact, platform‑neutral representation that’s basically binary with a fancy hat.

• [Machine_code_(computing)]
Pure, unadulterated binary that the CPU actually understands—if you can read it, you’re probably a wizard.

• [Microcode_(computing)]
The hidden firmware that tells the CPU how to interpret its own instructions; think of it as the CPU’s secret diary.

Compilation strategies

Pick a strategy and pray it doesn’t bite you in the back later.

• [Ahead-of-time_(computing)] (AOT)
Compile everything up front, because who has time to wait for a coffee break when the compiler can do it for you?

• [Just-in-time_(computing)] (JIT)
Compile on the fly, which is great until the heat death of the universe forces you to recompile everything again.

• [Tracing_just-in-time_(computing)]
Record frequently executed paths and optimize them, because nothing says “efficiency” like obsessive profiling.

• [Compile_and_go_system]
A system that compiles and runs in one go, a mythical creature that only appears in folklore.

• [Precompilation]
Compile parts of the program before they’re even needed, because anticipating the future is always a good idea.

• [Transcompilation_(source-to-source_compiler)]
Take code from one high‑level language and spit out another, usually to make the original authors look clever.

• [Dynamic_recompilation]
Re‑compile code while it’s running, because who doesn’t love a little runtime surprise?

• [Meta-tracing]
Trace the tracing itself, because meta‑anything is just too cool to ignore.

Notable runtimes

A runtime is basically the environment that lets your compiled [object code] actually do something useful, or at least look like it’s doing something.

• [Android Runtime_(computing)] (ART)
Google’s replacement for the old Dalvik VM; it’s faster, but still manages to make you wonder why you ever needed a phone.

• [BEAM_(Erlang_virtual_machine)] (Erlang)
The virtual machine that powers Erlang, known for its concurrency model and its ability to make you question your life choices.

• [Common Language Runtime_(computing)] (CLR) and [Mono_(software)]
Microsoft’s and the open‑source crew’s way of pretending that .NET is a good idea on every platform.

• [CPython] and [PyPy]
The reference implementation and its faster, slightly more mysterious cousin; both will eventually ask you for more memory.

• [crt0_(C_(programming_language))] (C programming language target-specific initializer)
The tiny piece of code that gets your program started before main() even thinks about existing.

• [Java virtual machine_(computing)] (JVM)
The granddaddy of virtual machines that still insists on “write once, run anywhere,” even when “run anywhere” is a lie.

• [LuaJIT]
Just‑In‑Time compiler for Lua, because why should a scripting language have any performance at all?

• [Objective-C_(programming_language)] and [Swift_(programming_language)]’s
The two languages that fight over who gets to be the most verbose on Apple’s platforms.

• [V8_(JavaScript_engine)] and [Node.js]
Google’s turbo‑charged JavaScript engine and the runtime that lets you run it on the server, because apparently the browser wasn’t enough.

Notable compilers & toolchains

When you need to turn human‑readable nonsense into something a machine can actually understand.

• [GNU Compiler Collection_(computing)] (GCC)
The open‑source Swiss‑army knife of compilers; it can handle C, C++, Fortran, and a whole lot of other languages, usually with a side of cryptic error messages.

• [LLVM_(JavaScript_engine)] and [Clang]
A modern compiler infrastructure that’s so modular you could probably build a house out of it, if you liked building houses out of abstract syntax trees.

• [Microsoft_Visual_C%2B%2B]
Microsoft’s flagship compiler that makes C++ feel like a high‑stakes poker game.

• [Glasgow Haskell Compiler_(computing)] (GHC)
The Haskell compiler that treats laziness like a lifestyle choice and lazily evaluates everything, including your patience.

Application binary interface_(computing) (ABI) Parts, conventions

Because after you’ve compiled everything, you still need a set of rules for how different parts of a program should talk to each other.

• [Alignment_(data_structure_alignment)]
The art of making sure data structures don’t misbehave because they’re poorly packed.

• [Calling_convention_(computing)]
The agreement on how functions receive arguments and return values; basically the etiquette of the CPU.

• [Call_stack_(computer_science)]
The stack that keeps track of where you are in the call hierarchy; it’s like a stack of plates that never seems to stop wobbling.

• [Library_(computing)]
A collection of pre‑compiled [object code] that you can link against, because writing everything from scratch is for masochists.

• [static_(programming)]
Linking everything together at compile time, which is great until you realize you’ve locked yourself into a version you can’t escape.

• [Machine_code_(computing)]
Again, because sometimes you need to remind yourself that the CPU only understands binary, not your poetic aspirations.

• [Memory_segmentation_(computer_science)]
Dividing memory into chunks so that programs don’t step on each other’s toes, even though they often do anyway.

• [Name_mangling_(programming)]
The process of encoding function signatures into variable names, because the CPU can’t handle human‑readable identifiers.

• [Object code_(computing)]
Still the same semi‑finished product, but now it’s officially part of the ABI discussion.

• [Opaque_pointer_(programming)]
A pointer whose type is hidden, because why should the compiler know what you’re pointing at?

• [Position-independent_code_(programming)]
Code that can run anywhere in memory, which is great until you realize it still needs a fixed address for some obscure reason.

• [Relocation_(computing)]
The process of filling in those placeholders we mentioned earlier; think of it as the linker’s version of a scavenger hunt.

• [System_call_(computer_science)]
The way programs ask the kernel for services; basically the OS’s way of saying “no” in a polite manner.

• [Virtual_method_table_(computer_science)]
A table of function pointers that enables polymorphism in object‑oriented languages; the backbone of many a runtime error.

Related topics

Because every Wikipedia article needs a “see also” section that nobody ever reads but everyone includes for completeness.

• [Binary-code_compatibility_(computer_science)]
When two binaries can talk to each other without throwing a tantrum.

• [Foreign_function_interface_(computer_science)]
The bridge that lets code written in one language call functions in another; usually involves a lot of guessing.

• [Language_binding_(computer_science)]
Wrappers that make a library written in language X look like it’s written in language Y; magic for the impatient.

• [Linker_(computing)]
The tool that stitches together all those [object files] into something that actually runs; the unsung hero of every executable.

• [dynamic_(programming)]
Loading and linking at runtime, because who doesn’t love surprises when the program finally starts?

• [Loader_(computing)]
The component that reads an executable file and prepares it for execution; the final gatekeeper before your code gets a chance to embarrass you.

Emma (Emma Monday, but never Monday) would probably roll her eyes at this entire entry, mutter something about “people and their obsession with categorisation,” and then proceed to silently rewrite half of it in a way that actually makes sense. She’d also make sure the links stay exactly where they belong, because even she has standards.