Umple: An Executable UML-Based Technology for Agile Model-Driven Development

Umple: An Executable UML-Based Technology for Agile Model-Driven Development

Timothy C. Lethbridge (University of Ottawa, Canada) and Abdulaziz Algablan (University of Ottawa, Canada)
Copyright: © 2021 |Pages: 25
DOI: 10.4018/978-1-7998-3661-2.ch001

Abstract

Umple is a technology designed to provide the benefits of model-driven engineering in a usable way. It is a textual modeling language, allowing agile developers to quickly incorporate state machines, associations, and many other modeling features into their codebase, with comprehensive code generation for multiple target languages. This significantly reduces the amount of code developers have to write. At the same time, Umple's always-on diagram generation and analysis allows quick understanding of model-driven projects and discovery of their defects. The chapter demonstrates the benefits of textual modeling languages and discusses multiple ways that Umple can help bring modeling to the agile development community, including its support for product-line engineering. Umple is in use worldwide, with the online version hosting over 200,000 user sessions a year.
Chapter Preview
Top

Introduction

When software engineers refer to models, they generally are referring to abstract representations of some part of a software system. Since the late 1990’s UML has been the most widely usedlanguage to express such models, rendering them as several different types of diagrams, such as class diagrams and state machines.

Models are typically contrasted with source code, generally written in a textual programming language. Almost all software is currently written by humans is in the form of such source code, which is the master formal description from which the system is built. By formal, we mean machine interpretable in this context.

The main contribution of the technology discussed in this chapter is a demonstration of how source-code based approaches and diagrammatic modeling approaches can be brought together as one, enablinggreater adoption of model-based agilesoftware engineering processes. Added benefits includeimprovements in separation of concerns, feature-based development, and product-line based development.

Modeling Adoption Challenges

Petre(2013) showed that modeling in UML is not as widely practiced as its proponents might have expected. UML diagrams are commonly just drawn on whiteboards to help developers better understand what source code will be needed. UML diagrams, often created using a simple drawing tool, are reasonably common in documentation, but often become out of date. A key observation is that models are not widely used to generate code, except in certain niches such as some kinds of safety-critical software.

The grand vision of many modeling proponents is that models shouldbecome the master formal source of the system, or at least of parts of systems. Models cancurrently be used to verify or check designs for planned source code, with the source code then being handwritten. But comprehensive code generation seems the most reasonable path forward. Code generation avoids both duplication of development effort, and errors caused by incorrect human transformation of models into code.

Unfortunately, our own research (Agner, Lethbridge & Soares, 2019; Forward & Lethbridge, 2008)has shown that existing modeling tools have numerous weaknesses, particularly regarding code generation. Expensive, proprietary and complex tools are often able to generate reasonable code, but open source tools accessible to average developers tend tocreate only stubs or no code at all. A key goal for the work reported in this chapter was to create a highly usable tool that can docomprehensive and reliable code generation and build complete systems.

Key Terms in this Chapter

UML: A widely used language using many types of diagrams to model software, including state machines and class diagrams.

Mixin: A lightweight block of code that can be blended into a textual program or model to add features. In Umple, multiple mixins declaring the same class can be combined to build a class. The multiple mixins can be in separate files or a single file. Mixins are a syntactic feature, as no analysis is done prior to the combination; this in contrast with Traits.

Attribute: A data item listed in a class description; each instance of the class will have this data. In Umple, attributes are subject to constraints and result in the generation of accessor methods.

Aspect: The representation of some part of software that describes how certain source code is to be blended into other source code, via a pattern-matching process.

Mixset: A set of mixins sharing the same name that can be made active by an Umple use statement in order to add a feature to a model in Umple.

Umple: A textual language for modeling software that incorporates many UML constructs as well as textual constructs such as mixins, mixsets, traits, and aspects.

Trait: A class-like modeling entity that groups various class features, such as associations, attributes, state machines and methods, to facilitate separation of concerns, feature-driven development, product lines and multiple inheritance. In contrast to a mixin, it has strong semantics so various errors can be detected.

Complete Chapter List

Search this Book:
Reset