Menu
▾
▴
Publications
List of peer-reviewed papers, theses and powerpoint presentations describing Umple
Below you will find detailed technical material about Umple.
Refereed Papers
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 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 these, email Dr. Lethbridge tcl@eecs.uottawa.ca and he will send a pdf.
See also the CiteULike page for Umple: http://www.citeulike.org/groupfunc/18117/home
See also the Mendeley page for Umple: http://www.mendeley.com/groups/3493941/umple/
- 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
Abstract
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.
- C111. Adesina, O., Somé, S., and Lethbridge, T., (2016) "Modeling State Diagrams with And-Cross Transitions", MoDeVVa 2016, Models 2016, France, CEUR
Abstract
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.
https://pdfs.semanticscholar.org/8a08/27abb01b70e467a0eaf3fe782adfa969edf4.pdf
- 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.
Abstract
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.
https://link.springer.com/chapter/10.1007/978-3-319-47169-3_14
- 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.
Abstract
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
Abstract
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.
- 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
Abstract
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
Abstract
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
Abstract
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
Abstract
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,
Abstract
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
Abstract
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
Abstract
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.
http://www.site.uottawa.ca/~tcl/papers/TeachingModelingUsingUmplePrinciples-Lethbridge-CSEET2014.pdf
- C90 Badreddin, O., Lethbridge, T.C., Forward, A. (2014), “Investigation and Evaluation of UML Action Languages”, MODELSWARD 2014, Portugal
Abstract
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.
Abstract
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.
Abstract
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
Abstract
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.
Abstract
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.
Abstract
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.
Abstract
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
Abstract
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.
Abstract
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.
Abstract
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.
Abstract
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.
Abstract
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
Abstract
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.
Abstract
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.
Abstract
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
http://onlinelibrary.wiley.com/doi/10.1002/spe.1155/abstract
Abstract
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.
http://dx.doi.org/10.1109/CSEET.2011.5876118
Abstract
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.
http://dx.doi.org/10.1145/1882291.1882345
Abstract
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.
http://dx.doi.org/10.1109/WCRE.2010.32
Abstract
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.
http://dx.doi.org/10.1109/WCRE.2010.32
Abstract
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.
http://dx.doi.org/10.1145/1810295.1810381
Abstract
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.
http://dx.doi.org/10.1109/ICPC.2009.5090073
Abstract
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
-
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
-
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
-
Opeyemi Adesina: (PhD in Computer Science, July 2017): Integrating Formal Methods with Model-Driven Engineering
-
Vahdat Abdelzad: (PhD in Electrical and Computer Engineering, July 2017): Promoting Traits into Model-Driven Development
-
Hamoud Aljamaan (PhD in Computer Science, December 2015): Model-Oriented Tracing Language: Producing Execution Traces from Tracepoints Injected into Code Generated from UML Models
-
Miguel Garzon (PhD in Computer Science, July 2015): Reverse Engineering Object-Oriented Systems into Umple: An Incremental and Rule-Based Approach
-
Aliaa Alghamdi (Masters of Systems Science, 2014) Queued and Pooled Semantics for State Machines in the Umple Model-Oriented Programming Language, Masters Thesis
-
Sultan Eid (Masters of Computer Science, 2013) Generation of C++ From the Umple Model-Oriented Programming Technology
-
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 -
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/ -
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/ -
Jenya Levin (MCS in Computer Science, 2010): "System Generation for Time and Activity Management Product Lines"
http://www.site.uottawa.ca/~tcl/gradtheses/jlevin/ -
Dusan Brestovansky (MCS in Computer Science, 2008): "Exploring Textual Modeling Using the Umple Language"
http://www.site.uottawa.ca/~tcl/gradtheses/dbrestovansky/
Sample of Presentations Discussing Umple
This section is a collection of presentations given by the core Umple team about Umple.
