Product Line Annotations with UML-F

The Unified Modeling Language (UML) community has started to define so-called profiles in order to better suit the needs of specific domains or settings. Product lines1 represent a special breed of systems they are extensible semi-finished pieces of software. Completing the semi-finished software leads to various software pieces, typically specific applications, which share the same core. Though product lines have been developed for a wide range of domains, they apply common construction principles. The intention of the UML-F profile (for framework architectures) is the definition of a UML subset, enriched with a few UML-compliant extensions, which allows the annotation of such artifacts. This paper presents aspects of the profile with a focus on patterns and exemplifies the profile’s usage.

💡 Research Summary

The paper “Product Line Annotations with UML‑F” presents a systematic approach for annotating software product lines—also referred to as frameworks—using a dedicated UML profile called UML‑F. The authors begin by explaining the concept of UML profiles, which extend the standard UML through stereotypes and tagged values, allowing domain‑specific notations without altering the core language. They argue that product lines, being extensible semi‑finished software artifacts, require clear visual cues to distinguish framework components from application‑specific extensions and utility libraries.

To meet this need, UML‑F defines a small, focused set of tags. The three primary class‑level tags are «framework», «application», and «utility». When applied to a package, the tag implicitly marks all contained classes and interfaces, providing an immediate visual separation between core framework elements, application‑specific additions, and external utility code. Table 1 in the paper summarizes the semantics of each tag.

Beyond classification, the authors introduce a completeness indicator. Standard UML uses an ellipsis (…) to denote omitted members, implicitly treating diagrams as incomplete. UML‑F adds a © tag that explicitly marks a model element as complete; otherwise, the ellipsis remains the default. This mechanism helps reviewers quickly identify whether a diagram intentionally omits details or represents a finished specification.

The core technical contribution lies in the representation of template‑hook relationships, which are fundamental to many framework construction principles. Two basic tags, «template» and «hook», label methods that serve as extensibility points (template methods) and the points where concrete behavior can be injected (hook methods). The authors extend this idea to higher‑level construction principles such as Unification and Separation. For Unification—where a template and its hook reside in the same class—the profile defines a tag set «Unif‑TH», «Unif‑t», and «Unif‑h» (or shortened forms like «U‑TH», «U‑t», «U‑h») to mark the class, the template method, and the hook method respectively. This layered tagging provides richer semantic information: a modeler can see not only that a method is a template or hook, but also that it participates in a specific construction principle, which in turn conveys expected flexibility and adaptation constraints (e.g., requiring subclassing and application restart).

The paper then bridges these construction‑principle tags to well‑known design patterns from the Gang‑of‑Four (GoF) catalog. Each pattern’s structural diagram is transformed into a set of UML‑F tags by concatenating the pattern name with the involved elements: «PatternName‑Class», «PatternName‑method», «PatternName‑association», and «PatternName‑attribute». As an illustration, the Factory Method pattern yields tags such as «FacM‑Creator», «FacM‑Product», «FacM‑facM», «FacM‑ConcreteCreator», and «FacM‑ConcreteProduct». The authors also show how the basic template‑hook tags can be combined with the pattern‑specific tags to convey both low‑level extensibility points and high‑level design intent.

A notable insight is the hierarchical organization of tag sets: basic template/hook tags form the foundation; construction‑principle tags (Unification, Separation, Composite, Decorator, Chain‑of‑Responsibility) sit on top; and pattern tags (Factory Method, Abstract Factory, Builder, etc.) reside at the highest level. This hierarchy enables incremental enrichment of model semantics without cluttering diagrams: a simple «template»/«hook» view suffices for quick inspection, while a full «Unif‑TH»/«FacM‑Creator» view reveals design rationale and expected adaptation mechanisms.

The authors also discuss domain‑specific patterns that may not appear in the GoF catalog. Because UML‑F’s tagging mechanism is generic, any new pattern can be introduced by defining a corresponding tag set following the same naming convention, ensuring that product‑line models remain extensible and consistent across domains.

In conclusion, the paper demonstrates that UML‑F provides a lightweight yet expressive means to annotate product‑line models. By clearly separating framework, application, and utility components, indicating model completeness, and explicitly marking template‑hook relationships and their associated construction principles, UML‑F improves readability, facilitates communication among stakeholders, and supports automated analysis tools that can detect missing hooks or inappropriate extensions. The integration of GoF pattern tags further aligns framework design with established best practices, making UML‑F a valuable addition to the model‑driven engineering toolbox for product‑line development.