Representation

/ˌeɪ ˈsiː/

noun … “Electric current that periodically reverses direction.”

AC, short for Alternating Current, is a type of electrical current in which the flow of electric charge reverses direction periodically, typically in a sinusoidal waveform. AC is the standard form of electricity delivered by power grids because it can be easily transformed to different voltages for efficient long-distance transmission.

Unlike DC, which flows in a single direction, AC continuously changes polarity and magnitude, allowing devices such as transformers to step voltage up or down without significant energy loss. AC is widely used to power homes, industrial equipment, and most household appliances.

Key characteristics of AC include:

• Periodic reversal: current alternates direction at a fixed frequency (e.g., 50 or 60 Hz).
• Variable amplitude: voltage and current vary continuously over time.
• Efficient transmission: high-voltage AC reduces energy loss over long distances.
• Conversion capability: AC can be converted to DC using rectifiers.
• Standardization: widely used for power grids worldwide.

Workflow example: AC powering a household device:

ac_wall_voltage = 120   -- volts, typical in North America
device_input = transformer.step_down(ac_wall_voltage, 12)
device.power(device_input)

Here, AC voltage from the wall is stepped down and conditioned to safely power an electronic device.

Conceptually, AC is like water sloshing back and forth in a pipe, constantly changing direction but delivering energy to a turbine or generator efficiently.

See DC, Transformer, Rectifier, Power Supply, Electricity.

/ˌdiː ˈsiː/

noun … “Electric current that flows in one direction.”

DC, short for Direct Current, is a type of electrical current in which electric charge flows consistently in a single direction. Unlike alternating current, where the direction of flow periodically reverses, DC maintains constant polarity, making it especially suitable for electronic circuits, digital systems, and energy storage.

DC is the natural form of electricity produced by sources such as batteries, solar cells, and fuel cells. Inside electronic devices, even those powered from AC wall outlets, electricity is almost always converted to DC using a rectifier and stabilized with a voltage regulator.

Key characteristics of DC include:

• Unidirectional flow: current moves in only one direction.
• Constant polarity: voltage does not alternate sign.
• Stable voltage levels: ideal for logic and control circuits.
• Energy storage compatibility: easily stored in batteries and capacitors.
• Low noise: preferred for sensitive electronic components.

Common uses of DC include powering microcontrollers, CPUs, memory, sensors, motors (with control electronics), and communication devices.

Workflow example: Supplying DC to a circuit:

battery_voltage = 9
regulated_voltage = voltage_regulator.set(5).apply(battery_voltage)
circuit.power(regulated_voltage)

Here, DC from a battery is regulated to a lower, stable voltage suitable for digital electronics.

Conceptually, DC is like water flowing steadily through a pipe in one direction, without reversing or pulsing back and forth.

See AC, Power Supply, Rectifier, Voltage Regulator, Battery.

/ˈbaɪnəri/

adjective … “Based on two discrete values, 0 and 1.”

Binary refers to a number system, representation, or data encoding that uses only two symbols, typically 0 and 1. In computing, binary underlies all digital systems, as digital signals, memory storage, and logic circuits operate on two-state systems. Binary representation enables efficient computation, storage, and communication of information using simple, reliable hardware components.

Key characteristics of Binary include:

• Two-state system: values are either 0 (off/false) or 1 (on/true).
• Foundation of digital logic: used in logic gates, flip-flops, and CPUs.
• Ease of processing: simple arithmetic and bitwise operations are supported natively.
• Representation of complex data: sequences of binary digits (bits) encode numbers, characters, images, and instructions.
• Compatibility: binary data can be transmitted, stored, and processed reliably in electronic systems.

Workflow example: Binary addition:

0b1010 + 0b0111 = 0b10001
-- 1010 (10 decimal) + 0111 (7 decimal) = 10001 (17 decimal)

Here, numbers are represented in binary and arithmetic is performed at the bit level, as in all digital computation.

Conceptually, Binary is like a series of light switches: each switch is either off or on, and combinations of switches encode information or control systems.

See Digital, Logic Gates, Bit, CPU, Memory.

/ˈdɪdʒɪtl/

adjective … “Discrete representation of information.”

Digital refers to signals, data, or systems that represent information using discrete values, typically in binary form (0s and 1s). Digital systems contrast with analog systems, which use continuous physical quantities. Digital representation allows reliable storage, transmission, and processing of information, as discrete values are less susceptible to noise and degradation.

Key characteristics of Digital include:

• Discreteness: information is encoded using a finite set of levels, usually binary.
• Noise resistance: small variations do not affect the interpreted value, ensuring signal integrity.
• Ease of processing: suitable for computers, microcontrollers, and digital electronics.
• Storage efficiency: can be copied, transmitted, and backed up without loss of fidelity.
• Integration with conversion: requires DAC for analog output and ADC for analog input.

