OMG-OCUP2-ADV300 OMG Certified UML Professional 2 (OCUP 2) - Advanced Level Questions and Answers

The MOF capability that supports the correlation of model elements across model transformations, where both the source and target models may be subject to change, is known as Federation 1 . Federation allows for the integration of different models, ensuring that changes in one model can be reflected in another, thus maintaining consistency across transformations.

The concept of  Extent  in MOF serves the purpose of defining a set of  Tags  that can be associated with any number of model elements. These tags provide additional information or metadata about the elements. Extent allows you to annotate model elements with relevant information beyond their intrinsic properties. It provides a context for identifying and managing these annotations independently from the element’s actual values.

The correct answer is B, which uses a selection edge to specify task behavior based on task priority. In UML, an object flow with a selection property is used to select objects from a collection according to some criterion, which is typically represented by a Boolean expression. In the case of B, the selection criterion is described as "ordering = the most important first", indicating that tasks are selected to be executed based on their priority.

References:

UML 2.5 Specification : The UML 2.5 specification describes how selection behaviors can be applied to object flows to filter objects according to specific criteria, such as priority in this scenario.

The execution semantics of Alf (Action Language for Foundational UML) are defined by mapping the concrete syntax of Alf to the abstract syntax of fUML 3 .  Alf provides a textual surface representation for a subset of UML model elements, and its main benefit is an execution semantics that allows for the generation of executable code out of Alf specifications 4 . This mapping ensures that Alf can be used to specify behavior in a way that is directly executable in the context of an fUML model.

To represent specific hardware environments in a deployment model, a modeler should create a UML profile that includes the necessary hardware stereotypes with applicable details. A profile allows the modeler to extend the standard UML metamodel to include domain-specific elements that can be applied to deployment models. These stereotypes can represent different types of hardware components and their attributes, which can then be used to model the physical aspects of the deployment environment. The creation and application of profiles are supported by the UML 2.x Superstructure Specification, which details how to tailor UML to particular domains or platforms using profiles.

In UML, when an operation is marked with the term {guarded} , it means that the operation is subject to a concurrency constraint. It specifies that the operation cannot have overlapping executions; in other words, if the operation is already in execution, a new attempt to start it will have to wait until the current one completes. This prevents race conditions and ensures thread safety for that operation when dealing with concurrent accesses in multi-threaded environments. This interpretation is based on the UML 2.x Superstructure Specification, which describes how operations can be marked with constraints to define their behavioral features in terms of concurrency.

In UML, a Dependency is a relationship that signifies that one NamedElement, the client, depends on another NamedElement, the supplier, meaning that a change in the supplier could affect the client. If NamedElement A is the supplier and NamedElement B is the client in a Dependency relationship, and there is a Comment indicating that both participate in a transformation, the interpretation is that B (the client) depends on A (the supplier) for that transformation. The comment does not necessarily change the nature of the Dependency relationship; it simply adds additional information about the nature of their interaction. A transformation could mean that B transforms A's supplied element in some way, but in terms of UML Dependency relationships, it would still be interpreted as "A depends on B" or "B requires A for its transformation". This interpretation aligns with the UML 2.x Infrastructure and Superstructure specifications, which explain Dependencies and their meanings within the UML metamodel.

For question number 50, the correct answer is C: Control tokens are offered on the outgoing Control Flows of the ExceptionHandler. According to the UML 2.5 specification, when an Exception Handler completes its execution, it does not halt the execution of the thread or retain control tokens internally; instead, it passes control tokens along the outgoing Control Flows. This behavior allows the activity to continue processing other behaviors or activities, based on the exception handling outcome.

References:

UML 2.5 Specification : Provides a detailed description of the behavior of Exception Handlers within activity diagrams, including how control tokens are managed upon the completion of an exception handling sequence.

In UML, a stereotype is a mechanism that extends the vocabulary of the UML in order to create new model elements. The given profile fragment defines a stereotype «architecture decision» that extends the metaclass Class . This stereotype includes three properties: Complexity, Risk, and Status, each typed by specific enumerations: Rank and Status. When a stereotype is applied to a UML element, it does not create physical attributes on the element; instead, it enables the element to carry additional information as specified by the stereotype — in this case, as Stereotype Properties. These properties are effectively tagged values that are associated with the stereotyped element. Hence, when a class is stereotyped as an «architecture decision», it will have the ability to hold values for Complexity, Risk, and Status according to the types defined by the enumerations in the profile. This is consistent with the rules defined in the UML 2.x Superstructure Specification for profiles and stereotypes.

