- Wiki Home
- FAQ Frequently asked questions
- Best practices for using Umple
- Publications and theses
- Installing Eclipse plugin
- Developer Setup
- UmpleOnline Setup
- Contribution Process
- Cheat sheet
- Umpleonline manual tests
- Planned development
Clone this wiki locally
List of peer-reviewed papers and theses describing Umple
Below you will find detailed technical material about Umple.
See also the user manual, and the presentations page for further information.
See also https://uniweb.uottawa.ca/#!uottawa/themes/3626/publications for Dr. Lethbridge's publications about Umple. The following is a subset, with a few additional items. We have provided DOI links and/or links to ACM, IEEE and other digital libraries. The most recent papers sometimes have several months delay before they appear in digital libries. For access to any paper for which you cannot find a pdf, email Dr. Lethbridge firstname.lastname@example.org and he will send a pdf.
- Lethbridge, TC., Forward, A., Badreddin, O., Brestovansky, D., Garzon, M., Aljamaan, H., Eid, S., Husseini Orabi, A., Husseini Orabi, M., Abdelzad, V., Adesina, O., Alghamdi, A., Algablan, A., Zakariapour, A. (2021) Umple: Model-Driven Development for Open Source and Education, Science of Computer Programming, Elsevier
Umple is an open-source software modeling tool and compiler. It incorporates textual language constructs for UML modeling, including associations and state machines. It includes traits, aspects, and mixins for separation of concerns. It supports embedding methods written in many object-oriented languages, enabling it to generate complete multilingual systems. It provides comprehensive analysis of models and generates many kinds of diagrams, some of which can be edited to update the Umple code. Umple runs on the command line, in a web browser or in integrated development environments. It is designed to help developers reduce code volume, while they develop in an agile, model-driven manner. Umple is also targeted at educational users where students are motivated by its ability to generate real systems from their software models.
- Husseini Orabi M., Husseini Orabi A., Lethbridge T.C. (2020) "Umple-TL: A Model-Oriented, Dependency-Free Text Emission Tool." Communications in Computer and Information Science, vol 1161. Springer
We describe the text-emission templating capabilities of Umple (Umple-TL) and compare this Umple feature to other technologies for text generation. Umple, which is written in itself, combines modeling synergistically with programming in languages like Java and C++. Umple-TL further builds on these synergies. With the use of Umple-TL, we eliminated dependencies on third-party libraries for text emission. We demonstrate how Umple-TL attains benefits such as smaller and faster executables, target-language independence and IDE independence. We compare Umple-TL and other text emission tools in order to show how Umple-TL can overcome many of the challenges a tool can face. The word ‘template’ in this paper refers to patterns for the generation of output, and not to generic types, another common use of the term.
- Agner, L.T.W. Agner , Lethbridge. T.C., Soares, I.W. Student Experience with Software Modeling Tools, Software & Systems Modeling 18 (5), pp. 3025-3047
Modeling is a key concept in software engineering education, since students need to learn it in order to be able to produce large-scale and reliable software. Quality tools are needed to support modeling in education, but existing tools vary considerably both in their features and in their strengths and weaknesses. The objective of the research presented in this paper was to help professors and students choose tools by determining which strengths and weaknesses matter most to students, which tools exhibit which of these strengths and weaknesses, and how difficult to use are various tools for students. To achieve this objective, we conducted a survey of the use of modeling tools among students in software engineering courses from Brazil, Canada, the USA, Spain, Denmark, the UK and China. We report the results regarding the 31 UML tools that 117 participants have used, focusing on the nine tools that the students have used most heavily. Common benefits quoted by students in choosing a tool include simplicity of installing and learning, being free, supporting the most important notations and providing code generation. The most cited complaints about tools include lack of feedback, being slow to use, difficulty drawing the diagrams, not interacting well with other tools, and being complex to use. This research also compares the results with the findings of another survey conducted among professors who taught modeling. The results should benefit tool developers by suggesting ways they could improve their tools. The results should also help inform the selection of tools by educators and students.
Open access version: https://www.site.uottawa.ca/~tcl/papers/SoSyM2019/Paper_Students_Survey-SoSyM-AgnerLethbridgeSoares.pdf
- Adesina, O., Lethbridge, T.C., Somé, S., (2019) “Optimizing Hierarchical, Concurrent State Machines in Umple for Model Checking”, 16th Workshop on Model Driven Engineering, Verification and Validation (MoDeVVa), Models Companion Volume, Munich, September, pp 523-531, IEEE
This paper presents our work on the optimization of hierarchical, concurrent state machines for the purpose of model checking software systems. We propose an encoding strategy that reduces the explosion of the state space during model checking. Our method removes non-concurrent composite states of a state machine but retains its concurrent and basic states counterparts. Transitions into and those originating from the removed states are redirected in a manner that is semantics-preserving. The resulting state machine has a state-space lesser than (or equal to) its unoptimized version. This in-turn yields improvements in resource utilization as attested by means of case studies. While cone of influence (COI) reduction remains a potent method for managing state space explosion during model checking, it was discovered that our approach outperforms COI on some parameters. It even facilitates further reduction in resource utilization when combined with COI.
- Husseini-Orabi, M., Husseini-Orabi, A., and Lethbridge, T.C. (2019) “Umple as a Template Language (Umple-TL)”, Modelsward 2019, pp. 98-106
We extend Umple, a model-oriented programming language, to incorporate text emission from templates as an integral feature. Umple as a template language (Umple-TL) is the term we use to describe the template sublanguage of Umple. Using Umple-TL, developers can benefit from synergies among UML modelling, templating and programming in several target languages (Java, C++), all in one textual language – Umple. Umple itself is written in Umple; using Umple-TL, we eliminated Umple's dependency on third-party libraries for text emission. We also support any other application developed in JET to be converted to use Umple-TL and attain benefits such as smaller and faster executables, target-language independence and IDE independence. The word ‘template’ in this paper refers to patterns for the generation of output, and not to generic types, another common use of the term.
- Lethbridge. T.C. and Algablan, A. (2018) “Applying Umple to the Rover Control Challenge Problem: A Case Study in Model-Driven Engineering”, MDETools, Models 2018, CopenHagen, October, CEUR
We demonstrate the use of the textual modeling language called Um- ple on a software modeling challenge problem that requires participants to create an executable model of a robotic rover that must follow another rover at a safe distance. We used a wide variety of features of Umple in the solution, including class models, state machines, aspects, and mixsets (feature models). We imple- mented two separate solutions to the problem. Our first solution, in which pulses of full power of varying lengths alternate with direction changes, performs sig- nificantly better than our second solution in which power and direction are blended together and varied in amplitude. Overall Umple proved very versatile at exploring various dimensions of this problem.
- Lethbridge. T.C. and Algablan, A. (2018) “Using Umple to Synergistically Process Features, Variants, UML Models and Classic Code”, ISOLA, October, Springer, pp 69-88
We describe the synergies gained by enabling variants for product lines, or features, to be modeled in the same master syntax as design models (class diagrams, state diagrams, composite structure) and traditional source code. Our approach, using a construct we call mixsets, facilitates better analysis, documentation generation, diagram generation, reviewing and testing. It also solves problems related to tool dependency. We have implemented the approach in Umple, building on our previous work which merged design models with code. Our approach continues to allow multiple programming languages to be embedded and generated from the design models. Our extensions allow multiple approaches to separation of concerns (variants, traits, mixins, aspects) to co-exist, operating on models as well as code, and to synergistically enhance each other.
- J24. Husseini Orabi, M., Husseini Orabi, A, Lethbridge, T.C. (2018), “A Textual Notation for Modeling and Generating Code for Composite Structure”, Springer CCIS 991, pp 355-379
Models of the composite structure of a software system describe its components, how they are connected or contain each other, and how they communicate using ports and connectors. Although composite structure is one of the UML diagram types, it tends to be complex to use, or requires particular library support, or suffers from weak code generation, particularly in open source tools. Our previous work has shown that software modelers can benefit from a textual notation for UML concepts as well as from high-quality code generation, both of which we have implemented in Umple. This paper explains our extensions to Umple in order create a simple textual notation and comprehensive code generation for composite structure. A particular feature of our approach is that developers do not always need to explicitly encode protocols as they can be in many cases inferred. We present case studies of the composite structure of several systems designed using Umple, and demonstrate how the volume of code and cyclomatic complexity faced by developers is far lower than if they tried to program such systems directly in C++.
- J23. Adesina, O, Lethbridge, T.C., Somé, S., Abdelzad, V., and Boaye Belle, A., (2018) "Improving Formal Analysis of State Machines with Particular Emphasis on And-Cross Transitions", Computer Languages, Systems and Structures, Elsevier.
In this paper, we present an approach to formally encode state machines expressed in Umple for symbolic verification. We illustrate this with a real-world modeling example that encodes and analyzes and-cross transitions. This paper discusses a formal description of our approach to represent state machine systems under analysis (SSUAs); a systematic approach to certifying that SSUAs are deterministic; and an evaluation of performance (memory usage and execution time) on the case study. Method — We describe a formalization of state machines in Umple that enables their translation to model checking tools and also to code that is consistent with this. We present three alternative modeling solutions for a sample problem and a solution based on the use of and-cross transitions. State machine models corresponding to these solutions are represented in Umple, a model-oriented programming language. These are automatically transformed to SMV, the input language of the nuXmv (or NuSMV) model checker. By cleanly separating concerns, we systematically integrate components of hierarchical state systems as opposed to the traditional flattening approach, yet manage the complexity introduced by concurrency and and-crossing. We then compose and verify a set of requirements (e.g., correctness, safety, liveliness, etc.) on the resulting systems of all the modeling approaches to empirically compare the different modeling alternatives with the use of and-cross transitions. Results — We can encode and formally analyse complex state machines with and-cross transition(s). We observed a large reduction in the number of required transitions for encoding the SSUA, as opposed to the alternative approaches. We asserted that solutions derived from the approaches are identical behavior-wise even though each approach models the SSUA differently. Each of the approaches yielded the same result for potentially conflicting pairs which is a false positive (i.e., the SSUAs are deterministic). We observe that each approach maintains the same global state-space irrespective of the variations in their number of transitions. Furthermore, we observe that it is untrue that a more abstract method applied to an SSUA outperforms its less abstract counterpart whenever parameters (such as execution time, memory usage and the number of Binary Decision Diagrams - BDDs) are the factors under consideration. Contributions — A systematic approach to encode state machines with and-cross transitions (including unusual transitions). An enhanced but fully automated approach to discovering nondeterminism in state machines even in the presence of unbounded domains and multiple and- cross transitions within the same enclosing orthogonal state. An empirical study of the impact of abstraction on some performance parameters. We also present an extended formalization of Umple state machines.
- C116. Husseini-Orabi, M., Husseini-Orabi, A., and Lethbridge, T.C. (2018) "Concurrent Programming using Umple", Modelsward 2018, pp. 575-585
UML standards lack systematic solutions that can handle concurrency and time constructs in a single unified notation. In this paper, we integrate concurrency as a part of Umple, a combined modelling and programming language. Our extensions can help ease component-based development of real-time, distributed, and embedded applications. The work, which is based on an extended implementation of active object, enables better validation of systems, and improves usability from the developer’s perspective. We describe the syntax and semantics of our Umple extensions, and also show how the constructs are transformed into C++. After that, we evaluate our work qualitatively, by comparing Umple with other specifications that focus on time as key; we show that Umple gives more flexibility than UML and MARTE. We also evaluate our work quantitatively using LOC and cyclomatic complexity metrics, showing that a developer would have to write many fewer lines of code when using Umple than when programming directly in C++.
- C115. Husseini-Orabi, M., Husseini-Orabi, A., and Lethbridge, T.C. (2018) "Component-Based Modeling in Umple", Modelsward 2018, pp. 247-255.
Modelling tools provide weak or no support for the rich semantics of composite structure, such as enforcing connection constraints and maintaining referential integrity. Tools that generate code from composite structure typically depend on excessive and complex internal class representations such as Actor or BasePort. In this paper, we present easy-to-comprehend syntax describing composite structure in Umple. We describe a novel protocol-free approach that dynamically extracts communication protocols as a way to ease component-based modelling, and lead to concise and optimized code generation. We outline Umple composite structure features, and the related code generation patterns that resolve difficulties around connections and the integrity of multiplicity constraints.
- C111. Adesina, O., Somé, S., and Lethbridge, T., (2016) "Modeling State Diagrams with And-Cross Transitions", MoDeVVa 2016, Models 2016, France, CEUR
We propose an approach to encode state diagrams with and-cross transitions. The notion of and-cross transitions is being rejected by researchers and practitioners in model-driven engineering community for reasons that include limited use-in-practice, unmanageable underlying complexity, and availability of alternative modeling solutions. In this paper, we show that and-cross transitions can be useful in practice and its underlying structural complexity can be managed for the purpose of analysis.
- C110. Lethbridge, T.C., Abdelzad, V., Husseini Orabi, M., Husseini Orabi, A., Adesina, O., (2016) "Merging Modeling and Programming using Umple", ISOLA 2016, Corfu, Springer LNCS 9953, pp. 187–197.
We discuss how Umple merges modeling and programming by adding modeling constructs to programming languages and vice-versa. Umple has what we call model-code duality; we show how it fulfills key attributes of being both a programming language and a modeling technology. Umple also has what we call text-diagram duality in that the model or code can be updated by editing the textual or diagram form. We give an example of Umple, and explain how key benefits of textual programming languages are found in Umple, as are important features of modeling technology.
- C109. Adesina, O., Lethbridge, T., and Somé, S., (2016) "A fully automated approach to discovering non-determinism in state machine diagrams", 10th Int. Conf. On the Quality of Information and Communications Technology, Portugal.
We present a fully automated technique to detect nondeterminism in state diagrams. Although nondeterminism is a tool often adopted by requirement engineers for specification of a system under development (SUD), it is normally undesirable in actual implementation. Discovering nondeterminism manually is infeasible for industrial-sized systems. Solutions in the literature lack the capability to analyze infinite-state systems. We leverage the nuXmv model checker to analyze unbounded domains and implement an algorithm that systematically computes a minimal set of comparable transitions for the SUD yet eliminates false positives by model checking. To validate our approach, we analyze a real-world system and report discovered cases of nondeterminism. We employ Umple's capability to convert state machines to nuXmv.
- C104. Husseini Orabi, M., Husseini Orabi,A., Lethbridge, T.C. (2016) "Umple as a component-based language for the development of real-time and embedded applications", Modelsward 2016
Component-based development enforces separation of concern to improve reusability and maintainability. In this paper, we show how we extended Umple (http://try.umple.org) to support component-based development. The development of components, ports, and connectors is enabled using easy-to-comprehend keywords. Development is supported in both textual and visual representations. The design pattern followed in our implementation is the active object pattern. We show a comparison between Umple and other modelling tools. We show that Umple has a set of component features comparable to commercial modelling tools, but is the most complete, particularly with regard to code generation, among the open source tools.
- J21 Abdelzad, V, and Lethbridge, T.C. (2015) “Promoting Traits into Model-Driven Development”, Software and Systems Modeling, Springer, DOI 10.1007/s10270-015-0505-x
Traits, as sets of behaviors, can provide a good mechanism for reusability. However, they are limited in important ways and are not present in widely used program- ming and modeling languages and hence are not readily available for use by mainstream developers. In this paper, we add UML associations and other modeling concepts to traits and apply them to Java and C++ through model-driven development. We also extend traits with required interfaces so dependencies at the semantics level become part of their usage, rather than simple syntactic capture. All this is accom- plished in Umple, a textual modeling language based upon UML that allows adding programming constructs to the model. We applied the work to two case studies. The results show that we can promote traits to the modeling level along with the improvement in flexibility and reusability.
- C102. Aljamaan, H. Lethbridge T.C., Garzon, M. (2015) “UmpleRun: a Dynamic Analysis Tool for Textually Modeled State Machines using Umple”, EXE 2015, CEUR, to appear
In this paper, we present a tool named UmpleRun that allows modelers to run the textually specified state machines under analysis with an execution scenario to validate the model's dynamic behavior. In addition, trace specification will output execution traces that contain model construct links. This will permit analysis of behavior at the model level.
- C101. Aljamaan, H., Lethbridge T.C. (2015) “MOTL: a Textual Language for Trace Specification of State Machines and Associations”, Cascon 2015, ACM
In a model-driven development (MDD) environment where most or all of the source code is generated from models, there is a lack of tools for model-level tracing, in whichgenerated execution traces can be linked to model level constructs. This lack of tools might inhibit the use of MDD, since it forces modelers to do dynamic analysis at a lower level of abstraction. In this paper, we propose a solution allowing modelers to textually specify the tracingof modeling constructs: attributes, state machines and associations using Umple. The resulting execution traces then contain model construct links. We describe the syntax and semantics of the language, as well as the generated execution traces, and give an example.
- C97, Garzon, M., Aljamaan, H., Lethbridge, T., (2015) “Umple: A Framework for Model Driven Development of Object-Oriented Systems”, 22nd IEEE International Conference on Software Analysis, Evolution, and Reengineering (SANER), pp494-498
Huge benefits are gained when Model Driven En-gineering are adopted to develop software systems. However, it remains a challenge for software modelers to embrace the MDE approach. In this paper, we present Umple, a framework for Model Driven Development in Object-Oriented Systems that can be used to generate entire software systems (Model DrivenForward Engineering) or to recover the models from existing software systems (Model Driven Reverse Engineering). Umple models are written using a friendly human-readable modeling notation seamlessly integrated with algorithmic code. In other words, wepresent a model-is-the-code approach, where developers are more likely to maintain and evolve the code as the system maturessimply by the fact that both model and code are integrated asaspects of the same system. Finally, we demonstrate how the framework can be used to elaborate on solutions supporting different scenarios such as software modernization and program comprehension.
- C96, Abdelzad, V., Aljamaan, H., Adesina, O., Garzon, M., Lethbridge, T., (2014) “A Model-Driven Solution for Financial Data Representation Expressed in FIXML”, Proc, Transformation Tool Contest 2014, York, UK, CEUR http://ceur-ws.org/Vol-1305/paper15.pdf
In this paper, we propose a solution based upon Umple for data transformation of Financial Informa-tion eXchange protocol (FIXML). The proposed solution includes syntactic and semantic analysisand automatic code generation. We discuss our solution based on development effort, modularity,complexity, accuracy, fault tolerance, and execution time factors. We have applied our technique to a set of FIXML test cases and evaluated the results in terms of error detection and executiontime. Results reveal that Umple is suitable for the transformation of FIXML data to object-oriented languages.
- **C95. Lethbridge, T., (2014) “Umple: An Open-Source Tool for Easy-To-Use Modeling, Analysis, and Code Generation”, Models 2014 Demonstration Track, Valencia Spain, CEUR, **
We demonstrate the Umple technology, which allows software de- velopers to blend abstract models, including class-, state- and composite struc- ture diagrams textually into their Java, C++ or PhP code. Umple is targeted at developers who prefer textual programming but also want additional abstractions in order to simplify their software and improve its quality. Umple devel- opment has involved over 60 people, mostly at Canadian and US universities, and is used to develop itself. Several systems have been umplified – converted into Umple – thus raising their abstraction and reducing code volume. The accompanying video can be found at http://youtu.be/xD-zTpB_zyQ
- C93. Garzon, M., Lethbridge, T.C., Aljamaan, H., and Badreddin, O. (2014) “Reverse Engineering of Object-Oriented Code into Umple using an Incremental and Rule-Based Approach”, Cascon 2014, ACM, 91-105
this paper we present a novelapproach to re-verse engineering, in which modeling information such as UML associations, state machinesand attributes is incrementally added tocode written in Java or C++, while maintaining the system in a textual format.Umple is a textual representation that blends modeling in UML with programming language code.The approach, called umplification, produces a program with behavior identical tothe original one, but written in Umpleand enhanced with model-level abstractions. As the resulting program is Umplecode, our approach eliminates the distinction between code and model. In this paper we discuss the principles of Umple, the umplification approach and a rule-driven tool called the Umplificator, which implements and validates the depictedapproach
- C91. Lethbridge, T.C. (2014), “Teaching Modeling Using Umple: Principles for the Development of an Effective Tool”, CSEET 2014, Klagenfurt Austria, IEEE Computer Society
Umple is a model-oriented programming technology designed to teach modeling while at the same time being practical for industrial application. In this paper we discuss six principles we followed in order to ensure Umple can be effective as a learning resource: being highly usable, facilitating incremental learning, providing an experience of positive reinforcement in learners, convincing learners about the value of the material, broadening learning opportunities, and being inexpensive.
- C90 Badreddin, O., Lethbridge, T.C., Forward, A. (2014), “Investigation and Evaluation of UML Action Languages”, MODELSWARD 2014, Portugal
We analyze the current direction of UML Action Language development and provide a classification of the proposed action language structure and statements. We also present a functioning implementation of an action language and discuss our platform for experimenting with Action Language based systems. We propose a novel approach that adopts a bottom-up technique to defining an action language. This approach embeds the action language into a textual environment that includes the UML modeling elements. Unlike current action languages that typically address class diagrams only, our proposal includes class and state machine modeling abstractions as part of the action language. We tackle the problem of modeling-in-text not by introducing yet another programming language, but instead by providing an increased level of abstraction to existing high level programming languages. Both, a textual representation of the model and its visual view represent the same underlying model but from different vantage points.
- C89. Badreddin, O., Lethbridge, T.C. and Forward, A. (2014), “A Novel Approach to Versioning and Merging Model and Code Uniformly”, MODELSWARD 2014, Portugal.
Model Driven Architecture (MDA) advocates the use of models, rather than code, as the main development artifact. Yet model versioning and merging tools still lag in capabilities, ease of use and adoption relative to source code versioning and merging tools. This forces many teams to avoid model-based collaboration and concurrent model modifications. In this paper, we highlight the main challenges behind the relatively small adoption of model merging approaches. We present a novel model-based programming technology that addresses many of those challenges. The approach treats code and models uniformly, effectively enabling modelers to version and merge models using existing text-based technologies.
- C88. Badreddin, O., Lethbridge, T.C., Forward, A., Elasaar, M. Aljamaan, H, Garzon, M. (2014), “Enhanced Code Generation from UML Composite State Machines”, MODELSWARD 2013, Portugal.
UML modelling tools provide poor support for composite state machine code generation. Generated code is typically complex and large, especially for composite state machines. Existing approaches either do not handle this case at all or handle it by flattening the composite state machine into a simple one with a combi- natorial explosion of states, and excessive generated code. This paper presents a new approach that trans- forms a composite state machine into an equivalent set of simple state machines before code generation. This avoids the combinatorial explosion and leads to more concise and scalable generated code. We imple- ment our approach in Umple. We report on a case study, comparing our approach to others in terms of code size and scalability.
- C87. Badreddin, O., Forward, A., and Lethbridge, T.C. (2014), “A Test-Driven Approach for Developing Software Languages”, MODELSWARD 2014, Portugal
Test-Driven Development (TDD) is the practice of attempting to use the software you intend to write, before you write it. The premise is straightforward, but the specifics of applying it in different domains can be complex. In this paper, we provide aTDD approach for language development. The essence is to apply TDD at each of four levels of language processing, hence we call our approach Multi-Level TDD, or MLTDD. MLTDD can be applied to programming languages, preprocessors, domain specific languages, and transformation engines. MLTDD was used to build Umple, a model-oriented programming language available for Java, Ruby, and PHP. We present two case studies where this approach was implemented to develop two other domain specific languages.
- C86. Aljamaan, H., Lethbridge, T.C., Badreddin, O., Guest, G., and Forward, A. (2014), “Specifying Trace Directives for UML Attributes and State Machines”, MODELSWARD 2014, Portugal.
Developers using model driven development (MDD) to develop systems lack the ability to specify traces that operate at the model level. This results in specification of traces at the generated code level. In this paper, we are proposing trace directives that operate at the model level to specify the tracing of UML attributes and state machines. Trace directives are implemented as part of the Umple textual modeling language, thus these directives can be expressed in a textual form. Trace code will be injected into system source code that corresponds to trace directives specified at the model level.
- C85. Lethbridge, T.C. (2013) “Key Properties for Comparing Modeling Languages and Tools: Usability, Completeness and Scalability”, Comparing Modeling Approaches 2013, Miami, FL, CEUR
- C84. Mussbacher, G. Alam, O., Alhaj, M., Ali, S., Amalio, N., Barn, B., Braek, R., Clark, T., Combarnale, B., Cysneiros, L., Fatima, U., France, R., Georg, G., Horkoff, J., Kienzle, J., Leite, J., Lethbridge, T.C., Luckley, M., Moreira, A., Mutz, F., Oliveira, A., Petriu, D., Schöttle, M., Troup, L and Werneck, V. (2013) “Assessing composition in modeling approaches”, CMA, ACM,
- C83. Badreddin, O. , Forward, A., and Lethbridge, T.C. (2013), “Exploring a Model-Oriented and Executable Syntax for UML Attributes”, SERA 2013, Springer, Springer SCI 496, pp. 33-53.
UML classes involve three key elements: attributes, associations, and methods. Current object-oriented languages, like Java, do not provide a distinction between attributes and associations. Tools that generate code from associations currently provide little support for the rich semantics available to modellers such as enforcing multiplicity constraints or maintaining referential integrity. In this paper, we introduce a syntax for describing associations using a model-oriented language called Umple. We show source code from existing code-generation tools and highlight how the issues above are not adequately addressed. We outline code generation patterns currently available in Umple that resolve these difficulties and address the issues of multiplicity constraints and referential integrity.
- C82. Badreddin, O., Forward, A., and Lethbridge, T.C. (2013), “Improving Code Generation for Associations: Enforcing Multiplicity Constraints and Ensuring Referential Integrity”, SERA 2013, Springer, SCI 496, pp. 129-149.
Implementing UML attributes directly in an object-oriented language may not appear to be complex since these languages already define member variables. The distinction arises when considering the differences between modelling a class and implementing it in the underlying programming language. Member variables can represent not only attributes, but also association ends and internal data including counters, caching, or sharing of local data. There is also a need when modeling to specify attribute characteristics such as being unique, immutable, or subject to lazy instantiation. In this paper we present an analysis of the modeling characteristics of attributes from first principles and investigate how attributes are handled in several open-source systems. We also look at how code is generated by various UML tools. We present our own Umple language along with its code generation patterns for attributes, using Java as the target language.
- Badreddin, O. (2013), "Empirical Evaluation of Research Prototypes at Variable Stages of Maturity", USER 2013: 2nd Workshop on User evaluations for Software Engineering Researchers, in conjunction with ICSE 2013
Empirical evaluation of research tools is growing especially in the field of software engineering. A number of research techniques have been proposed and used in evaluating research prototypes. We take the view that evaluation of software engineering tools is best achieved in industrial settings, with real life artifacts and tasks, and with professional software engineers. However, the feasibility of such evaluation is limited for many reasons. Some challenges are related to the prototypes under study, others are related to the industrial environments where the need to meet business requirements take precedence on experimenting with new tools and techniques.
In this paper, we summarize our experiences in evaluating a research prototype tool using a grounded theory study, a questionnaire, and a controlled experiment. We discuss the challenges that hindered our industrial evaluation and share ideas on how to overcome these challenges. We propose an action research study where the research tool is used by a small number of experienced professionals in an industrial project.
- C81. Badreddin, O., Lethbridge, T.C. and Elassar, M. (2013), “Modeling Practices in Open Source Software”, OSS 2013, 9th International Conference on Open Source Systems.
It is widely accepted that modeling in software engineering increases productivity and results in better code quality. Yet, modeling adoption remains low. The open source community, in particular, remains almost entirely code centric. In this paper, we explore the reasons behind such limited adoption of modeling practices among open source developers. We highlight characteristics of modeling tools that would encourage their adoption. We propose Umple as a solution where both modeling and coding elements are treated uniformly. In this approach, models can be manipulated textually and code can be edited visually. We also report on the Umple compiler itself as a case study of an open source project where contributors, using the above approach, have and continue to routinely commit code and model over a number of years.
- C80. Badreddin, O., and Lethbridge, T.C. (2013), “Model Oriented Programming: Bridging the Code-Model Divide”, Modeling in Software Engineering, in conjunction with ICSE 2013.
Model Driven Engineering proposes the use of models as the main development artifacts. This methodology involves generating code from models and then perhaps adding some details to the generated code. Frequently, it is required to also reverse-engineer code to generate models. Despite the wide acceptance of modeling benefits, the use of model driven engineering practices remains limited. We present model oriented programming as a new paradigm to reduce the ever- present tension between model-centric and code-centric development styles. The core of this approach is to add UML abstractions such as associations and state machines directly into a high-level programming language code. In this approach, model diagrams become just another abstract view of the code. The need for reverse engineering is eliminated, since everything in the diagram is represented directly in the code. Model orientation is illustrated using Umple, a working model oriented programming platform. A functional layer of an airline reservation system is presented as a case study.
- C79. Lethbridge, T.C. (2012), “A Model of bCMS Using the Umple Model-Oriented Programming Approach”, Comparing Modeling Approaches 2012, Vienna Austria.
In this paper we present a model developed using the Umple model-oriented programming technology. We have modeled the bCMS crisis management system, which has been set as a common modeling challenge for the Comparing Modeling Approaches workshop. We demonstrate modeling of the class structure of the system and the state machine used to co-ordinate the crisis management effort. This model captures some of the benefits of model-oriented programming approach: The model looks like a program, so it can be extensively documented inline using comments and easily edited. The textual model is designed to be highly readable, but if desired can also be viewed and edited as a diagram. Mixin, and product-line capabilities of Umple are also used.
- C78. Aljamaan, H., and Lethbridge, T.C. (2012), “Towards Tracing at the Model Level”, WCRE 2012, Kingson, Doctoral Symposium.
In this research we are exploring how to inject tracing directives into a UML model rendered as text in an extension to the Umple language we call Model-Oriented Tracing Language (MOTL). We have so far implemented tracing of UML/Umple attributes and state machines and conducted a pilot usability study of the language. In this paper we outline the work completed, the research questions we are addressing and the path forward.
- C77. Garzon, M., and Lethbridge, T.C. (2012), “Exploring how to Develop Transformations and Tools for Automated Umplification”, WCRE 2012, Kingston. Doctoral Symposium
In this research we are exploring how to perform incremental reverse engineering from Java to Umple, a process we call Umplification. Umple is a textual representation that blends modeling in UML with programming language code. It is designed to allow anything from pure textual modeling to almost-pure traditional programming with some modeling concepts added. Umplification involves increasing the proportion of modeling concepts in the code. Novel features of this work are: a) the transformations required are intended to be applied incrementally by a programmer who has a body of legacy code and wants to gradually transform it into Umple, preserving much of the layout, comments and other aspects of the original code if possible; b) the transformations required are at the same time code-to-model, model-to-model and code-to- code. The main contributions will be developing the transformations, developing a usable tool, and demonstrating its effectiveness by means of case studies.
- C76. Badreddin, O., Forward, A., and Lethbridge, T. (2012), “Model Oriented Programming: An Empirical Study of Comprehension”, Cascon, ACM.
Many tools and approaches support the use of modeling abstractions in textual form. However, there have been few studies about whether textual models are as comprehensible as graphical models. We present an experiment investigating the understandability of three different notations: Systems modeled in UML, and the same systems in both Java and Umple. Umple is a model- oriented programming technology that enhances languages like Java and PHP with textual modeling abstractions. It was designed to bridge the gap between textual and graphical modeling. Our experiment asked participants to answer questions reflecting their level of comprehension. The results reveal that for simple comprehension tasks, a visual model and a textual model are comparable. Java’s comprehension levels were lowest of all three notations. Our results align with the intuition that raising the abstraction levels of common object-oriented programming languages enhances comprehensibility.
- C75. Badreddin, O. and Lethbridge, T. (2012) “Combining Experiments and Grounded Theory to Evaluate a Research Prototype: Lessons from the Umple Model-Oriented Programming Technology”, 2012 First International Workshop on User evaluation for Software Engineering Researchers (USER 2012), in conjunction with ICSE 2012, pp 1-4. DOI: 10.1109/USER.2012.6226575.
Research prototypes typically lack the level of quality and readiness required for industrial deployment. Hence, conducting realistic experimentation with professional users that reflect real life tasks is challenging. Experimentation with toy examples and tasks suffers from significant threats to external validity. Consequently, results from such experiments fail to gain confidence or mitigate risks, a prerequisite for industrial adoption. This paper presents two empirical studies conducted to evaluate a model-oriented programming language called Umple; a grounded theory study and a controlled experiment of comprehension. Evaluations of model-oriented programming is particularly challenging. First, there is a need to provide for highly sophisticated development environments for realistic evaluation. Second, the scarcity of experienced users poses additional challenges. In this paper we discuss our experiences, lessons learned, and future considerations in the evaluation of a research prototype tool.
- J20 Forward, A., Badreddin, O., Lethbridge, T.C., Solano, J., (2011) “Model-Driven Rapid Prototyping with Umple”, Software Practice and Experience, 42: pp. 781-707
The emergence of model-driven software development brings new opportunities and challenges for rapid prototyping. On the one hand, the modeling process is inherently abstract, removing the prototyper from details, and letting him or her focus on exploring design alternatives for various aspects of the system. On the other hand, the most popular modeling languages and tools entirely omit the modeling and generating of user interfaces. As a result, the benefit of user interface prototypes as a medium for interaction with the user and customer is lost. This paper presents a model-oriented technology called Umple that can be used for prototyping while also supporting model driven engineering. Umple allows end users to quickly create class and state machine models and to incrementally embed implementation artifacts. At any point in the modeling process, users can quickly generate a fully functional prototype that exposes modeling implications on the user interface, and allows stakeholders to get a feel of how the full system will behave.
- C74. Lethbridge, T., Mussbacher, G, Forward, A. and Badreddin, O., (2011) “Teaching UML Using Umple: Applying Model-Oriented Programming in the Classroom”, CSEE&T 2011, pp. 421-428.
We show how a technology called Umple can be used to improve teaching UML and modeling. Umple allows UML to be viewed both textually and graphically, with updates to one view reflected in the other. It allows UML concepts to be added to programming languages, plus web-based code generation from UML to those languages. We have used Umple in student laboratories and assignments for two years, and also live in the classroom. In a survey, students showed enthusiasm about Umple, and indicated they believe it helps them understand UML better. Improvements in their grades also support our approach.
- Badreddin, O. and Timothy C. Lethbridge. 2010 "A study of applying a research prototype tool in industrial practice" 18th ACM SIGSOFT international symposium on Foundations of Software Engineering (FSE '10- Doctoral Symposium). ACM, New York, NY, USA, 353-356.
Our research tool, Umple, has the objective of raising the abstraction level of programming languages by adding modeling abstractions such as UML associations, attributes and state machines. My research focuses on the syntax and semantics of state machines in Umple plus the empirical validation of Umple. The latter consists of a grounded theory study of Umple users, and action research involving the use of Umple in an industrial sitting. The grounded theory study is guiding our research and development of Umple. The action research is enlarging the pool of Umple users and contributing to the validation of Umple's approach.
- C72. Lethbridge, T.C., Forward, A. and Badreddin, O. (2010), “Umplification: Refactoring to Incrementally Add Abstraction to a Program”, Working Conference on Reverse Engineering, Boston, October 2010, pp. 220-224.
Umple adds UML abstractions to a base programming language. The resulting program can be seen as both model and code at the same time. Base languages currently supported include Java, PHP, and Ruby. Umplification is the process of converting a base language program to Umple by a series of refactorings. The result is a program that is semantically equivalent to the original, but which can be rendered and edited as UML diagrams by any modeling tool. Yet, it can still be manipulated as a textual program for those who prefer. In this paper we discuss the basic principles of Umple, the general process of umplification, and our experiences performing it in real contexts, including umplification of the Umple compiler itself.
- C69. Forward, A., Badreddin, O., and Lethbridge T.C. (2010), “Umple: Towards Combining Model Driven with Prototype Driven System Development”, 21st IEEE International Symposium on Rapid System Prototyping, Fairfax VA, June.
The emergence of model driven methodologies is bringing new challenges for software prototyping. Models tend to focus on the design of the system, and are less concerned with, or less able to, support prototype qualities like re-use, evolution, or weaving together independently designed parts. This paper presents a model-oriented prototyping tool called Umple that supports model driven engineering and overcomes some of the challenges related to prototyping in a modeling environment. Umple allows end users to quickly model class and state machine models and to incrementally embed implementation artifacts. At any point in the modeling process, users can quickly generate a fully functional prototype that exposes modeling implications on the user interface, and allows stakeholders to quickly get a feel of how the full system will behave.
- Badreddin, O., "Umple: A model-oriented programming language", 32nd ACM/IEEE International Conference on Software Engineering - Doctoral Consortium - Volume 2, 2010, pp. 337--338.
Our research tool, Umple, has the objective of raising the abstraction level of programming languages by including modeling abstractions such as UML associations, attributes and state machines. My research focuses on the syntax and semantics of state machines in Umple and the empirical validation of Umple as a whole.
- C67. Forward, A., Lethbridge, T.C., and Brestovansky, D. (2009), “Improving Program Comprehension by Enhancing Program Constructs: An Analysis of the Umple language”, International Conference on Program Comprehension (ICPC) 2009, Vancouver, IEEE Computer Society, pp. 311-312.
Umple is a set of extensions to existing object-oriented languages (currently PHP and Java) that provides a concrete syntax for UML abstractions like associations as well as certain software patterns. Umple, we argue, will help increase software program comprehension by allowing developers to describe a system at a more abstract level, and also by significantly reducing the amount of code that needs to be written and later understood.
PhD and Master's Theses
15 Sultan Eid Almaghthawi: (PhD in Computer Science, April 2020) Model-Driven Testing in Umple
14 Amid Zakariapour: (Masters in Computer Science, January 2018) Model-Driven Development of Distributed Systems in Umple
13 Mahmoud Orabi: (PhD in Computer Science, July 2017) Facilitating the Representation of Composite Structure, Active objects, Code Generation, and Software Component Descriptions in the Umple Model-Oriented Programming Language
12 Ahmed Orabi: (PhD in Computer Science, July 2017) Multi-Modal Technology for User Interface Analysis including Mental State Detection and Eye Tracking Analysis - UmpleOnline was used for testing
11 Opeyemi Adesina: (PhD in Computer Science, July 2017): Integrating Formal Methods with Model-Driven Engineering
10 Vahdat Abdelzad: (PhD in Electrical and Computer Engineering, July 2017): Promoting Traits into Model-Driven Development
9 Hamoud Aljamaan (PhD in Computer Science, December 2015): Model-Oriented Tracing Language: Producing Execution Traces from Tracepoints Injected into Code Generated from UML Models
8 Miguel Garzon (PhD in Computer Science, July 2015): Reverse Engineering Object-Oriented Systems into Umple: An Incremental and Rule-Based Approach
7 Aliaa Alghamdi (Masters of Systems Science, 2014) Queued and Pooled Semantics for State Machines in the Umple Model-Oriented Programming Language, Masters Thesis
6 Sultan Eid (Masters of Computer Science, 2013) Generation of C++ From the Umple Model-Oriented Programming Technology
5 Omar Badreddin (PhD in Computer Science, 2012): "A Manifestation of Model-Code Duality: Facilitating the Representation of State Machines in the Umple Model-Oriented Programming Language”. http://www.ruor.uottawa.ca/en/handle/10393/22733
4 Andrew Forward (PhD in Computer Science, 2010): "The Convergence of Modeling and Programming: Facilitating the Representation of Attributes and Associations in the Umple Model-Oriented Programming Language" http://www.site.uottawa.ca/~tcl/gradtheses/aforwardphd/
3 Julian Solano (Masters in Computer Science, 2010): "Exploring How Model Oriented Programming can be Extended to the UI Level" http://www.site.uottawa.ca/~tcl/gradtheses/jsolano/
2 Jenya Levin (MCS in Computer Science, 2010): "System Generation for Time and Activity Management Product Lines" http://www.site.uottawa.ca/~tcl/gradtheses/jlevin/
1 Dusan Brestovansky (MCS in Computer Science, 2008): "Exploring Textual Modeling Using the Umple Language" http://www.site.uottawa.ca/~tcl/gradtheses/dbrestovansky/