CS-300 Chapter 2 Notes

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.

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.

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.