Computer Fundamentals
Fundamentals and Theory of Computing
This content area contains the fundamentals and theory behind computer design, networking, and entry level computing concepts. This includes knowledge of types of basic computer components, CPU architectures, and OS concepts.
Von Neumann Architecture
The Von Neumann Architecture is a foundational model for modern computing systems, proposed by mathematician and physicist John von Neumann in 1945. It describes a system where the CPU, memory, and input/output devices share a common communication pathway. This architecture is characterized by the following five main components:
Registers:
High-speed storage locations within the CPU used for temporarily holding data, instructions, or intermediate results during processing.
Input/Output Devices:
Interfaces that allow the computer to interact with external devices, such as keyboards, monitors, printers, and storage devices.
Arithmetic Logic Unit (ALU):
A subsystem of the CPU responsible for performing arithmetic operations (e.g., addition, subtraction) and logical operations (e.g., comparisons, AND, OR).
Memory Unit:
Stores both data and instructions in a single memory space. This shared storage is a defining feature of the Von Neumann Architecture, enabling the CPU to fetch instructions and data from the same memory.
Control Unit:
Manages and coordinates the operations of the CPU, memory, and input/output devices. It decodes instructions from memory and directs the flow of data within the system.
Key Characteristics of the Von Neumann Architecture:
Stored Program Concept: Both instructions and data are stored in the same memory, allowing the CPU to fetch and execute instructions sequentially.
Single Data Path: A single bus is used for data transfer between the CPU and memory, which can lead to a bottleneck known as the "Von Neumann bottleneck."
Sequential Execution: Instructions are executed one at a time in the order they are stored in memory, unless altered by control flow instructions (e.g., loops, branches).
This architecture remains the basis for most modern computers, though enhancements and variations have been introduced to address its limitations, such as the bottleneck issue.
Parts of a Modern Computer
A modern computer is a complex system composed of several key components, each playing a specific role in ensuring the system operates efficiently. These components can be broadly categorized into hardware and software elements. By working together, these components form a cohesive system capable of performing a wide range of tasks, from basic computing to advanced data processing and gaming. Below is an overview of the major hardware components of a modern computer:
Central Processing Unit (CPU)
The CPU, often referred to as the "brain" of the computer, is responsible for executing instructions and performing calculations. It consists of the following subcomponents:
Control Unit (CU): Directs the flow of data and instructions within the CPU and coordinates the execution of tasks.
Arithmetic Logic Unit (ALU): Handles arithmetic operations (e.g., addition, subtraction) and logical operations (e.g., comparisons).
Registers: Small, high-speed storage locations used for temporary data storage during processing.
Cache: A small, high-speed memory within the CPU that stores frequently accessed data and instructions to improve performance.
Memory (RAM)
Random Access Memory (RAM) is the primary memory of the computer, used to store data and instructions that the CPU needs while performing tasks. It is volatile, meaning its contents are lost when the computer is powered off. RAM plays a critical role in determining the speed and responsiveness of a system.
Storage
Modern computers use a combination of storage devices to manage data:
Solid-State Drives (SSD): Faster and more reliable than traditional hard drives, SSDs use flash memory to store data.
Hard Disk Drives (HDD): Use spinning magnetic disks to store data. While slower than SSDs, they are more cost-effective for large storage capacities.
NVMe Drives: A newer type of SSD that connects directly to the motherboard via PCIe, offering significantly faster data transfer speeds.
Motherboard
The motherboard is the main circuit board that connects all components of the computer. It provides the pathways (buses) for communication between the CPU, memory, storage, and peripherals. Key features of a motherboard include:
Chipset: Manages data flow between the CPU, memory, and peripherals.
Expansion Slots: Allow the addition of components like graphics cards, sound cards, and network adapters.
Power Connectors: Distribute power from the power supply to various components.
Graphics Processing Unit (GPU)
The GPU is specialized hardware designed to handle rendering of images, videos, and 3D graphics. Modern GPUs are also used for parallel processing tasks, such as machine learning and scientific simulations. GPUs can be:
Integrated: Built into the CPU, suitable for basic tasks.
Dedicated: Separate hardware with its own memory, ideal for gaming, video editing, and other intensive tasks.
Power Supply Unit (PSU)
The PSU converts electricity from an external source into usable power for the computer's components. It ensures that each component receives the correct voltage and current.
Input Devices
Input devices allow users to interact with the computer. Common examples include:
Keyboard: For text input and command execution.
Mouse: For navigation and selection.
Touchscreen: Combines input and display functionality.
Output Devices
Output devices display or output the results of the computer's processes. Examples include:
Monitor: Displays visual output from the GPU.
Speakers: Output audio signals.
Printers: Produce physical copies of digital documents.
Cooling System
To prevent overheating, modern computers use cooling systems such as:
Fans: Circulate air to dissipate heat.
Heat Sinks: Absorb and disperse heat from components like the CPU and GPU.
Liquid Cooling: Uses a liquid coolant to transfer heat away from components, often used in high-performance systems.
Network Interface
Modern computers include network interfaces for connectivity:
Ethernet Port: For wired network connections.
Wi-Fi Adapter: For wireless connectivity.
Bluetooth: For short-range wireless communication with peripherals.
Peripherals
Peripherals are external devices that expand the functionality of a computer. Examples include:
External Storage Devices: USB drives, external hard drives.
Webcams: For video communication.
Game Controllers: For gaming applications.
Important Software Components
BIOS/UEFI
The Basic Input/Output System (BIOS) or Unified Extensible Firmware Interface (UEFI) is firmware stored on a chip on the motherboard. It initializes hardware during the boot process and provides an interface for configuring system settings.
Operating System (OS)
While not hardware, the OS is a critical component that manages hardware resources and provides a platform for running applications. Examples include Windows, macOS, Linux, and Android.
CPU Architecture
A CPU (Central Processing Unit) is the brain of the computer, responsible for executing instructions and managing data. It relies on several key components to perform its tasks efficiently:
CPU Components
Registers
Registers are small, high-speed storage locations within the CPU used for temporarily holding data, instructions, or intermediate results during processing. Common types of registers include:
Memory Address Register (MAR): Holds the memory address of data that needs to be accessed.
Memory Data Register (MDR): Temporarily stores data being transferred to or from memory.
Program Counter (PC): Contains the address of the next instruction to be executed.
Current Instruction Register (CIR): Holds the current instruction being executed.
Accumulator (AC): Stores intermediate results of arithmetic and logic operations.
Arithmetic Logic Unit (ALU)
The ALU is a critical subsystem of the CPU responsible for performing arithmetic operations (e.g., addition, subtraction) and logical operations (e.g., comparisons, AND, OR). It works closely with the registers, particularly the Accumulator, to process data and produce results.
Control Unit (CU)
The Control Unit manages and coordinates the operations of the CPU. It:
Decodes instructions fetched from memory.
Directs the flow of data between the CPU, memory, and input/output devices.
Sends control signals to other components to execute instructions in the correct sequence.
Cache
The CPU cache is a small, high-speed memory located within the CPU. It stores frequently accessed data and instructions to reduce the time needed to fetch them from main memory. Cache is typically divided into levels:
L1 Cache: Closest to the CPU, fastest but smallest in size.
L2 Cache: Larger but slightly slower than L1.
L3 Cache: Shared among CPU cores, larger but slower than L1 and L2.
Clock
The CPU clock generates a steady stream of pulses that synchronize the operations of the CPU. The clock speed, measured in hertz (Hz), determines how many instructions the CPU can execute per second.
Bus Interface
The CPU communicates with other components of the computer via buses. These include:
Data Bus: Transfers actual data between the CPU, memory, and peripherals.
Address Bus: Carries the addresses of data or instructions in memory.
Control Bus: Sends control signals to coordinate operations across the system.
Instruction Decoder
The instruction decoder is part of the Control Unit. It interprets the binary instructions fetched from memory and translates them into signals that the CPU components can execute.
Instruction Set Architectures (ISAs)
An Instruction Set Architecture (ISA) defines the set of instructions that a CPU can execute. It acts as the interface between software and hardware, specifying how programs interact with the processor. Also called computer architecture, it is an abstract model of how software and hardware in a computer interacts. A device that executes instructions described by that ISA, such as a central processing unit (CPU), is called an implementation. There are seven common types of ISAs:
RISC (Reduced Instruction Set Computing)
Philosophy: Simplify the instruction set to improve execution speed and efficiency.
Key Features:
Fixed-length instructions for easier decoding.
Load/store architecture: Memory access is limited to specific instructions, while arithmetic operations are performed only on registers.
Pipelining is heavily utilized to execute multiple instructions simultaneously.
Advantages:
Faster execution due to simpler instructions.
Lower power consumption, making it ideal for mobile and embedded systems.
Examples:
ARM: Found in most smartphones, tablets, and IoT devices.
RISC-V: An open-source ISA gaining traction in academia and industry.
SPARC: Scalable Processor Architecture; Used in Sun and Oracle enterprise servers and high-performance computing.
CISC (Complex Instruction Set Computing)
Philosophy: Provide a rich set of instructions to reduce the number of instructions per program.
Key Features:
Variable-length instructions, which can perform complex tasks in a single instruction.
Microcode is often used to translate complex instructions into simpler internal operations.
Emphasis on backward compatibility with older software.
Advantages:
Reduces the need for complex compilers.
Efficient for tasks requiring fewer instructions, such as desktop applications.
Examples:
x86: Dominates the desktop, laptop, and server markets.
IA-32: A 32-bit architecture used in older Intel processors (also known as i386).
EPIC (Explicitly Parallel Instruction Computing)
Philosophy: Exploit instruction-level parallelism by explicitly encoding parallelism in the instruction set.
Key Features:
Relies on the compiler to schedule instructions for parallel execution.
Large instruction words contain multiple operations.
Advantages:
High performance for workloads that can be parallelized.
Examples:
IA-64: Used in Intel Itanium processors, primarily for enterprise servers.
VLIW (Very Long Instruction Word)
Philosophy: Bundle multiple operations into a single, long instruction word.
Key Features:
Compiler-driven parallelism: The compiler determines which instructions can be executed in parallel.
Simplifies hardware design by reducing the need for complex scheduling logic.
Advantages:
High throughput for specific workloads.
Examples:
Used in specialized processors like DSPs (Digital Signal Processors).
MISC (Minimal Instruction Set Computer)
Philosophy: Use a minimal set of instructions to simplify hardware design.
Key Features:
Often used in educational or experimental contexts.
Focuses on simplicity and ease of understanding.
Advantages:
Extremely low hardware complexity.
Examples:
Rarely used in commercial applications but valuable for teaching computer architecture.
OISC (One Instruction Set Computer)
Philosophy: Use a single instruction to perform all operations.
Key Features:
Theoretical and experimental architecture.
Typically uses a single instruction like "subtract and branch if less than or equal to zero."
Advantages:
Simplifies the design of the instruction set.
Examples:
Used in academic research and as a teaching tool.
LIW (Long Instruction Word)
Philosophy: Similar to VLIW but focuses on encoding long instruction words for specific tasks.
Key Features:
Optimized for specific applications requiring high throughput.
Advantages:
Efficient for workloads with predictable parallelism.
Examples:
Found in some embedded systems and specialized processors.
Emerging Architectures
RISC-V
Philosophy: Open-source and modular design for flexibility and innovation.
Key Features:
Extensible ISA allows customization for specific applications.
Strong focus on academic and industrial adoption.
Advantages:
Free from licensing fees, encouraging widespread adoption.
Suitable for a wide range of applications, from IoT to supercomputing.
Examples:
Used in research, embedded systems, and experimental processors.
Advanced RISC Machines (ARM)
Philosophy: Energy-efficient design for mobile and embedded systems.
Key Features:
RISC-based architecture with a focus on low power consumption.
Widely adopted in smartphones, tablets, and IoT devices.
Advantages:
High performance per watt.
Extensive ecosystem and software support.
Examples:
Apple's M1 and M2 processors.
Qualcomm Snapdragon series.
x86-64
Philosophy: Extend the x86 architecture to support 64-bit computing.
Key Features:
Backward compatibility with 32-bit x86 programs.
Enhanced performance for modern applications.
Advantages:
Ubiquitous in desktops, laptops, and servers.
Mature ecosystem with extensive software support.
Examples:
Intel Core and AMD Ryzen processors.
Neuromorphic Architectures
Philosophy: Mimic the structure and function of the human brain for AI and machine learning tasks.
Key Features:
Uses spiking neural networks to process information.
Optimized for low-power, high-efficiency AI workloads.
Advantages:
Energy-efficient for AI applications.
Examples:
IBM TrueNorth, Intel Loihi.
Quantum Computing
Philosophy: Use quantum bits (qubits) to perform computations that are infeasible for classical computers.
Key Features:
Exploits quantum phenomena like superposition and entanglement.
Promises exponential speedups for specific problems.
Advantages:
Potential to revolutionize fields like cryptography, optimization, and material science.
Examples:
IBM Q, Google Sycamore.
Summary of Architectures
Architecture
Key Features
Use Cases
RISC
Simple, fast, energy-efficient
Mobile devices, IoT, embedded systems
CISC
Complex instructions, backward-compatible
Desktops, laptops, servers
EPIC
Parallelism through explicit encoding
Enterprise servers
VLIW
Compiler-driven parallelism
Specialized processors, DSPs
RISC-V
Open-source, modular
Research, embedded systems, supercomputing
ARM
Energy-efficient, RISC-based
Smartphones, tablets, IoT
x86-64
Backward-compatible, high performance
Desktops, laptops, servers
Neuromorphic
Brain-inspired, AI-focused
Machine learning, AI
Quantum
Exploits quantum phenomena
Cryptography, optimization, material science
Modern CPU architectures continue to evolve, balancing performance, energy efficiency, and specialized capabilities to meet the diverse demands of today's computing landscape.
System Bus and CPU Interaction with Hardware
The system bus is a critical component that connects the CPU to other parts of the computer, enabling communication and data transfer. It is divided into three main parts:
Address Bus:
Purpose: Carries the addresses of data between the CPU and memory.
Role: Specifies the location in memory where data is stored or retrieved.
Direction: Unidirectional (from CPU to memory).
Control Bus:
Purpose: Carries control signals and commands from the CPU to other components.
Role: Coordinates and manages the activities of the computer.
Direction: Bidirectional (to and from the CPU).
Data Bus:
Purpose: Transfers actual data between the CPU, memory, and input/output devices.
Role: Facilitates the movement of data within the system.
Direction: Bidirectional (to and from the CPU).
How the CPU Interacts with Other Hardware
The CPU interacts with other hardware components through the system bus and a series of well-defined processes:
Fetching Instructions:
The CPU retrieves instructions from memory using the Address Bus.
The Program Counter (PC) points to the memory location of the next instruction.
Decoding Instructions:
The instruction is loaded into the Current Instruction Register (CIR).
The Control Unit decodes the instruction to determine the required operation.
Executing Instructions:
The Arithmetic Logic Unit (ALU) performs calculations or logical operations.
Data is transferred between the CPU and memory via the Data Bus.
Storing Results:
The result of an operation is stored in the Accumulator (AC) or written back to memory.
Input/Output Operations:
The CPU communicates with input/output devices through the Control Bus.
Data is transferred to or from devices via the Data Bus.
By coordinating these processes, the CPU ensures seamless interaction with memory, storage, and peripheral devices, enabling the computer to perform complex tasks efficiently.
Kernel vs. User Space
The 4 Rings of Protection
The concept of "rings of protection" is a hierarchical privilege model used in computer systems to protect data and functionality from faults and malicious behavior. These rings define different levels of access to system resources, with lower-numbered rings having more privileges.
Ring 3 - Userland (Applications)
This is the least privileged ring and is where user applications and processes run.
Applications in this ring have restricted access to system resources and must rely on system calls to interact with the kernel.
Examples: Web browsers, text editors, and other user-facing software.
Runs in user mode, which imposes restrictions to prevent direct access to hardware or critical system resources.
Ring 2 - Drivers
This ring is typically used for device drivers that require more privileges than user applications but less than the kernel.
Drivers in this ring can interact with hardware but are still somewhat restricted to ensure system stability.
Note: Many modern operating systems do not use Ring 2 explicitly and instead run drivers in Ring 0 or Ring 3, depending on their design.
Ring 1 - Hypervisors (Optional)
This ring may be used by hypervisors or other system-level software that manages virtual machines.
Hypervisors in this ring have more privileges than user applications but less than the kernel.
Examples: VMware ESXi, Microsoft Hyper-V.
Not all operating systems implement this ring.
Ring 0 - Kernel Mode
This is the most privileged ring and is where the operating system kernel operates.
The kernel has unrestricted access to all hardware and system resources.
It manages critical tasks such as memory management, process scheduling, and hardware communication.
Runs in kernel mode, which allows direct interaction with hardware and full control over the system.
Kernel Space vs. User Space
Modern operating systems divide memory into two distinct regions: kernel space and user space. This separation ensures system stability, security, and efficient resource management.
Kernel Space
Definition: The portion of memory reserved for the operating system's core (the kernel) and its extensions.
Purpose: Provides low-level access to hardware and manages critical system functions.
Characteristics:
Runs in Ring 0 (highest privilege level).
Has unrestricted access to hardware and system resources.
Executes tasks such as process scheduling, memory management, and device driver operations.
Errors in kernel space can lead to system crashes or instability (e.g., "blue screen of death" in Windows).
Examples of Kernel Functions:
Managing system calls from user applications.
Allocating and deallocating memory.
Handling interrupts and I/O operations.
User Space
Definition: The portion of memory allocated for user processes and applications.
Purpose: Provides a restricted environment for running user-level applications to ensure they cannot directly interfere with the kernel or other processes.
Characteristics:
Runs in Ring 3 (lowest privilege level).
Applications must use system calls to request services from the kernel (e.g., file access, network communication).
Errors in user space are isolated and typically do not affect the entire system.
Examples of User Space Applications:
Web browsers, media players, office software, and other end-user programs.
Interaction Between Kernel and User Space
The interaction between kernel space and user space is carefully controlled to maintain system security and stability. This interaction occurs through system calls.
System Calls:
User applications cannot directly access kernel space. Instead, they use system calls to request services from the kernel.
Examples of system calls:
read()andwrite()for file operations.fork()for creating new processes.socket()for network communication.
Context Switching:
When a system call is made, the CPU switches from user mode to kernel mode to execute the requested operation.
After the operation is complete, the CPU switches back to user mode.
This switching ensures that user applications cannot directly manipulate critical system resources.
Memory Protection:
The kernel enforces memory protection to prevent user applications from accessing or modifying kernel memory.
This is achieved through hardware mechanisms such as the Memory Management Unit (MMU).
Key Differences Between Kernel Space and User Space
Privilege Level
High (Ring 0)
Low (Ring 3)
Access to Hardware
Direct
Indirect (via system calls)
Stability Impact
Errors can crash the entire system
Errors are isolated to the application
Memory Access
Full access to all system memory
Restricted to allocated memory
Examples
Kernel, device drivers, system calls
User applications, libraries
By separating kernel space and user space, operating systems achieve a balance between performance, security, and stability.
Memory
Primary Memory
Primary memory, also known as main memory, is the memory directly accessible by the CPU. It is volatile, meaning its contents are lost when the computer is powered off. Primary memory is essential for the execution of programs and the temporary storage of data.
RAM (Random Access Memory)
Definition: RAM is a type of volatile memory that temporarily stores data and instructions that the CPU needs while performing tasks.
Types of RAM:
SRAM (Static RAM):
Faster and more reliable than DRAM.
Does not need to be refreshed, as it uses flip-flops to store data.
Used in CPU caches (L1, L2, L3).
More expensive and consumes more power.
DRAM (Dynamic RAM):
Slower than SRAM but more cost-effective.
Requires periodic refreshing to maintain data.
Commonly used as the main system memory in computers.
Use Cases: Running applications, loading operating systems, and temporarily storing data for active processes.
ROM (Read-Only Memory)
Definition: ROM is non-volatile memory that retains its contents even when the computer is powered off. It is primarily used to store firmware.
Characteristics:
Data is written during manufacturing and cannot be modified (in traditional ROM).
Variants like EEPROM (Electrically Erasable Programmable ROM) and Flash memory allow limited rewriting.
Use Cases: Storing the BIOS/UEFI firmware, bootloader programs, and other critical system instructions.
Video Memory
Definition: Video memory is a specialized type of memory used by the GPU (Graphics Processing Unit) to store graphical data such as textures, frame buffers, and shaders.
Types of Video Memory:
VRAM (Video RAM):
A dual-ported memory that allows simultaneous read and write operations.
Used in older graphics cards.
GDDR (Graphics Double Data Rate):
A modern type of video memory optimized for high bandwidth.
Variants include GDDR5, GDDR6, and GDDR6X.
HBM (High Bandwidth Memory):
A newer type of memory with extremely high bandwidth, used in high-end GPUs.
Use Cases: Rendering 3D graphics, gaming, video editing, and other GPU-intensive tasks.
CPU Registers
Definition: Registers are small, high-speed storage locations within the CPU. They are the fastest type of memory and are used to store data and instructions currently being processed.
Types of Registers:
General-Purpose Registers: Store temporary data and intermediate results.
Special-Purpose Registers:
Program Counter (PC): Holds the address of the next instruction to execute.
Instruction Register (IR): Stores the current instruction being executed.
Accumulator (AC): Holds intermediate arithmetic and logic results.
Stack Pointer (SP): Points to the top of the stack in memory.
Use Cases: Performing arithmetic operations, managing program flow, and storing temporary data during execution.
Buses
Buses are communication pathways that transfer data between different components of a computer, such as the CPU, memory, and peripherals.
Types of Buses:
Data Bus:
Transfers actual data between the CPU, memory, and I/O devices.
Width (e.g., 32-bit, 64-bit) determines how much data can be transferred at once.
Address Bus:
Carries memory addresses from the CPU to other components.
Determines the maximum addressable memory (e.g., a 32-bit address bus can address 4 GB of memory).
Control Bus:
Sends control signals (e.g., read/write commands) to coordinate operations between components.
Use Cases: Facilitating communication between the CPU, RAM, storage devices, and peripherals.
Memory Hierarchy
The memory hierarchy in a computer system is designed to balance speed, cost, and capacity:
Memory Type
Speed
Size
Cost
Registers
Fastest
Smallest
Most expensive
Cache (L1, L2, L3)
Faster than RAM
Smaller than RAM
More expensive
RAM
Slower than cache
Larger than cache
More affordable
Secondary Storage
Slowest
Largest
Cheapest
Memory Layout and Logical Structure
Memory's layout and logical structure refer to how a program's memory is organized and managed during program execution.
Understanding memory layout and logical structure is essential for:
Writing efficient and secure code.
Debugging memory-related issues.
Optimizing performance by choosing the appropriate memory region (stack vs. heap).
Preventing and mitigating vulnerabilities in software.
Key Components of Memory Layout
Stack
Definition: The stack is a region of memory used for managing function calls, local variables, and control flow. It operates on a Last-In, First-Out (LIFO) principle.
Location: The stack resides at the "top" of memory and grows downward toward lower memory addresses.
Purpose:
Stores function call information, such as return addresses and parameters.
Allocates memory for local variables.
Tracks the execution flow of a program.
Stack Pointer: A special processor register that holds the memory address of the top of the stack.
Advantages:
Fast allocation and deallocation of memory.
Memory is automatically managed when functions are called and return.
Limitations:
Limited size (stack overflow occurs if the stack exceeds its allocated size).
Not suitable for large or persistent data.
Heap
Definition: The heap is a region of memory used for dynamic memory allocation. It allows programmers to allocate and deallocate memory manually during runtime.
Location: The heap resides at the "bottom" of memory and grows upward toward higher memory addresses.
Purpose:
Stores dynamically allocated objects and data structures (e.g., arrays, linked lists).
Provides flexibility for managing memory that needs to persist beyond the scope of a single function.
Advantages:
Suitable for large and persistent data.
Memory size is only limited by the system's available memory.
Limitations:
Slower allocation and deallocation compared to the stack.
Requires manual memory management (e.g.,
mallocandfreein C, ornewanddeletein C++).Risk of memory leaks if memory is not properly freed.
Code Segment (Text Segment)
Stores the program's executable instructions.
Typically read-only to prevent accidental or malicious modification.
Data Segment
Divided into two parts:
Initialized Data Segment: Stores global and static variables that are explicitly initialized.
Uninitialized Data Segment (BSS): Stores global and static variables that are not explicitly initialized. These are initialized to zero by default.
Free Space
The area between the stack and heap. This space shrinks as the stack and heap grow toward each other.
Pointers and Memory Management
Pointers:
A pointer is a variable that holds the memory address of another variable.
Pointers are essential for dynamic memory allocation and accessing data stored in the heap.
Example in C:
Memory Management:
Proper memory management is crucial to avoid issues such as memory leaks, dangling pointers, and segmentation faults.
Tools like garbage collectors (in languages like Java and Python) automate memory management, while languages like C and C++ require manual management.
Exploits Related to the Stack and Heap
Stack-Based Exploits
Buffer Overflow:
Occurs when a program writes more data to a buffer (a fixed-size memory region) than it can hold, overwriting adjacent memory.
Can overwrite the return address on the stack, allowing attackers to execute arbitrary code.
Example:
Stack Smashing:
A specific type of buffer overflow where the stack is corrupted to inject malicious code or redirect execution flow.
Heap-Based Exploits
Heap Overflow:
Occurs when a program writes more data to a heap-allocated buffer than it can hold, corrupting adjacent memory.
Can overwrite metadata used by the memory allocator, leading to arbitrary code execution.
Use-After-Free:
Occurs when a program accesses memory after it has been freed, potentially allowing attackers to manipulate the freed memory.
Mitigations for Stack and Heap Exploits
Stack Mitigations
Stack Canaries:
Special values placed between the stack frame and return address.
If the canary value is altered, the program detects the corruption and terminates.
Non-Executable Stack (DEP):
Marks the stack as non-executable to prevent execution of injected code.
Address Space Layout Randomization (ASLR):
Randomizes the memory addresses of the stack, heap, and other segments to make it harder for attackers to predict memory locations.
Heap Mitigations
Heap Metadata Protection:
Modern memory allocators include integrity checks to detect corruption of heap metadata.
Safe Memory Functions:
Use safer alternatives to standard memory functions (e.g.,
strncpyinstead ofstrcpy).
Garbage Collection:
Automatically manages memory allocation and deallocation, reducing the risk of use-after-free and memory leaks.
General Mitigations
Input Validation:
Validate and sanitize all user inputs to prevent buffer overflows and other vulnerabilities.
Compiler Protections:
Use compiler options like
-fstack-protector(GCC) to enable stack protection mechanisms.
Code Auditing:
Regularly review and test code for vulnerabilities.
Permanent Storage: HDDs vs. SSDs
When it comes to permanent storage in computers, two primary technologies dominate the landscape: Hard Disk Drives (HDDs) and Solid State Drives (SSDs). Both serve the same purpose—storing data persistently even when the computer is powered off—but they achieve this in fundamentally different ways.
What is Permanent Storage?
Permanent storage, also known as non-volatile storage or secondary memory, refers to storage devices that hold data permanently or semi-permanently retains data even when the power is turned off. This is in contrast to volatile memory like RAM, which loses its contents when the computer shuts downand is generally slower to access. Permanent storage is essential for saving operating systems, applications, and user data. Examples include hard drives (HDDs), solid-state drives (SSDs), and optical discs.
Hard Disk Drives (HDDs)
How HDDs Work
An HDD is a mechanical storage device that uses magnetic storage to write and read data. It consists of two main components:
Rotating Magnetic Platter: This is where the data is stored. The platter spins at high speeds (commonly 5,400 or 7,200 RPM, though some high-performance drives can reach 10,000 RPM or more).
Disk Head: This component reads and writes data to the platter. It hovers just above the spinning platter, using magnetic fields to manipulate data.
Key Concepts in HDDs
Sector: The smallest unit of storage on an HDD. Typical sector sizes are 512 bytes or 4,096 bytes (4 KB) on newer devices.
Track: A concentric circle on a single platter where data is stored.
Cylinder: The same track across all platters in the HDD.
Cluster: The minimum amount of space that one saved file occupies. A cluster may span multiple sectors.
Advantages of HDDs
Cost-Effective: HDDs offer a much lower cost per gigabyte compared to SSDs. For example, an 8TB HDD might cost around $200, while a 4TB SSD could cost $600 or more.
High Storage Capacity: HDDs are ideal for storing large amounts of data, such as backups, media libraries, and archives.
Disadvantages of HDDs
Moving Parts: The mechanical nature of HDDs makes them prone to wear and tear. The number one cause of HDD failure is the failure of moving parts.
Slower Performance: Compared to SSDs, HDDs are significantly slower in terms of read/write speeds.
Noise and Heat: The spinning platters and moving disk head generate noise and heat during operation.
Solid State Drives (SSDs)
How SSDs Work
SSDs use flash memory to store data, which means they have no moving parts. Instead, data is stored in interconnected flash memory chips. This design makes SSDs faster, more reliable, and more durable than HDDs.
Key Concepts in SSDs
Write Amplification: When data is written to an SSD, the smallest unit of storage affected is typically larger than the actual data being written. For example, if an SSD has a 128 KB erase block and you save a 4 KB file, the entire 128 KB block must be erased before the 4 KB file can be written.
Wear Leveling: To prolong the life of an SSD, data is written and erased across different memory blocks evenly. This prevents certain blocks from wearing out prematurely.
Advantages of SSDs
Speed: SSDs are significantly faster than HDDs, offering near-instant boot times and rapid file transfers.
Durability: With no moving parts, SSDs are less prone to physical damage and mechanical failure.
Quiet Operation: SSDs operate silently since they lack spinning platters or moving heads.
Energy Efficiency: SSDs consume less power, making them ideal for laptops and portable devices.
Disadvantages of SSDs
Cost: SSDs are more expensive per gigabyte compared to HDDs.
Limited Write Cycles: Flash memory has a finite number of write cycles, though modern SSDs use wear leveling to mitigate this limitation.
Comparing HDDs and SSDs
Speed
Slower (mechanical components)
Faster (flash memory)
Durability
Prone to mechanical failure
More durable (no moving parts)
Noise
Noisy (spinning platters)
Silent
Heat
Generates heat
Minimal heat
Cost
Cheaper per GB
More expensive per GB
Capacity
Higher capacities available
Limited high-capacity options
Lifespan
Longer (no write cycle limits)
Limited by write cycles
Choosing Between HDDs and SSDs
The choice between an HDD and an SSD depends on your specific needs:
HDDs are ideal for bulk storage, such as backups, media libraries, and archival data.
SSDs are perfect for operating systems, applications, and tasks requiring high-speed performance.
For many users, a hybrid approach works best: using an SSD for the operating system and frequently accessed files, and an HDD for mass storage.
Virtualization
Virtualization is the process of creating a virtual version of a physical computing resource, such as a server, storage device, or network. This is achieved by using software to simulate hardware functionality, enabling multiple operating systems and applications to run on a single physical machine. Virtualization provides flexibility, scalability, and efficiency in managing IT resources.
Key Concepts in Virtualization
Partitioning:
Virtualization allows a single physical machine to be divided into multiple virtual machines (VMs).
Each VM operates as an independent system with its own operating system and applications.
System resources such as CPU, memory, and storage are allocated to each VM, ensuring efficient utilization of hardware.
Encapsulation:
The entire state of a virtual machine, including its configuration, operating system, and data, is saved into files.
This enables easy movement and copying of VMs between different physical hosts, simplifying backup, migration, and disaster recovery processes.
Isolation:
Virtual machines are isolated from each other and from the host system.
This ensures fault tolerance and security, as issues in one VM do not affect others.
Advanced resource controls preserve performance by preventing one VM from monopolizing system resources.
Hardware Independence:
Virtual machines are abstracted from the underlying hardware, allowing them to run on different physical machines without modification.
This flexibility simplifies hardware upgrades and migrations.
Types of Hypervisors
A hypervisor is the core software component in virtualization. It manages the creation and operation of virtual machines, allocating resources and ensuring isolation between VMs.
Type 1 Hypervisor (Bare-Metal):
Installed directly on the physical hardware, without requiring a host operating system.
Provides high performance and efficiency, as it has direct access to hardware resources.
Common examples:
VMware ESXi
Microsoft Hyper-V
Citrix XenServer
Type 2 Hypervisor (Hosted):
Runs on top of a host operating system, relying on the OS for hardware interaction.
Easier to set up and use, but typically less efficient than Type 1 hypervisors due to the additional OS layer.
Common examples:
VMware Workstation
Oracle VirtualBox
Parallels Desktop
Popular Virtualization Platforms
VMware ESXi:
A Type 1 hypervisor designed for enterprise environments.
Offers advanced features like vMotion (live migration of VMs) and Distributed Resource Scheduler (DRS).
Microsoft Hyper-V:
A Type 1 hypervisor integrated into Windows Server.
Supports features like nested virtualization and integration with Azure cloud services.
Proxmox VE:
An open-source virtualization platform that supports both KVM (Kernel-based Virtual Machine) and container-based virtualization.
Includes a web-based management interface for ease of use.
Oracle VirtualBox:
A Type 2 hypervisor that is free and open-source.
Popular for desktop virtualization and testing environments.
Containers
Containers are lightweight, portable, and isolated environments that package an application and its dependencies together. Containers ensure that applications run consistently across different environments, from development to production.
Key Features of Containers:
Isolation: Each container operates independently, ensuring that applications do not interfere with one another.
Portability: Containers can run on any system that supports containerization, making them ideal for hybrid and multi-cloud deployments.
Efficiency: Containers use fewer resources compared to virtual machines since they share the host OS kernel.
Consistency: By bundling the application with its dependencies, containers eliminate the "it works on my machine" problem.
Common Use Cases:
Microservices Architecture: Containers are ideal for breaking down applications into smaller, manageable services.
DevOps and CI/CD: Containers streamline development, testing, and deployment pipelines.
Cloud-Native Applications: Containers are a cornerstone of modern cloud-native development, enabling scalability and resilience.
Application Modernization: Containers help migrate legacy applications to modern infrastructure without significant rewrites.
Virtualization vs. Containers
While virtualization creates virtual machines with their own full operating systems, containers provide a lightweight alternative by sharing the host OS kernel. Containers are isolated environments for running applications, offering faster startup times and reduced resource overhead compared to VMs.
Virtual Machines:
Each VM includes a full operating system, virtual hardware, and applications.
Suitable for running multiple OS types or legacy applications.
Containers:
Share the host OS kernel but maintain isolation for applications.
Lightweight and faster to deploy, making them ideal for microservices and cloud-native applications.
Popular container platforms:
Docker: Simplifies container creation and management.
Kubernetes: Orchestrates and manages containerized applications at scale.
Benefits of Virtualization
Virtualization has become a cornerstone of modern IT infrastructure, enabling organizations to optimize resources, enhance flexibility, and accelerate innovation.
Cost Savings: Reduces the need for physical hardware, lowering capital and operational expenses.
Scalability: Easily add or remove virtual machines to meet changing demands.
Disaster Recovery: Simplifies backup and recovery processes through VM encapsulation.
Improved Resource Utilization: Maximizes the use of physical hardware by running multiple workloads on a single machine.
Numbering Systems & Conversions: Binary, Decimal, Hex, Octal
Computers use different numbering systems to represent and process values in memory, code, and programming. Each numbering system serves a specific purpose, depending on the context:
Binary (Base-2): The fundamental numbering system for computers, binary uses only two digits (0 and 1) to represent data. It directly corresponds to the on/off states of transistors in computer hardware. Binary is used for low-level operations, such as memory addressing, machine code, and logic gates.
Decimal (Base-10): The numbering system humans use daily, decimal is often used in programming for user-facing calculations and outputs. While computers process data in binary, decimal is used to make data more readable and intuitive for humans.
Hexadecimal (Base-16): Hexadecimal is a compact way to represent binary data. Each hexadecimal digit corresponds to four binary bits, making it easier to read and write large binary values. Hex is commonly used in programming for memory addresses, color codes in web design, and debugging.
Octal (Base-8): Octal is another shorthand for binary, where each octal digit represents three binary bits. It was historically used in early computing systems and is still occasionally used in specific contexts, such as Unix file permissions.
Conversions between these systems are essential for understanding how data is stored, processed, and displayed in computing environments. For example, programmers often convert between binary and hexadecimal to debug low-level code or between decimal and binary to understand how numbers are represented in memory.
The Binary Numbering System
The binary numbering system is the foundation of all modern computing. It uses only two digits, 0 and 1, to represent data. These digits correspond to the two states of a transistor in a computer's hardware: off (0) and on (1). Binary is used because it aligns perfectly with the physical properties of electronic circuits, making it efficient and reliable for processing and storing data.
How Binary Works in Computing
In computing, binary numbers are used to represent all types of data, including numbers, text, images, and instructions. Each binary digit (bit) represents a power of 2, starting from 2^0 on the rightmost bit. The value of a binary number is calculated by summing the powers of 2 for each bit that is set to 1.
Key Terms:
Bit: The smallest unit of data in computing, representing a single binary digit (
0or1).Byte: A group of 8 bits. It is the standard unit of data used to encode a single character in most computer systems.
Nibble: A group of 4 bits, or half a byte.
Octet: Another term for a byte, specifically 8 bits.
Quartet: A group of 4 bits, equivalent to a nibble.
Binary to Decimal Conversion
To convert a binary number to decimal:
Write the binary number.
Assign powers of 2 to each bit, starting from
2^0on the right.Multiply each bit by its corresponding power of 2.
Sum the results.
Example:
Convert 1101 (binary) to decimal:
Binary Value
1
1
0
1
Power of 2
2³
2²
2¹
2⁰
Decimal Value
8
4
0
1
Result: 8 + 4 + 0 + 1 = 13 (decimal)
Decimal to Binary Conversion
To convert a decimal number to binary:
Start with the decimal number.
Subtract the largest power of 2 less than or equal to the number.
Mark a
1in the corresponding binary position.Repeat for the remainder until it reaches
0.
Example:
Convert 19 (decimal) to binary:
Binary Value
1
0
0
1
1
Result: 19 in decimal is 10011 in binary.
Binary Representation in Programming
In programming, binary numbers are often prefixed with 0b to indicate they are in base-2. For example:
Binary is used in:
Bitwise operations: Manipulating individual bits in a number.
Memory addressing: Identifying specific locations in memory.
Data encoding: Representing characters, colors, and other data types.
Binary Table for a Byte (8 Bits)
A byte consists of 8 bits, and each bit represents a power of 2. The table below shows the relationship between bit positions and their decimal values:
Power of 2
2⁷
2⁶
2⁵
2⁴
2³
2²
2¹
2⁰
Decimal Value
128
64
32
16
8
4
2
1
Example:
The binary number 10101010 represents:128 + 0 + 32 + 0 + 8 + 0 + 2 + 0 = 170 (decimal).
Binary and Data Storage
Binary is used to encode all types of data:
Text: Characters are represented using binary codes like ASCII or Unicode.
Example: The letter
Ais01000001in ASCII.
Images: Pixels are represented as binary values for color and intensity.
Audio/Video: Digital media is encoded as streams of binary data.
Summary of Binary Numbering System
Understanding binary is essential for working with low-level programming, hardware design, and data encoding in computing systems.
Feature
Binary
Base
2
Digits
0, 1
Prefix
0b
Smallest Unit
Bit
Standard Unit
Byte (8 bits)
Applications
Data encoding, memory addressing, logic operations
The Hexadecimal Numbering System
The hexadecimal numbering system, or "hex," is a base-16 system that uses 16 unique characters to represent values. These characters include the digits 0 through 9 and the letters A through F, where A represents 10, B represents 11, and so on up to F, which represents 15. Hexadecimal is widely used in computing because it provides a more human-readable representation of binary data.
How Hexadecimal Works in Computing
In computing, hexadecimal numbers are often used as a shorthand for binary numbers. Each hexadecimal digit corresponds to exactly four binary bits, making it easier to represent large binary values compactly. Hexadecimal is commonly used in memory addressing, color codes in web design, and debugging.
Key Terms:
Nibble: A group of 4 bits, equivalent to a single hexadecimal digit.
Byte: A group of 8 bits, represented by two hexadecimal digits.
Word: A larger unit of data, often represented by multiple hexadecimal digits.
Hexadecimal to Decimal Conversion
To convert a hexadecimal number to decimal:
Write the hexadecimal number.
Assign powers of 16 to each digit, starting from
16^0on the right.Multiply each digit by its corresponding power of 16.
Sum the results.
Example:
Convert 1F (hexadecimal) to decimal:
Power of 16
16
1
Decimal Value
16
15
Result: 16 + 15 = 31 (decimal)
Decimal to Hexadecimal Conversion
To convert a decimal number to hexadecimal:
Divide the decimal number by 16.
Record the remainder as the least significant digit (rightmost).
Repeat the division with the quotient until it equals 0.
Write the remainders in reverse order.
Example:
Convert 255 (decimal) to hexadecimal:
255 ÷ 16
15
F
15 ÷ 16
0
F
Result: 255 in decimal is FF in hexadecimal.
Hexadecimal Representation in Programming
In programming, hexadecimal numbers are often prefixed with 0x or # to indicate they are in base-16. For example:
Hexadecimal is used in:
Memory Addresses: Representing locations in memory.
Color Codes: Defining colors in web design (e.g.,
#FF5733).Machine Code: Representing instructions in assembly language.
Hexadecimal Table for a Byte (8 Bits)
A byte consists of 8 bits, which can be represented by two hexadecimal digits. The table below shows the relationship between binary and hexadecimal:
0000
0
0001
1
0010
2
0011
3
0100
4
0101
5
0110
6
0111
7
1000
8
1001
9
1010
A
1011
B
1100
C
1101
D
1110
E
1111
F
Example:
The binary number 11111111 represents:F (first quartet) + F (second quartet) = FF (hexadecimal).
Hexadecimal and Data Representation
Hexadecimal is used to encode various types of data:
Text: ASCII and Unicode characters are often represented in hexadecimal.
Example: The letter
Ais41in hexadecimal.
Colors: RGB values are encoded as hexadecimal triplets.
Example:
#FFFFFFrepresents white.
Memory: Addresses and offsets in memory are displayed in hexadecimal for compactness.
Summary of Hexadecimal Numbering System
Understanding hexadecimal is essential for working with low-level programming, debugging, and data representation in computing systems.
Feature
Hexadecimal
Base
16
Digits
0–9, A–F
Prefix
0x or #
Smallest Unit
Nibble (4 bits)
Standard Unit
Byte (8 bits)
Applications
Memory addressing, color codes, debugging
The Octal Numbering System
The octal numbering system, or base-8 system, uses eight unique digits: 0 through 7. It is a compact way to represent binary numbers, grouping them into sets of three bits. Octal was historically used in early computing systems and is still occasionally used in specific contexts, such as Unix file permissions.
Octal in Computing
In computing, octal numbers are often used as a shorthand for binary numbers. Each octal digit corresponds to exactly three binary bits, making it easier to represent large binary values compactly. Octal is particularly useful in systems where binary data needs to be grouped into manageable chunks.
Key Terms:
Triplet: A group of three binary bits, equivalent to a single octal digit.
Octal Digit: A number between
0and7that represents three binary bits.
Binary to Octal Conversion
To convert a binary number to octal:
Group the binary number into sets of three bits, starting from the right. Add leading zeros if necessary to complete the leftmost group.
Write the corresponding octal digit for each group.
Example:
Convert 110101 (binary) to octal:
Octal Digit
0
6
5
Result: 110101 in binary is 065 in octal.
Octal to Binary Conversion
To convert an octal number to binary:
Write the 3-bit binary representation for each octal digit.
Join the binary groups together.
Example:
Convert 57 (octal) to binary:
Binary Group
101
111
Result: 57 in octal is 101111 in binary.
Octal Representation in Programming
In programming, octal numbers are often prefixed with 0 or 0o to indicate they are in base-8. For example:
Octal is used in:
Unix File Permissions: Representing read, write, and execute permissions (e.g.,
chmod 755).Legacy Systems: Early computing systems that grouped binary data in sets of three bits.
Octal Table for a Byte (8 Bits)
A byte consists of 8 bits, which can be represented by up to three octal digits. The table below shows the relationship between binary and octal:
000
0
001
1
010
2
011
3
100
4
101
5
110
6
111
7
Example:
The binary number 11010110 represents:110 (6) + 101 (5) + 10 (2, with leading zero added) = 652 (octal).
Octal and Data Representation
Octal is used to encode various types of data:
File Permissions: Unix systems use octal to represent file permissions (e.g.,
rwxis7in octal).Memory: Early systems used octal to simplify binary memory addresses.
Summary of Octal Numbering System
Understanding octal is essential for working with legacy systems, Unix file permissions, and compact binary representations.
Feature
Octal
Base
8
Digits
0–7
Prefix
0 or 0o
Smallest Unit
Triplet (3 bits)
Applications
Unix permissions, legacy systems, binary shorthand
Endianess
Endianness refers to the order in which bytes are arranged and interpreted in computer memory. It determines how multi-byte data types (e.g., integers, floating-point numbers) are stored and accessed in memory. This concept is crucial in various areas of computing, including computer memory, networking, programming, and numbering systems.
What is Endianness?
Endianness defines the sequence in which bytes are stored in memory for multi-byte data types. It specifies whether the most significant byte (MSB) or the least significant byte (LSB) is stored first. The two primary types of endianness are:
Big-Endian (BE):
The most significant byte (MSB) is stored at the lowest memory address.
Data is stored in a way that aligns with how humans typically read numbers (left to right).
Example: The hexadecimal number
0x12345678is stored in memory as:
Little-Endian (LE):
The least significant byte (LSB) is stored at the lowest memory address.
Data is stored in reverse order compared to how humans read numbers.
Example: The hexadecimal number
0x12345678is stored in memory as:
Most modern computers store data in a little-endian format, where the least significant byte (LSB) is stored first in memory. This format is commonly used in x86 and x86-64 architectures due to its efficiency in certain hardware operations. However, exceptions do exist, such as some older systems and network protocols, which often use big-endian format for compatibility and standardization.
How Endianness Relates to Computer Memory
In computer memory, data is stored as a sequence of bytes. Endianness determines how these bytes are ordered for multi-byte data types. For example:
A 32-bit integer consists of 4 bytes.
Depending on the system's endianness, these bytes are stored in a specific order.
Key Points:
Big-Endian Systems: Store the most significant byte first, making the memory layout intuitive for humans.
Little-Endian Systems: Store the least significant byte first, which can simplify certain hardware operations, such as incrementing memory addresses.
Most modern PCs, including those using x86 and x86-64 architectures, use little-endian format. However, some network protocols and older systems use big-endian format.
Endianness in Networking
In networking, data is transmitted between systems that may have different endianness. To ensure compatibility, most network protocols, such as TCP/IP, use big-endian format, also known as network byte order. This standardization ensures that data is interpreted consistently, regardless of the endianness of the sending or receiving system.
Example:
When transmitting a 32-bit integer
0x12345678over a network:It is sent in big-endian order:
0x12 0x34 0x56 0x78.A little-endian system receiving this data must convert it to its native format for processing.
Endianness in Programming
Endianness plays a critical role in programming, especially when dealing with low-level operations, file formats, and cross-platform compatibility. Many programming languages provide tools to handle endianness explicitly:
C/C++:
Use bitwise operations or functions like
htonl()(host-to-network long) andntohl()(network-to-host long) to convert between endianness.Example:
Python:
Use the
structmodule to specify endianness when packing or unpacking binary data.Example:
Swift:
Swift uses little-endian format by default but provides methods to convert between endianness.
Example:
Endianness and Numbering Systems
Endianness is closely related to numbering systems like binary, decimal, and hexadecimal. While numbering systems define how numbers are represented, endianness determines how these representations are stored in memory.
Example:
The binary representation of
0x12345678is00010010 00110100 01010110 01111000.In big-endian format, this binary sequence is stored as-is.
Hex:
0x12 0x34 0x56 0x78Binary:
00010010 00110100 01010110 01111000
In little-endian format, the sequence is reversed at the byte level (chunked as two hex characters, or 8 bits, not every single bit is reversed).
Hex:
0x78 0x56 0x34 0x12Binary:
01111000 01010110 00110100 00010010
Endianness and File Formats
Many file formats specify a particular endianness for storing multi-byte data. For example:
Big-Endian Formats: Used in older systems and some multimedia formats (e.g., JPEG, TIFF).
Little-Endian Formats: Common in modern systems and formats like BMP and WAV.
When reading or writing files, programmers must account for the file's endianness to ensure correct data interpretation.
Endianness and Cross-Platform Compatibility
Endianness differences can cause issues when transferring data between systems with different architectures. To address this:
Use standardized formats (e.g., network byte order) for data exchange.
Include metadata in files or protocols to indicate the endianness of the stored data.
Use libraries or APIs that handle endianness conversions automatically.
Byte Order Mark (BOM)
The Byte Order Mark (BOM) is a special marker used in Unicode text files to indicate the file's endianness and encoding. It helps systems interpret the text correctly, especially when transferring files between platforms with different endianness.
Example:
A BOM for UTF-16 big-endian is
0xFEFF.A BOM for UTF-16 little-endian is
0xFFFE.
Summary
Endianness is a fundamental concept in computing that affects how data is stored, transmitted, and interpreted. It is closely tied to computer memory, networking, programming, and numbering systems. Understanding endianness is essential for developing cross-platform applications, working with binary data, and ensuring compatibility in networked systems.
Aspect
Big-Endian
Little-Endian
Memory Order
MSB stored first
LSB stored first
Network Protocols
Standard (network byte order)
Requires conversion
Programming
Explicit handling often needed
Native format for most PCs
File Formats
Common in older formats
Common in modern formats
Usage
Intuitive for humans
Efficient for hardware
Last updated
Was this helpful?