Lukas Holy

Supplying Compiler's Static Compatibility Checks by the Analysis of Third-Party Libraries

Statically typed languages and their compile time checks prevent a lot of runtime errors thanks to type mismatches detection, namely calls of incompatible methods. Since current applications typically include tens of already compiled third-party libraries, the compile checks are powerless to detect their mutual dependencies. However, the calls among third-party library methods are not less error prone due to bugs or wrong library usage. These all lead to runtime failures. In this paper, we describe a partial solution to this problem based on the static analysis of third-party libraries and verification of their dependencies. This verification is invoked as the application is compiled and assembled, essentially supplying the compiler detecting errors before the application runs. This approach promises improved error detection of complex applications on the static type checking level.

Lowering Visual Clutter in Large Component Diagrams

Nowadays component applications can easily consist of hundreds or thousands of components and it is thus difficult to understand their structure. Diagram visualisation does not help much because of visual clutter caused by big amount of elements and connections, especially in the case of flat component models. This paper describes a novel approach of removing a large part of connections from the diagram while preserving the information about component interconnections. It uses a separated components area to show the components with big amount of connections. For each component in this area, clustered interfaces are shown instead of all interfaces, with the ability to show details on demand. The main idea of this technique can be used in a similar way to reduce the clutter in node-link graphs. To show the effect of this technique we discuss example lines reductions for several component applications.

Software Components Compatibility Verification Based on Static Byte-Code Analysis

Current enterprise systems are widely implemented using statically typed languages such as Java. One of the reasons are strong type checks at compile time that help prevent runtime errors. The static type checks are also well integrated into current development tools. One of the less explored area are, however, static type checks of binary software components. Since current software usually contains a large amount of third-party components, the compilers can no longer cover the static type checks of the final product, especially the inter-dependencies of the components are out of their reach. In this work, we propose an approach that analyses the byte-code of Java classes to reconstruct the mutual dependencies of respective components first. Then, the dependencies are examined to find any type inconsistencies. As a result, this approach detects dependency problems early in the development phase and prevents undesirable run time product failures caused by them.

A Visualization Tool for Reverse-Engineering of Complex Component Applications

Nowadays, component applications can contain thousands of components whose structure is difficult to understand. As a solution, we proposed a visualization technique that removes large part of connections from component binding diagrams. This technique uses a separated components area to display components with a big amount of connections detached from the main diagram. In this area, component interfaces are shown clustered instead of showing them all. Benefit of this approach is improvement of application understanding by reducing the diagrams visual clutter during its reverse engineering. In this work, we present implementation of the technique in a form of a tool, called CoCA-Ex. CoCA-Ex is a publicly accessible web application and a reverse-engineering solution for various component systems. The tool is built on modern technologies such as HTML5 and JavaScript and has Java EE server backend.

Visualization of Component-Based Applications Structure Using AIVA

The architecture of component-based applications can easily contain hundreds of components with a complex structure. Such structure is created from various types of relations between these components. However, component architects and assemblers need to study more than just simple structure in order to be able to analyze these applications. Many details might be necessary to check to ensure compatibility and re-usability of existing components. Thus, comprehensible visualization of structure is important for the maintenance and evolution of these complex systems. AIVA is the implementation of an approach that is able to visualize these structures comprehensibly while making details easy to reach. It combines various interactive techniques to achieve this goal. This paper describes the possibilities of AIVA as they are implemented, while briefly discussing the theory behind such functionality.

Viewport for component diagrams

This paper describes a viewport technique for use in the visualization of large graphs, e.g. UML component diagrams. This technique should help to work with complex diagrams (hundreds or thousands of components) by highlighting details of the important parts of the diagram and their related surroundings without losing the global perspective. To avoid visual clutter it uses clusters of interfaces and components.

Visual clutter reduction for UML component diagrams: A tool presentation

Nowadays component applications can easily consist of hundreds or thousands of components and it is thus difficult to understand their structure. Earlier, we proposed a novel approach of removing large part of connections from the diagram while preserving the information about component interconnections. It uses a separated components area to remove the components with a big amount of connections from the main diagram. For each component in this area, clustered interfaces are shown instead of all interfaces, with the ability to show details on demand. In this work we present the implementation of this technique as a web application and a reverse-engineering solution for component applications.

AIVA vs UML: Comparison of Component Application Visualizations in a Case-study

UML is the state of the art in visualization of software. However, it does not satisfy the needs of modeling in the domain of component applications and complex software architectures. UML has to be extended with profiles so as to be able to model the specifics of a particular component model; its diagrams are not scalable, therefore one has to balance the amount of information and readability; and it presents all the information at once so visual data mining is harder. These were the reasons for developing a completely new approach called AIVA (Advanced Interactive Visualization Approach) that focuses solely on the component domain and addresses the problems of scalability and readability by adopting interactive techniques like information hiding and details on demand. In this paper we analyse how this new approach stands compared with UML by modelling a nontrivial component application.

Exploration of Component Diagrams with Multifocal Highlighting.

In the paper we present multifocal highlighting in reverse engineered component diagrams to support software engineers in answering questions on relations between a number of components. With component oriented systems such questions arise quite often. We use color to highlight all components relevant to selected focus components. Further, we allow the users to filter the diagram. Our approach, unlike the state-of-the-art methods allows analysis of relations between dozens of components. We have performed an user study to evaluate our multifocal highlighting. The results of the subjective evaluation show that the multifocal highlighting supports software engineers in answering questions on relations between components.

Preventing Composition Problems in Modular Java Applications

Java JAR files have become a common means to bring reusability into Java programming. While they allow developers to easily share and use third-party libraries, they bring new challenges as well. This paper addresses the problem of Linkage Errors that occur when a type incompatibility or a missing dependency between two libraries is detected at runtime. This is a direct impact of composing applications from pre-existing binary libraries as the problem would be normally detected during compilation. A problem may occur relatively easily as rules of source and binary compatibility in Java differ and may be counter-intuitive. To deal with this problem, we offer a set of tools that analyse existing binaries and discover problems normally leading to runtime errors. The tools work automatically, may complement existing testing, and find problems effectively from the start of development. Their additional features such as detection of redundant or duplicated libraries are usually not provided by standard testing tools.