Markku Sakkinen

Object-oriented specification of reactive systems

A novel approach to the operational specification of concurrent systems that leads to an object-oriented specification language is presented. In contrast to object-oriented programming languages, objects are structured as hierarchical state-transition systems, methods of individual objects are replaced by roles in cooperative multiobject actions whereby explicit mechanisms for process communication are avoided, and a simple nondeterministic execution model that requires no explicit invocation of actions is introduced. The approach has a formal basis, and it emphasizes structured derivation of specifications. Top-down and bottom-up methodologies are reflected in two variants of inheritance. The former captures the methodology of designing distributed systems by superimposition; the latter is suited to the specification of reusable modules.<<ETX>>

Requirements quality control: a unifying framework

Literature tends to discuss software (and system) requirements quality control, which includes validation and verification, as a heterogeneous process using a great variety of relatively independent techniques. Also, process-oriented thinking prevails. In this paper, we attempt to promote the point that this important activity must be studied as a coherent entity. It cannot be seen as a rather mechanical process of checking documents either. Validation, especially, is more an issue of communicating requirements, as constructed by the analysts, back to the stakeholders whose goals those requirements are supposed to meet, and to all those other stakeholders, with whose goals those requirements may conflict. The main problem, therefore, is that of achieving a sufficient level of understanding of the stated requirements by a particular stakeholder, which may be hindered by, for example, lack of technical expertise. In this paper, we develop a unifying framework for requirements quality control. We reorganize the existing knowledge around the issue of communicating requirements to all the different stakeholders, instead of just focusing on some techniques and processes. We hope that this framework could clarify thinking in the area, and make future research a little more focused.

Transformations Between UML Diagrams

The Unified Modeling Language (UML) provides various diagram types for describing a system from different perspectives or abstraction levels. Hence, UML diagrams describing the same system are dependent and strongly overlapping. In this paper we study how this can be exploited for specifying transformation operations between different diagram types. We discuss various general approaches and viewpoints of model transformations in UML. The source and target diagram types for useful transformations are analyzed and given categories. The potentially most interesting transformation operations are discussed in detail. It is concluded that the transformation operations can automate a substantial part of both forward and reverse engineering. These operations can be used, for example, for model checking, merging, slicing, and synthesis.

From Rules To Rule Patterns

Rule-based systems are a commonly accepted solution for smoothly capturing the context-dependent and time-dependent organizational knowledge of large enterprises, also known as business policies. At the same time, however, the design of rule-based applications is one of the most pressing open research problems. This is largely because of the expressive power and flexibility of existing rule-based models together with a lack of design guidelines on how to apply these models. Learning from analogous problems in object-oriented system development and borrowing their solution metaphor we introduce rule patterns as generic rule-based solutions for specifying business policies. The advantage of rule patterns is their predefined, reusable, and dynamically customizable nature allowing the designer to reuse existing experience for building new rule-based applications. The paper introduces the general notion of rule patterns and illustrates the approach by sample rule patterns for specifying interaction policies in workflow applications.

How to make apples from oranges in UML

Unified Modeling Language (UML) provides various diagram types for describing a system from different perspectives or abstraction levels. Hence, various UML models of the same system are dependent and strongly overlapping. This paper discusses various general approaches and viewpoints of model transformations in UML. The possible source and target diagram types are analyzed and categories are given for different transformations. It is argued that such transformations should be defined in terms of the UML metamodel, rather than on the level of the actual diagrams. A detailed example of a transformation operation from sequence diagrams into class diagrams is presented to illustrate such operations. It is concluded that the transformation operations can automate a substantial part in both forward and reverse engineering. These operations can be used, for example, for model checking, merging, slicing and synthesis.

Comments on “the law of demeter” and C++

A rule of good style for object-oriented programming has recently been put forward, actually in several flavours (class vs. object, weak vs. strong). Some possible problems in the original rule are discussed, and a modified formulation is proposed to overcome at least part of the them. Doubts still remain about how useful the rule is with Smalltalk and other untyped languages. Then the application of the rule to the C++ language is studied and shown not to be as straightforward as has been suggested. This is largely a consequence of the intertwining of the conventional and the object-oriented component in C++. On the other hand, being typed, it is a promising language for enforcing rules of this kind at compile time. A new language-specific formulation is finally presented, argumenting that it is better in class than object flavour.

Bottom-up design of active object-oriented databases

Active object-oriented databases (AOODB) are a commonly accepted solution for smoothly capturing the frequently changing business policies of large enterprises [2]. By factoring out business policies from single applications and incorporating them into an AOODB, they are maintained in an application-independent manner, and may be imposed on all applications. One of the most prominent basic mechanisms of an AOODB system is an Event/Condition/Action rule (ECA rule), which allows for a localized specification of a business policy as opposed to spreading it over several applications. Monitoring events and conditions, ECA rules execute the corresponding action when the event occurs and the condition is true [8]. Extensions of the basic ECA paradigm allow a more flexible definition of rule execution points. For instance, in our research AOODB system TriGS the model is ECEA, which means another event may be awaited before the action is triggered [4, 9]. (TriGS stands for Triggersystem for GemStone, which is an active layer on top of the object-oriented database system GemStone.) Unfortunately, AOODB designers are overtaxed with the expressive power and flexibility of existing active object-oriented models, especially with the options for mapping business policies onto ECA rules. Rather than provide guidelines on which business policies to put into the AOODB, existing techniques follow a top-down design approach— focusing on the graphical representation of rules at the conceptual level by integrating them into existing conceptual design models [12]. Logical AOODB design, including the transformation of a conceptual model into an AOODB schema, has been dealt with infrequently [1]. Learning from similar design problems in OO system development , we propose a bottom-up design approach. We introduce rule patterns in analogy to design patterns [3], describing sample rule patterns for specifying interaction policies in workflow applications. More extensive annotated examples written in TriGS code can be found at Using our approach to AOODB design necessitates two subtasks: specifying application classes, and identifying business policies, which are generally spread over different classes. Since the first subtask resembles traditional OO design, we use Top-down design approaches give database designers little guidance with transforming a conceptual model into an active object-oriented database schema. A bottom-up design approach may provide a better perspective.

On the Darker Side of C

We discuss several negative features and properties of the C++ language, some common with C, others pertaining to C++ classes. Remedies are proposed for most of the latter ones, most of the former ones being feared to be already incurable. The worst class-related defects claimed in present C++ have to do with free store management. Some hints are given to programmers on how to avoid pitfalls.

Exploratory Analysis of the Relations between Code Cloning and Open Source Software Quality

In recent literature there is still a lack of understanding how the reuse and cloning of software affects its quality. The focus of this study is to analyze the relationships between source code cloning and software quality for the case of open source software project forks (SPFs) as a kind of software reuse. In total 117 releases related to three generations of eight eMule SPFs were scrutinized. Software quality was measured in terms of internal quality attributes. The tools CCFinderX and SoftCalc were used to measure code cloning metrics and internal quality attributes, respectively. In total 8 code cloning metrics and 71 internal quality attributes were analyzed. The quantitative relationships between the code cloning metrics and internal quality attributes were identified based on Pearson product moment correlation analysis. Our results revealed a number of important relationships between the metrics under study.

Content quality in location-based services: a case study

Most LBS studies share a common tacit assumption that the service is based on some information content useful enough to mobile users to pay for. This study provides, however, some empirical evidence that the quality of LBS content is an issue to be explicitly addressed in both practice and research. This paper also extends, from the practical application perspective, the discussion of our LBS content quality evaluation method.