User:Zarzuelazen/Books/Reality Theory: Operating Systems&Architecture

Reality Theory: Operating Systems&Architecture

 * ABA problem
 * Abstract syntax tree
 * Access control
 * Access control list
 * Access token
 * Accumulator (computing)
 * Active Directory
 * Active message
 * Adaptive optimization
 * Adder (electronics)
 * Address space
 * Address space layout randomization
 * Addressing mode
 * Adware
 * Affinity mask
 * Ahead-of-time compilation
 * Alt code
 * Ambient authority
 * Amdahl's law
 * Ancilla bit
 * Android (operating system)
 * Anomaly-based intrusion detection system
 * Anonymous pipe
 * Anti-computer forensics
 * Antivirus software
 * Apple File System
 * Application binary interface
 * Application checkpointing
 * Arbitrary-precision arithmetic
 * Archive file
 * Arithmetic logic unit
 * Arithmetic shift
 * Arithmetic underflow
 * ARM architecture
 * Assembly language
 * Asymmetric multiprocessing
 * Asynchronous I/O
 * Asynchronous System Trap
 * Attack surface
 * Attribute-based access control
 * Authentication
 * Authorization
 * Autoplay
 * Autorun
 * Avast Antivirus
 * .bss
 * Backdoor (computing)
 * Background process
 * Bank switching
 * Barrier (computer science)
 * Bash (Unix shell)
 * Basic block
 * Batch file
 * Batch processing
 * Berkeley Software Distribution
 * bfloat16 floating-point format
 * Bijective numeration
 * Binary-coded decimal
 * Binary file
 * BIOS
 * BIOS interrupt call
 * Bit field
 * Bit numbering
 * Bit-level parallelism
 * Bitwise operation
 * Blacklist (computing)
 * Block (data storage)
 * Blocking (computing)
 * Blue Screen of Death
 * Boot sector
 * Booting
 * Bootstrapping (compilers)
 * Branch (computer science)
 * Branch predictor
 * Branch table
 * Bubble (computing)
 * Buffer over-read
 * Buffer overflow
 * Buffer overflow protection
 * Busy waiting
 * Bytecode
 * Cache (computing)
 * Cache coherence
 * Cache replacement policies
 * Call gate (Intel)
 * Call stack
 * Calling convention
 * Capability-based operating system
 * Capability-based security
 * CAPTCHA
 * Carriage return
 * Carry flag
 * CCSID
 * Central processing unit
 * Challenge–response authentication
 * Child process
 * Chrome OS
 * Circular shift
 * Classic RISC pipeline
 * Clipboard (computing)
 * Clustered file system
 * Code generation (compiler)
 * Code injection
 * Code segment
 * Cold boot attack
 * Command substitution
 * Commit charge
 * Compare-and-swap
 * Comparison of instruction set architectures
 * Compile time
 * Compiler
 * Complex instruction set computer
 * Component Object Model
 * Computer access control
 * Computer architecture
 * Computer code
 * Computer file
 * Computer forensics
 * Computer multitasking
 * Computer number format
 * Computer security
 * Computer virus
 * Computer worm
 * Concurrency (computer science)
 * Concurrent computing
 * Configuration file
 * Confused deputy problem
 * Constant folding
 * Context (computing)
 * Context switch
 * Control character
 * Control flow analysis
 * Control flow graph
 * Control register
 * Control unit
 * Control-Alt-Delete
 * Cooperative multitasking
 * Copy-on-write
 * Core dump
 * Coscheduling
 * CP/M
 * CPU cache
 * CPU modes
 * CPU time
 * CPU-bound
 * Crash (computing)
 * Critical section
 * Cross compiler
 * Cycles per instruction
 * Cylinder-head-sector
 * Daemon (computing)
 * Dangling pointer
 * Data buffer
 * Data cluster
 * Data dependency
 * Data erasure
 * Data parallelism
 * Data recovery
 * Data remanence
 * Data segment
 * Data structure alignment
 * Data-flow analysis
 * Dataflow
 * Dataflow architecture
 * Dataflow programming
 * Dead code
 * Deadlock
 * Decimal floating point
 * Decompiler
 * Defense strategy (computing)
 * Defragmentation
 * Delay slot
 * Delimiter
 * Demand paging
 * Denormal number
 * Desktop environment
 * Device driver
 * Device file
 * DIGITAL Command Language
 * Digital forensics
 * Dining philosophers problem
 * Direct memory access
 * Directory (computing)
 * Directory service
 * Directory structure
 * Directory traversal attack
 * Disassembler
 * Discretionary access control
 * Disk encryption
 * Disk image
 * Disk operating system
 * Disk partitioning
 * Disk sector
 * Display server
 * Distributed data flow
 * Distributed file system for cloud
 * Distributed memory
 * Distributed operating system
 * Distributed shared memory
 * DOS
 * Double-precision floating-point format
 * DLL Hell
 * Dominator (graph theory)
 * Dynamic Data Exchange
 * Dynamic linker
 * Dynamic recompilation
 * Dynamic-link library
 * Earliest deadline first scheduling
 * Embedded operating system
 * Emulator
 * Endianness
 * Environment variable
 * Error message
 * Escape character
 * ESET NOD32
 * Event (synchronization primitive)
 * Everything is a file
 * Exec (system call)
 * Executable
 * Executable and Linkable Format
 * Executable space protection
 * Execution (computing)
 * Execution model
 * exFAT
 * Exit (system call)
 * Exokernel
 * Explicit parallelism
 * Explicitly parallel instruction computing
 * Exploit (computer security)
 * Extended basic block
 * Extended file attributes
 * ext4
 * Fatal exception error
 * Fatal system error
 * Fetch-and-add
 * Fiber (computer science)
 * FIFO (computing and electronics)
 * File Allocation Table
 * File attribute
 * File deletion
 * File descriptor
 * File format
 * File locking
 * File manager
 * File sequence
 * File system
 * File system fragmentation
 * File system permissions
 * Filename
 * Filename extension
 * Filter (software)
 * Firmware
 * Fixed-point arithmetic
 * Fixed-priority pre-emptive scheduling
 * FLAGS register
 * Flat memory model
 * Floating-point arithmetic
 * Floating-point unit
 * Flynn's taxonomy
 * Fork (file system)
 * Fork (system call)
 * Formatted text
 * Fragmentation (computing)
 * FreeBSD
 * Garbage (computer science)
 * Garbage collection (computer science)
 * General protection fault
 * Glob (programming)
 * Global Descriptor Table
 * Granularity (parallel computing)
 * Green threads
 * Group identifier
 * GUID Partition Table
 * Half-precision floating-point format
 * Handle (computing)
 * Hang (computing)
 * Hard link
 * Hardware performance counter
 * Hardware register
 * Hardware virtualization
 * Hazard (computer architecture)
 * Heap overflow
 * Here document
 * HFS Plus
 * Hibernation (computing)
 * Hierarchical File System
 * High Performance File System
 * Honeypot (computing)
 * Hooking
 * Host-based intrusion detection system
 * Hosts (file)
 * Hybrid kernel
 * Hyper-threading
 * Hypervisor
 * IBM PC DOS
 * I/O bound
 * I/O scheduling
 * Implicit parallelism
 * Indirect branch
 * Induction variable
 * Init
 * Inode
 * Inode pointer structure
 * Input/output
 * Installation (computer programs)
 * Instruction cycle
 * Instruction pipelining
 * Instruction register
 * Instruction scheduling
 * Instruction selection
 * Instruction set architecture
 * Instruction window
 * Instruction-level parallelism
 * Instructions per cycle
 * Integer overflow
 * Intel Memory Model
 * Inter-process communication
 * Intermediate representation
 * Interpreter (computing)
 * Interrupt
 * Interrupt descriptor table
 * Interrupt handler
 * Interrupt latency
 * Interrupt request (PC architecture)
 * Interrupt vector table
 * Intrusion detection system
 * Intrusion detection system evasion techniques
 * IOS
 * ISO 9660
 * Job (computing)
 * Job control (computing)
 * Job control (Unix)
 * Job Control Language
 * Job queue
 * Job scheduler
 * Journaling file system
 * Just-in-time compilation
 * Kaspersky Internet Security
 * Kernel (operating system)
 * Kernel panic
 * Key finding attacks
 * Keystroke logging
 * Large-file support
 * Library (computing)
 * Light-weight process
 * Linearizability
 * Link time
 * Linker (computing)
 * Linux
 * Linux kernel
 * List of file formats
 * List of instruction sets
 * Live CD
 * Live USB
 * Live variable analysis
 * Liveness
 * Load (computing)
 * Loadable kernel module
 * Loader (computing)
 * Locality of reference
 * Lock (computer science)
 * Logic bomb
 * Logic synthesis
 * Logical block addressing
 * Logical disk
 * Logical partition
 * Logical shift
 * Logical volume management
 * Login
 * Login session
 * Login spoofing
 * Loop interchange
 * Loop nest optimization
 * Loop optimization
 * Loop unrolling
 * Low-level programming language
 * Mach-O
 * Machine code
 * Machine epsilon
 * MacOS
 * Malware
 * Mandatory access control
 * Manual memory management
 * Mask (computing)
 * Master boot record
 * Memory access pattern
 * Memory address
 * Memory address register
 * Memory buffer register
 * Memory coherence
 * Memory corruption
 * Memory debugger
 * Memory hierarchy
 * Memory leak
 * Memory management
 * Memory management (operating systems)
 * Memory management unit
 * Memory pool
 * Memory protection
 * Memory safety
 * Memory segmentation
 * Memory-mapped file
 * Message passing
 * Message Passing Interface
 * Message queue
 * Metamorphic code
 * Method of complements
 * Microarchitecture
 * Microcode
 * Microkernel
 * Micro-operation
 * Microsoft Windows
 * MIMD
 * MISD
 * Mobile malware
 * Mobile operating system
 * Mobile security
 * Monolithic kernel
 * Mount (computing)
 * MS-DOS
 * Multi-factor authentication
 * Multi-pass compiler
 * Multi-user
 * Multics
 * Multilevel queue
 * Multiply–accumulate operation
 * Multiprocessing
 * Multiprocessor scheduling
 * Multithreading (computer architecture)
 * Mutual exclusion
 * Name Service Switch
 * Named pipe
 * NaN
 * Network booting
 * Network operating system
 * Network socket
 * Network virtualization
 * Newline
 * Non-blocking algorithm
 * Non-uniform memory access
 * NOP (code)
 * NOP slide
 * Normal number (computing)
 * Normalized number
 * Norton Internet Security
 * NTFS
 * Null pointer
 * Object code
 * Object file
 * Object Linking and Embedding
 * Offset binary
 * OLE Automation
 * One-pass compiler
 * Ones' complement
 * Opcode
 * OpenBSD
 * OpenVMS
 * Operand forwarding
 * Operating system
 * Operating-system-level virtualization
 * Optical disc image
 * Optimizing compiler
 * Orders of magnitude (data)
 * Order of operations
 * Orphan process
 * OS/2
 * Out-of-order execution
 * Page (computer memory)
 * Page cache
 * Page fault
 * Page replacement algorithm
 * Page table
 * Paging
 * Parallel computing
 * Parallel programming model
 * Parent process
 * Parity bit
 * Parity flag
 * Parsing
 * Path (computing)
 * Payload (computing)
 * Peephole optimization
 * Persistence (computer science)
 * Pharming
 * Physical address
 * Pipeline (computing)
 * Pipeline (software)
 * Pipeline (Unix)
 * Plain text
 * Polling (computer science)
 * Polymorphic code
 * Polytope model
 * Portable Executable
 * POSIX
 * Power-on self-test
 * Predication (computer architecture)
 * Preemption (computing)
 * Preprocessor
 * Principle of least privilege
 * Priority inheritance
 * Priority inversion
 * Privilege (computing)
 * Privilege escalation
 * Privilege separation
 * Process (computing)
 * Process control block
 * Process group
 * Process identifier
 * Process management (computing)
 * Process migration
 * Process state
 * Process substitution
 * Processor affinity
 * Processor register
 * Producer–consumer problem
 * Profile-guided optimization
 * Program counter
 * Program lifecycle phase
 * Programmable interrupt controller
 * Programmed input/output
 * Programming model
 * Protected mode
 * Protection ring
 * Quantum register
 * Quarantine (computing)
 * Race condition
 * RAID
 * Ransomware
 * Reaching definition
 * Reactive programming
 * Readers–writer lock
 * Readers–writers problem
 * Real mode
 * Real-time operating system
 * Reboot (computing)
 * Redirection (computing)
 * Reduced instruction set computer
 * Reentrancy (computing)
 * Reference counting
 * Region-based memory management
 * Register allocation
 * Relocation (computing)
 * Rematerialization
 * Remote direct memory access
 * Remote procedure call
 * Reset (computing)
 * Resident monitor
 * Resource contention
 * Resource leak
 * Resource management (computing)
 * Rogue security software
 * Role-based access control
 * Root directory
 * Rooting (Android)
 * Rootkit
 * Round-robin scheduling
 * Runlevel
 * Runtime (program lifecycle phase)
 * Runtime library
 * Runtime system
 * Safe mode
 * Sandbox (computer security)
 * Scareware
 * Scheduling (computing)
 * Screensaver
 * Secure attention key
 * Security-focused operating system
 * Security question
 * Segmentation fault
 * Self-hosting (compilers)
 * Semaphore (programming)
 * Server Message Block
 * Shared memory
 * Shared resource
 * Shell (computing)
 * Shell builtin
 * Shell script
 * Shellcode
 * Shortcut (computing)
 * Shortest remaining time
 * Shutdown (computing)
 * Signal (IPC)
 * Sign bit
 * Signed number representations
 * Signed zero
 * Significand
 * Simultaneous multithreading
 * Single instruction, multiple threads
 * Single-precision floating-point format
 * Single user mode
 * SIMD
 * SISD
 * SPMD
 * Sleep (system call)
 * Sleep mode
 * Snapshot (computer storage)
 * Software lockout
 * Software pipelining
 * Source code
 * Source-to-source compiler
 * Sparse conditional constant propagation
 * Spawn (computing)
 * Speculative execution
 * Speedup
 * Spinlock
 * Spyware
 * Stack (abstract data type)
 * Stack-based memory allocation
 * Stack buffer overflow
 * Stack overflow
 * Stack register
 * Stack trace
 * Standard streams
 * Starvation (computer science)
 * Static build
 * Static library
 * Static single assignment form
 * Status register
 * Storage violation
 * Storage virtualization
 * Stream (computing)
 * Stream processing
 * Strength reduction
 * Superuser
 * Symbol table
 * Symbolic link
 * Symmetric multiprocessing
 * Synchronization (computer science)
 * Syntax-directed translation
 * System call
 * System console
 * System image
 * System monitor
 * System partition and boot partition
 * System programming
 * System resource
 * System software
 * System time
 * System virtual machine
 * Task (computing)
 * Task manager
 * Task Manager (Windows)
 * Task parallelism
 * Task state segment
 * Temporal multithreading
 * Terminal emulator
 * Test-and-set
 * Text file
 * Thrashing (computer science)
 * Thread (computing)
 * Threaded code
 * Thread pool
 * Thread safety
 * Thread-local storage
 * Timeout (computing)
 * Time-sharing
 * Tracing garbage collection
 * Tracing just-in-time compilation
 * Track (disk drive)
 * Trap (computing)
 * Trash (computing)
 * Transactional memory
 * Translation lookaside buffer
 * Translation unit (programming)
 * Translator (computing)
 * Trojan horse (computing)
 * Trusted computing base
 * Two's complement
 * Uncontrolled format string
 * Undeletion
 * Unified Extensible Firmware Interface
 * Uniform memory access
 * Unikernel
 * Universal Disk Format
 * Unix
 * Unix domain socket
 * Unix File System
 * Unix filesystem
 * Unix shell
 * Unix-like
 * Unum (number format)
 * Uptime
 * User (computing)
 * User identifier
 * User space
 * Vector (malware)
 * Very long instruction word
 * Virtual address space
 * Virtual desktop
 * Virtual disk and virtual drive
 * Virtual file system
 * Virtual machine
 * Virtual memory
 * Virtual security switch
 * Virtualization
 * Volume (computing)
 * Volume boot record
 * Von Neumann architecture
 * Vulnerability (computing)
 * Vulnerability scanner
 * Whitelisting
 * Wildcard character
 * Windows Defender
 * Window manager
 * Windows API
 * Windows NT
 * Windows Registry
 * Windows service
 * Windows shell
 * Windows Task Scheduler
 * Windows Update
 * Windowing system
 * Word (computer architecture)
 * Work-conserving scheduler
 * Working directory
 * Working set
 * X86
 * X86 assembly language
 * X86 calling conventions
 * X86 instruction listings
 * x86 memory segmentation
 * Z/OS
 * Zero-copy
 * Zero-day (computing)
 * Zip (file format)
 * Zombie process