OCUP 2 Advanced key terms

A model element that is simultaneously an association and a class, letting the link itself carry attributes, operations, and associations while remaining a single element in the namespace.

A structural relationship whose instances are links between typed instances of classifiers, described by two or more member ends with multiplicities and navigability.

An association with three or more member ends, whose links connect one instance from each end simultaneously rather than forming a chain of binary links.

A property of an association member end stating whether instances at the opposite end can be reached efficiently from the owning classifier, usually rendered as an open arrowhead.

A typed structural feature of a classifier or association end, owning multiplicity, aggregation, and default value; the metamodel class behind attributes and association ends alike.

An abstract metamodel class giving an element a lower and upper bound, plus ordering and uniqueness flags, from which Property and connector ends inherit their cardinality.

A grouping of generalization relationships that marks them as covering (every instance of the parent is an instance of some child) or disjoint (no instance belongs to two children).

A classifier whose instances are themselves subtypes of another classifier, typically modeled by placing a generalization set in the powertype role over a set of generalizations.

A relationship in which a subtype feature or role replaces an inherited one, keeping the same signature while narrowing type, multiplicity, or behavior.

A constraint declaring that the values or links denoted by one property are a subset of those denoted by another, commonly used to constrain association ends and derived unions.

The relationship that supplies actual parameters to a template classifier or package, producing a bound element whose contents are substituted accordingly.

A declared placeholder inside a template element that is replaced by an actual parameter at binding time, typed as a classifier, operation, or value parameter.

A property of an encapsulated classifier that specifies a distinct interaction point, with its own provided and required interfaces, through which the classifier communicates with its environment.

A link between two or more parts or ports of a structured classifier that enables communication, optionally typed by an association and carrying a contract of required and provided interfaces.

A classifier whose internal structure is described by owned properties representing parts, together with connectors that wire those parts and ports together.

A dependency-like relationship in which a classifier commits to honoring the contract declared by an interface, listing that interface among its provided interfaces.

An interaction fragment holding a boolean constraint over the lifelines of an interaction, asserted to be true at the point where the fragment appears.

An interaction fragment with an operator such as alt, opt, loop, par, or critical that composes the enclosed lifelines and messages into a larger behavior pattern.

One nested region inside a combined fragment, guarded by an optional interaction constraint, whose messages execute as a unit under the fragment's operator.

A state machine container that holds vertices and transitions; regions nest within states to express orthogonal or sequential submachine behavior.

A composite state whose internal behavior is split into two or more regions that execute concurrently, each with its own initial and final vertices.

A directed relationship between state machine vertices, optionally triggered by events, guarded by a boolean constraint, and carrying an effect behavior.

A state machine that specifies the legal order of operation invocations on a classifier, using pre- and postconditions on transitions rather than effects.

A grouping of activity nodes in an activity diagram, often representing an organizational unit or classifier responsible for executing the contained actions.

A structured activity region that executes its contained nodes once for each element of an input collection, producing output collections.

The fundamental executable unit in an activity, such as an invocation, object creation, or signal send, with pins for its inputs and outputs.

A model element describing a single runtime instance by naming its classifier and giving slot values for the structural features it holds.

The part of an instance specification that assigns a value or collection of values to one defining feature of the instance's classifier.

An abstraction dependency stating that a model element is physically embodied by an artifact, such as a class being realized by a source file.

A dependency between a deployment target node and deployed artifacts, describing where executable components are physically installed at runtime.

The Meta-Object Facility, an OMG standard defining a reflective, extensible metamodeling language and repository interface used to define UML itself and other modeling languages.

A class whose instances are themselves classes; in MOF and UML, metaclasses such as Class or Property define the elements of user models.

A model that defines the abstract syntax, well-formedness rules, and semantics of the elements permitted in models of a given language.

A UML package that extends the metamodel with stereotypes, tagged values, and constraints for a specific domain without altering the base metamodel.

A profile element that extends one or more metaclasses, adding tagged values and constraints so that base model elements can be annotated with domain-specific meaning.

The relationship by which a package applies a profile, importing its stereotypes and extensions so they become available on elements in that package.

The XML Metadata Interchange specification, a MOF-based serialization format for exchanging models and metamodels as XML documents.

The Foundational UML specification defining precise, executable semantics for a subset of UML activities and classes, forming the reference execution engine for models.

The Action Language for Foundational UML, a textual surface syntax that maps onto fUML actions and lets modelers write executable behavior bodies instead of graphical action graphs.

A deliberately underspecified area of UML semantics where conforming tools may differ, which fUML resolves by fixing one precise interpretation.