Software Publications

Software modeling, documentation, and empirical studies peer reviewed list of published conference papers, articles and theses.

Conference Publications

Enhanced Code Generation from UML Composite State Machines

Omar Badreddin, Timothy C. Lethbridge, Andrew Forward, Maged Elaasar, Hamoud Aljamaan, Miguel A. Garzon1. Enhanced Code Generation from UML Composite State Machines. Modelsward 2014.
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.

A Test-Driven Approach for Developing Software Languages

Omar Badreddin, Andrew Forward, Timothy C. Lethbridge. A Test-Driven Approach for Developing Software Languages. Modelsward 2014.
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.

Investigation And Evaluation Of UML Action Languages

Omar Badreddin, Timothy C. Lethbridge, Andrew Forward. Investigation And Evaluation Of UML Action Languages. Modelsward 2014.
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.

A Novel Approach to Versioning and Merging Model and Code Uniformly

Omar Badreddin, Timothy C. Lethbridge, Andrew Forward. A Novel Approach to Versioning and Merging Model and Code Uniformly. Modelsward 2014.
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.

Specifying Trace Directives for UML Attributes and State Machines

Hamoud Aljamaan, Timothy C. Lethbridge, Andrew Forward. Specifying Trace Directives for UML Attributes and State Machines. Modelsward 2014.
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.

Exploring a Model-Oriented and Executable Syntax for UML Attributes

Omar Bahy Badreddin, Andrew Forward, Timothy C. Lethbridge: Exploring a Model-Oriented and Executable Syntax for UML Attributes. SERA (selected papers) 2013: 33-53
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.

Improving Code Generation for Associations: Enforcing Multiplicity Constraints and Ensuring 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
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.

Model Oriented Programming: An Empirical Study of Comprehension

Omar Badreddin, Andrew Forward and Timothy C. Lethbridge: Model Oriented Programming: An Empirical Study of Comprehension. CASCON 2012
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.

Teaching UML Using Umple: Applying Model-Oriented Programming in the Classroom

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.

Challenges and Opportunities in Applying Research Prototypes and Findings into Industrial Practice

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
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?

Umplification: Refactoring to Incrementally Add Abstraction to a Program

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.

Perceptions of Software Modeling: A Survey of Software Practitioners

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.

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.

Umple: Towards Combining Model Driven with Prototype Driven System Development

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.

Improving Program Comprehension by Enhancing Program Constructs: An analysis of the Umple language

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.

A Taxonomy of Software Types to Facilitate Search and Evidence-Based Software Engineering

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.

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.

Problems and opportunities for model-centric versus code-centric software development: a survey of software professionals

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.

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.

CodeSnippets Plug-in to Eclipse, Introducing Web 2.0 Tagging to Improve Software Developer Recall

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.

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?".

The Relevance of Software Documentation, Tools and Technologies: A Survey

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.

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.

Andrew Forward first son, Hayden Daniel Forward

Journal Publications

Model-driven Rapid Prototyping with Umple

Forward, A., Lethbridge, T.C., Badreddin, O., Solan, J., (2011) "Model-driven Rapid Prototyping with Umple", IEEE Software Practice and Experience. DOI: 10.1002/spe.1155

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 and 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.

How Software Engineers Use Documentation: The State of the Practice.

Lethbridge, T.C., Singer, J and Forward, A., (2003) "How software engineers use documentation: the state of the practice", IEEE Software special issue: The State of the Practice of Software Engineering, Nov/Dec 2003, pp 35-39.

Software engineering is a human task, and as such we must study what software engineers do and think. Understanding the normative practice of software engineering is the first step toward developing realistic solutions to better facilitate the engineering process. We conducted three studies using several data-gathering approaches to elucidate the patterns by which software engineers (SEs) use and update documentation. Our objective is to more accurately comprehend and model documentation use, usefulness, and maintenance, thus enabling better decision making and tool design by developers and project managers. Our results confirm the widely held belief that SEs typically do not update documentation as timely or completely as software process personnel and managers advocate. However, the results also reveal that out-of-date software documentation remains useful in many circumstances.

Academic Theses

The Convergence of Modeling and Programming: Facilitating the Representation of Attributes and Associations in the Umple Model-Oriented Programming Language

This thesis investigates approaches to model-driven development (MDD) in which developers can keep using their familiar textual programming languages, but with additional modeloriented concepts. The added concepts include associations and attributes as found in the Unified Modeling Language (UML), as well as concepts from software patterns and other common programming abstractions.

Software Documentation – Building and Maintaining Artefacts of Communication

Software documentation is an important aspect of both software projects and software engineering in general. In fact, documentation engineering has become a popular sub-domain in the software engineering community. Unfortunately, the current perception of documentation is that it is outdated, irrelevant and incomplete. For the most part, this perception is probably true. Regrettably, the documentation concern cannot be resolved by simply mandating more and better documentation. This approach fails to resolve the problem as the solution ignores the fundamental goals of software engineering. The role of documentation in a software engineering environment is to communicate information to its audience and instil knowledge of the system it describes. Documentation should efficiently allow for future software development without hindering current progress. Our research focuses on the issue of documentation quality. In particular, which attributes of documentation make it effective to the audience and how can this information be monitored and parameterized to provide a better perspective about the relevance of documentation in a software project.