Academic and Technology Publications

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.

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.

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.

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.

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.

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.

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

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.

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.

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.