The UML diagram fragment provided shows a UML profile with a required extension from the metaclass Class to the stereotype DisplayArea , which in turn has two subclasses Frame and Form . The use of {required} indicates that whenever an instance of Class is extended by the DisplayArea stereotype, it becomes mandatory to do so. However, this does not enforce that every instance of Class must be linked to DisplayArea or its subclasses ( Frame or Form ). It only means that if the DisplayArea stereotype is applied, it is required. Therefore, there is no obligation for every instance of Class or its subclasses to be stereotyped as DisplayArea , Frame , or Form . It's also worth noting that the last option (E) could be considered true in some interpretations of UML, but given the options provided and common UML practices, option D is more accurate.

In addition to ObjectFlow, which is used to denote the flow of objects between activities in a UML Activity diagram, data movement can also be facilitated through:

A. Pin is a point on a node that is used to accept or provide objects or data, but does not move data by itself.

B. Correct. Variables can be used to hold and move data within an activity, facilitating state maintenance or transitions between different actions.

C. Property, while it holds data, typically pertains to classes or components, not activities.

D. ControlFlow dictates the order of execution but does not inherently move data.

References:

UML Specification: Activity Diagrams section.

Details on how data can be managed within activities can be explored in the UML 2.5 Documentation, particularly under Activity and Object Nodes.

Alf (Action Language for Foundational UML) is essentially a textual notation for UML behaviors that can be attached to a UML model in any place where a UML behavior can be specified. Alf Input text serves as a concrete representation for UML model elements within the fUML, allowing for behavioral modeling using a textual surface notation.  This facilitates a model-driven process capable of generating fully executable source code, thus integrating structural modeling with behavioral modeling 1 2 .  Alf allows for detailed behavioral specification in a textual form as opposed to the more cumbersome graphical activity diagram notation, making it a practical tool for specifying the operational behavior of a system within the UML framework 2 .

StateMachine Redefinition in UML allows for the specialization of a StateMachine by a derived Classifier. This is crucial as it ties into the broader capability of UML to specialize behaviors and classifiers:

A is incorrect; UML does discuss StateMachine Redefinition.

B describes one aspect of redefinition but is too narrow as it omits that redefinition can also redefine transitions and internal behaviors, not just states or events.

C describes more of an error correction or revision process, which is not specifically what StateMachine Redefinition is about.

D captures the essence of StateMachine Redefinition, emphasizing that it is a necessary extension of UML's capabilities to allow for specialization and refinement of classifiers and their behaviors.

References:

UML Specification, Section on StateMachines

StateMachine Redefinition is further elaborated in UML 2.5 Documentation under the Behavior StateMachines sections.

In UML, profiles are mechanisms to extend the UML for a specific domain or purpose. The UML specification allows for one profile to reuse or import elements from another profile. This enables modularity and encourages reusability of profile elements across different domains. Additionally, one profile may extend the stereotypes or metaclasses defined in another profile, which allows for the creation of layered profiles where each layer adds its own specificities. This is a common practice in software and systems modeling to cater to different aspects of a system within separate profiles, which are then integrated to form a comprehensive model. The capability to reuse and extend profiles is defined in the UML 2.x Superstructure Specification, which gives guidelines on how to define and use profiles within UML.

In UML, an InformationItem represents an abstraction of all those elements in a UML model that have an information-bearing feature. It is depicted as a classifier with the keyword «informationItem». An InformationItem does not have direct instances and serves as a mechanism to handle unspecified, untyped information in a model. In the context of a commercial transaction model, currencies such as euros, pesos, and dollars can be abstractly represented as InformationItems to signify that they are used as a form of data exchange but without specifying the concrete structure or data type. Figure 2 correctly uses InformationItem notation, with the «informationItem» keyword and the directed association pointing from the Currency InformationItem to the Euro, Peso, and Dollar, which are likely representations or manifestations of the Currency. This complies with the UML specification for representing abstract entities in models that are involved in the exchange or flow of information.

The capability that enables the discovery and manipulation of metaobjects and metadata is  Reflection . In the context of the Meta-Object Facility (MOF), reflection allows you to examine and interact with the structure and semantics of metamodels, models, and their elements. It provides a way to introspect and dynamically access information about the modeling constructs, such as classes, attributes, relationships, and constraints.

 In the context of the Meta-Object Facility (MOF), a metamodel is essentially a model that defines the structure and semantics of a modeling language. It is a set of constructs and rules that describe how models can be constructed for a particular domain or purpose.  The MOF itself is an example of a metamodel because it provides the language for defining other metamodels, such as the UML metamodel 1 .

