Knowledge discovery is widely considered to be an interactive and iterative process. The data mining phase of KDD is, on the other hand, often assumed to be an indivisible step. We argue that user interaction during discovery runs is a central element in very large scale data mining. We describe a system architecture centered around a common, persistently stored search space. This gives good performance while simultaneously allowing for high user interactivity. Furthermore, the architecture supports an extremely robust and modular implementation of the data mining process. As a concrete instantiation, we discuss the use of this architecture in the ESPRIT KESO project (Knowledge Extraction for Statistical Offices).

Software process measurement is an essential skill to be taught to future software engineers. It is not adopted through classroom teaching, unless the students are required to try out the suggested methods, in order to experience both the advantages and the pitfalls of process measurement. The Personal Software Process (PSP) is a well known tool for this purpose. In our university we have used PSP as a part of our graduate course for teaching process measurement. Our experience and the feedback from our students suggest some changes both in the exercises and in the process itself.

Software is more and more developed in international cooperative efforts where project team members have different educational and cultural backgrounds and the team may even be distributed among sites in several countries. Software engineering education should also involve distributed and cross-cultural project work to prepare the future software developers for this kind of work environment. In a pilot project of two universities in Finland and in Russia a cross-cultural student team gathered experience by developing a common software product in a distributed project. While in general the project was successful, the team encountered some problems mainly due to the need to work in a foreign language and the practical limitations of remote connections

Data mining methods have been applied to a wide variety of domains. Surprisingly enough, only a few examples of data mining in text are available. However, considering the amount of existing document collections, text mining would be most useful. Traditionally, texts have been analysed using various information retrieval related methods and natural language processing. In this paper, we present our first experiments in applying general methods of data mining to discovering phrases and co-occurring terms. We also describe the text mining process developed. Our results show that data mining methods - with appropriate preprocessing - can be used in text processing, and that by shifting the focus the process can be used to obtain results for various purposes.

It is shown how software metrics and architectural patterns can be used for the management of software evolution. In the presented architecture-centric software evolution method the quality of a software system is assured in the software design phase by computing various kinds of design metrics from the system architecture, by automatically exploring instances of design patterns and anti-patterns from the architecture, and by reporting potential quality problems to the designers. The same analysis is applied in the implementation phase to the software code, thus ensuring that it matches the quality and structure of the reference architecture. Finally, the quality of the ultimate system is predicted by studying the development history of previous projects with a similar composition of characteristic software metrics and patterns. The architecture-centric software evolution method is supported by two integrated software tools, the metrics and pattern-mining tool Maisa and the reverse-engineering tool Columbus.

Many important product quality characteristics, such as performance and maintainability, cannot be added on late in the development, and hence early warnings of poor quality expectation would be very useful to allow early corrective measures. To produce such information, we base product quality prediction on measurements and calculations of the UML design diagrams of the software. Some design metrics may be used as direct predictors of quality; as an example, cohesion and coupling metrics are generally considered good predictors of the maintainability of the product. On the other hand, certain quality characteristics, e.g., performance, require more complex analysis of the design by computing predictions of the execution time of a typical use case with user provided information of the input size and attributes. Another way of taking advantage of the design diagrams is by detecting design patterns and anti-patterns in the design, and using these as predictors of the final product quality. While using design patterns is considered to have a positive effect on the quality and productivity of the development process, their effect in product quality is more complex and may in fact be positive or negative, depending on the context. We suggest using the pattern library to store information of the previous uses of the patterns and the quality of the corresponding systems, to predict the quality effects of the design patterns . In our paper, we present a tool for measuring UML diagrams of the product to predict three central product quality characteristics, size, understandability, and performance. The tool also detects all occurrences of a previously defined set of design patterns and antipatterns from the diagrams. Our paper reports industrial experience in using the tool to detect patterns and measure quality of design diagrams.

A software architecture is the key artifact in software design, describing the main elements of a software system and their interrelationships. We present a method for automatically analyzing the quality of an architecture by searching for architectural and design patterns from it. In addition to approximating the quality of the design, the extracted patterns can also be used for predicting the quality of the actual system. The method is demonstrated by an industrial case over a complex telephone exchange software.

The use of design patterns in object-oriented software development is recommended to improve both the software structure and the development process. On the other hand, their e ect on the performance of the nal product may greatly depend on the particular application and the projected workload. In addition to intentional use, the design may also contain patterns (and anti-patterns) that have not been used on purpose. We propose an approach where all patterns and anti-patterns embedded in the design are discovered by a mining tool and their performance e ects are evaluated using previous experience stored in a pattern library.

