Glossary
This glossary defines many of the terms that we use frequently throughout the book. All terms are related to various aspects of concurrent and networked software. When a definition consists of other terms in the glossary we italicize these terms.
We have omitted terminology used in only one context, for example the network management terms from the Extension Interface and Asynchronous Completion Token patterns. Where such terms need a definition, we present them in context rather than including them here. For completeness, we have also included common terms, such as ‘pattern’, ‘software architecture’, and ‘idiom’, that were explained in depth in various sections of [POSA1].
Abstract Class
A class that does not implement all the methods defined in its interface. An abstract class defines a common abstraction for its subclasses.
Abstract Component
A component that specifies an interface for other components. An abstract component can either be explicit, such as an abstract class, or implicit, such as a class parameter of a C++ template function. Abstract components form the basis for exploiting polymorphism and implementing flexible systems. This term is used in the same way as abstract class, to avoid restricting the pattern to object-oriented languages.
Abstract Method
The declaration of an operation of a class that must be defined by a subclass.
Active Connection Establishment
The connection role played by a peer application that initiates a connection to a remote peer. (Compare with Passive Connection Establishment).
Active Object
An object that executes its methods in a different thread than the clients that invoke its methods. (Compare with passive object).
API
Application programming interface. The external interface of a software platform, such as an operating system, that is used by systems or applications built on top of it.
Application
A program or collection of programs that fulfills a customer or user’s requirements.
Application Framework
An integrated set of components that collaborate to provide a reusable software architecture for a family of related applications. In an object-oriented environment an application framework consists of abstract and concrete classes. Instantiation of such a framework consists of composing and subclassing from existing classes.
Architectural Pattern
An architectural pattern expresses a fundamental structural organization schema for software systems. It provides a set of predefined subsystems, specifies their responsibilities, and includes rules and guidelines for organizing the relationships between them.
Associative Array
An array indexed via arbitrary key values, such as strings, rather than integers. Hash tables are a common way to implement associative arrays.
Asynchronous I/O
A mechanism for sending or receiving data in which an I/O operation is initiated but the caller does not block waiting for the operation to complete.
Backus Naur Form (BNF)
A standard technique for describing the syntax of a language.
Bandwidth
The capacity of a communication media, such as a network or bus.
Bus
A high-speed communication channel that links computing devices, such as CPUs, disks, and network interfaces.
Busy Wait
A technique used by a thread to wait for a lock by executing a tight loop and polling to see if the lock is available on each iteration, in contrast to waiting for the lock to be released by sleeping and allowing other threads to run.
Cache Affinity
A thread scheduling optimization that gives preference to dispatching a thread on the CPU on which it most recently ran to maximize the probability of its state being present in the CPU’s instruction and data caches.
Class
A fundamental building block in object-oriented languages. A class specifies an interface and encapsulates its internal data structure as well as the functionality of its instances or objects. A class can extend on one or more other classes via inheritance.
Client
In our descriptions client denotes a role, component, or subsystem that invokes or uses the functionality offered by other components.
Closure
See Method Closure.
Collaborator
A component that cooperates with another component. An element of a CRC card.
Collocation
The activities associated with placing an object into the same process or host with the clients that access it. Collocation is often applied to improve locality of reference. (Compare with Distribution).
Completion Event
A event containing response information related to a request event initiated by a client.
Component
An encapsulated part of a software system that implements a specific service or set of services. A component has one or more interfaces that provide access to its services. Components serve as building blocks for the structure of a system. On a programming language level components may be represented as modules, classes, objects, or a set of related functions. A component that does not implement all the elements of its interface is called an abstract component.
Concrete Class
A class from which objects can be instantiated. In contrast to abstract classes, all methods are implemented in a concrete class. The term is used to distinguish concrete subclasses from their abstract superclass.
Concrete Component
A component that implements all elements defined in its interfaces. Used to distinguish components from the abstract component that defines their interface, in the same way that a concrete class is distinguished from an abstract class.
Concurrency
The ability of an object, component, or system to execute operations that are ‘logically simultaneous’. (Compare with parallelism).
Condition Variable
A condition variable [IEEE96] is a synchronization mechanism used by collaborating threads to suspend themselves temporarily until condition expressions involving data shared between the threads attain desired states. A condition variable is always used in conjunction with a mutex, which the thread must acquire before evaluating the condition expression. If the condition expression is false the thread atomically suspends itself on the condition variable and releases the mutex, so that other threads can change the shared data. When a cooperating thread changes this data, it can notify the condition variable, which atomically resumes a thread that had previously suspended on the condition variable and acquires its mutex again.
Connection
A full association that is used by peers to exchange data between endpoints of a network application.
Container
A common name for data structures that hold a collection of elements. Examples of containers are lists, sets, and associative arrays. In addition, component models, such as EJB [MaHa99] and ActiveX Controls, define containers that provide a run-time environment that shields components from the details of their underlying infrastructure, such as an operating system.
Continuation
A continuation is a language feature that allows a program’s run-time system to transfer the control of a method closure from one part of the program to another [DBRD91].
CORBA
The Common Object Request Broker Architecture (CORBA), a distributed object computing middleware standard defined by the Object Management Group (OMG).
CPU
Central processing unit. A hardware component that executes binary program instructions.
CRC Card
Class-Responsibility-Collaborator card. A design tool and notation for describing the responsibilities and collaborators of classes in a software architecture. In this book, we also use CRC cards to describe components that are not classes.
Critical Section
Code that should not execute concurrently in an object or subsystem can be synchronized by a critical section. A critical section is a sequence of instructions that obeys the following invariant: while one thread or process is executing in the critical section, no other thread or process can execute in the critical section [Tan95]. (Compare with Read-side and Write-side Critical Section).
Deadlock
A deadlock is a concurrency hazard that occurs when multiple threads attempt to acquire multiple locks and become blocked indefinitely in a circular wait state.
Daemon
A server process that runs continuously as in the background performing various services for clients.
Data-Mode Socket
See Socket.
Demarshaling
The conversion of a marshaled message from a host-independent format into a host-specific format.
Demultiplexing
A mechanism that routes incoming events from an input port to its intended receivers. There is a 1:N relationship between input port and receivers. Demultiplexing is commonly applied to incoming events and data streams. The reverse operation is known as ‘multiplexing’.
Design
The activities performed by software developers that results in the software architecture of a system. Often the term ‘design’ is also used as a name for the result of these activities.
Design Pattern
A design pattern provides a scheme for refining components of a software system or the relationships between them. It describes a commonly-recurring structure of communicating components that solves a general design problem within a particular context [GoF95].
Device
A hardware component that provides a service in a computing and/or communication system.
Device Driver
A software component in an operating system kernel that is responsible for controlling a hardware device attached to the computer, or a software device, such as a ram disc.
Distribution
The activities associated with placing an object into a different process or host than the clients that access it. Distribution is often applied to improve fault tolerance or to access remote resources. (Compare with Collocation).
Domain
Denotes concepts, knowledge and other items that are related to a particular problem area. Often used in ‘application domain’ to denote the problem area addressed by an application. On the Internet, a domain is a logical addressing entity, such as uci.edu or siemens.de.
Dynamic Binding
A mechanism that defers the association of an operation name (a message) to the corresponding code (a method) until run-time. Used to implement polymorphism in object-oriented languages.
Dynamically Linked Library (DLL)
A library that can be shared by multiple processes and linked into and out of a process’ address space dynamically in order to improve application flexibility and extensibility at run-time.
Endpoint
The termination point of a connection.
Exception-Safe
A component is exception-safe if an exception raised in the component or propagated from a component called by the component does not cause resource leaks or an unstable state.
Event
A message that conveys the occurrence of a significant activity, together with any data associated with the activity.
Factory
A method or function that creates and assembles the resources needed to instantiate and initialize an object or component instance.
Flow Control
A communication protocol mechanism that prevents a fast sender from overrunning the buffering and computing resources of a slow receiver.
Framework
See Application Framework.
Full Association
The five-tuple in the Internet protocol domain that identifies a TCP connection. It consists of the protocol type, the local address and port number, and the remote address and port number.
Function
A closed sub-routine that is passed zero or more parameters and that may return a value to its caller. Functions are typically ‘stand-alone’, as opposed to methods, which are associated with a class.
Functional Property
A particular aspect of a system’s functionality, usually related to a specified functional requirement. A functional property may be either made directly visible to users of an application by means of a particular function, or it may represent aspects of its implementation, such as the algorithm used to compute the function.
Future
A future [Hal85] [LS88] allows a client to obtain the result of method invocations after the invoked method finishes executing. The future reserves space for the invoked method to store its result. When a client wants to obtain this result it can rendezvous with the future, either blocking or polling until the result is computed and stored in the future.
Gateway
A gateway decouples co-operating components in a network and allows them to interact without having direct dependencies among each other.
GUI
Graphical user interface.
Handle
A handle identifies resources that are managed by an operating system kernel. These resources commonly include, among others, network connections, open files, timers, and synchronization objects.
Hardwiring
Writing inflexible programs, for example by using a literal number or string instead of a variable. Such literals are also known as ‘magic numbers’ because the number itself provides no clue to the understanding of its origin or purpose.
Host
An addressable computer attached to a network.
HTTP
The Hyper Text Transport Protocol, which is a simple protocol layered on top of TCP and used by clients to download content from a Web server via GET requests.
Idempotent Initialization
Object initialization is idempotent if an object can be reinitialized multiple times without harmful side-effects.
Idiom
An idiom is a low-level pattern specific to a programming language. An idiom describes how to implement particular aspects of components or the relationships between them using the features of the given language.
Indication Event
A event containing request information sent from a client to a service provider.
Inheritance
A feature of object-oriented languages that allows new classes to be derived from existing ones. Inheritance defines implementation reuse, a subtype relationship, or both. Depending on the programming language, single or multiple inheritance is possible.
Inlining
Code expansion at compile-time that inserts the code of a function or method body instead of the code used to call the function/method. Inlining long function/method bodies can lead to code ‘bloat’, with negative effects on storage consumption and paging effects.
Instance
An object originated from a specific class. Often used as a synonym for object in an object-oriented environment. This term may also be used in other contexts (see Instantiation).
Instantiation
A mechanism that creates a new instance from a template. The term is used in several contexts. Objects are instantiated from classes. C++ templates are instantiated to create new classes or functions. An application framework is instantiated to create an application. The phrase ‘instantiating a pattern’ is sometimes used to refer to taking the pattern as described and filling in the necessary details to implement it in the context of a specific application.
Instruction and Data Caches
Special high-speed memory collocated with a CPU that can improve overall system performance.
Interface
A publically accessible portion of a class, component, or subsystem.
Internet
A world-wide ‘network of networks’ that is based on the Internet Protocol (IP). Widely considered to be the most important human invention since fire and MTV.
Internet Protocol (IP)
A network layer protocol that performs segmentation, reassembly, and routing of packets.
Intranet
A network of computers within a company or other organization. Such a network may be secured from outside access and provide a platform for company-wide information exchange, co-operative work, and work flow, using Internet technologies for communication.
Introspection
The examination of selected aspects of the structure, behavior, or state of a system by the system itself.
Interprocess Communication (IPC)
Communication between processes residing in separate address spaces. Examples of IPC mechanisms include shared memory, UNIX pipes, message queues, and socket communication.
Invariant
A property of the state of an object, component, or module that always holds at a specific point in time or space. For example: ‘the invariant a < b holds whenever control passes line 50 of method foo()’.
Jitter
The standard deviation of the latency for a series of operations.
Late Binding
Synonym for Dynamic Binding.
Latency
The delay experienced by operations.
Layer
A level of abstraction that defines a particular set of services in a hierarchy. Layern is a consumer of services at layern-1 and a supplier of services to layern+1.
Load Balancing
A technique used to distribute client workloads among various processes and hosts in a network.
Lock
A mechanism used to implement some type of a critical section. A lock that can be acquired and released serially, such as a static mutex, may be added to a class. If multiple threads attempt to acquire the lock simultaneously, only one thread will succeed and the others will block until the lock is available [Tan92]. Other locking mechanisms, such as semaphores or readers/writer locks, define different synchronization semantics.
Loopback Device
A software device that appears like a network interface to applications, but instead simply redirects messages passed to it back to another process or thread on the same host.
Marshaling
The conversion of an unmarshaled message from a host-specific format into a host-independent format.
Message
Messages are used to communicate between objects, threads, or processes. In an object-oriented system the term message is used to describe the selection and activation of an operation or the method of an object. This kind of message is synchronous, which means that the sender waits until the receiver finishes the activated operation. Threads and processes often communicate asynchronously, in which the sender continues its execution without waiting for the receiver to reply. Remote procedure calls (RPC) are a means of synchronous IPC over a network. While messages in IPC communication protocols consist of a protocol-defined structure and are generally not visible to higher layers, Message Queueing systems, such as IBM MQSeries or Microsoft MSMQ messages, define a user-defined body where higher layers can implicitely transmit user data.
Message Passing
An IPC mechanism that exchanges messages between threads or processes. (Compare with shared memory).
Method
A function performed by an object. A method is specified within a class. The term is also used in ‘software development method’, which consists of a set of rules, guidelines, and notations to be used by engineers during the process of developing software.
Method Closure
An object that contains the context of a method, which can include the method’s parameters, a binding to the servant or completion handler that will process the method, and potentially a future for the method’s result.
Mix-In
A ‘small’ class that defines an additional interface or functionality to be added to classes by multiple inheritance. Mix-in also denotes the mechanism for adding such functionality by inheriting from classes.
Middleware
A set of layers and components that provides reusable common services and network programming mechanisms. Middleware resides on top of an operating system and its protocol stacks but below the structure and functionality of any particular application.
Module
A syntactical or conceptual entity of a software system that is often used synonymously for component or subsystem. Sometimes ‘modules’ also denote compilation units or files. We use the term in its former sense. Other writers use the term as an equivalent to ‘package’ when referring to a code body with its own name space.
Monitor
A monitor encapsulates functions and their internal variables into thread-safe modules. To prevent race conditions, a monitor contains a lock that allows only one thread at a time to be active within the monitor. Threads that want to leave the monitor temporarily can block on a condition variable.
Moore’s Law
A surprisingly accurate heuristic that states the pace of change in microchip technology is such that the amount of data storage a microchip can hold doubles every year, or at least every eighteen months. When preparing a lecture in 1965, Gordon Moore noticed that up to that time microchip capacity seemed to double each year. As the pace of change has slowed a little over the past few years, the definition has changed—with Gordon Moore’s approval—to reflect the fact that the doubling occurs only every eighteen months.
Multiple Inheritance
Inheritance in which a class can have more than one superclass.
Multicast
A communication protocol that allows a client to transmit messages to multiple servers. A broadcast is a special form of multicast, where messages are transmitted to all servers in a particular domain.
Mutex
A mutex is a ‘mutual exclusion’ locking mechanism that ensures only one thread at a time is active concurrently within a critical section in order to prevent race conditions.
Network
A communication medium that enables hosts and other devices to exchange messages.
Network Interface
A hardware device that connects a network with a host.
Non-functional Property
A feature of a system not covered by its functional description. A nonfunctional property typically addresses aspects related to the reliability, compatibility, efficiency, cost, ease of use, maintenance, or enhancement of a system.
Object
An identifiable entity in an object-oriented system. Objects respond to messages by performing a method (operation). An object may contain data values and references to other objects, which together define the state of the object. An object therefore has state, behavior, and identity.
Object Request Broker
A middleware layer that allows clients to invoke methods on distributed objects without concern for object location, programming language, operating system platform, communication protocols, or hardware.
On-the-wire Protocol
An ‘on-the-wire protocol’ defines how higher-level communication middleware, such as DCE, CORBA, or Java RMI, or other communication protocols, such as HTTP, transform messages or objects into buffers that can be passed ‘across the wire’ (network). The term ‘wire’ encompasses a range of transmission media, such as microwave, fiber-optics, and radio waveforms.
One-way Method Invocation
A call to a method that passes parameters to a server object but does not receive any results from the server. (Compare with Two-way Method Invocation).
Operating System
A collection of services and APIs that manage hardware and software resources on behalf of applications and end-users.
Operating System Kernel
A collection of core operating system services, such as process and thread management, virtual memory, and interprocess communication (IPC).
Out-of-Band
A protocol or mechanism that occurs outside the normal ‘in-band’ processing sequence.
Packet
A message used to convey header and data information in the TCP/IP protocols.
Parallelism
The ability of an object, component, or system to execute operations that are ‘physically simultaneous’. (Compare with concurrency).
Parameter
An instance of a data type or object passed to a function, method, or parameterized type.
Parameterized Type
A programming language feature that allows classes to be parameterized by various other types. (Compare with template.)
Passive-Mode Socket
See Socket.
Passive Connection Establishment
The connection role played by a peer application that accepts a connection from a remote peer. (Compare with Active Connection Establishment).
Passive Object
An object that borrows the thread of its caller to execute its methods. (Compare with active object).
Pattern
A pattern describes a particular recurring design problem that arises in specific design contexts and presents a well-proven solution for the problem. The solution is specified by describing its constituent participants, their responsibilities and relationships, and the ways in which they collaborate.
Pattern Language
A family of interrelated patterns that define a process for resolving software development problems systematically.
Peer-to-peer
In a distributed system peers are processes that communicate with each other. In contrast to components in client-server architectures, peers may act as clients, as servers, or as both, and may change these roles dynamically.
Platform
The combination of hardware and/or software that a system uses for its implementation. Software platforms include operating systems, libraries, and frameworks. A platform implements a virtual machine with applications running on top of it.
Polymorphism
A concept in which a single name may denote different things. For example, a function name may be bound over time to several different operations, or a variable may be bound to objects of different types. This concept makes it possible to implement flexible systems based on abstractions. In object-oriented languages polymorphism is implemented by the dynamic binding mechanism of operations. This implies that a fixed portion of code may behave differently depending on its collaborating objects.
Port
An endpoint of communication.
Port Number
A 16 bit number used to identify an endpoint of communication in the TCP protocol.
Priority Inversion
A scheduling hazard that occurs when a lower-priority thread or request blocks the execution of a higher-priority thread or request.
Process
A process provides certain resources, such as virtual memory, and protection capabilities, such as user/group identifiers and a hardware-protected address space, that can be used by one or more threads in the process. Compared with a thread, however, a process maintains more state information, requires more overhead to spawn, synchronize, and schedule, and often communicates with other processes via message passing or shared memory.
Protocol
A set of rules that describe how messages are exchanged between communicating peers, as well as the syntax and semantics of these messages.
Protocol Stack
A group of hierarchically-layered protocols.
Quality of Service
A collection of policies and mechanisms designed to control and enhance communication properties, such as bandwidth, latency, and jitter.
Race Condition
A race condition is a concurrency hazard that can occur when multiple threads simultaneously execute within a critical section that is not properly serialized.
Read-side Critical Section
A set of sequences of instructions that obeys the following invariant: while one or more threads or processes are executing in the read-side critical section, no thread or process can execute in a corresponding write-side critical section. (Compare with Write-side Critical Section).
Readers/Writer Lock
A lock that allows multiple threads to access a resource concurrently, but allows only one thread at a time to modify the resource and further prevents concurrent access and modifications.
Reification
The act of creating a concrete instance of an abstraction. For example, a concrete reactor implementation is a reification of the Reactor pattern (179) and an object reifies a class.
Request Event
A event sent by a client to a service provider asking it to perform some processing on the client’s behalf.
Response Event
A event sent by a service provider containing the reply to a client’s request event.
Recursive Mutex
A lock that can be re-acquired by the thread that owns the mutex without incurring self-deadlock on the thread.
Refactoring
An incremental activity that abstracts general-purpose behavior from existing software to enhance the structure and reusability of components and frameworks.
Relationship
An association between components. A relationship may be static or dynamic. Static relationships show directly in source code. They deal with the placement of components within an architecture. Dynamic relationships deal with the interaction between components. They may not be easily visible from source code or diagrams.
Responsibility
The functionality of an object or a component in a specific context. A responsibility is typically specified by a set of semantically-related operations. The responsibility section is an element of a CRC card.
Role
The responsibility of a component within a context of related components. For example, an object-oriented class defines a single role that all its instances support. Another example is an interface that defines a role that all implementations support. If a component supports a given role it must provide an implementation of the interface defining the role. Components expose different roles by implementing different interfaces. Different components may expose the same role by implementing the same interface, which allows clients to treat them polymorphically with respect to that particular role. An implemented component may take different roles, even within a single pattern.
Scheduler
A mechanism that determines the order in which threads or request events are executed.
Semaphore
A locking mechanism that maintains a count. As long as the count is greater than zero a thread can acquire the semaphore without blocking. After the count becomes zero, however, threads block on the semaphore until its count become greater than zero as a result of another thread releasing the semaphore, which increments the count.
SEP
Somebody Else’s Problem, Software Engineering Process, or Software Engineering with Patterns, whichever you prefer.
Serialization
A mechanism for ensuring that only one thread at a time executes within a critical section in order to prevent race conditions.
Servant
A component triggered by client requests. When a client request arrives the servant attempts to fulfill it, either by itself or by delegating subtasks to other components.
Server
Servers denote applications that provide services such as middleware functionality, database access, or Web page access, to clients. In distributed object computing middleware these services are typically implemented by servants that represent distributed objects.
Service
A set of functionality offered by a service provider or server to its clients.
Shared Memory
An operating system mechanism that allows multiple processes on a computer to share a common memory segment. (Compare with message passing).
Single Inheritance
Inheritance in which a class can have at most one direct superclass.
Socket
A family of terms related to network programming. A socket is an endpoint of communication that identifies a particular network address and port number. The Socket API is a set of function calls supported by most operating systems and used by network applications to establish connections and communicate via socket endpoints. A data-mode socket can be used to exchanged data between connected peers. A passive-mode socket is a factory that returns a handle to a connected data-mode socket.
Software Architecture
A software architecture is a description of the subsystems and components of a software system and the relationships between them. Subsystems and components are often specified via different views to show the relevant functional and non-functional properties of a software system. The software architecture of a system is an artifact that results from software design activities.
Starvation
A scheduling hazard that occurs when one or more threads are continually pre-empted by higher-priority threads and never execute.
Subclass
A class that inherits from a superclass.
Subsystem
A set of collaborating components that perform a given service or services. A subsystem is considered a separate entity within a software architecture. It performs its designated service(s) by interacting with other subsystems and components.
Superclass
A class from which another class inherits.
Synchronization
A locking mechanism that coordinates the order in which threads execute.
Synchronous I/O
A mechanism for sending or receiving data in which an I/O operation is initiated and the caller blocks waiting for the operation to complete.
System
A collection of software and/or hardware performing one or several services. A system can be a platform, an application, or both.
System Family
A set of related systems solving similar services. Systems in a system family share much of their software architecture and implementation, often because every system is derived from the same framework. When a single system evolves over time, its delivered releases also build a system family.
Template
A C++ programming language feature that enables classes and functions to be parameterized by various types, constants, or pointers to functions. A template is often called a generic or parameterized type.
Thread
An independent sequence of instructions that executes within an address space that can be shared with other threads. Each thread has its own run-time stack and registers, which enables it to perform synchronous I/O without blocking other threads that are executing concurrently. Compared to processes, threads maintain minimal state information, require relatively little overhead to spawn, synchronize and schedule, and usually communicate with other threads via objects in global memory, rather than shared memory.
Thread-per-Connection
A concurrency model that associates a separate thread for each network connection. This model handles each client that connects with a server in a separate thread for the duration of the connection. It is useful for servers that must support long-duration sessions with multiple clients. It is not useful for clients, such as HTTP 1.0 Web browsers, that associate a single request with each connection, which is effectively a thread-per-request model.
Thread-per-Request
A concurrency model that spawns a new thread for each request. This model is useful for servers that must handle long-duration request events from multiple clients, such as database queries. It is less useful for short-duration requests, due to the overhead of creating a new thread for each request. It can also consume a large number of operating system resources if many clients send requests simultaneously.
Thread Pool
A concurrency model that allocates a pool of threads that can execute request events simultaneously. This model is a variant of thread-per-request that amortizes thread creation costs by pre-spawning a pool of threads. It is useful for servers that want to bound the number of operating system resources they consume. Client requests can be executed concurrently until the number of simultaneous requests exceeds the number of threads in the pool. At this point, additional requests must be queued until a thread becomes available.
Transmission Control Protocol (TCP)
A connection-oriented transport protocol that reliably exchanges byte-streams of data in-order and un-duplicated between a local and remote process.
Transport Endpoint
An endpoint that connects peer applications at the transport layer.
Transport Layer
The layer in a protocol stack that is responsible for end-to-end data transfer and connection management.
Transport Layer Interface (TLI)
TLI is a set of function calls provided in System V UNIX and used by network applications to establish connections and communicate via connected transport endpoints.
Two-way Method Invocation
A call to a method that passes parameters to a server object and receives results back from the server. (Compare with One-way Method Invocation).
Unicode
A standard for character representation using 16-bit coding. Unicode includes characters for most written languages as well as representations for punctuation, mathematical notations, and other symbols.
Upcall
A callback that is invoked from a lower layer of a software architecture to a higher layer [Cla85].
User Datagram Protocol (UDP)
An unreliable, connectionless transport protocol that exchanges datagram messages between local and remote processes.
View
A view presents a partial aspect of a software architecture that emphasizes specific properties of a software system.
Virtual Machine
An abstraction layer that offers a set of services to higher-level applications or other virtual machines.
Virtual Memory
An operating system mechanism that permits developers to program applications whose address space is larger than the amount of physical memory on the computer.
Write-side Critical Section
A set of sequences of instructions that obeys the following invariant: at most one thread or process may be executing in the write-side critical section, and while a thread or process is executing in this write-site critical section, no thread or process can execute in a corresponding read-side critical section. (Compare with Read-side Critical Section).