m362glossary Part 2 Flashcards Preview

M362 glossary > m362glossary Part 2 > Flashcards

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

XML Schema Definition (XSD)

An XML-based description of an XML document, allowing for better type checking than a DTD and more rigorous constraints for XML documents to meet.