NWPER 2002 accepted papers.

All papers as a large zip-file.

Long papers (allocated full presentation time)

1. Jani Airaksinen, Kai Koskimies, Johannes Koskinen, Jari Peltonen, Petri Selonen, Mika Siikarla, Tarja Systä. xUMLi: Towards a Tool-independent UML Processing Platform. pdf-file.

   Abstract. Being a modeling language rather than a method, UML does not inherently define a design process. Consequently there is no common basis for building design process support for UML tools. They often offer extension interfaces, which allow external applications to access and handle the UML models constructed using that particular tool. Although they support extensibility and customizability, such tool-dependent solutions are typically suitable only for performing single operations or tasks. In this paper, we propose a tool-independent software platform, which allows the user to build and combine various kinds of UML processing facilities and use them from integrated CASE-tools. The proposed solution conforms to the UML standard metamodel and hides the individual conventions and complexities of the CASE-tool APIs. We discuss our solution, its architecture and API, and also illustrate their usage by giving an example.
   
   

2. Erik Arisholm, Dag I.K. Sjøberg, Gunnar J. Carelius and Yngve Lindsjørn. SESE – an Experiment Support Environment for Evaluating Software Engineering Technologies. pdf-file.

   Abstract. The software engineering communities frequently propose new software engineering technologies, such as new development techniques, programming languages and tools, without rigorous scientific evaluation. One way to evaluate software engineering technologies is through controlled experiments where the effects of the technology can be isolated from confounding factors, i.e., establishing cause-effect relationships. For practical and financial reasons, however, such experiments are often quite unrealistic, typically involving students in a class-room environment solving small pen-and- paper tasks. A common criticism of the results of the experiments is their lack of external validity, i.e., that the results are not valid outside the experimental conditions. To increase the external validity of the experimental results, the experiments need to be more realistic. The realism can be increased using professional developers as subjects who conduct larger experimental tasks in their normal work environment. However, the logistics involved in running such experiments are tremendous. More specifically, the experimental materials (e.g., questionnaires, task descriptions, code and tools) must be distributed to each programmer, the progress of the experiment needs to be controlled and monitored, and the results of the experiment need to be collected and analyzed. To support this logistics for large-scale, controlled experiments, we have developed a web-based experiment support environment called SESE. This paper describes SESE, its development and the experiences from using it to conduct a large controlled experiment in industry.
   
   

3. Christian Heide Damm and Klaus Marius Hansen. Distributing Knight Using Type-Based Publish/Subscribe for Building Distributed Collaboration Tools. pdf-file.
   
   Abstract. Distributed applications are hard to understand, build, and evolve. The need for decoupling, flexibility, and heterogeneity in dis-tributed collaboration tools present particular problems; for such ap-plications, having the right abstractions and primitives for distributed communication becomes even more important. We present Distributed Knight, an extension to the Knight tool, for distributed, collaborative, and gesture-based object-oriented modelling. Distributed Knight was built using the type-based publish/subscribe paradigm. Based on this case, we argue that type-based publish/subscribe provides a natural and ef-fective abstraction for developing distributed collaboration tools.
   
   
4. Erik Ernst. Safe Dynamic Multiple Inheritance. pdf-file.
   
   Abstract. Combination of descriptive entities—i.e. multiple inheritance and related mechanisms—is usually only supported at compile time in statically typed languages. The language gbeta is statically typed and has supported run-time creation of classes and methods since 1997, by means of the pattern combination operator ‘ &’. However, with certain combinations of operands the ‘ &’ operator fails; as a result, creation of new classes and methods at run-time had to be considered a dangerous operation. This paper presents a large and useful class of combinations, and proves that combinations in this class will always succeed.
   
   
