While the users of completed applications are heavily moving from desktop to the web browser, the majority of developers are still working with desktop IDEs such as Eclipse or Visual Studio. In contrast to professional installable IDEs, current web-based code editors are simple text editors with extra features. They usually understand lexical syntax and can do highlighting and indenting, but lack many of the features seen in modern desktop editors. In this paper, we present CoRED, a browser-based collaborative real-time code editor for Java applications. CoRED is a complete Java editor with error checking and automatic code generation capabilities, extended with some features commonly associated with social media. As a proof of the concept, we have extended CoRED to support Java based Vaadin framework for web applications. Moreover, CoRED can be used either as a stand-alone version or as a component of any other software. It is already used as a part of browser based Arvue IDE.

Abstract Software architecture contains, in addition to its structural part, interaction patterns that can be regarded as part of the architectural solution of the system. The interaction patterns define architecturally significant behavior of the software system. In this paper we propose a visual modeling language, behavioral profiles, for specifying architecturally significant behavioral rules for an application. The language is built on the Unified Modeling Language (UML), which is a visual language widely used in software development. We show how behavioral profiles can be used to support software designers in creating behavioral models that conform to some predefined rules and for ensuring that an application behaves correctly with respect to the rules given in the profiles. A tool called Bebop was built to support software engineers in behavioral profile‐based design and analysis of program behavior. To evaluate the approach and the tools in different application domains, they are utilized in three cases. The size of the applications used in the cases varies from small to quite large software systems, and from academic to industrial ones. The examples demonstrate how the approach presented can be used in practice for different steps in a software engineering process. The examples cover specializing an application framework and monitoring the program execution in run‐time. In addition, they show how behavioral profiles can be used to support guided program comprehension and to validate program execution by analyzing execution traces. Copyright © 2010 John Wiley & Sons, Ltd.

Software development relies heavily on reusable libraries and software components. For correct use of the provided API, proper documentation is needed. API usage is often demonstrated by giving example applications and code samples. In this paper we propose an approach for mining such usage scenarios from run-time communication between sample applications and the API. This is done automatically by first monitoring the API usage of sample applications, then filtering the generated traces, and finally synthesizing the sequence diagrams and illustrating them in a well-formed way as UML2 sequence diagrams. Such usage scenarios support the software engineer in comprehending the usage of the API. With proper tool support they can also be used for validating other applications' API usage and for generating code for a new application using the same API.

Although static structures are often advocated as the main ingredient of a software architecture, dynamic program behavior forms an essential part of it. Verifying the behavior is a crucial yet often troublesome part of testing. Hence, it is of great concern to find means to facilitate the testing of dynamic behaviors. This paper studies one approach to such behavioral monitoring. The details of the approach are the following. We have used the concept of behavioral profiles to specify the desired program behavior using UML. Provided with a behavioral profile created with a CASE tool, we are able to automatically generate AspectJ aspects that are woven into Java program code, thus adding a monitoring concern to the system. This results in the opportunity to monitor architecturally significant behaviors defined with architectural profiles at code level. Towards the end of the paper, we study the applicability of the approach in industrial use.

When reusing an existing software component, the software developer needs to understand the functionality and possible extension points of the component, as well as constraints and rules to be taken into account when using it. In addition to structural rules, the software component may imply interaction rules that must be followed in application development. In this paper we discuss behavioral profiles, given in UML, used to capture and illustrate architecturally significant behavioral rules. The behavioral rules may capture interaction rules to be obeyed when reusing an existing software component. They can also be used to support runtime analysis of existing systems: with a proper tool support, the validity of extracted interaction models can be automatically checked against the behavioral rules given in the profiles. Moreover, the profiles can be used to prune the size of the interaction trace to include only the information relevant from the point of view of the behavioral rules. In this paper we discuss such tool support and demonstrate the usefulness of the approach by applying behavioral profiles to define and illustrate behavioral rules relevant for applications using the graphical editing framework (GEF). Moreover, we analyze a sample GEF application by validating its run-time behaviour with respect to the defined behavioral rules

The Unified Modeling Language (UML) provides several diagram types, viewing a system from different perspectives. In this research, we exploit the logical relationships between different UML models. We propose operations to compare, merge, slice and synthesize UML diagrams based on these relationships. In a formal demonstration, we show how statechart diagrams can be synthesized semi-automatically from a set of sequence diagrams using an interactive algorithm called MAS. We also demonstrate how a class diagram, annotated with pseudocode presentations of key operations, can be synthesized from sequence diagrams, and how class diagrams and sequence diagrams can be sliced against each other.