Workflow example: Representing a sensor reading digitally:

analog_value = sensor.read()
digital_value = adc.convert(analog_value)   -- Converts continuous signal to discrete binary
process(digital_value)

Here, the analog sensor signal is digitized for processing by a digital system, ensuring reliable computation and storage.

Conceptually, Digital is like using numbered bins to sort items: each item fits into a discrete category rather than a continuous range.

See Analog, ADC, DAC, Binary, Signal Processing.

/ˈænəlɔːɡ/

adjective … “Continuous representation of information.”

Analog refers to signals, data, or systems that represent information using continuous physical quantities rather than discrete values. In computing and electronics, analog signals vary smoothly over time, often representing real-world phenomena such as sound, light, temperature, or voltage. Analog systems contrast with digital systems, which represent data using discrete levels or binary values.

Key characteristics of Analog include:

• Continuity: values can take any value within a range, without discrete steps.
• Signal representation: often voltage, current, or frequency variations encode information.
• Sensitivity to noise: analog signals can degrade due to interference or distortion.
• Conversion requirement: analog-to-digital conversion is often needed for digital processing.
• Applications: audio systems, radio transmission, sensors, instrumentation, and control circuits.

Workflow example: Representing sound with an analog waveform:

microphone_voltage = analog_signal.read()
amplified_signal = amplifier.process(microphone_voltage)
speaker.write(analog_signal=amplified_signal)

Here, the microphone captures sound as a continuous voltage, which is processed and output to a speaker, demonstrating analog signal flow.

Conceptually, Analog is like a dimmer switch for lights: the brightness can vary smoothly across a continuous range rather than being limited to fixed levels.

See DAC, ADC, Signal Processing, Radio, Digital.

/ˌaɪ ˈɑːr/

noun … “The shared language between source code and machines.”

IR, short for Intermediate Representation, is an abstract, structured form of code used internally by a Compiler to bridge the gap between high-level source languages and low-level machine instructions. It is not meant to be written by humans or executed directly by hardware. Instead, IR exists as a stable, analyzable format that enables transformation, optimization, and portability across languages and architectures.

The core purpose of IR is separation of concerns. Front ends translate source code into IR, capturing program structure, control flow, and data flow without committing to a specific processor. Back ends then consume IR to generate target-specific machine code. By standardizing this middle layer, a single optimizer and code generator can serve many languages and platforms. This design is foundational to systems such as LLVM, where multiple language front ends and many hardware targets share a common optimization pipeline.

A defining property of IR is that it is lower level than syntax trees but higher level than assembly. Compared to an AST, IR removes most surface syntax and focuses on explicit operations, control flow, and data dependencies. Compared to Bytecode, IR is usually richer in semantic detail and designed for aggressive optimization rather than direct interpretation. This balance makes IR ideal for program analysis, transformation, and performance tuning.

Strong typing is another common characteristic of IR. Values and operations carry explicit type information, allowing compilers to reason precisely about correctness and optimization opportunities. Control flow is typically represented using basic blocks and explicit branches, which simplifies analysis such as dominance, liveness, and dependency tracking. These structural choices allow optimization passes to be composed, reordered, and reused without ambiguity.

In practical workflows, IR enables powerful optimization strategies. A compiler may convert source code into IR, run dozens of optimization passes, and repeatedly refine the program representation before emitting final machine code. The same IR can be optimized differently depending on goals such as speed, code size, or energy efficiency. In dynamic systems, IR may be generated and optimized at runtime by a JIT compiler, adapting the program based on observed execution behavior.

Consider a typical compilation pipeline. Source code is parsed and type-checked, then lowered into IR. Optimizers analyze loops, eliminate redundant computations, and simplify control flow within the IR. Finally, the refined IR is translated into instructions tailored for a specific CPU. At no point does the optimizer need to know which language the program came from, only how the IR behaves.

Conceptually, IR is like a universal wiring diagram. Different architects may sketch buildings in different styles, and different electricians may wire systems differently, but the diagram captures the essential connections in a standard form. Once everything is reduced to that shared diagram, improvements and adaptations become systematic rather than ad hoc.

See Compiler, LLVM, AST, Bytecode, JIT.

/ˌeɪˌɛsˈtiː/

noun … “Structural map of code for analysis and execution.”

AST, short for Abstract Syntax Tree, is a tree representation of the syntactic structure of source code in a programming language. Each node in the tree denotes a construct occurring in the source, such as expressions, statements, operators, or function calls, abstracted from concrete syntax details like punctuation or formatting. ASTs are essential in Compiler design, Interpreter execution, static analysis, and code transformation tools.

During parsing, the source code is tokenized and transformed into an AST. The tree captures the hierarchical relationships between constructs: for example, a function call node may have child nodes representing the function identifier and its arguments. This abstraction allows subsequent stages—semantic analysis, optimization, or Bytecode generation—to operate on a structured and unambiguous representation of the program.

