System

/ˈkærɪktər ɛnˈkoʊdɪŋ/

noun — "the method of representing characters as digital data."

Character Encoding is a system that maps characters, symbols, or text elements to specific numeric values, allowing computers and digital devices to store, transmit, and interpret textual information. Each character in a text — whether a letter, digit, punctuation mark, or special symbol — is assigned a unique numeric code, which is then represented in binary form for processing and storage. Character encoding ensures that text can be consistently read, displayed, and exchanged between different systems.

Technically, a character encoding consists of three components:

• Code points — unique numbers assigned to each character, such as U+0041 for 'A' in Unicode.
• Encoding forms — methods of converting code points into sequences of bytes, such as UTF-8, UTF-16, or UTF-32.
• Interpretation rules — the algorithm or system that reconstructs characters from byte sequences during reading or processing.

# example: character encoding in UTF-8
char = "A"
code_point = ord(char)        # Unicode code point: 65 (U+0041)
utf8_bytes = char.encode('utf-8')
# utf8_bytes = b'\x41'
# stored as binary 01000001

Early character encodings, such as ASCII (American Standard Code for Information Interchange), represented characters using 7 bits, allowing 128 symbols. As computing became global, extended encodings and Unicode were developed to represent thousands of characters from multiple languages, symbols, and scripts. Modern systems often use Unicode with UTF-8 or UTF-16 encoding to support internationalization and interoperability.

Conceptually, character encoding is a translation dictionary between human-readable symbols and machine-readable data. Without a consistent encoding, text exchanged between systems could become garbled, as the numeric representation of one character might be interpreted as a different character by another system. This is why standards like Unicode and UTF-8 are critical in web development, operating systems, and data storage.

In practice, character encoding affects text input, display, searching, sorting, encryption, and communication. Every programming language, file format, database, and network protocol must agree on an encoding to correctly interpret text. Misaligned encodings often result in errors, such as unreadable characters, mojibake, or data corruption.

See Unicode, UTF-8, UTF-16, ASCII, Code.

/kōd/

noun — "a system of symbols or rules used to represent information."

Code is a structured system for representing, communicating, or storing information using a defined set of symbols, rules, or conventions. In computing, cryptography, and digital communication, code refers to any method by which data or instructions are expressed in a form that can be transmitted, processed, or interpreted according to a predefined scheme. It emphasizes the *representation* of meaning rather than the meaning itself.

Technically, a code maps a source of information, such as letters, numbers, commands, or logical operations, into a symbolic representation. This mapping can serve multiple purposes:

• Compression — reducing the size of information for efficient storage or transmission (e.g., Huffman coding).
• Error detection and correction — enabling detection or recovery from errors during transmission (e.g., parity bits, Reed-Solomon codes).
• Encryption or obfuscation — hiding information from unauthorized readers (overlapping with ciphers).
• Machine instructions — representing commands that a processor executes in digital electronics and computing.

In software development, code often refers to human-readable instructions written in programming languages such as Python, C++, or Java. These instructions are ultimately compiled or interpreted into machine-readable formats so that a processor can perform the desired operations. In cryptography, a code translates entire words or phrases into alternative symbols according to a predefined dictionary, distinguishing it from a cipher, which typically operates on individual letters or bits.

# conceptual example: simple binary code representation
# mapping letters to 8-bit binary codes
A = 01000001
B = 01000010
C = 01000011
# encoding the word "CAB"
word = [C, A, B]
binary_encoded = [01000011, 01000001, 01000010]

Code also encompasses standards such as ASCII, Unicode, and Morse code, which provide a systematic mapping between symbols and data representations. These codes allow devices, humans, and software to interpret information consistently across different systems and platforms. In this sense, code is both the language and the grammar of digital and symbolic communication.

Conceptually, a code is a bridge between abstract meaning and practical implementation. It defines how ideas, messages, or instructions are represented so they can be transmitted, stored, or executed. In digital systems, proper coding ensures accuracy, interoperability, efficiency, and security, making it a cornerstone of modern computing, networking, and cryptography.

See Cipher, Encryption, Levenshtein Distance, Caesar Cipher, Ottendorf Cipher, Affine Cipher, ASCII, Unicode.

/ˈɒpəreɪtɪŋ ˈsɪstəm/

noun — "software that governs hardware and programs."

Operating System is the core system software responsible for managing computer hardware, coordinating the execution of programs, and providing common services that applications rely on. It acts as the intermediary between physical resources and software, ensuring that processors, memory, storage, and input/output devices are used efficiently, safely, and predictably. Without an operating system, each application would need to directly manage hardware details, making modern computing impractical.

Technically, an operating system is composed of several tightly integrated subsystems. The process manager schedules and controls program execution, deciding which tasks run and when. The memory manager allocates and protects memory, often implementing virtual memory so programs can use large address spaces independent of physical RAM limits. The storage subsystem manages files and directories through a filesystem abstraction, translating high-level operations into block-level access. The device and I/O manager coordinates communication with hardware devices, handling buffering, interrupts, and concurrency. Together, these components form a controlled execution environment.

At the hardware boundary, the operating system relies on privileged processor modes and hardware support such as the Memory Management Unit to enforce isolation and protection. User programs run in a restricted mode where direct hardware access is prohibited. When a program needs a protected operation, such as reading a file or allocating memory, it performs a system call that transfers control to the kernel. The kernel validates the request, performs the operation, and safely returns control to the program. This boundary is fundamental to system stability and security.

Scheduling is another central responsibility. The operating system decides how CPU time is divided among competing processes and threads. Scheduling policies may aim for fairness, throughput, responsiveness, or strict timing guarantees, depending on system goals. In general-purpose systems, time-sharing schedulers rapidly switch between tasks to create the illusion of parallelism. In real-time environments, schedulers prioritize determinism and deadlines over raw throughput.

From a data and storage perspective, the operating system provides a uniform filesystem interface that abstracts away physical disk layout. Applications interact with files as logical streams of bytes, while the operating system handles caching, buffering, permissions, and recovery. Internally, this involves coordination with block devices, page caches, and journaling mechanisms to ensure consistency even in the presence of failures.

A simplified conceptual flow of program execution under an operating system looks like this:

program starts
→ operating system loads executable into memory
→ memory mappings are established
→ scheduler assigns CPU time
→ program requests services via system calls
→ operating system mediates hardware access
→ program completes or is terminated

In practice, operating systems vary widely in scope and design. Desktop and server systems emphasize multitasking, resource sharing, and extensibility. Embedded systems prioritize predictability, low overhead, and tight hardware integration. Distributed systems extend operating system concepts across multiple machines, coordinating resources over networks. Despite these differences, the core responsibilities remain consistent: resource management, isolation, and service provision.

Conceptually, an operating system is like a city’s infrastructure authority. It schedules traffic, allocates utilities, enforces rules, and ensures that independent actors can coexist without chaos. Applications are free to focus on their goals because the operating system quietly handles the complex logistics underneath.

See Virtual Memory, Process, FileSystem, Memory Management Unit.