5. Markku Hakala. Feature Models, Pattern Languages and Software Patterns: Towards a Unified Approach. pdf-file.
   
   
6. Markku Hakala, Juha Hautamäki, Kai Koskimies and Pekka Savolainen. Generating Pattern-based Documentation for Application Frameworks. pdf-file.
   
   Abstract. Application frameworks are a popular technique to implement product-line architectures. The problem of communicating the relevant properties of a framework for application developers is studied. It is argued that a conventional API specification is not sufficient for a framework, but a pattern-based specification of the extension interface is required. A technique to generate a pattern-based browser for the extension interface of a framework is described, relying on an existing tool developed for the generation of a programming environment for a framework.
   
   
7. Imed Hammouda, Kai Koskimies. A Pattern-Based J2EE Application Development Environment. pdf-file.
   
   Abstract. J2EE (Java 2 Platform, Enterprise Edition) is Java’s platform for building distributed enterprise applications. The platform takes advantage of a wide range of new and evolving technologies and has been enriched by proven design solutions. These solutions are formulated and documented in what is known as J2EE design patterns. Rather than applying the patterns in isolation, a complete design system can be composed of the patterns. This pattern-based system can significantly ease the development process of J2EE applications and improve the quality of the produced software. In this paper, we will show how a general architectural tool (Fred) can be used to model such a pattern system and to generate an architecture-centric environment for developing J2EE applications. The environment is a task-based wizard that guides the user through the development of the application by enforcing certain design rules.
   
   
8. Vesa Hirvisalo.Combining Static Analysis and Simulation to Speed up Cache Performance Evaluation of Programs. pdf-file.
   
   Abstract. This paper presents a new method for cache performance evaluation of programs. The method is especially suitable for programs using dynamic memory allocation. For such programs, static analysis methods are fast, but often not sufficiently accu-rate. On the other hand, traditional memory simulations are accurate, but slow. The new method combines the benefits of static analysis and simulation. 
       Often, data transfers between main memory and cache memory cause the domi-nating performance bottlenecks. We must locate the bottlenecks of a subject program to improve its performance. This can be done by simulating the cache behavior of the subject program. Typically, the subject program is augmented with commands for a memory simulator. 
       The new method is based on integrated simulation, partial evaluation, and pro-gram slicing. Because of memory access patterns of typical programs, the augmented simulation code can be partially evaluated during compilation of the integrated sim-ulation program. Program slicing is used to remove the computations of the subject program that are not needed in the cache simulation. The new method can reduce the time needed in cache performance evaluations without losing accuracy of the results.
   
   
9. Anders Ive, Anders Blomdell, Torbjörn Ekman, Roger Henriksson, Anders Nilsson, Klas Nilsson, and Sven Robertz-Gestegård. Garbage Collector Interface. pdf-file. 
   
   Abstract. The purpose of the presented garbage collector interface is to provide a universal interface for many different implementations of garbage collectors. This is to simplify integration and exchange of garbage collectors, but also to support incremental, non-conservative, and thread safe implementations. Due to the complexity of the interface, it is aimed at code generators and preprocessors. Experiences from ongoing implementations indicate that the garbage collector interface successfully provides the necessary functionality in an efficient way.
   
   
10. Anders Nilsson. JaTack - Java Acceptance testing Tool ACKronym. pdf-file.
    
    Abstract. In XP, automatic testing of the produced software takes a central role in the development process. For unit tests, there are a multitude of freely available testing frameworks for many programming languages while there seems to be a complete lack of available testing frameworks for automating acceptance tests. At the department of Computer Science, Lund University, we felt the need for a light-weight acceptance testing framework that could be used in both students programming projects courses and in our own research projects. This paper discusses the thoughts behind, and the implementation of, JaTack, a very lightweight framework for automating acceptance tests for batch-oriented programs.
    
    
11. Thomas Vestdam. Generating Consistent Program Tutorials. pdf-file.
    
    Abstract. In this paper we present a tool that supports construction of program tutorials. A program tutorial provides the reader with an understanding of an example program by interleaving fragments of source code and explaining text. An example program can for example illustrate how to use a library or a framework. We present a means for specifying the fragments of a program that are to be in-lined in the tutorial text. These in-line fragments are defined by addressing named syntactical elements, such as classes and methods, but it is also possible to address individual code lines by labeling them with source markers. The tool helps ensuring consistency between program tutorial and example programs by extracting fragments of source code based on the fragment specifications and by detecting when a program tutorial is addressing program fragments that do not exist. The program tutorials are presented as online resources, providing navigation to other documents, such as reference manuals, other tutorials, internal documentation, and also to a presentation of the source code fragment in its original context. We have produced three example program tutorials in order to get some experience with the tool, and we see potential in using the tool to produce program tutorials to be used for frameworks, libraries, and in educational contexts.
    
    