Key characteristics of AST include:

• Hierarchical structure: nodes reflect the nested, logical composition of the program.
• Language-agnostic manipulation: many tools transform ASTs without concern for concrete syntax.
• Facilitates static analysis: allows type checking, linting, and code quality inspection.
• Supports code transformation: used in refactoring, transpilation, and optimization workflows.

Workflow example: In Python, the built-in ast module can parse source code into an AST object. A developer analyzing a script might traverse the AST to detect unused variables or modify function calls for optimization. Similarly, a Compiler generates an AST before producing Bytecode, ensuring accurate representation of control flow and expressions.

import ast

source = "x = a + b * c"
tree = ast.parse(source)
print(ast.dump(tree))

This snippet produces a structured tree reflecting assignment and arithmetic operations, which can be analyzed or transformed programmatically.

Conceptually, an AST is like a blueprint of a building. It does not show colors, textures, or furniture (concrete syntax), but it precisely maps the structural relationships between rooms and supports engineers (the Compiler or Interpreter) in building or modifying the final structure (executable program).

See Compiler, Interpreter, Bytecode, Python.

/ˈbaɪtkəʊd/

noun … “Intermediate code optimized for virtual machines.”

Bytecode is a low-level, platform-independent representation of source code generated by a compiler or interpreter. It is designed to be executed by a virtual machine rather than directly by a physical CPU. Unlike human-readable source code, Bytecode is a compact, numeric encoding of operations and control flow instructions, optimized for quick parsing and execution within the virtual environment. This layer of abstraction allows programs to run consistently across different hardware and operating systems.

When a programming language such as Python or Java is used, the source code is first translated into Bytecode. In Python’s reference implementation, CPython, the source file is parsed into an abstract syntax tree (AST), then compiled into Bytecode, which is executed by the Python virtual machine. Java compilers generate Bytecode stored in .class files, executed by the Java Virtual Machine (JVM). The virtual machine reads the Bytecode instructions, performs necessary memory management, evaluates expressions, and interfaces with the underlying operating system via system calls.

Key characteristics of Bytecode include:

• Platform independence: the same Bytecode runs on any system with a compatible virtual machine.
• Compact representation: instructions are encoded efficiently to reduce memory footprint.
• Optimized for interpretation or just-in-time (JIT) compilation.
• Preserves high-level language constructs such as loops, functions, and object references in an intermediate, machine-agnostic form.

In workflow terms, Bytecode acts as a bridge between high-level source code and hardware execution. A developer writes a Python script to process data from an API. The interpreter compiles the script into Bytecode, which is executed by the virtual machine, performing operations like arithmetic, function calls, and memory allocation, while maintaining platform independence. Errors encountered during execution are reported in terms of the original source, allowing developers to debug at the high-level language rather than the machine code level.

A conceptual metaphor for Bytecode is a musical score. The composer writes in a high-level notation understandable to humans, which is then interpreted by musicians (the virtual machine) to produce sound. Just as the score abstracts the specific mechanics of playing each instrument, Bytecode abstracts the specifics of the CPU architecture, allowing consistent execution on different platforms.

See Interpreter, Compiler, Virtual Machine, Python.

/ˈbeɪsˌsɪkstiˈfɔːr/

[from base (numeral system) + 64 (character set size)]

n.
A binary-to-text encoding scheme used to represent arbitrary binary data in an ASCII string format by translating it into a radix-64 representation. Base64 is commonly used in computing and data transmission systems where binary data must be safely transported over media designed to handle textual data.

Base64 works by dividing binary input into 24-bit groups, which are then split into four 6-bit values. Each 6-bit value is mapped to a printable ASCII character from a fixed set of 64 symbols, typically consisting of uppercase letters (A–Z), lowercase letters (a–z), digits (0–9), and two additional characters (usually + and /). Padding characters (=) may be appended to ensure the output length is a multiple of four characters.

The encoding is not a form of encryption and provides no confidentiality or security on its own. Instead, it is designed for data representation and transport, ensuring compatibility across systems that may not handle raw binary data correctly. As such, Base64 is frequently encountered in contexts such as email attachments (MIME), embedded images in HTML and CSS (data URIs), API payloads (JSON and XML), authentication headers (HTTP Basic Auth), and cryptographic material such as keys and signatures.

While Base64 increases the size of the encoded data by approximately 33%, it remains widely adopted due to its simplicity, reliability, and broad platform support. Variants of Base64 exist, including URL-safe Base64, which replaces certain characters to avoid conflicts in URLs and filenames.

In modern systems, Base64 is best understood as a transport encoding, bridging the gap between binary data and text-based protocols, rather than as a security mechanism.