CMSC412 - Operating-System Structures - Chapter (2)

user interface (UI): A method by which a user interacts with a computer.

graphical user interface (GUI): A computer interface comprising a window system with a pointing device to direct I/O, choose from menus, and make selections and, usually, a keyboard to enter text.

touch-screen interface: A user interface in which touching a screen allows the user to interact with the computer.

command-line interface (CLI): A method of giving commands to a computer based on a text input device (such as a keyboard).

shared memory: In interprocess communication, a section of memory shared by multiple processes and used for message passing.

message passing: In interprocess communication, a method of sharing data in which messages are sent and received by processes. Packets of information in predefined formats are moved between processes or between computers.

command interpreter: The operating system component that interprets user commands and causes actions based on them.

shell: One of the command interpreters on a system with multiple command interpreters to choose from.

desktop: In a GUI, the standard workspace represented by the GUI on the screen, in which a user executes tasks.

icons: Images representing objects (such as files or applications) that users can chose via the GUI.

folder: A file system component that allows users to group files together.

gestures: A user interface component in which motions cause computer actions (e.g., "pinching" the screen).

springboard: The iOS touch-screen interface.

system administrators: Computer users that configure, monitor, and manage systems.

power users: Users with unusually deep knowledge of a system.

shell script: A file containing a set series of commands (similar to a batch file) that are specific to the shell being used.

system call: Software-triggered interrupt allowing a process to request a kernel service.

application programming interface (API): A set of commands, functions, and other tools that can be used by a programmer in developing a program.

C library (libc): The standard UNIX/Linux system API for programs written in the C programming language.

run-time environment (RTE): The full suite of software needed to execute applications written in a given programming language, including its compilers, libraries, and loaders.

system-call interface: An interface that serves as the link to system calls made available by the operating system and that is called by processes to invoke system calls.

push: The action of placing a value on a stack data structure.

stack: A sequentially ordered data structure that uses the last-in, first-out (LIFO) principle for adding and removing items; the last item placed onto a stack is the first item removed.

process control: A category of system calls.

information maintenance: A category of system calls.

communications: A category of system calls.

protection: A category of system calls. Any mechanism for controlling the access of processes or users to the resources defined by a computer system.

debugger: A system program designed to aid programmers in finding and correcting errors.

bug: An error in computer software or hardware.

lock: A mechanism that restricts access by processes or subroutines to ensure integrity of shared data.

sketch: An Arduino program.

single step: A CPU mode in which a trap is executed by the CPU after every instruction (to allow examination of the system state after every instruction); useful in debugging.

message-passing model: A method of interprocess communication in which messages are exchanged.

host name: A human-readable name for a computer.

process name: A human-readable name for a process.

daemon: A service that is provided outside of the kernel by system programs that are loaded into memory at boot time and run continuously.

client: A computer that uses services from other computers (such as a web client). The source of a communication.

server: In general, any computer, no matter the size, that provides resources to other computers.

shared-memory model: An interprocess communication method in which multiple processes share memory and use that memory for message passing.

system service: A collection of applications included with or added to an operating system to provide services beyond those provided by the kernel.

system utility: A collection of applications included with or added to an operating system to provide services beyond what are provided by the kernel.

registry: A file, set of files, or service used to store and retrieve configuration information. In Windows, the manager of hives of data.

service: A software entity running on one or more machines and providing a particular type of function to calling clients. In Android, an application component with no user interface; it runs in the background while executing long-running operations or performing work for remote processes.

subsystem: A subset of an operating system responsible for a specific function (e.g., memory management).

application program: A program designed for end-user execution, such as a word processor, spreadsheet, compiler, or Web browser.

relocatable object file: The output of a compiler in which the contents can be loaded into any location in physical memory.

linker: A system service that combines relocatable object files into a single binary executable file.

executable file: A file containing a program that is ready to be loaded into memory and executed.

loader: A system service that loads a binary executable file into memory, where it is eligible to run on a CPU core.

relocation: An activity associated with linking and loading that assigns final addresses to program parts and adjusts code and data in the program to match those addresses.

dynamically linked libraries (DLLs): System libraries that are linked to user programs when the processes are run, with linking postponed until execution time.

executable and linkable format (ELF): The UNIX standard format for relocatable and executable files.

portable executable (PE): The Windows format for executable files.

Mach-O: The macOS format of executable files.