12. Antti Viljamaa and Jukka Viljamaa. Creating Framework Specialization Instructions for Tool Environments. pdf-file
    
    Abstract. Object-oriented application frameworks provide an established way of reusing the design and implementation of applications in a specific domain. Using a framework for creating applications is not a trivial task, however, and special tools are needed for supporting the process. Tool support, in turn, requires explicit annotations of the reuse interfaces of frameworks. Unfortunately these annotations typically become quite extensive and complex for non-trivial frame-works. In this paper we focus on describing techniques for minimizing the work needed for creating framework annotations. We discuss the possibility of generating annotations based on frameworks’ and example applications’ source code, automating annotation creation with dedicated wizards, and introducing coding conventions and advanced language features, such as inheritance, for framework annotations languages. We also introduce a programming environment that supports framework annotation and specialization. In our environment we have incorporated many of the techniques described in this paper.
    
    

Short papers (allocated half presentation time)

1. Henrik Enqvist and Johan Lilius. Region Based Allocation in Java. pdf-file.
   
   Abstract. De-allocation of memory in Java is carried out by a garbage collector. Modern garbage collectors are fast and effectively reduces fragmentation. It is, however, not always possible to use sophisticated algorithms, e.g. if the data-structures are  too memory consuming. This is the case in embedded systems, the limited amount of memory forces the memory usage and the memory footprint of the virtual machine to be modest. This work will suggest a method for reducing the work of the garbage collector and decreasing memory fragmentation through region based allocation.
   
   
2. Per Madsen. Testing by Contract - Combining Unit Testing and Design by Contract. pdf-file.
   
   Abstract. In modern software development a lot of time is spent on testing. Nevertheless it is commonly agreed that testing is almost never done well enough. This paper presents a new approach to software testing called Testing by Contract. The new approach builds on top of a couple of well-known techniques especially Design by Contract as known from Eiffel and Unit testing as known from Extreme Programming. The basic idea is to reuse the assertions written as part of Design by Con-tract in Unit test cases. To provide test data the idea of a Testable interface is presented. The interface uses the notion of equivalence partitioning. The paper sketches how a concrete tool for Testing by Contract could be build. The main argument for using Testing by Contract is that if the programmer provides an implementation of the Testable interface together with pre- and post-conditions and class-invariants, a number of test cases and test result come for free. This paper is work in progress and the development of a prototype of a Testing by Contract tool has been started, but no results are available yet.
   
   
3. Jonas Munsin and Johan Lilius. An Implementation of Escape Analysis for Java. pdf-file.
   
   Abstract. In this paper, a tool implementing escape analysis for Java is presented. The goal of the tool is to use escape analysis to extend Java class files with information that can be used to perform compile time garbage collection on objects with a short lifetime. The information form the tool can also be used to remove unnecessary synchronizations due to the multi-threading support in Java.
   
   
4. Jüri Kiho and Svetlana Solopova. Heterogeneous File Projects in the Sketchy Modeling Environment. pdf-file.
   
   Abstract. The sketchy modeling environment (SKME) is a software tool for handling graphically modeled computer texts. It is a multi-representational environment with heterogeneous file collections. In this paper, a general formal definition for the basic notion file project description is given and a special feature of SKME, the file project support is introduced. The concept of file project originates from so called Project tool feature in many common IDEs. SKME supports hierarchical project descriptions. Beside attributed file names and sub-projects, file project descriptions may contain arbitrary auxiliary data. All file attributes such as locators, pre-open and post-save actions are user-defined, and can be inherited from super-projects.