Flashcards in m362glossary Part 2 Deck (330):
1
namespace
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.
2
namespace prefix
The use of a namespace name as a qualifier for the simple name of an element or attribute, so forming an extended name.
3
native thread
A thread visible to the operating system and scheduled by it.
4
navigation (of a relation)
The ability to access the related record/entity of the given record/entity.
5
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.
6
node
See host.
7
nonce
A value used once to defeat replay attacks in cryptography algorithms.
8
non-pre-emptive multitasking
A process scheduling policy allowing a process to run to completion before applying a selection function.
9
non-repeatable read
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.
10
non-repudiation
The property of a system that prevents users from denying sending or receiving some information or performing some action.
11
normalised turnaround time
The value q/s, where q is the turnaround time and s is the service time.
12
null process
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.
13
object (CORBA)
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.
14
object adaptor
A component facilitating communication between an ORB and a CORBA servant.
15
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'.
16
Object Management Group (OMG)
The group responsible for the Object Management Architecture (OMA).
17
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.
18
object serialisation
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.
19
object service (CORBA)
A general description for operations provided by objects in the context of CORBA.
20
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.
21
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).
22
OMG Object Model
A platform-independent description of CORBA objects, operations, interfaces and types.
23
one-time pad
A cipher with perfect secrecy, invented in 1917.
24
one-to-many relation
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.
25
one-to-one relation
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.
26
one-way function
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.
27
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.
28
Open Systems Interconnection (OSI) model
A layered, abstract description for the design of communication and network protocols.
29
operating system
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.
30
operation (CORBA)
A general term for the message-passing ability of components in CORBA applications, roughly equivalent to a method.
31
optimistic algorithm
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.
32
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.
33
orphan
A remote procedure call whose client (i.e. the node making the call) crashes after the request has been sent.
34
owning side
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.
35
packet
The unit of information in network communication.
36
packet filtering
A technique allowing only desirable packets to travel across a firewall.
37
paradigm
A model example or pattern, especially an outstandingly clear or typical example or archetype.
38
parallel bus
A set of parallel wiring connections that can link closely positioned CPUs in a multiprocessor system.
39
parallel system
A concurrent system that can really carry out a number of activities simultaneously because it has more than one processor.
40
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.
41
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.
42
peer-to-peer (P2P)
A distributed system architecture where each computer has similar capabilities and responsibilities - each can act as a server as well as a client.
43
perfect secrecy
The property of a code in which the ciphertext does not reveal any information about the plaintext or code.
44
performance
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.
45
permissions
Values that determine which actions are authorised within a system.
46
persistence context
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.
47
persistence unit
The entity classes and the relational database that they are associated with.
48
persistent connection
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.
49
persistent storage
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)
50
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.
51
personal digital assistant (PDA)
A small handheld computing device, usually with relatively limited resources of display, memory and storage.
52
pessimistic algorithm
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).
53
phantom read
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.
54
physical mobility
The ability of a hardware component to change physical location.
55
physical portability
The ability to easily carry and move a computing device from one physical location to another.
56
plaintext
Communication that has not been subjected to encryption.
57
pointer
A memory address that may be manipulated in a variety of ways.
58
policy entry
An entry in a policy file describing permissions assigned to a class according to its code base, signing or principals.
59
polling
The technique of repeatedly checking for an event.
60
polyalphabetic substitution
A code in which ciphertext is formed from groups of more than one character at a time.
61
port
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.
62
portability
In the context of mobile systems, this means physical portability. In the context of software development, it means application portability.
63
precedence graph
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.
64
pre-emptive multitasking
A process scheduling policy that may require a process to give up the CPU before it would ordinarily have done so.
65
pre-emptive multithreading
A thread scheduling policy that may require a thread to give up the CPU before it has completed running.
66
prepare phase
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.
67
primary key
A column that uniquely identifies a record among all others in the same table.
68
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.
69
primordial loader
The trusted class loader in the JVM which bootstraps the system, loading the main class.
70
principal
An identity associated with a subject, such as the subject's login ID or an organisation's name.
71
priority queue
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.
72
priority
A number used to indicate the importance of a process, thread or interrupt.
73
private key
A cipher key that is kept secret and is used in conjunction with a public key in asymmetric cryptography.
74
privileged instructions
Machine code instructions that may only be executed by a processor in supervisor mode.
75
probabilistic synchronisation
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.
76
procedure call
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.
77
process descriptor
A data structure containing sufficient information about a process to allow it to be paused and restarted.
78
process identifier
A unique value (ID) distinguishing one process from another.
79
process scheduler
A general term for software that manages process state transitions according to a scheduling policy.
80
process state
A high-level categorisation of a process in terms of what it may do next, for example, Runnable or Blocked.
81
process table
A data structure used by an operating system to store information about processes.
82
processor
The part of a computer system that carries out the instructions of a software program in order to process data.
83
producer-consumer model
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).
84
program counter
A pointer to the next instruction to be executed in a program.
85
program interrupts
A class of interrupt generated by software due to an exception.
86
programmatic security
Explicit authorisation checks by method invocation.
87
prologue
The first part of an XML document, which declares its version number and may include information such as the encoding (character set).
88
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."
89
protection domain
The interaction of features enforcing security policies in Java, particularly as regards permissions allocated to classes.
90
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.
91
provider (security)
A supplier of cryptographic products.
92
proxy object
An object that 'stands in' for another object. Calls to the proxy's methods are redirected to the referred object.
93
proxy server
A server that acts as an intermediary between clients and other servers.
94
pseudo-parallel system
A concurrent system which shares processor time between a number of activities but only one activity is actually running at any given time.
95
public key
A key used in combination with a private key that may be publicised without compromising security of communication.
96
public key cryptography
Cryptography in which public and private key pairs are employed; an example of asymmetric cryptography.
97
public key infrastructure (PKI)
A system for the association of keys with users and the management of key-related information.
98
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.
99
pull technology
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.
100
push technology
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.
101
qualified name
A name formed from a prefix and a simple name in XML.
102
quantum
A time during which a process may run under a pre-emptive scheduling policy.
103
query language
The language that is used with a relational database in order to query the database and retrieve information.
104
race conditions
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).
105
radio-frequency identification (RFID)
A radio-based technology to communicate with small devices that can store and change small amounts of data.
106
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).
107
read lock
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.
108
realm
A set of valid users and groups for an application.
109
real-time system
A system which must guarantee to respond correctly to inputs within a specified time period.
110
record
In a relational database, a record is a set of values for one entry into a database.
111
recovery manager (in a transaction processing system)
The part of a transaction processing system that deals with the recovery from crashes.
112
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.
113
re-entrant locking
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.
114
reference
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.
115
registers
High-speed memory, local to the CPU, used to execute instructions.
116
registration service
A component providing a way of registering interfaces in a repository to allow a client to perform service discovery.
117
registry
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.
118
relation
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.
119
relational 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.
120
relational schema
The structure, in terms of tables and columns, of the data in a relational database.
121
release phase
The phase in two-phase locking in which the locks are released, and in which no more locks are acquired.
122
remote evaluation
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.
123
remote interface
An interface that extends Remote and declares a set of remote methods.
124
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.
125
remote method
A method that can be called from another JVM. Remote methods may throw a RemoteException.
126
remote object
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.
127
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.
128
remote process
A process running on a different machine from (but connected to) the one on which the object it is dealing with resides.
129
remote reference
See stub object.
130
replay
An attack in which intercepted or stored information is reused to gain advantage.
131
request dispatcher
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.
132
request-response
A communication approach between software components where one sends a request and the other returns a response, for example HTTP.
133
reserved characters
Characters in a URL that have a special meaning, such as / or #, and so cannot be used as part of identifiers.
134
resolution phase
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.
135
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.
136
responsiveness
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.
137
rich client
See thick client.
138
role (security)
A collection of identities or category of identities with shared permissions.
139
rolling back
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.
140
root certificate
A certificate granted to a certifying authority.
141
root element
The first element in an XML document, which encloses other elements and acts as a way of identifying the type of a document.
142
RSS (Really Simple Syndication)
A technology that allows users to sign up to receive updates from a website whenever something important has changed.
143
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.
144
runnable process
A process that may be selected to be run; same as a ready process.
145
running process
A process that is being executed by the CPU.
146
runtime environment
The software environment supporting loading, linking to libraries and execution of programs.
147
safe method
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.
148
safety
This property asserts that nothing bad happens during the execution of a program. See also liveness.
149
salt
A number used to prevent collisions in hash functions, or more generally to add variability to the processing of information in security systems.
150
sandbox
A restrictive environment in which untrusted Java applets execute. The word is derived from an American term for a children's sandy playing area.
151
scaffolding
The technique of providing an infrastructure delivering commonly required operations and allowing modification for special cases, so facilitating rapid development.
152
scalability
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.
153
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.
154
schedule (for transactions)
A sequence of operations that specifies the chronological order in which the operations of concurrent transactions are executed.
155
scheduler (in a transaction processing system)
The part of the transaction processing system that puts together serialisable schedules for the operations of transactions.
156
scheduling
Allocation of processor (i.e. CPU) time between the various activities in a concurrent system.
157
scheduling policy
A policy contributing to process state change at any given time and in particular determining which process is allowed to run.
158
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.
159
scope object
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.
160
scope of discovery
The extent to which a service discovery application will search for a service matching a request.
161
scripting tag
An element in JSP, with several possible types, that allows inclusion of Java declarations, Java executable statements, or Java expressions in the JSP page.
162
scriptless
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.
163
scriptlet
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.
164
secret key
A key that must be kept secret, particularly as used in symmetric cryptography.
165
secure channel
A communication channel between a pair of processes providing authentication, confidentiality, integrity services and time stamping.
166
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.
167
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.
168
security through obscurity
The discredited notion that secrecy of design alone can provide security.
169
selection function
A function used by a scheduler to select which process is allowed to run.
170
semaphore
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.
171
sequential system
A system in which each activity must complete execution before another activity can start.
172
serial schedule
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.
173
serialisability (databases)
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.
174
serialisable (databases)
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.
175
servant
An object, under the control of a server, providing a CORBA operation to a client.
176
server (CORBA)
A CORBA object acting in the role of a server in some operation.
177
ServerSocket
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.
178
service
A generic term describing the message-passing ability of components, but particularly used in service-oriented systems.
179
service time
The time a process would run if it had sole use of the CPU.
180
service-oriented architecture
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.
181
servlet
A Java program that runs on the server and that follows a request-response model, normally responding to HTTP requests.
182
session
A conversation consisting of a series of linked requests and responses between the client and server on behalf of a particular user.
183
session bean
A type of EJB that handles an interactive session between a client and the application server. Session beans are neither persistent nor shared.
184
session ID
A number or string that uniquely identifies a particular session and any associated data.
185
session key
A key that is used only while a session is in effect and then discarded.
186
shadowing
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.
187
shareable lock
See read lock.
188
shared resources
A resource, which may be either data (in the form of variables or files) or hardware, that a number of processes have access to.
189
short-term scheduler
A process scheduler concerned mainly with which process is allowed to run next.
190
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.
191
simple name
A name used to uniquely identify an XML document's namespace.
192
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.
193
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.
194
single-threaded servlet
A servlet that is limited to handling only one request at a time - this approach is not now recommended.
195
singleton
A programming design pattern ensuring that only one of an object may exist at a time.
196
skeleton
A layer between a servant and an ORB in a CORBA application.
197
sniping
See auction sniping.
198
SOAP
An XML-based protocol supporting communication between distributed systems and widely used in web services.
199
social engineering
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.
200
socket
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.
201
software architecture
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.
202
software component
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.
203
spin lock
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.
204
stable storage
An abstraction which means that the results of an atomic operation are written to two independent places in a persistent store.
205
stack
A last-in, first-out (LIFO) data structure, used to store activation records for Java threads.
206
standard action
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).
207
starvation
Starvation occurs when a runnable process is overlooked indefinitely by the scheduler.
208
stateful packet inspection
A firewall technique in which the state of a system is used to determine the legality of traffic across a firewall.
209
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.
210
stateless protocol
A communication protocol, such as HTTP, where no state information is stored and each request or other communication is independent of any others.
211
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.
212
statically typed
Checking typing of variables at compile time.
213
statistical analysis
A cryptanalytical technique using patterns of frequency of letters in languages as an aid to deciphering messages.
214
storage
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.
215
stream cipher
A cipher whose key changes frequently to encrypt a stream of data.
216
strict two-phase locking (strict 2PL)
A form of two-phase locking in which all locks are released on commit.
217
strong mobility
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.
218
strong typing
Checking for potentially troublesome conversions of types at compile time.
219
Structured Query Language (SQL)
The most widely used and standardised query language for relational databases.
220
Struts framework
An MVC application framework for use in constructing web applications.
221
stub
A layer between a client and an ORB in a CORBA application.
222
stub object
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.
223
subject (for authentication)
A grouping of related information for an entity in a security system, such as a collection of identities (principals) and credentials.
224
substitution
A ciphering technique in which one character in a language is substituted for another.
225
supervisor call interrupt
An interrupt used to signal that supervisor instructions are to be executed.
226
supervisor mode
The mode a CPU enters to execute supervisor instructions.
227
suspended process
A process that is stored on a disk; same as swapped out.
228
swapped out
See suspended process.
229
swapping
The action of moving a process from volatile to persistent storage.
230
swarm
A group of connected peers working together in a peer-to-peer system.
231
symmetric cryptography
Cryptography employing a private key or in which the decoding key is trivially related to the coding key.
232
synchronisation (processes)
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.
233
synchronisation (time)
To cause clocks to indicate the same time or time values as closely as possible.
234
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.
235
synchronous replication
A strategy for replication of data, where all copies are updated at the same time.
236
system
In the context of security, refers to the hardware, platform, application software and users' interactions.
237
system bus
A hardware channel for data transmission between device controllers and CPU.
238
system domain
The collection of classes within a protection domain that are trusted.
239
tag
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.
240
tag handler
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.
241
target
An entity to which a permission is applied in a policy file.
242
task
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.
243
TCP/IP TCP
(Transmission Control Protocol) and IP (Internet Protocol) are the most commonly used specifications of the detailed format of messages exchanged between internet hosts.
244
terminal
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.
245
test-and-set (TAS)
A special atomic operation that tests and sets a Boolean, provided by the operating system as an indivisible machine instruction.
246
thick client
Complex client software that carries out significant processing on the client machine in a client-server system.
247
thin client
In a client-server system, a simple client with very limited functionality, mainly limited to display and communication - for example, a web browser.
248
thread
A lightweight process; a thread of execution.
249
thread of execution
A path of execution within a process.
250
thread pool
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.
251
thread safety
A class is thread safe if it can be executed concurrently by multiple threads without the shared data getting into an inconsistent state.
252
thread safety
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.
253
thread-compatible class
A class that provides no internal synchronisation. As such, access to it requires external synchronisation within a concurrent application.
254
thread-hostile class
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.
255
thread-safe
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.
256
thread-safe class
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.
257
threat monitoring
The active consideration of dangers to a system's security.
258
throughput
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.
259
tier
The common functionality of computer processes or components at a very high conceptual level.
260
tight coupling
A tightly coupled component communicates directly with another in such a way that changes in one are liable to affect the other.
261
time stamping
The inclusion of information with a message so that its time of occurrence can be determined.
262
timeout
The expiry of a preset time interval causing a thread to stop running because it has used its allocated execution time.
263
timer interrupts
A class of interrupt used to keep track of the passage of time; used by schedulers to pre-empt processes.
264
time-sharing
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.
265
time-slicing
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.
266
time-stamp
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).
267
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.
268
topic
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.
269
topological sorting
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.
270
transaction
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.
271
transaction isolation level
The levels that allow fine-tuning of transactions, based on different reads: dirty reads, non-repeatable reads and phantom reads.
272
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.
273
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.
274
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.
275
transceiver
A transmitter and receiver of radio wave signals.
276
transfer object
An object used for transferring aggregated data between clients and session beans.
277
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.
278
transparency
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).
279
transposition
An encryption technique where the order of information in the plaintext is obscured.
280
trapdoor function
A one-way function which is reversible if given some secret information.
281
trusted applet
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.
282
tunnelling
Wrapping one protocol in another protocol.
283
turnaround
The time interval between the submission of a process and its completion.
284
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.
285
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).
286
two-tier model
A software architecture consisting of a database tier and a client applications tier.
287
type safety
The ability of a language to check that types are being used correctly.
288
ubiquitous computing
A situation where computing devices are so small and cheap that they occur in huge numbers throughout everyday environments.
289
unicast
A point-to-point form of communication, that is, involving one sender and one receiver at a time.
290
unicast communication
Point-to-point communication.
291
unidirectional relation
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.
292
uniprocessor
A computer system with a single central processing unit (CPU).
293
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.
294
unmarshalling
The process of extracting a data structure from a series of bytes.
295
unresponsive
Unacceptably slow to respond to a request for action or information - the definition of acceptability depends on the context.
296
unsafe character
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.
297
untrusted applet
The default situation for an applet automatically downloaded along with a web page and subject to severe restrictions in the interests of security.
298
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.
299
update phase (in optimistic concurrency control)
The phase in which a transaction has been validated, and can now commit.
300
URL encoding
A means of including potentially unsafe characters in a URL by encoding them using the corresponding ASCII code, such as using %2F instead of /.
301
user mode
The CPU mode when it is executing ordinary (not supervisor) instructions.
302
user thread
A thread created by a user; a non-daemon thread.
303
UTC
See Coordinated Universal Time.
304
valid
An XML document is valid if it is well formed and conforms to a DTD.
305
validation phase (in optimistic concurrency control)
The phase in which a transaction gets validated. If validation succeeds, the transaction can commit.
306
vector
A route by which an attack may occur on a computer system.
307
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.
308
virtual memory
External memory; persistent storage used to supplement main memory.
309
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.
310
volatile storage
Storage that requires power in order to retain any data stored in it, for example RAM, cache and registers.
311
volatile variable
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.
312
wait set
The set of threads that have called wait and are waiting to be notified. Each object in Java has one wait set.
313
wait-notify mechanism
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.
314
weak mobility
The ability, provided by the platform or middleware, to transfer code from one site to another.
315
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.
316
web container
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.
317
web form
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.
318
web of trust
A non-hierarchical approach to establishing trustworthiness of digital certificates.
319
web service
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.
320
Web Services Description Language (WSDL)
A language used by UDDI for the description of web service operations using XML.
321
web tier
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.
322
well formed
The property of an XML document of being syntactically (as opposed to semantically) correct.
323
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).
324
workflow ownership
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.
325
working phase (in optimistic concurrency control)
The phase in which a transaction works with a tentative version of the objects.
326
wrapper method
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.
327
write lock
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.
328
write-ahead log
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.
329
XML
See eXtensible Markup Language (XML).
330