Data mining methods easily produce large collections of rules, so that the usability of the methods is hampered by the sheer size of the rule set. One way of limiting the size of the result set is to provide the user with tools to help in finding the truly interesting rules. We use this approach in a case study where we search for association rules in NCHS health care data, and select interesting subsets of the result by using a simple query language implemented in the KESO data mining system. Our results emphasize the importance of the explorative approach supported by efficient selection tools.

Iinowledge dz,scouery in databases seeks to find neur and useful anformation hidden in large data collections. Due to tht, large volume of data and the wide uariet!/ of the methods applied, A*DD may involve serious performance problems which have not been extensively evaluated.

Traditionally, texts have been analysed using various information retrieval related methods, such as full-text analysis, and natural language processing. However, only few examples of data mining in text particularly in full text, are available.In this paper we show that general data mining methods are applicable to text analysis tasks such as descriptive phrase extraction. Moreover, we present a general framework for text mining. The framework follows the general knowledge discovery process, thus containing steps from preprocessing to the utilization of the results. The data mining method that we apply is based on generalized episodes and episode rules.We give concrete examples of how to preprocess texts based on the intended use of the discovered results and we introduce a weighting scheme that helps in pruning out redundant or non-descriptive phrases. We also present results from real-life data experiments.

Sequences of events describing the behavior and actions of users orsystems can be collected in several domains. An episode is acollection of events that occur relatively close to each other in agiven partial order. We consider the problem of discoveringfrequently occurring episodes in a sequence. Once such episodes areknown, one can produce rules for describing or predicting thebehavior of the sequence. We give efficient algorithms for thediscovery of all frequent episodes from a given class of episodes,and present detailed experimental results. The methods are in use intelecommunication alarm management.

ALCHEMIST is a general purpose transformation generating environment, which supports specification, generation and execution of data transformations. ALCHEMIST allows an abstract specification of the transformation through a window-based interface and supports the generation and compilation of transformation program code from these specifications. Unlike compiler-compilers, ALCHEMIST is intended to automate building transformations between two complex representation formats and is thus especially suitable for constructing transformations between database tools, CASE tools, graphical editors or text formatters. In this paper we describe the design principles and the structure of ALCHEMIST, and demonstrate its use. We also discuss our experiences with several example transformations and present a real-life case study of using ALCHEMIST for interfacing two software development environments.

Integrating two separate development environments requires information transfer between the tools or the underlying repositories of the environments. This information transfer has usually been solved by applying ad hoc transformations to integrate the tools within a single development environment. We study the problem of making tools in diierent environments cooperate without modifying the tools or their environment. This requires building a permanent interfacing mechanism between the two environments. Problems particular to this context are incompatibility of the source and target languages, multiple views used within the environments, diierent naming conventions , and diierent ways of representing graphical information.

Information sharing between two well-defined development environments demands data transformation between the tools or the underlying repositories of the environments. We give a solution to the problem of making tools in different environments cooperate without modifying the tools or their environments. In building an interface between a KBS environment and a selected CASE tool we have used a transformation generator called ALCHEMIST. This has reduced the work of respecifying the environments for each transformation. We have encountered several problems in the transformation that we have solved including, e.g., incompatible views of the tools, multiple views, and different ways of representing graphical information. Additional problems can be addressed through user interaction before, during, or after the transformation.

Sequences of events describing the behavior and actions of users or systems can be collected in several domains. In this paper we consider the problem of recognizing frequent episodes in such sequences of events. An episode is defined to be a collection of events that occur within time intervals of a given size in a given partial order. Once such episodes are known, one can produce rules for describing or predicting the behavior of the sequence. We describe an efficient algorithm for the discovery of all frequent episodes from a given class of episodes, and present experimental results.

We compare the process of knowledge based system development to the software engineering approach of the more traditional application development. Many similarities can be identiied in the process structures. The most important diierences are in the knowledge acquisition and conceptual modelling of the KBS which have no direct counterpart in the traditional software life cycle. We also study the cooperation of the KBS development environment and ordinary CASE tools. We develop a scheme to support this cooperation. The method is based on transformations between KBS development tools and the repository supporting the CASE toolset. For the case where no repository is available, the scheme can be modiied to use transformations between each KBS development tool and the corresponding CASE tool. Since the phase structures of a KBS project and a SE project are fairly similar, the interface may be relatively simple.

Association rules, introduced by Agrawal, Imielinski, and Swami, are rules of the form “for 90% of the rows of the relation, if the row has value 1 in the columns in set W, then it has 1 also in column B”. Efficient methods exist for discovering association rules from large collections of data. The number of discovered rules can, however, be so large that browsing the rule set and finding interesting rules from it can be quite difficult for the user. We show how a simple formalism of rule templates makes it possible to easily describe the structure of interesting rules. We also give examples of visualization of rules, and show how a visualization tool interfaces with rule templates.