OMG Certified UML Professional 2™ (OCUP 2™): Advanced Level
Coverage Map and References
IMPORTANT: THIS IS THE COVERAGE MAP FOR THE NEW OCUP 2 ADVANCED EXAM, which is the only version available now that the original exam has been withdrawn. Because no questions were carried over from the original Advanced exam to the new OCUP 2 version, you MUST use this new Coverage Map to prepare for the new exam - The studying, and study material, that you used to prepare for the original exam will not help you prepare for this new one..
The OCUP 2 Certification Program tests your knowledge and skill in the use of the UML® language to construct and interpret models of software systems. The language elements and attributes added in this Advanced Level Coverage Map complete the set that you studied at Foundation and Intermediate levels, enabling you to represent virtually all aspects of software structure and behavior in your UML models. The OCUP 2 Advanced examination then tests your knowledge and skill in the use of this completed palette. Finally, the Advanced exam tests your knowledge, albeit at an awareness level, of metamodeling and the role and some uses of metamodels.
|Examination Number: ........................||OMG-OCUP2-ADV300|
|Duration: .............................................||105 minutes for residents of English-speaking countries;
135 minutes for all others
|Exam Fee: ...........................................||US$200 (or local equivalent) for residents of English-speaking countries; US$210 (or local equivalent) for all others.|
|Minimum Passing Score: ...................||57 items correct out of 90|
|Prerequisite: ......................................||OCUP 2 Intermediate level certification|
This page starts with the Coverage Map for the OCUP 2 Advanced Level Examination in two forms - First, a concise listing of the topics and subtopics covered, and the percentage of the exam that each occupies; then a more detailed description tied to the UML 2.5 specification document and, at the end, to the metamodeling sources used for that final section of the exam. Following this is a section containing guidance and suggestions for study, and finally the list of references including a link to download (for free) the UML 2.5 and metamodeling specifications, and a white paper.
Do not assume that, because we are using the UML 2.5 specification as a reference to delineate the coverage, you can study exclusively from the spec document and be prepared for the exam because you can not. The OCUP 2 program is designed to test a candidate's knowledge and skill in the use of UML in modeling, and goes far beyond these definitions. To prepare fully, you must learn to use the language elements listed here in practice, whether by cross-referencing them to a modeling textbook, or taking a preparatory course, or using another source.
As you know since you have already (presumably) taken the Intermediate OCUP 2 exam, it and Advanced exam are not organized by diagram type: As a candidate at this level, you already know that the language itself is not organized in this way, as many model elements may appear on more than one diagram type, and a structural diagram - rather than be typed specifically - may take its type from the preponderance of elements that appear on it.
OCUP 2 COVERAGE MAP - ADVANCED LEVEL
Templates; Name Expression; Realization; Values; String Expression
Profiles; Information Flows
Classifier Templates; Features; Properties; Operations; Generalization sets
Associations; Collaborations; Components; Deployments; Artifacts
Behaviors - Reentrant; FunctionBehavior; Events - Event pool
Behavior StateMachines; StateMachine Redefinition; Protocol StateMachines
Activities; Control Nodes; Object Nodes; Executable Nodes; Exception; Activity Groups
Invocation Actions; Object Actions - ValueSpecificationActions; AcceptEventActions; Structured Actions - RaiseExceptionActions
Interactions; Lifelines; Messages; Occurrences; Fragments; Interaction Uses; Interaction Overview Diagrams
|The MOF and Metamodeling
Architectural alignment; models and what they model; the semantics of languages, models, and metamodels; the MOF
Scope; Terms and Definitions; Overviews of Abstract Syntax and Execution Model; Behavioral Semantics
Scope; Semantic Conformance; Integration with UML Models; Lexical Structure
LEVEL OF COVERAGE OF THE LISTED TOPICS:
As we just pointed out, the Intermediate and Advanced OCUP 2 coverage maps are not organized by Diagram type - The UML 2 specification does not assign elements and features to diagrams precisely enough for this. Instead, we have organized these coverage maps around the spec itself even though this comes at a price: Candidates may mistakenly assume that they will be tested on language details and aspects, rather than functionality and usage. Our experts resisted this temptation when they wrote these exams and kept their focus on modeling; you must do the same as you study: As you consider each UML element, think about what it could represent in a model and how it could be used. Look up the element in a modeling textbook (one recommended on our References page, perhaps, or another already on your bookshelf) and examine how the authors use and exercise it in their modeling. You should still be aware of the way it fits into the language structure, especially if that helps you remember and keep track of the element's characteristics and attributes, but do not concentrate on these aspects. This exam was written to test your UML knowledge and skills in the context of modeling.
So, this coverage map lists the additional primary expository sections and first-level subsections or, in some cases, individual UML elements or attributes, of the UML 2.5 specification that, combined with the material covered at Foundation and Intermediate levels, constitute the total of material covered on this Advanced exam. Related material contained in the specification's Notation and Examples sections is included automatically in our coverage by association (as it was in the two lower level exams) even though these sections are not listed explicitly. IMPORTANT: Information about an individual language element, attribute, or topic may be spread throughout the UML specification document, appearing in multiple sections or subsections. Even though we only mention or include an element or item once in this map, all of the information in the UML specification document about it is in scope for this exam and it is up to you to identify the various scattered mentions and form a thorough understanding about how that element contributes to your model. This principle (of only mentioning items once in this map) applies to exclusions as well.
IMPORTANT: See paragraph (below) about Study Guides.
But the level of coverage for the Metamodeling section is very different: The people in your modeling workgroup, along with your technical and managing superiors, will expect that you, as an Advanced level OMG-Certified UML practitioner, are knowledgeable about Metamodeling - That you know what a metamodel is and what it's good for, and what the metamodel-related OMG specifications contain and how they can contribute to your project. With this level of awareness, you will know which one or several of the OMG metamodeling or metamodel-based standards covered in this section will be useful if or when you need its capabilities, and this is the level that our experts chose for this section that closes out the OCUP 2 rogram. Concentrate on the usefulness of the material as you study for this part of the Advanced exam.
Coverage of UML includes these Elements:
Chapter 6: General Topics
Backus-Naur Form (BNF)
- This exam uses BNF where appropriate to specify textual notation, similar to the way it is used in the UML specification itself. BNF is defined in Ch. 6 on page 9 (UML 2.5 Specification, Beta 1). Also in Ch. 6 is a (very!) brief description of execution scope, a term that will be used later in several contexts.
- Every first-level subsection of the UML specification starts with a UML diagram labeled Abstract Syntax. The OCUP 2 exams do not ask about these diagrams explicitly, but they are good examples of the language you're studying(!) and represent the relationships linking the elements to be presented in the sections that follow in a particularly clear and concise way. As an Advanced candidate, you presumably know how to read these diagrams and use the information they display. If you don't have this skill, you should develop it. It will provide an advantage to your study, and your work in the field at this level.
Chapter 7: Common Structure
- 7.3 Templates -
- Add Templates. Postponed until now, Templates and the many elements that support them are covered at this Advanced level. Coverage is fairly complete, encompassing elements and attributes defined for Templates here in Section 7.3 and later on (String Expressions and Name Expressions, e.g.; most have "Template" somewhere in their names). There are many of these scattered throughout the specification but we will not point out, for each, that it is now included. We will, however, specifically mention the following:
- Add Template Signatures, Template Bindings, Bound Element Semantics, and Template Notation
- 7.4 Namespaces - Add:
- NamedElement association with StringExpression, and having both a name and a nameExpression.
- 7.7 Dependencies - Add:
Chapter 8: Values
- 8.3 Add: String Expressions
Chapter 12: Packages
- 12.3 Profiles: Includes All except MOF-equivalent semantics and non-UML metamodels. Also exclude XMI Serialization.
Chapter 20: Information Flows
- 20.1 InformationFlows
- Add InformationFlow sources and targets, channels, InformationItems
Chapter 9: Classification
- 9.2 Classifiers
- Classifiers: Add Classifier may own CollaborationUses and UseCases
- Generalization: Add Substitutability
- Redefinition: Add redefinitionContext
- Substitution: All
- 9.2.4 Notation: NOTE: UML allows a conforming tool to suppress the drawing of individual compartments or features of a classifier. Scenarios in this examination may use this ability.
- 9.3 Classifier Templates: All
- 9.4 Features: Add: concurrency property, effect property, notation of feature redefinitions
- 9.5 Properties: Add: Note the reference to qualifiers. Add ternary and higher-order associations, redefinition, composition and transitive deletion, subsettedproperty, isDerivedUnion.
- 9.6 Operations: Add featuringClassifier, isQuery, owning classifier context
- 9.7 Generalization Sets - Add: powertypes
Chapter 11: Structured Classifiers
- 11.2 Structured Classifiers: Add: contracts, n-ary Connectors
- 11.4 Classes: Add: the stereotype «Metaclass»
- 11.5 Associations: Add: n-ary Associations (n>2), Subsetting, Specialization, qualifiers and qualified Association end, derivation of an Association, navigability via Class:ownedAttribute and Association:ownedEnd
- 11.6 Components: Add: Profiles based around components, wiring dependency, details of the "white-box" view beyond the treatment at Intermediate level, execution time semantics of a Connector, and «Specification» and «Realization» stereotypes
- 11.7 Collaborations: Add: extension of collaborationRole in a specialization
Chapter 19: Deployments
- 19.1 Summary: Add: extending the package
- 19.2 Deployments Add: extending in profiles, Property and InstanceSpecification as targets
- 19.3 Artifacts Add: organizing into composition hierarchies, extending especially as profiles
Chapter 13: Common Behavior
- 13.2 Behaviors Add: reentrant Behavior, Function Behavior, Behavior owned as a nestedClassifier
- 13.3 Events Add: Event handling by context object, event pool, wait point, SignalBroadcastAction
Chapter 14: StateMachines
- 14.2 Behavior StateMachines: Add: event pool
- 14.3 StateMachine Redefinition: All
- 14.4 Protocol StateMachines: Add: Declarative and Executable ProtocolStateMachines, use of sophisticated forms of modeling as detailed in the section, multiple ProtocolStateMachines per Classifier, use of other types of events, ProtocolStateMachine refinement, Protocol Conformance. NOTE: Unexpected trigger reception and Unexpected behavior will not be covered in OCUP 2.
Chapter 15: Activities
- 15.2 Activities:
- Activities and Activity Nodes: Add: isControlType
- Activity Edges: Add: Object tokens flowing over ControlFlow edges, object tokens accepted by ExecutableNodes, managing contention between multiple nodes, the weight property
- Object Flows: Add: remainder of subsection. (Basic definition and null token already covered.)
- Variables: All Except the discussion of variable setting in the Note paragraph.
- Activity Execution: Add: remainder of subsection. (Material preceding isSingleExecution has already been covered.)
- Activity Generalization: All.
- 15.3 Control Nodes
- Decision Nodes: Add: decisionInput behavior, Parameters, and guards on multiple outgoing edges.
- 15.4 Object Nodes
- Object Nodes: Add upperBound, ordering, selection Behavior
- Activity Parameter Nodes: Add: effect of ordering
- Data Store Nodes: Add: selection and transformation
- 15.5 Executable Nodes
- Executable Nodes: Add: concurrent execution
- Exceptions and Exception Handlers: All
- 15.6 Activity Groups
- Activity Partitions: Add: the descriptive text about preparation of descriptive models for review
- Interruptible Activity Regions: Add: isSingleExecution
Chapter 16: Actions
- 16.1 Summary: Add dependence of Actions on Activities, basic definition of concrete syntax, and of execution engine
- 16.2 Actions:
- Actions: Add isLocallyReentrant and isReentrant.
- Pins: Add ordering and isOrdered, token behavior on StructuredActivityNodes, fromActions
- Actions and Pins in Activities: Add: disallowing of acceptance of more tokens than will be consumed by one execution of an Action, isLocallyReentrant, isControl, isControlType.
- 16.3 Invocation Actions
- Call Actions: Add StartObjectBehaviorAction, classifierBehavior, non-reentrant and reentrant Behavior, matching owned Parameters to Pins by ordering
- Send Actions: BroadcastSignalAction, SendObjectAction, ordering of owned and inherited Properties of a Signal, effects of local or remote target object.
- Invocation Actions and Ports: All
- 16.4 Object Actions
- Summary: All
- ValueSpecificationAction: All
- 16.5 - 16.9: Material in these sections is not covered in OCUP 2.
- 16.10 Accept Event Actions
- Accept Call Actions: Add triggering by an asynchronous call, method behavior caveat
- Reply Actions: All
- 16.11 Structured Actions
- Structured Activity Nodes: Add: Variables, semantics of activity edge when contained or not contained by a StructuredActivityNode
- Isolation: All
- 16.13 Other Actions
- Raise Exception Actions: All
Chapter 17: Interactions
- Interactions in detailed design phase, all discussion of role of interactions, interleaving
- NOTE THAT ALL discussion of disallowed or invalid traces in this chapter is included. This Coverage Map does not list specific references to disallowed or invalid traces.
- Interaction Diagram Variants: Add Interaction Overview Diagram
- 17.2 Interactions
- Add Specializing and redefining an Interaction
- 17.3 Lifelines
- Add coregion
- 17.4 Messages
- Add representation of ConnectableElement with a Type, wildcard argument
- Messages: Add assignment-target, value-specification
- Notation: As in all other sections, notation of covered elements is included automatically. For this subsection, which includes some notation for elements not mentioned previously, we point out that All of the notation section is included.
- 17.5 Occurrences
- General Orderings: All
- 17.6 Fragments
- Consider Ignore Fragments: All
- Continuations: All
- Negative: All
- Critical Region: All
- Ignore/Consider: All
- Assertion: All
- 17.7 Interaction Uses
- Notation: InteractionUse, CollaborationUse, strict, and return value
- 17.8 Sequence Diagrams
- Sequence Diagram Notation: Add Continuation, coregion
- Graphic Paths: Add GeneralOrdering
- 17.9 Communication Diagrams
- Sequence expression: Add iteration notation for concurrent execution
- 17.10 Interaction Overview Diagrams: All
Chapter 18: Use Cases
- 18.1.3 Semantics
- Use Cases and Actors: Add description through a Collaboration; being owned by a Classifier.
Coverage of Metamodeling includes these Topics:
Our coverage of metamodeling and the functionality that it enables (executable UML, e.g.) is intended as a survey, and the experts who wrote the exam questions did not expect you to study these specifications in enough depth to be able to work with the language. Learn the basics of these topics well and try to retain this knowledge as your modeling work evolves so that, when you come to a point in a project that calls for metamodeling or generating a UML model intended for execution, you know where to look for solutions.
Metamodeling and the MOF, from UML 2.5:
- 6.2 Architectural alignment: All
- 6.3.1 Models and What They Model: All except Execution Scope, which was covered in the main exam
Metamodeling and the MOF, from fUML v1.2.1:
- 6.2 On the Semantics of Languages and Models: All
- 6.3 On the Semantics of Metamodels: All
Metamodeling and the MOF, from OMG White Paper:
- Meta-Modeling and the OMG Meta Object Facility (MOF): All
Metamodeling and the MOF, from the MOF 2.5 specification:
- 9.1, 9.2 Reflection: All
- 10.1, 10.2 Identifiers: All
- 11.1, 11.2 Extension: All
Semantics of a Foundational Subset for Executable UML Models (fUML), from fUML v1.2.1:
- 1 Scope: All
- 4 Terms and Definitions: All
- 7.1 Abstract Syntax: Overview
- 8.1 Execution Model: Overview, Behavioral Semantics
Action Language for Foundational UML (Alf), from Alf v1.0.1:
- 1 Scope: All
- 2.3 Semantic Conformance: All
- 6.1 Overview - General: All
- 6.2 Integration with UML Models: All
- 6.4 Lexical Structure: All
OCUP 2 Advanced EXAM - REFERENCE LIST
Since the release in 2003 of UML 2.0 with its collection of new features and improvements, the history of the language has reflected more evolution than revolution. Even version 2.5, the stimulus for the upgrade of our certification program to OCUP 2, makes minimal changes to your models compared to its predecessor versions 2.4 and 2.4.1 in spite of the major changes it makes to the underlying structure of the specification - such as the merging of the superstructure and infrastructure into a single document! (In fact, the authors of the 2.5 revision were required to minimize model-level changes as they simplified UML's underlying metamodel.)
This means that you can study for the OCUP 2 examinations from older books about UML 2. (This is fortunate because the recent evolution of UML has lacked the high-level spec changes that would otherwise inspire authors to produce a new generation of books.) We've listed two below (the Nutshell and Dummies books) that we believe reflect particularly high quality, but you should do well on the exam if you study from almost any book that covers the diagrams and elements listed on this page. Remember, when you select a book or reference for study, that the OCUP 2 examinations will ask you to interpret and and "construct" (by choosing the correct diagram from a set of options) UML diagrams, unlike the original OCUP program which restricted itself to definitions from the specification.
UML 2.0 in a Nutshell
Dan Pilone, Neil Pitman - O'Reilly Media, 2005 [ISBN 978-0-596-00795-9]
UML 2 for Dummies
Michael J Chonoles, James A. Schardt - Wiley, 2003 [ISBN 978-0-7645-2614-5]
Can I study for the OCUP 2 Advanced exam using the Certification Guide written for the original OCUP Fundamental and Intermediate exams? In a word, No. The two programs are very different - while the original OCUP restricted itself to UML syntax and semantics (including the UML metamodel), the OCUP 2 Advanced exam tests UML usage in the context of modeling and this aspect is not presented in the study guide. Study from one of the books just mentioned or another good book about UML modeling, and explore the ways you can control the listed UML elements in your modeling tool. Learn how to use, or recognize and interpret, these elements in larger diagrams and how they can relate to each other. We based the new examination on these aspects of UML because they are the ones that you will use in your career as either a model builder or a model user. If you concentrate on the material presented in the original OCUP Certification Guide, you will be unprepared for the new OCUP 2 exam.
OMG Specification (Downloadable Free):
Unified Modeling Language (UML), V2.5
The Coverage Map presented on this page is keyed to the UML 2.5 specification downloadable free from the OMG specification library. Use it to identify the UML elements and attributes covered on the exam from the citations on this page, but do not think that this is all you need to know about them - The real value of UML lies in the models that you construct or read using the language, and the way they present the structure and behavior of the modeled system. This is the aspect of UML modeling that the OCUP 2 exams will test, and it is not presented in the specification. So, use this document as a starting point but move on quickly to study the way the cited elements and attributes work together in modeling by looking them up in one of the books cited above, or a similar text already on your bookshelf. This is the path to success in your career, and in OCUP 2 certification!
Meta-Object Facility (MOF), V2.5
The MOF 2.5 specification provides the basis for metamodel definition in OMG's family of modeling languages (including the UML) and is based on a simplification of UML 2's class modeling capabilities. In addition to providing the means for metamodel definition, it adds core capabilities for model management in general including Identifiers, a simple generic Tag capability, and Reflective operations that are defined generically and can be applied regardless of metamodel. This s the MOF specification covered in the Metamodeling section of this OCUP 2 Advanced exam.
Semantics of a Foundational Subset for Executable UML Models (fUML)V1.2.1
The scope of this specification is the selection of a subset of the UML 2 metamodel that provides a shared foundation for higher-level UML modeling concepts, as well as the precise definition of the execution semantics of that subset. This subset is referred to as Foundational UML or “fUML.”
Action Language for Foundational UML (Alf)V1.0.1
The Action Language for Foundational UML (or “Alf”) is a textual surface representation for UML modeling elements. The execution semantics for Alf are given by mapping the Alf concrete syntax to the abstract syntax of the standard Foundational Subset for Executable UML Models (known as “Foundational UML” or “fUML”). The result of executing an Alf input text is thus given by the semantics of the fUML model to which it is mapped, as defined in the fUML specification.
Papers (Downloadable Free):
OMG OCUP 2 Program, Meta-Modeling and the OMG Meta Object Facility, White Paper, March 2017
J.D. Baker, Model Organization with Packages and the Package Diagram, White paper, May 2013
Filip Stachecki, Concurrency in UML, White Paper, March 2014. Concurrency is a complex concept, and may be represented in most UML behavioral diagrams. This paper doesn't attempt to explain what Concurrency is - you'll have to learn that from books or courses - but it does point out the UML elements used to present concurrency in Activity diagrams (tested at Foundation level), and Sequence and State Machine diagrams (tested at Intermediate level).
Bran Selic, Getting It Right on the Dot, White Paper, April 2013. Use and significance of the black dot notation on UML associations.
For more information or questions about the OMG Certification Program, contact firstname.lastname@example.org.
OCUP, OCRES, OCEB and OCSMP are joint programs of the OMG and the UML Technology Institute (UTI).