Rainer Weinreich

An environment for cooperative software development realization and implications

The development of large software systems is teamwork that requires tool support for coordinating cooperative activities, maintaining project control and sharing information. Existing collaborative environments that aim to support cooperative software development often try to predefine and automate the development process. This leads to problems since software development is a highly dynamic process where creativity, uncertainty, informal communication and incremental modification play important roles. The authors present an environment for distributed cooperative software development that supports informal communication as well as planning, defining, manipulating and supervising cooperative development activities. The environment accommodates the highly dynamic development process primarily by providing guidelines for various activities and work processes that can be changed according to a clearly defined cooperation model.

Towards supporting the software architecture life cycle

Software architecture is a central element during the whole software life cycle. Among other things, software architecture is used for communication and documentation, for design, for reasoning about important system properties, and as a blueprint for system implementation. This is expressed by the software architecture life cycle, which emphasizes architecture-related activities like architecture design, implementation, and analysis in the context of a software life cycle. While individual activities of the software architecture life cycle are supported very well, a seamless approach for supporting the whole life cycle is still missing. Such an approach requires the integration of disparate information, artifacts, and tools into one consistent information model and environment. In this article we present such an approach. It is based on a semi-formal architecture model, which is used in all activities of the architecture life cycle, and on a set of extensible and integrated tools supporting these activities. Such an integrated approach provides several benefits. Potentially redundant activities like the creation of multiple architecture descriptions are avoided, the captured information is always consistent and up-to-date, extensive tracing between different information is possible, and interleaving activities in incremental development and design are supported.

Models and tools for SOA governance

Organizations are moving rapidly towards Service-Oriented Architectures (SOAs). Benefits include cost reduction through reuse, better integration through standardization, and new business opportunities through agility. The successful implementation of an SOA requires not only protocols and technologies like SOAP and WSDL but also support for the processes of creating, validating and managing services in an enterprise. Tools for SOA governance and management are evolving to be the heart of enterprise SOAs. We present an approach for supporting SOA governance activities. Notable aspects of our approach are an extensible model for describing service metadata of arbitrary service types (not only Web services), the concept of service proposals for the process of service specification and service creation, a service browser for service reuse, and support for service evolution through information about service versioning, service dependencies and service installations.

Automatic Tracing of Decisions to Architecture and Implementation

Traceability requires capturing the relations between software artifacts like requirements, architecture and implementation explicitly. Manual discovery and recovery of tracing information by studying documents, architecture documentation and implementation is time-intensive, costly, and may miss important information not found in the analyzed artifacts. Approaches for explicitly capturing traces exist, but either require manual capturing or lack comprehensive tracing to both architecture and implementation. In this paper we present an approach for (semi)automatically capturing traceability relationships from requirements and design decisions to architecture and implementation. Traces are captured in a non-intrusive way during architecture design and implementation. The captured traces are integrated with a semi-formally defined architecture description model and serve as the basis for different kinds of architecture-related activities.

Integrating requirements and design decisions in architecture representation

It has been proposed to make architectural design decisions first-class entities in software architecture representation. The actual means of capturing, representing, and managing architectural design decisions is still an open issue of research. We present an approach for capturing requirements and design decisions during design and development. We integrate design decisions, requirements, scenarios, and their relationships along with other architectural elements directly in a single, consistent, and formally defined architecture model. Capturing, visualizing, and tracing of architectural knowledge are supported by an integrated set of tools working on this model. The approach supports comprehensive tracing between requirements, design decisions, other architectural elements, and implementation artifacts, impact analysis, and architecture analysis and evaluation.

Connecting Architecture and Implementation

Software architectures are still typically defined and described independently from implementation. To avoid architectural erosion and drift, architectural representation needs to be continuously updated and synchronized with system implementation. Existing approaches for architecture representation like informal architecture documentation, UML diagrams, and Architecture Description Languages (ADLs) provide only limited support for connecting architecture descriptions and implementations. Architecture management tools like Lattix, SonarJ, and Sotoarc and UML-tools tackle this problem by extracting architecture information directly from code. This approach works for low-level architectural abstractions like classes and interfaces in object-oriented systems but fails to support architectural abstractions not found in programming languages. In this paper we present an approach for linking and continuously synchronizing a formalized architecture representation to an implementation. The approach is a synthesis of functionality provided by code-centric architecture management and UML tools and higher-level architecture analysis approaches like ADLs.

Classification of design decisions: an expert survey in practice

Support for capturing architectural knowledge has been identified as an important research challenge. As the basis for an approach for recovering design decisions and capturing their rationale we have performed an expert survey in practice to gain insights into the different kinds, influence factors, and sources for design decisions and also on how they are currently captured in practice. The survey has been performed with software architects, software team leads, and senior developers from six different companies in Austria with more than 10 years of experience in software development on average. The survey confirms earlier work by other authors on design decision classification and influence factors but also identifies additional kinds of decisions and influence factors not mentioned in this previous work. In addition, we gained insight into the practice of capturing, the relative importance of different decisions and influence factors, and on potential sources for recovering decisions.

Extracting and Facilitating Architecture in Service-Oriented Software Systems

In enterprises using service-oriented architecture (SOA) architectural information is used for various activities including analysis, design, governance, and quality assurance. Architectural information is created, stored and maintained in various locations like enterprise architecture management tools, design tools, text documents, and service registries/repositories. Capturing and maintaining this information manually is time-intensive, expensive and error-prone. To address this problem we present an approach for automatically extracting architectural information from an actual SOA implementation. The extracted information represents the currently implemented architecture and can be used as the basis for quality assurance tasks and, through synchronization, for keeping architectural information consistent in various other tools and locations. The presented approach has been developed for a SOA in the banking domain. Aside from presenting the main drivers for the approach and the approach itself, we report on experiences in applying the approach to different applications in this domain.

A Versioning Model for Enterprise Services

Software systems based on a service-oriented architecture (SOA) are partitioned into loosely coupled services. Services may be developed by different parties, deployed to different nodes and operated by different organizations. In an SOA services may evolve independently from one another, ideally without sacrificing interoperability. Supporting service evolution is still a topic of ongoing research. We present a versioning model for supporting the evolution of service-oriented architectures. We present suggestions for release management, evolution scenarios, and a versioning scheme for enterprise services. The presented approach has been developed for an SOA in the banking domain.

Enhancing presentation level integration of remote applications and services in Web portals

Web portals are a means for presentation level integration of enterprise applications and services. We describe an approach for enhancing presentation level integration in Web portals by supporting communication between presentation level components. The approach is based on established standards in this area and allows the exchange of structured XML-data between local and remote applications and services. Since the approach is mostly declarative, it can also be used for improving integration of already existing presentation components.