Johannes Koskinen

CoRED: browser-based Collaborative Real-time Editor for Java web applications

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.

Adaptable concern-based framework specialization in UML

Architectural-level reuse of software can be achieved in the form of application frameworks. Then, the architecture of a system can be copied from a framework, and the developer is liberated to application development. In this scheme, patterns utilized for specializing the framework play a critical role. Unfortunately, the bigger the specialization pattern, the harder it is to adapt the pattern to a particular design due to increasing number of bindings between pattern roles and the elements of the design. We introduce a tool supported methodology based on UML in which specialization patterns are grouped to match different concerns, i.e. conceptual matters of interest, they treat. Also, user-controlled instantiation of individual patterns is allowed to promote learning the architectural conventions. We argue that this approach overcomes some limitations, especially the lack of adaptability, of wizards that are commonly used for similar purposes.

Run-time monitoring of architecturally significant behaviors using behavioral profiles and aspects

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.

A UML-based Approach for Abstracting Application Interfaces to REST-like Services

The REST (representational state transfer) architectural style defines a set of interface constraints that aim at retaining interoperability between systems that may evolve independently of each other. However, REST developers are currently lacking modeling tools that would help them apply interface constraints to legacy APIs when exposing them as REST-like services. We believe that REST-aware tools would implement three major steps: analyzing a legacy API, abstracting it to a canonical form with constraints in place, and generating adapter code for the abstraction. In this paper we present a model-based approach to the abstraction step of such a tool. First we discuss the role of fully profiled UML models in representing API operations. Using those models, we focus on describing how to transform an API model into a canonical interface model. As a concrete part of our work we specify how UML models are processed during these transformations. To demonstrate the applicability of our approach, we present a real world API example

Profile-Based Approach to Support Comprehension of Software Behavior

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

Model processing tools in UML

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.

Experiences from scenario-based architecture evaluations with ATAM

Software architecture may go through many changes during its existence. Architecture evaluation can point out current problems, help to anticipate some of the future changes, and also show the absolute limits of a design. This paper presents experiences from eleven scenario based architecture evaluations with ATAM. The evaluations were completed on a tight two day evaluation schedule. This limited time forced to search for alternative scheduling options. The evaluated system designs had relatively long life cycle up to 30 years and all the designs were evaluated for the first time. We have learnt that in evaluations current issues often overshadow the long view of the future. We suggest that architecture evaluations should be integrated to the development process as a tool not only for today but also for tomorrow.

Knowledge transfer in collaborative teams: experiences from a two-week code camp

Software engineering has both technological and social dimensions. As development teams spanning across the globe are increasingly the norm and while the web enables massive online collaboration, there is a growing need for effective collaboration tools. In this paper, we describe experiences on collaborative programming as a tool for learning software development. To investigate the nature of collaboration in software engineering education, we arranged a two-week-long course experiment where students used a collaborative online integrated development environment to create different kinds of web services. We present lessons learned from the experiment and discuss how collaboration can act as a tool for knowledge transfer among learners.

Design framework enhancing developer experience in collaborative coding environment

Software development is teamwork, where the team members collaborate despite of their working environments ranging from shared office to working in separate sites around the globe. Regardless of location, the teams need support for their collaborative tasks. In this paper, we present results of utilizing collaborative online coding environment to create new, innovative cloud-based services. We collected data from 37 students in two separate coding exercises, each lasting several days. The results indicate that while some experienced coders saw no benefits of such system, in general participants reported both pragmatic benefits -- increased efficiency of coordinating actions -- and increased motivation due to perceived presence of team members. As our main contribution, we present a design framework for enhancing developer experience in collaborative environments.

Safety Process Patterns: Demystifying Safety Standards

Development of safety critical embedded systems is regulated by legislation and related standards. However, at least for beginners in the field, the standards are relatively hard to understand hindering their practical applicability. In this paper, we propose using process patterns to document the requirements for different lifecycle phases set in the safety standards. Ideally, such patterns could make these standards accessible to a wider audience of potential users. Moreover, the companies using the standards could enhance their quality manuals with the help of the patterns. In addition to the requirements set in the standards, the patterns should capture best practices in implementing the requirements. Such best practices could be application domain specific or company specific, according to the purpose of use and availability of information. To demonstrate our approach, we present example patterns identified from the IEC 61508-3 ed2.0 standard.