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