fUML (Foundational UML) is a subset of the standard Unified Modeling Language (UML) that includes standard, precise execution semantics. This subset encompasses typical structural modeling constructs of UML such as classes, associations, data types, and enumerations, as well as the ability to model behavior using UML activities composed from a set of primitive actions.  Therefore, a model constructed in fUML is executable in the same sense as a program in a traditional programming language, but with the level of abstraction and richness of expression of a modeling language 2 .

To provide the ability to specify CORBA physical components within a UML tool, the most appropriate approach is to create a UML profile that includes stereotypes, tagged values, and constraints that reflect the characteristics and requirements of CORBA components. Applying this profile to a UML model would extend the semantics of UML to support CORBA-specific concepts without modifying the UML metamodel itself. This approach allows the modeler to leverage the existing UML tooling while incorporating the additional semantics required for CORBA components. This practice is supported by the extensibility mechanisms provided by UML, as described in the UML 2.x Superstructure Specification, which outlines how to create and apply profiles.

In UML, profiles are applied to specific model elements to adapt the UML metamodel to different domains or platforms. The provided diagram shows a UML package diagram within which the «Versioning» profile is applied to the "Business Logic" package, and the «DBProfile» is applied to the "Data" package. This is a correct use of profiles in UML as they allow the customization of parts of a model by applying additional constraints and stereotypes to specific packages or classes. There is no restriction in UML that a profile cannot be applied to multiple packages in the model simultaneously, and profiles do not necessarily need to be members of the namespace of the model they are applied to; they can be defined externally. Therefore, the scenario presented is a correct application of two different profiles to two distinct packages within the same model, conforming to the UML 2.x Superstructure Specification.

In UML, modeling individual things (such as instances) involves making statements about them. Here are the details for each option:

A. A UML Model can contain individual things (e.g. Instances) UML does not prescribe the level of detail to be used in the description.

This statement is partially correct. UML models can indeed contain individual things (instances), but the level of detail is not explicitly prescribed by UML. However, the statement does not cover the possibility of incomplete or imprecise information.

B. A UML Model can contain statements about individual things If a thing is an instance of a Classifier, these statements must be consistent (all mandatory Properties must be defined, all Constraints must be satisfied).

While it is true that a UML model can contain statements about individual things (instances), the requirement for consistency (mandatory properties and constraints) is not explicitly mentioned in UML. Therefore, this option is not entirely accurate.

C. A UML Model can contain statements about individual things These statements can be incomplete, imprecise, and abstract, but not wrong.

This statement is also partially correct. UML allows for incomplete, imprecise, and abstract statements about individual things. However, it does not guarantee that these statements cannot be wrong.

D. A UML Model can contain statements about individual things. These statements can be incomplete, imprecise, abstract, may turn out to be wrong, or even be asserted as counterfactual.

This option provides a more accurate representation. UML allows for statements about individual things that can be incomplete, imprecise, abstract, and even potentially incorrect. It acknowledges the uncertainty and variability in modeling individual things.

E. A UML Model can only contain statements about sets of individual things (e.g. Classifiers).

This statement is incorrect. UML models can contain statements about both individual things (instances) and sets of things (classifiers).

References:

UML 2.5.1 Specification

While the UML specification does not explicitly state the options, it provides the foundation for UML modeling principles and allows for flexibility in expressing statements about individual things.

Remember that UML is a modeling language, and its primary purpose is to capture and communicate information about systems and their components. The level of detail, precision, and correctness can vary based on the modeling context and the specific use case. Therefore, option D best reflects the UML approach to modeling individual things.

Please note that the information provided here is based on UML 2.5.1, and it’s essential to consult the official UML specification for the most accurate and up-to-date details.

The correct representation of a binding of the template operation addElement <</b> E > with E being bound to the type Card is addElement (e : Card) . This notation means that the template parameter E is being replaced by the concrete type Card , thus instantiating the template operation with that specific type. In UML, this instantiation does not require the «bind» keyword or the template brackets <</b> > around the type in the operation signature itself; it is simply represented by using the concrete type as the type of the parameter in the operation. This usage is consistent with the UML 2.x Superstructure Specification, which explains how operations of a template classifier are instantiated when template parameters are bound to actual types.