port: A communication address; a system may have one IP address for network connections but many ports, each for a separate communication. In computer I/O, a connection point for devices to attach to computers. In software development, to move code from its current platform to another platform (e.g., between operating systems or hardware systems). In the Mach OS, a mailbox for communication.

software engineering: A field of study and a career involving writing software (i.e., programming.)

policy: A rule that defines what will be done.

mechanism: An operation that defines how something will be done.

monolithic: In kernel architecture, describes a kernel without structure (such as layers or modules).

tightly coupled systems: Systems with two or more processors in close communication, sharing the computer bus and sometimes the clock, memory, and peripheral devices.

loosely coupled: Describes a kernel design in which the kernel is composed of components that have specific and limited functions.

layered approach: A kernel architecture in which the operating system is separated into a number of layers (levels); typically, the bottom layer (layer 0) is the hardware, and the highest (layer N) is the user interface.

Mach: An operating system with microkernel structure and threading; developed at Carnegie Mellon University.

microkernel: An operating-system structure that removes all nonessential components from the kernel and implements them as system and user-level programs.

loadable kernel module (LKM): A kernel structure in which the kernel has a set of core components and can link in additional services via modules, either at boot time or during run time.

user experience layer: in the layered macOS and iOS operating system design, the layer that defines the software interface that allows users to interact with computing devices.

application frameworks layer: in the layered macOS and iOS operating system design, the layer that includes Cocoa and Cocoa Touch frameworks, providing an API for Objective-C and Swift programming languages.

core frameworks: in the layered macOS and iOS operating system design, the layer that defines frameworks that support graphics and media, including quicktime and opengl.

kernel environment: in the layered macOS and iOS operating system design, the darwin layer that includes the mach microkernel and the bsd unix kernel.

Darwin: The Apple code name for its open-source kernel.

trap: A software interrupt. The interrupt can be caused either by an error (e.g., division by zero or invalid memory access) or by a specific request from a user program that an operating-system service be performed.

kernel abstractions: Components provided with the Mach microkernel to add functionality beyond the microkernel, such as tasks, threads, memory objects, and ports.

kernel extensions (kexts): Third-party components added to the kernel (usually to support third-party devices or services).

kexts: Third-party components added to the kernel (usually to support third-party devices or services).

ahead-of-time (AOT) compilation: A feature of the Android RunTime (ART) virtual machine environment in which Java applications are compiled to native machine code when they are installed on a system (rather than just in time, when they are executed).

Bionic: A type of standard C library used by Android; it has a smaller memory footprint than glibc and is more efficient on slower (mobile) CPUs.

Windows Subsystem for Linux (WSL): A Windows 10 component allowing native Linux applications (ELF binaries) to run on Windows.

Linux instance: A set of Pico processes running in Windows created by WSL containing an init process and a bash shell (allowing executing of Linux commands within Windows)

Pico: In WSL, a special Linux-enabling process that translates Linux system calls to the LXCore and LXSS services.

system build: Creation of an operating-system build and configuration for a specific computer site.

booting: The procedure of starting a computer by loading the kernel.

bootstrap program: The program that allows the computer to start running by initializing hardware and loading the kernel.

BIOS: Code stored in firmware and run at boot time to start system operation.

boot block: A block of code stored in a specific location on disk with the instructions to boot the kernel stored on that disk. The UFS boot control block.

unified extensible firmware interface (UEFI): The modern replacement for BIOS containing a complete boot manager.

running: The state of the operating system after boot when all kernel initialization has completed and system services have started. In general, the system state after booting and before crashing or being shut down.

GRUB: A common open-source bootstrap loader that allows selection of boot partitions and options to be passed to the selected kernel.

recovery mode: A system boot state providing limited services and designed to enable the system admin to repair system problems and debug system startup.

single-user mode: A system boot state providing limited services and designed to enable the system admin to repair system problems and debug system startup.

debugging: The activity of finding and removing errors.

performance tuning: The activity of improving performance by removing bottlenecks.

bottleneck: A performance-limiting aspect of computing (e.g., poorly written code or a hardware component that is not as fast as others in the system).

log file: A file containing error or "logging" information; used for debugging or understanding the state or activities of the system.

core dump: A copy of the state of a process written to disk when a process crashes; used for debugging.

crash: Termination of execution due to a problem. A failure in the kernel results in a system crash and reboot, while a process failure results in a process crash.

crash dump: A copy of the state of the kernel written to disk during a crash; used for debugging.

BPF compiler collection (BCC): A rich toolkit for tracing system activity on Linux for debugging and performance-tuning purposes.