Flashcards in m362glossary Part 2 Deck (330):
A hierarchical partitioning of names that provides a way of uniquely identifying any name in a context such as an XML document or software application.
The use of a namespace name as a qualifier for the simple name of an element or attribute, so forming an extended name.
A thread visible to the operating system and scheduled by it.
navigation (of a relation)
The ability to access the related record/entity of the given record/entity.
nested monitor lockout
A situation in which a thread T blocks or waits while holding a lock on the monitor that would enable other threads to make T progress. Thread T has therefore locked itself inside the monitor, keeping the 'key', i.e. the monitor's lock.
A value used once to defeat replay attacks in cryptography algorithms.
A process scheduling policy allowing a process to run to completion before applying a selection function.
A non-repeatable read occurs if a transaction reads the same object twice during execution and finds a different value the second time, although the transaction has not changed the value in the meantime.
The property of a system that prevents users from denying sending or receiving some information or performing some action.
normalised turnaround time
The value q/s, where q is the turnaround time and s is the service time.
A process executed by the scheduler when no other processes are Runnable; can be used to perform housekeeping tasks or to simplify a scheduling algorithm.
In CORBA, the general term for an object within a CORBA application, incorporating user-defined client and server objects as well as those implementing standard specifications such as those contained in common services.
A component facilitating communication between an ORB and a CORBA servant.
Object Management Architecture (OMA)
The architecture produced by the OMG, of which CORBA is a part; described as an 'open, vendor independent specification for an architecture and infrastructure that computer applications use to work together over networks'.
Object Management Group (OMG)
The group responsible for the Object Management Architecture (OMA).
object request broker (ORB)
Middleware that sits between the client and the objects the client wishes to invoke. The ORB is responsible for locating each object and communicating the client's request to the object. The object carries out the request and replies.
The marshalling and unmarshalling of objects so that they can be sent as streams of bits across JVMs. A class whose instances may be serialised has to implement the Serializable interface.
object service (CORBA)
A general description for operations provided by objects in the context of CORBA.
object type (CORBA)
In CORBA, a type defined by an interface within a module, specifying message-passing behaviour for a class of objects in a CORBA application.
OMG Interface Definition Language (OMG IDL)
The interface definition language specified by the Object Management Group for use in CORBA. See interface definition language (IDL).
OMG Object Model
A platform-independent description of CORBA objects, operations, interfaces and types.
A cipher with perfect secrecy, invented in 1917.
A relationship between two tables or entity classes, in which each record or entity of the first table/class is related to zero or more records/entities of the second table/class.
A relationship between two tables or entity classes, in which each record/entity of each table/class is related to exactly one record/entity of the other table/class.
A function with the property that it is easy to obtain an output from an input, but hard to determine the input given the output.
Open Database Connectivity (ODBC)
An interface to SQL-based databases, which aids the communication with a database and the access to the database metadata. The aim of ODBC is to enable access to a great number of databases, independent of the programming language of the application that seeks access to a database, and independent of the database systems and operating systems.
Open Systems Interconnection (OSI) model
A layered, abstract description for the design of communication and network protocols.
Software that interacts with the underlying hardware of a computer system and provides a layer or platform on which other software, such as application software, can run without needing detailed knowledge of the hardware.
A general term for the message-passing ability of components in CORBA applications, roughly equivalent to a method.
In concurrency control for transactions, an algorithm that assumes that conflicts will occur rarely, and that takes measures after the event. Example: optimistic concurrency control.
optimistic concurrency control
A concurrency control algorithm (optimistic) that works with the assumption that there is not much concurrency contention between transactions. It allows transactions to proceed without locking or time-stamping, and only just before it commits does it perform a validation check. It has three phases: working phase, validation phase and update phase. See also the definition of each phase.
A remote procedure call whose client (i.e. the node making the call) crashes after the request has been sent.
An entity class that holds the foreign key in an underlying table. If both underlying tables involved in a relation have foreign keys, then either class can be the owning side.
The unit of information in network communication.
A technique allowing only desirable packets to travel across a firewall.
A model example or pattern, especially an outstandingly clear or typical example or archetype.
A set of parallel wiring connections that can link closely positioned CPUs in a multiprocessor system.
A concurrent system that can really carry out a number of activities simultaneously because it has more than one processor.
parameter (in an HTTP request)
A named item of data that is sent as part of the HTTP request as a name-value pair and can be extracted for processing by a servlet or JSP page.
Partially Committed (transaction state)
The state a transaction is in after the final part of the transaction has taken place, but before the transaction has committed.
A distributed system architecture where each computer has similar capabilities and responsibilities - each can act as a server as well as a client.
The property of a code in which the ciphertext does not reveal any information about the plaintext or code.
A measurement of how well a system deals with its workload, usually expressed in terms of its responsiveness to users and the throughput of work.
Values that determine which actions are authorised within a system.
A set of entities that are mapped to corresponding records in the database. Entities in the persistence context are in the Managed or Removed state, while those outside the context are in the New or Detached state.
The entity classes and the relational database that they are associated with.
The approach used by HTTP v1.1 in keeping the TCP connection open after a first request to allow for possible subsequent requests. This contrasts with HTTP v1.0 which requires a new TCP connection for each request.
Storage that does not require power such as a disk drive, so that stored data such as a file or database outlives the execution of the program that created it. (cf. volatile)
personal area network
A short-range network connecting various devices, typically for personal use, with each other; for example, a network connecting home entertainment devices, a personal computer and a mobile phone.
personal digital assistant (PDA)
A small handheld computing device, usually with relatively limited resources of display, memory and storage.
In concurrency control for transactions, an algorithm that assumes that there are likely to be many conflicts and that takes measures to avoid them. Examples: two-phase (2PL) locking and time-stamp ordering (TSO).
A phantom read occurs when a transaction re-executes a query, returning a set of data that satisfies the condition in the query, and finds that the set of data has changed as a result of another recently committed transaction.
The ability of a hardware component to change physical location.
The ability to easily carry and move a computing device from one physical location to another.
Communication that has not been subjected to encryption.
A memory address that may be manipulated in a variety of ways.
An entry in a policy file describing permissions assigned to a class according to its code base, signing or principals.
The technique of repeatedly checking for an event.
A code in which ciphertext is formed from groups of more than one character at a time.
A numbered conduit into a host on the internet, which allows a client to request a particular kind of service and allows a server to listen for particular kinds of request on a specific port. For example, port 80 is normally used to access a web server.
In the context of mobile systems, this means physical portability. In the context of software development, it means application portability.
A way of representing the order constraints among a collection of transactions (or other statements). The nodes of the graph represent the transactions, and there is a directed edge from node A to node B if transaction A must be executed before transaction B.
A process scheduling policy that may require a process to give up the CPU before it would ordinarily have done so.
A thread scheduling policy that may require a thread to give up the CPU before it has completed running.
In the two-phase commit protocol for distributed transactions, the phase in which each process involved with dealing with part of the transaction has to send a message to the coordinator to indicate whether it intends to commit. See also resolution phase.
A column that uniquely identifies a record among all others in the same table.
primary time server
A host that has direct access to a standard time source (such as an atomic radio clock) and that makes this time value available to other hosts in a distributed system - in NTP, a stratum 1 host.
The trusted class loader in the JVM which bootstraps the system, loading the main class.
An identity associated with a subject, such as the subject's login ID or an organisation's name.
A queue that orders elements according to their associated priority so that the next element to be removed from the queue has the highest priority.
A number used to indicate the importance of a process, thread or interrupt.
A cipher key that is kept secret and is used in conjunction with a public key in asymmetric cryptography.
Machine code instructions that may only be executed by a processor in supervisor mode.
An approach to clock synchronisation in distributed systems that guarantees the accuracy of synchronisation with a certain probability as opposed to a deterministic (100% certain) guarantee - the accuracy can be increased by increasing the number of synchronisation requests.
When a procedure is called, the code associated with the procedure is executed, and once this is finished and any necessary data has been returned, the execution of the main program continues with the next statement. This is similar to a method invocation.
A data structure containing sufficient information about a process to allow it to be paused and restarted.
A unique value (ID) distinguishing one process from another.
A general term for software that manages process state transitions according to a scheduling policy.
A high-level categorisation of a process in terms of what it may do next, for example, Runnable or Blocked.
A data structure used by an operating system to store information about processes.
The part of a computer system that carries out the instructions of a software program in order to process data.
A model in which two processes work together and share data in such a way that one process assumes the role of producer (i.e. writes to the data resource) and the other assumes the role of consumer (i.e. reads from the resource).
A pointer to the next instruction to be executed in a program.
A class of interrupt generated by software due to an exception.
Explicit authorisation checks by method invocation.
The first part of an XML document, which declares its version number and may include information such as the encoding (character set).
property (of a JavaBean)
This loosely corresponds to the instance variables or attributes of a JavaBean class. Usually the property is implemented directly as an instance variable but it need not be. JavaBeans must have a getter and setter method for each property."
The interaction of features enforcing security policies in Java, particularly as regards permissions allocated to classes.
protocol (for communication)
The rules used in a communication, such as HTTP for the Web, or, more generally, rules governing the interaction between different components in a system.
A supplier of cryptographic products.
An object that 'stands in' for another object. Calls to the proxy's methods are redirected to the referred object.
A server that acts as an intermediary between clients and other servers.
A concurrent system which shares processor time between a number of activities but only one activity is actually running at any given time.
A key used in combination with a private key that may be publicised without compromising security of communication.
public key cryptography
Cryptography in which public and private key pairs are employed; an example of asymmetric cryptography.
public key infrastructure (PKI)
A system for the association of keys with users and the management of key-related information.
publish/subscribe messaging model
A communication model in which an object that generates events publishes the type of event it makes available for observation by other objects; and objects that want to receive notifications subscribe to events that are of interest to them.
An informal description of the request-response nature of HTTP - that information travels from the server to the client only when the client does something to 'pull' that information to it.
An informal description of various ways to mitigate the request-response nature of HTTP by enabling the server to send (or 'push') information to the client, in order to keep the client up to date, without an explicit request from the client.
A name formed from a prefix and a simple name in XML.
A time during which a process may run under a pre-emptive scheduling policy.
The language that is used with a relational database in order to query the database and retrieve information.
Race conditions exist if the final outcome of a process is dependent on the timing or sequence of other processes (as if the processes are 'racing' each other).
radio-frequency identification (RFID)
A radio-based technology to communicate with small devices that can store and change small amounts of data.
random access memory (RAM)
Short-term, rapidly accessed hardware for storing data - normally in the form of volatile semiconductor devices (loses data if it loses power).
Also referred to as a shareable lock. A lock that needs to be taken out if a process needs to read from a data resource. Several processes can hold a read lock.
A set of valid users and groups for an application.
A system which must guarantee to respond correctly to inputs within a specified time period.
In a relational database, a record is a set of values for one entry into a database.
recovery manager (in a transaction processing system)
The part of a transaction processing system that deals with the recovery from crashes.
redundant array of independent disks (RAID)
A redundant array of independent drives (or disks), also known as a redundant array of inexpensive drives (or disks). RAID is an umbrella term for data storage schemes that divide and/or replicate data among multiple hard drives. They offer, depending on the scheme, increased data reliability and/or I/O performance.
The locking mechanism used in Java. If a thread holds the lock for an object, and it invokes another synchronized method for the same object, it is allowed to continue. This means that under these circumstances no deadlock will arise.
A value that merely provides access to an associated object, as opposed to providing direct access to a memory location or the ability to manipulate memory addresses.
High-speed memory, local to the CPU, used to execute instructions.
A component providing a way of registering interfaces in a repository to allow a client to perform service discovery.
A naming service that allows names to be bound to object stubs for later lookup. Names have to be unique within a registry. Registries usually run in their own JVMs in the server host.
In a relational database, a relation is also known as a table. The table has a fixed number of uniquely named columns, and each row represents a record for an entry into the database.
A database model, where the data is conceptually modelled as a relation. It uses a collection of tables to represent both the data and the relationships between the data.
The structure, in terms of tables and columns, of the data in a relational database.
The phase in two-phase locking in which the locks are released, and in which no more locks are acquired.
The transfer of code from the client to the server, where it is executed using local resources, after which a reply is sent to the client.
An interface that extends Remote and declares a set of remote methods.
Remote Method Invocation (RMI)
A form of middleware, and the Java version of remote method calling, allowing methods in one JVM to invoke methods in another JVM. With RMI, methods can be invoked on objects whether they are local to or remote from the invoking client.
A method that can be called from another JVM. Remote methods may throw a RemoteException.
An object that implements a remote interface. The object may provide other methods that are not to be called remotely. Remote object classes usually extend UnicastRemoteObject.
remote procedure call (RPC)
A call to a procedure located on a machine that is different from the machine from which the call is sent.
A process running on a different machine from (but connected to) the one on which the object it is dealing with resides.
See stub object.
An attack in which intercepted or stored information is reused to gain advantage.
An object available to servlets (and JSP pages) that can be used to send an HTTP request to another servlet (or JSP) to produce some, or all, of the response.
A communication approach between software components where one sends a request and the other returns a response, for example HTTP.
Characters in a URL that have a special meaning, such as / or #, and so cannot be used as part of identifiers.
In the two-phase commit protocol for distributed transactions, the phase in which the coordinator decides on whether or not the transaction as a whole can commit or not, based on the responses received from the processes involved in carrying out parts of the transaction.
resolving a name
The process by which an object reference is associated with a particular servant object in a CORBA application; a binding of a reference to an object name.
The ability of a system to remain acceptably fast in its response to a request for action or information (the definition of what is acceptable depends on the context). If a system has this property, we say it is responsive.
See thick client.
A collection of identities or category of identities with shared permissions.
The act of restoring the state of a persistent store to one that existed before the start of an atomic operation that was aborted due to a system crash or exception.
A certificate granted to a certifying authority.
The first element in an XML document, which encloses other elements and acts as a way of identifying the type of a document.
RSS (Really Simple Syndication)
A technology that allows users to sign up to receive updates from a website whenever something important has changed.
Ruby on Rails
An approach to the development of web-based access to databases that uses a database specification, and scaffolding to provide the most commonly required operations.
A process that may be selected to be run; same as a ready process.
A process that is being executed by the CPU.
The software environment supporting loading, linking to libraries and execution of programs.
A method without any side effects for which users are held responsible - for example, a database query because it does not change any stored data.
This property asserts that nothing bad happens during the execution of a program. See also liveness.
A number used to prevent collisions in hash functions, or more generally to add variability to the processing of information in security systems.
A restrictive environment in which untrusted Java applets execute. The word is derived from an American term for a children's sandy playing area.
The technique of providing an infrastructure delivering commonly required operations and allowing modification for special cases, so facilitating rapid development.
The ability of a system to scale (to grow, or less commonly shrink) in order to support changes in demand, for example, different volumes of data or users. If a system has this property, we say that it is scalable.
scalability under contention
The ability of an algorithm to maintain a high throughput under contention, i.e. to keep a high ratio of number of threads per time unit that access the same resource.
schedule (for transactions)
A sequence of operations that specifies the chronological order in which the operations of concurrent transactions are executed.
scheduler (in a transaction processing system)
The part of the transaction processing system that puts together serialisable schedules for the operations of transactions.
Allocation of processor (i.e. CPU) time between the various activities in a concurrent system.
A policy contributing to process state change at any given time and in particular determining which process is allowed to run.
scope (of an object)
The extent over which an object or other item is valid or accessible. For example, items that have session scope continue to exist throughout the duration of the session in which they were created.
An object associated with a particular scope in a web application, such as the JSP page, the request, the session, or the whole application. Scope objects can be used to store or transfer data between components such as JSP pages and servlets. See also attribute.
scope of discovery
The extent to which a service discovery application will search for a service matching a request.
An element in JSP, with several possible types, that allows inclusion of Java declarations, Java executable statements, or Java expressions in the JSP page.
JSP pages can be specified as scriptless so that no Java-style scripting tags will be accepted by the compiler, hence enforcing use of JSP EL and JSP tags.
A fragment of Java code in a JSP page, consisting of one or more complete Java statements that will be executed when the JSP page runs.
A key that must be kept secret, particularly as used in symmetric cryptography.
A communication channel between a pair of processes providing authentication, confidentiality, integrity services and time stamping.
security manager (JVM)
A component of the JVM concerned with authorisation of what code may or may not do. The security manager enforces a security policy.
security policy (JVM)
A collection of permissions contained in a policy object, usually determined using policy files. The policy defines what code may, or may not, do at runtime.
security through obscurity
The discredited notion that secrecy of design alone can provide security.
A function used by a scheduler to select which process is allowed to run.
A type of object that is used to protect a resource from concurrent access by multiple processes. It does this through the use of two operations semWait and semSignai. Internally, a semaphore has a data field that holds its value and a queue that is used to hold blocked processes.
A system in which each activity must complete execution before another activity can start.
A schedule for the operations of concurrent transactions, in which the operations of one transaction all occur before the operations of the next transaction, such that the transactions execute in a strictly serial fashion. There is no interleaving.
If a schedule in which transactions are interleaved is equivalent to a serial schedule it is said to have the serialisability property or to be serialisable. A serialisable schedule is also said to have serial equivalence.
A schedule for a group of concurrent transactions is serialisable if, and only if, it produces the same result as if the transactions had executed in some serial order.
An object, under the control of a server, providing a CORBA operation to a client.
A CORBA object acting in the role of a server in some operation.
A type of object used by a server program in a client-server application. The object has the role of waiting for a client and returning a connection socket once the connection with this client is established.
A generic term describing the message-passing ability of components, but particularly used in service-oriented systems.
The time a process would run if it had sole use of the CPU.
An architecture in which the main unit of communication is a message as opposed to a method invocation. Service providers use an interface to describe their services, and can be connected together in arbitrary configurations.
A Java program that runs on the server and that follows a request-response model, normally responding to HTTP requests.
A conversation consisting of a series of linked requests and responses between the client and server on behalf of a particular user.
A type of EJB that handles an interactive session between a client and the application server. Session beans are neither persistent nor shared.
A number or string that uniquely identifies a particular session and any associated data.
A key that is used only while a session is in effect and then discarded.
Where the results of a transaction are built up in a structure that mirrors the persistent store but the persistent store is not updated until the transaction commits. Once the transaction has committed the shadow structure replaces the persistent store.
See read lock.
A resource, which may be either data (in the form of variables or files) or hardware, that a number of processes have access to.
A process scheduler concerned mainly with which process is allowed to run next.
Simple API for XML (SAX)
An API providing access to XML as a stream of data and allowing serial access to elements but not random access.
A name used to uniquely identify an XML document's namespace.
single anonymous condition variable
Java's concurrency mechanism allows just one wait set for all the threads that have called wait on a given object's lock. This acts as the condition variable. This is in contrast to so-called Hoare monitors which can have multiple condition variables, and a queue for each specific condition. Therefore, we say that Java has a single condition variable, which is anonymous as it does not belong to any particular condition.
single point of failure
The part of a system that can cause the whole system to go down when a failure occurs in this particular part.
A servlet that is limited to handling only one request at a time - this approach is not now recommended.
A programming design pattern ensuring that only one of an object may exist at a time.
A layer between a servant and an ORB in a CORBA application.
See auction sniping.
An XML-based protocol supporting communication between distributed systems and widely used in web services.
A collection of techniques used to manipulate people into performing actions, or divulging confidential information. The term typically applies to trickery associated with information gathering or accessing computer systems.
An abstraction for each of the two sides of the connection between the client and server. It is identified by a combination of port and host name, and provides the facilities (e.g. input and output streams) to enable data to be transferred between client and server. In Java these are implemented with the Socket class.
A software architecture is concerned with the structures of the system. These structures comprise software elements, the main properties of those elements and the relationships between them.
A software element that conforms to certain requirements for interoperability defined by a component object model, for example, provision of an interface through which services are provided, hiding implementation details. In particular, software components support the goal of composability to create higher functionality than they individually provide.
A lock where the thread simply waits in a loop ('spins'), repeatedly checking until the lock becomes available. This is also known as busy-waiting because the thread remains active but is not performing a useful task.
An abstraction which means that the results of an atomic operation are written to two independent places in a persistent store.
A last-in, first-out (LIFO) data structure, used to store activation records for Java threads.
One of the JSP tags that form a standard part of the JSP specification and that cause some sort of action to be carried out by the JSP page (as opposed to custom actions which are user-defined via custom tag libraries).
Starvation occurs when a runnable process is overlooked indefinitely by the scheduler.
stateful packet inspection
A firewall technique in which the state of a system is used to determine the legality of traffic across a firewall.
stateful session bean
A session bean that implements a single business service that spans multiple method calls, hence requiring state to be kept between calls.
A communication protocol, such as HTTP, where no state information is stored and each request or other communication is independent of any others.
stateless session bean
A session bean that does not keep state between calls, because each method implements a separate service: each session consists of a single method call.
Checking typing of variables at compile time.
A cryptanalytical technique using patterns of frequency of letters in languages as an aid to deciphering messages.
Computer hardware for holding data in the long term (even after being powered down) - typically uses devices such as magnetic or optical disks that are slower but cheaper per unit of data than memory.
A cipher whose key changes frequently to encrypt a stream of data.
strict two-phase locking (strict 2PL)
A form of two-phase locking in which all locks are released on commit.
The ability, provided by the platform or middleware, to suspend an execution unit, capture its state (including the code it is executing and the data it is manipulating) and transfer all this to a new site, where execution is resumed.
Checking for potentially troublesome conversions of types at compile time.
Structured Query Language (SQL)
The most widely used and standardised query language for relational databases.
An MVC application framework for use in constructing web applications.
A layer between a client and an ORB in a CORBA application.
A proxy for a remote object. There is a copy of the stub object on the registry and on each client JVM that wants to use the corresponding remote object.
subject (for authentication)
A grouping of related information for an entity in a security system, such as a collection of identities (principals) and credentials.
A ciphering technique in which one character in a language is substituted for another.
supervisor call interrupt
An interrupt used to signal that supervisor instructions are to be executed.
The mode a CPU enters to execute supervisor instructions.
A process that is stored on a disk; same as swapped out.
See suspended process.
The action of moving a process from volatile to persistent storage.
A group of connected peers working together in a peer-to-peer system.
Cryptography employing a private key or in which the decoding key is trivially related to the coding key.
The need for different processes to synchronise their operations by waiting for each other. In Java, the keyword synchronized is used for methods, so that only one thread can execute the method at a time, forcing the other threads to wait.
To cause clocks to indicate the same time or time values as closely as possible.
synchronous message passing
A form of communication in which the sender waits (i.e. it is blocked) until it receives a response from the receiver. See also asynchronous message passing.
A strategy for replication of data, where all copies are updated at the same time.
In the context of security, refers to the hardware, platform, application software and users' interactions.
A hardware channel for data transmission between device controllers and CPU.
The collection of classes within a protection domain that are trusted.
An element of a markup language, such as HTML or XML, or in JSP, with a variety of meanings and uses. In JSP, tags are mainly used to include fragments of Java code, or equivalent items such as JSTL and JSP EL, in order to generate the dynamic parts of web pages.
The Java code that is executed when a JSP page containing its associated custom tag is run - this code is stored in a tag library.
An entity to which a permission is applied in a policy file.
A sequence of instructions treated as an element of work. A task may be represented by a method in a Java program, for example, but the term is more widely applied and can refer to elements of work at a low (processor) or high (application) level.
(Transmission Control Protocol) and IP (Internet Protocol) are the most commonly used specifications of the detailed format of messages exchanged between internet hosts.
A device for accessing a centralised computer system via local cabling or, if more remote, via the telephone system. Some terminals have limited processing ability, often to aid in graphical display, but the bulk of processing in the system is carried out on the central processor.
A special atomic operation that tests and sets a Boolean, provided by the operating system as an indivisible machine instruction.
Complex client software that carries out significant processing on the client machine in a client-server system.
In a client-server system, a simple client with very limited functionality, mainly limited to display and communication - for example, a web browser.
A lightweight process; a thread of execution.
thread of execution
A path of execution within a process.
A set of threads, each one taking a task from a common queue, executing it and then fetching the next task. The main aim of the pool is to reuse threads for multiple tasks, in order to optimise the memory usage and the performance of the application.
A class is thread safe if it can be executed concurrently by multiple threads without the shared data getting into an inconsistent state.
The property of a class behaving under concurrent access in the same way as under sequential execution. There are various levels of thread safety, depending on how much external synchronisation is necessary to achieve it.
A class that provides no internal synchronisation. As such, access to it requires external synchronisation within a concurrent application.
A class that is not safe to use in concurrent programs. No amount of external synchronisation will make instances of such classes behave as if they were accessed sequentially.
Shared data, or program components that access it, are thread-safe if there is no possibility of data loss or corruption when a number of concurrent threads are active.
A class that has mutable instances and where the effect of any concurrent access to an instance could also be obtained by some sequential execution. Thread-safe classes do not require any external synchronisation.
The active consideration of dangers to a system's security.
The rate at which computational work is done. This may be measured in a variety of ways, for example, by the number of processes completed per unit of time by a CPU or the number of transactions completed per second in a database system.
The common functionality of computer processes or components at a very high conceptual level.
A tightly coupled component communicates directly with another in such a way that changes in one are liable to affect the other.
The inclusion of information with a message so that its time of occurrence can be determined.
The expiry of a preset time interval causing a thread to stop running because it has used its allocated execution time.
A class of interrupt used to keep track of the passage of time; used by schedulers to pre-empt processes.
A rather dated term for a concurrent system with a number of users that allocates time to each user, so that each has the impression that the computer is responding to just their request.
A scheduling approach for concurrent systems in which each activity gets a fixed and equal amount of processor time before the processing switches to the next activity.
A record of the time of an event (such as the sending of a message) that is attached to that event (such as being appended to the message in a data packet).
time-stamp ordering (TSO)
An algorithm for concurrency control for transactions based on time-stamps. A time (such as the time at which the transaction started) is associated with each transaction and is recorded by every object involved with each operation invoked by the transaction. This time-stamp is used to serially order transactions.
In a messaging system (such as JMS), a topic is a named area of interest to which clients can subscribe, such that they receive any messages relating to this area.
In graph theory, a topological sort of a directed acyclic graph is a linear ordering of its nodes such that each node comes before all nodes to which it has edges. Every directed acyclic graph has one or more topological sorts.
A sequence of atomic actions, with the property that either the entire sequence is performed, or no part of the sequence is performed at all.
transaction isolation level
The levels that allow fine-tuning of transactions, based on different reads: dirty reads, non-repeatable reads and phantom reads.
transaction manager (in a transaction processing system)
The part of a transaction processing system that provides an interface between the clients and the system, and which passes on requests for transaction processing to the scheduler.
transaction processing (TP) system
A layer of middleware to manage the correct and efficient execution of transactions. Also known as a transaction processing (TP) monitor.
transaction-scoped persistence context
A persistence context that has the same lifetime as a transaction. This is the default setting for persistence contexts used with container-managed entity managers.
A transmitter and receiver of radio wave signals.
An object used for transferring aggregated data between clients and session beans.
Transmission Control Protocol (TCP) connection
A link agreed between two internet hosts that is established by a 'handshake' (an exchange of a number of initial data packets), prior to the hosts sending actual data.
The extent to which a distributed system appears to its users as a coherent system providing a range of functions (so that the user does not need to know that the system is distributed).
An encryption technique where the order of information in the plaintext is obscured.
A one-way function which is reversible if given some secret information.
An applet that can guarantee its origination from a known source by means of cryptography, and may therefore be permitted to carry out a wider range of actions than an untrusted applet.
Wrapping one protocol in another protocol.
The time interval between the submission of a process and its completion.
two-phase commit (2PC) protocol
A protocol for distributed transactions, where one process acts as the coordinator for several parts of a transaction. All parts of the transaction must agree to commit in order for the transaction to commit as a whole. There are two phases: the prepare phase and a resolution phase.
two-phase locking (2PL)
An algorithm for concurrency control for transactions based on locking. Locks are acquired for a transaction as they are needed (acquire phase), and no lock can be released until all locks have been acquired. When locks are released, no more locks can be acquired (release phase).
A software architecture consisting of a database tier and a client applications tier.
The ability of a language to check that types are being used correctly.
A situation where computing devices are so small and cheap that they occur in huge numbers throughout everyday environments.
A point-to-point form of communication, that is, involving one sender and one receiver at a time.
This kind of relation can be navigated in only one direction, namely from the table/class that holds the foreign key to the other table/class.
A computer system with a single central processing unit (CPU).
Universal Description, Discovery and Integration (UDDI)
An XML-based standard used by a server to register WSDL descriptions of web services and by a client to discover such services. As such it allows the creation of directories for web services.
The process of extracting a data structure from a series of bytes.
Unacceptably slow to respond to a request for action or information - the definition of acceptability depends on the context.
One of the reserved characters or other characters that cannot be included in a URL without the possibility of confusion about their intended role or meaning.
The default situation for an applet automatically downloaded along with a web page and subject to severe restrictions in the interests of security.
update anywhere ownership
A style of ownership for data in schemes for replication of data, where anyone is allowed to update. Often used in the peer-to-peer environment of open source projects.
update phase (in optimistic concurrency control)
The phase in which a transaction has been validated, and can now commit.
A means of including potentially unsafe characters in a URL by encoding them using the corresponding ASCII code, such as using %2F instead of /.
The CPU mode when it is executing ordinary (not supervisor) instructions.
A thread created by a user; a non-daemon thread.
See Coordinated Universal Time.
An XML document is valid if it is well formed and conforms to a DTD.
validation phase (in optimistic concurrency control)
The phase in which a transaction gets validated. If validation succeeds, the transaction can commit.
A route by which an attack may occur on a computer system.
virtual machine (VM)
An abstract computing device implemented in software. A virtual machine defines a certain set of instructions and how code and data are organised in the machine's memory.
External memory; persistent storage used to supplement main memory.
virtual private network (VPN)
A network created by a form of tunnelling in which end-to-end encryption takes place between the two ends of the tunnel, so creating a private network of sorts.
Storage that requires power in order to retain any data stored in it, for example RAM, cache and registers.
A variable declared with the volatile modifier. For practical purposes it is as if such variables are always accessed directly in shared memory. Moreover, an access to a volatile variable creates a memory barrier.
The set of threads that have called wait and are waiting to be notified. Each object in Java has one wait set.
The Java mechanism to implement condition synchronisation. A thread calls wait and will be blocked as long as the condition it is waiting on is not satisfied. Another thread calling notify or notifyAii can release this thread from its blocked state.
The ability, provided by the platform or middleware, to transfer code from one site to another.
weakly consistent operation
An operation that does not guarantee consistency invariants and as such does not fail under concurrent accesses. The iterators returned by the concurrency classes introduced in Java 1.5 are weakly consistent and never throw a exception due to concurrent modification.
A software environment in which servlets and JSP pages run, and that provides a number of services including security, concurrency and management of the servlet lifecycle.
A portion of a web page that allows the user to enter data to be sent, in the form of an HTTP request with associated parameters, for processing by the server.
web of trust
A non-hierarchical approach to establishing trustworthiness of digital certificates.
An example of the network services paradigm in which software services are provided via a Web-based application, particularly using HTTP, web pages and SOAP as communication mechanisms.
Web Services Description Language (WSDL)
A language used by UDDI for the description of web service operations using XML.
The part of the middle tier in a Java EE application that communicates with the client tier, typically by receiving and responding to HTTP requests using dynamically generated web pages.
The property of an XML document of being syntactically (as opposed to semantically) correct.
wide area network (WAN)
A computer network that spans a large geographical area such as a region, a country or the world and which typically relies on public providers of telecoms or other long-distance services for part of its communication path (in contrast to a LAN).
A style of ownership of data in schemes for replication of data, where the right to make updates to replicated parts moves from site to site.
working phase (in optimistic concurrency control)
The phase in which a transaction works with a tentative version of the objects.
A method that adds new functionality or properties to existing objects. The Collections class provides static wrapper methods to turn thread-compatible collections into conditionally thread-safe ones.
Also referred to as an exclusive lock. A lock that needs to be acquired by a writer process. Only one process can hold a write lock at the same time.
In logging, a log must be written ahead of the actual update made to the data, in case a crash occurs just after an update is made, and before this update could be recorded in the log.
See eXtensible Markup Language (XML).