Model Driven Engineering - 2018
A Decade of Software Design and Modeling: A Survey to Uncover Trends of the Practice
We present the results of a survey of 228 software practitioners conducted on two phases ten years apart. The goal of the study is to uncover trends in the practice of software design and the adoption patterns of modeling languages such as UML. The first phase was conducted in April-December 2007 and included 113 responses. The second phase was conducted in March-November 2017 and included 115 responses. Both surveys were conducted online, employed identical solicitation mechanisms, and included the same set of questions. The survey results are analyzed within each phase and across phases. We present the results and analysis of the data identifying upward and downward trends in design and modeling practices. The results suggest some increase in formal and informal modeling and identify key challenges with modeling platforms and tools. The results can help researchers, practitioners, and educators to focus efforts on issues of relevance and significance to the profession.
Omar Badreddin, Rahad Khandoker, Andrew Forward, Omar Masmali, Timothy C Lethbridge. "A Decade of Software Design and Modeling: A Survey to Uncover Trends of the Practice". Proceedings of the 21th ACM/IEEE International Conference on Model Driven Engineering Languages and Systems. 2018.
Models - 2015
UmpleRun: a Dynamic Analysis Tool for Textually Modeled State Machines using Umple
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. Keywords— UmpleRun; Umple; UML; MOTL; state machine; execution trace; analysis.
Hamoud Aljamaan, Miguel A. Garzon, Timothy C. Lethbridge, Andrew Forward, "UmpleRun: a Dynamic Analysis Tool for Textually Modeled State Machines using Umple", Workshop on Executable Modeling at the 18th ACM/IEEE International Conference on Model Driven Engineering Languages and Systems (MODELS), 2015.
Modelsward - 2014
A Novel Approach to Versioning and Merging Model and Code Uniformly
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.
Omar Badreddin, Timothy C. Lethbridge, Andrew Forward. A Novel Approach to Versioning and Merging Model and Code Uniformly. Modelsward 2014.
Modelsward - 2014
Specifying Trace Directives for UML Attributes and State Machines
Developers using model driven development (MDD) to develop systems lack the ability to specify traces 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 the model level to specify the tracing of UML attributes and state machines. Trace directives are implemented as a 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.
Hamoud Aljamaan, Timothy C. Lethbridge, Andrew Forward. Specifying Trace Directives for UML Attributes and State Machines. Modelsward 2014.
Modelsward - 2014
A Test-Driven Approach for Developing Software Languages
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.
Omar Badreddin, Andrew Forward, Timothy C. Lethbridge. A Test-Driven Approach for Developing Software Languages. Modelsward 2014.
Modelsward - 2014
Enhanced Code Generation from UML Composite State Machines
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.
Omar Badreddin, Timothy C. Lethbridge, Andrew Forward, Maged Elaasar, Hamoud Aljamaan, Miguel A. Garzon1. Enhanced Code Generation from UML Composite State Machines. Modelsward 2014.
Modelsward - 2014
Investigation And Evaluation Of UML Action Languages
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.
Omar Badreddin, Timothy C. Lethbridge, Andrew Forward. Investigation And Evaluation Of UML Action Languages. Modelsward 2014.
SERA - 2013
Exploring a Model-Oriented and Executable Syntax for UML Attributes
Implementing UML attributes directly in an object-oriented language may not appear to be complex, since such languages already support member variables. The distinction arises when considering the differences between modelling a class and implementing it. In addition to representing attributes, member variables can also represent association ends and internal data including counters, caching, or sharing of local data. Attributes in models also support additional characteristics such as being unique, immutable, or subject to lazy instantiation. In this paper we present modeling characteristics of attributes from first principles and investigate how attributes are handled in several open-source systems. We look code-generation of attributes by various UML tools. Finally, we present our own Umple language along with its code generation patterns for attributes, using Java as the target language.
Omar Bahy Badreddin, Andrew Forward, Timothy C. Lethbridge: Exploring a Model-Oriented and Executable Syntax for UML Attributes. SERA (selected papers) 2013: 33-53
SERA - 2013
Improving Code Generation for Associations: Enforcing Multiplicity Constraints and Ensuring Referential Integrity
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.
Omar Bahy Badreddin, Andrew Forward, Timothy C. Lethbridge: Improving Code Generation for Associations: Enforcing Multiplicity Constraints and Ensuring Referential Integrity. SERA 2013: 129-149
CSEE&T - 2012
Teaching UML Using Umple: Applying Model-Oriented Programming in the Classroom
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.
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.
Cascon - 2012
Model Oriented Programming: An Empirical Study of Comprehension
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.
Omar Badreddin, Andrew Forward and Timothy C. Lethbridge: Model Oriented Programming: An Empirical Study of Comprehension. CASCON 2012
RSP - 2010
Umple: Towards Combining Model Driven with Prototype Driven System Development
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.
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.
RE - 2010
Umplification: Refactoring to Incrementally Add Abstraction to a Program
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.
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.
MDD - 2010
Perceptions of Software Modeling: A Survey of Software Practitioners
In this paper we analyze the results of survey of how, when and why some software developers model, as well why many prefer not to model. The survey of 113 software practitioners studied the reasons developers chose code-centric versus model-centric software engineering, and also gathered data about the notations and tools used. Key findings include: UML is confirmed as the dominant modeling notation; modeling tools are primarily used to create documentation and for up-front design with little code generation; and modeling tools are also used to transcribe models from other media including whiteboards. The type and quality of generated code is one of the biggest reported problems.
Forward, A., Badreddin, O., and Lethbridge T.C. (2010), "Perceptions of Software Modeling: A Survey of Software Practitioners", 5th Workshop From code centric to model centric: Evaluating the effectiveness of MDD (C2M:EEMDD), Paris, June 2010, http://www.esi.es/modelplex/c2m/papers.php.
Cascon - 2010
Challenges and Opportunities in Applying Research Prototypes and Findings into Industrial Practice
Software Engineering has always been a fast moving and changing industry. This has continually presented an
additional challenge for the Software Engineering research community; namely, how to catch up with fast changing
technologies, tools, and practices? How to bring on-board yet another tool, methodology, or results to influence an
industry that is driven by a variety of business objectives and regulations? How to make sure that current research
efforts are aligned with cutting edge technologies and practices? Why is it that many of the technical advancements
that we have seen in the software engineering and computer science come from the industry, rather than academia as
it is the case in other disciplines?
Omar Bahy Badreddin, Timothy Lethbridge, Hisham El-Shishiny, Margaret-Anne D. Storey, Andrew Forward: Challenges and opportunities in applying research prototypes and findings into industrial practice. CASCON 2010: 414-415
ICPC - 2009
Improving Program Comprehension by Enhancing Program Constructs: An analysis of the Umple language
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.
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.
ICSE - 2008
Problems and opportunities for model-centric versus code-centric software development: a survey of software professionals
We present some results of a survey of 113 software practitioners conducted between April and December 2007. The aim of the survey was to uncover their attitudes and experiences regarding software modeling, and development approaches that avoid modeling. We were motivated by observations that modeling is not widely adopted; many developers continue to take a code-centric approach. Key findings overall include: Modeling tools are primarily used to create documentation and for up-front design with little code generation; and participants believe that model-centric approaches to software engineering are easier but are currently not very popular as most participants currently work in code-centric environments. Key findings from sub-samples include: problems identified with model-centric approaches are similar regardless of a participant's country. Programmers that model extensively (versus those that do not model much) are more likely to agree that models become out of date and inconsistent with code.
Forward, A., and Lethbridge, T.C. (2008), "Problems and Opportunities for Model-Centric Versus Code-Centric Software Development: A Survey of Software Professionals", Workshop on Modeling in Software Engineering, in conjunction with ICSE 2008, Leipzig, ACM, pp. 27-32.
Cascon - 2008
A Taxonomy of Software Types to Facilitate Search and Evidence-Based Software Engineering
Empirical software research could be improved if there was a systematic way to identify the types of software for which empirical evidence applies. This is because results are unlikely to be globally applicable, but are more likely to apply only in certain contexts such as the type of software on which the evidence has been tested. We present a software taxonomy that should help researchers to apply their research systematically to particular types of software. The taxonomy was generated using existing partial taxonomies and input from survey participants. If a taxonomy such as ours gains acceptance, it will facilitate comparison and appropriate application of research. In the paper, we present the benefits of such a taxonomy, the process we used to develop it, and the taxonomy itself.
Forward, A. and Lethbridge, T.C. (2008) "A Taxonomy of Software Types to Facilitate Search and Evidence-Based Software Engineering", Cascon 2008, IBM and ACM, pp.179-181.
SERA - 2007
CodeSnippets Plug-in to Eclipse, Introducing Web 2.0 Tagging to Improve Software Developer Recall
Putting aside the marketing hype of Web2.0, a few central themes have emerged: user generated content, software to enable users (not restrict them), building a community and instant feedback. Many of these concepts can equally apply to rich client applications and a focus on software development teams. The initial motivation for Code Snippets was to fulfill the personal needs of software developers. At times, they need to reuse the same coding constructs, library access, method calls, and web services. Recalling (or finding) this information is Drawing on similar success as online tagging libraries like del.icio.us and flickr.com, we have developed an Eclipse plug-in called CodeSnippets that allows software teams to document, store, share and search communal code to help answer the question, "How do I code that?".
Forward, A., Lethbridge, T.C. and Deugo, D (2007), "CodeSnippets Plug-in to Eclipse: Introducing Web 2.0 Tagging to Improve Software Developer Recall", Software Engineering Research, Management and Applications (SERA) 2007, August, IEEE Computer Society, pp. 451-460.
DocEng - 2002
The Relevance of Software Documentation, Tools and Technologies: A Survey
This paper highlights the results of a survey of software professionals. The survey was conducted in the spring of 2002. The results are compiled from 48 individuals in the software field ranging from junior developers to managers and project leaders. One of the goals of this survey was to uncover the perceived relevance (or lack thereof) of software documentation, and the tools and technologies used to maintain, verify and validate such documents. The survey results highlight the preferences for and aversions against software documentation tools. Participants agree that documentation tools should seek to better extract knowledge from core resources. These resources include the system’s source code, test code and changes to both. Resulting technologies could then help reduce the effort required for documentation mainte-nance, something that is shown to rarely occur. The data reports compelling evidence that software professionals value technolo-gies that improve automation of the documentation process, as well as facilitating its maintenance.
Forward, A. and Lethbridge, T.C. (2002), "The Relevance of Software Documentation, Tools and Technologies: A Survey", DocEng 2002: The ACM Conference on Documentation Engineering, pp 26-33.