Looking back the history of software engineering, we can observe an alternating cycle of interest on product-centered view vs. process-centered view in software research and practices.

To engineer adaptive software systems, it is crucial to capture changes that drive adaptation. We believe that a pair of concepts, context and roles, is most effective in capturing such changes and creating an adaptation mechanism to deal with those changes. We propose a new framework for developing adaptive software systems based on Epsilon, a context-role oriented approach. The framework covers the whole process of adaptive system development, starting from the requirements phase through the implementation phase of program generation by means of model building and model transformation. We show effectiveness of our approach with a case study of the Traffic Jam Monitoring System. In this case, traffic jam occurrence, growth and dissolution are captured as context creation, merging and splitting and roles are played by intelligent cameras. How an Epsilon model is built and then successively transformed into a final program through several steps of model transformation is explained.

Many embedded systems not only affect their context through actuators but also are affected by the context through sensors. It is important to provide a context-dependent development method for constructing safe and reliable embedded systems. However, most of the current requirements analysis methods do not explicitly provide a systematic way for deciding the boundary of the context that should be taken into account because it is essentially difficult to decide which context element should be included as the targets of requirements analysis. If a developer explores the context boundary in an ad-hoc manner, he or she will be faced with the frame problem because there are unlimited context elements in the real world where the target system exists. To deal with this problem, this paper proposes a context-dependent requirements analysis method called CAMEmb (Context Analysis Method for Embedded systems) in which only the value-context elements are extracted as the associated context elements. Applying the guide words provided by CAMEmb, we can explore only a sequence of context elements directly or indirectly affecting the data value observed or controlled by the system sensors and actuators. Other context elements not affecting the system observation and control are not taken into account because these context elements do not affect the system behavior. Using CAMEmb and lightweight formal tools, we can explore the context boundary that guarantees the expected system behavior. We developed CAMEmbModeler, a support tool consisting of a CAMEmb-based modeling editor and a model compiler that transforms system and context models into the design model reflecting the context boundary.

Software risk comes mainly from its poor reliability, but how to effectively achieve high reliability still remains a challenge. This paper puts forward a framework for systematically integrating formal specification, review, and testing, and shows how it can be applied to effectively eliminate errors in the major phases of software development process to enhance software reliability. In this framework, requirements errors can be removed and missing requirements can be identified by formalizing requirements into formal specifications whose validity can be ensured by rigorous review. The valid specification can then be used as a firm foundation for implementation and for rigorous inspection, testing, and walkthrough of the implemented program. We discuss how formalization, review, and testing work together at different levels of software development to improve software reliability through detecting and removing errors in documentation.

This paper proposes Archface, an interface mechanism for bridging the gap between architectural design and its implementation. Archface, which encapsulates design essence based on the component-and-connector architecture, is not only an ADL (Architecture Description Language) but also a programming-level interface. Archface is effective for software evolution because traceability between design and its implementation can be realized by enforcing architectural constraints on program implementation, and this traceability is bidirectional. In Archface, a component exposes program points such as method call/execution and a connector defines how to coordinate exposed program points. A collaborative architecture consisting of components can be encapsulated into a group of interfaces and separated from implementation, because dynamic program points representing control flow can be specified in the interfaces. We can characterize the notion of Archface with the phrase "predicate coordination," in which program points are exposed by a predicate and coordinated by a trait-based connector.

Model checking is a formal technique for software verification. In the early stage of software development, it can be used to validate software models. If the result of model checking is false, producing a counterexample, the developer fixes the target model employing information obtained from the counterexample. However, as no systematic method is known, how to fix the model is highly dependent on the developer's skill and experience. In this paper, we propose an iterative method for fixing models based on counterexamples. For this purpose, multi-valued transition systems (four-valued, to be precise) are used to allow iterative model improvement. Firstly, a MVTS model that satisfies all properties validated so far is generated. Secondly, another MVTS model is synthesized from the counterexample that avoids the paths to lead to the counterexample. Then, the two models are merged using the behavioral model merging technique. The advantage of our approach is that both safety properties and liveness properties can be treated in the same way.

Extensive research efforts have been devoted to implement a group of type-safe mutually recursive classes; recently, proposals for separating each member of the group as a reusable and composable programming unit have also been presented. One problem of these proposals is verbosity of the source programs; we have to declare a recursive type parameter to parameterize each mutually recursive class within each class declaration, and we have to declare a fixed-point class with empty class body for each parameterized class. Therefore, even though the underlying type system is simple, programs written in these languages tend to be rather complex and hard to understand. In this paper, we propose a language with lightweight dependent classes that forms a simple type system built on top of generic Java. In this language, we can implement each member of type-safe mutually recursive classes in a separate source file without writing a lot of complex boilerplate code. To carefully investigate type soundness of our proposal, we develop X.FGJ, a simple extension of FGJ supporting lightweight dependent classes. This type system is proved to be sound.

Refactoring is a method for improving a program's structure without changing its external behavior. Refactoring is a promising approach to assist reliable and safe software evolution. However, in aspect-oriented programming (AOP), it is not necessarily easy for a programmer to understand the overall behavior of a woven program because the weaving modifies the behavior. Unexpected bugs can be embedded in a program if the programmer does not modify the program carefully. In order to deal with this problem, we propose the notion of RbC (refactoring by contract), a technique to verify refactoring based on contracts. Contracts in RbC consist of preconditions, postconditions, and invariants. A precondition states under which conditions refactoring can be applied. A postcondition states what condition should be verified after refactoring has been accomplished, and an invariant states what conditions refactoring should preserve. After introducing RbC, we check whether refactoring preserves behavior and whether it actually improves internal structure. A contract is described in COW (contract writing language), a language for describing a predicate based on first-order logic. COW provides a set of primitive predicates that represent program structure and behavior. Adopting our approach, software evolution in AOP becomes reliable and safe.

AspectM, a UML-based aspect-oriented modeling (AOM) language, provides not only basic modeling constructs but also an extension mechanism called metamodel access protocol (MMAP) that allows a modeler to extend the AspectM metamodel. MMAP enables a modeler to construct domain-specific AOM languages at relatively low cost. In this paper, we show the overview of an AspectM support tool consisting of a reflective model editor and a verifying model weaver.

ccJava, a new kind of class-based AOP language, provides the weaving-interface mechanism in which the weaving can be realized by the component-and-connector architecture. The interface description constructs in ccJava can be considered a kind of architecture description language that takes into account the weaving. This paper provides a lightweight verification approach using Alloy, a structural modeling language based on relational logic. Using Alloy, we can verify whether the weaving based on the component-and-connector architecture satisfies some kinds of properties--whether advice-types are specified correctly,whether a pointcut selects join points correctly, and so on. By enforcing the architecture verified by Alloy to the class implementation, we can construct a reliable system.

One limitation of the well-known family polymorphism approach is that each "family" will be a large monolithic program. In this paper, we introduce a minimal lightweight set of language features that treat each member of a family as a reusable programming unit, while preserving the important feature of scalability. The only one language construct we propose in this paper is type parameter members, which allows type parameters to be referred from the outside of class declarations. To investigate properties of type parameter members in the real programming language settings, we develop a programming language Scalable Java (SJ), an extension of Java generics with type parameter members. To carefully investigate the type soundness of SJ, we develop FGJ#, a core calculus of this extension based on FGJ, a functional core of Java with generics. Furthermore, to explore how to implement this proposal, we define the erasure of FGJ# programs as an extension of the erasure of FGJ programs, which compiles SJ to Java without generics.

Aspect-oriented programming (AOP) separates crosscutting concerns from primary concerns. These concerns are woven together by a weaver. Although AOP provides an effective module mechanism, it is not necessarily easy for a programmer to understand the overall behavior of a woven program. To deal with this problem, we propose a new kind of information hiding mechanism called a weaving-interface that encapsulates weaving in class-based AOP in which all kinds of concerns are described according to classes. Weaving-interfaces are completely separated from concerns described in terms of classes. A programmer who designs how to compose concerns does not have to know the details of class definitions, but has only to be aware of weaving-interfaces. A programmer who designs each concern does not have to know how the concern is composed, but has only to be aware of weaving-interfaces. Adopting the weaving-interface mechanism, AO weaving can be realized by the component-and-connector software architecture. This weaving-interface mechanism is effective for software modularity, evolution, and reuse

Our research goal is to Jind relations between requirements quality and project success. To attain the goal, we investigated 32 projects started and completed during the period of 2003-2005 in a large business application software development division of a company in Tokyo. Data of requirements specijication quality evaluated by software quality assurance teams as well as overall project pevormance data in terms of cost and time overrun were available. Requirements specijication quality data were Jirst converted into a multiple-dimensional space, each dimension corresponding to an item of the recommended structure of software requirements specijications (SRS) deJined in IEEE Std. 830-1998. We applied various statistical analysis techniques over the SRS quality data and project outcomes. Some interesting relations between requirements quality and project success or failure were found, including: 1) a relatively small set of SRS items have strong impact on project success or failure; 2) descriptions of SRS in normal projects tend to be balanced; 3) SRS descriptions in Section 1, where purpose, overview and general context of SRS are written, are rich in normal projects and poor in overrun projects; 4) when the descriptions of SRS Section 1 are poor while those of functions and product perspective are rich, the project tends to result in a cost overrun.

Since the inception of software engineering in the late 1960's, its main target to attack has been complexity of software. But until the mid 1990's, software complexity mostly stemmed from its size, i.e. the larger, the more complex. Characteristics of software in the past decade changed drastically. They can be described with four epithets: ubiquitous, evolving, diverse and reliability-sensitive.

To enhance motivation of students to study software engineering, some way of finding balance between the scientific aspect and the practical aspect of software engineering is required. In this paper, we claim that teaching multiple software modeling techniques from a unified viewpoint is a good way of obtaining the balance and attracting the students' interest as well.

To achieve the goal of realizing object adaptation to environments, a new role-based model Epsilon and a language EpsilonJ is proposed. In Epsilon, an environment is defined as a field of collaboration between roles and an object adapts to the environment assuming one of the roles. Objects can freely enter or leave environments and belong to multiple environments at a time so that dynamic adaptation or evolution of objects is realized. Environments and roles are the first class constructs at runtime as well as at model description time so that separation of concerns is not only materialized as a static structure but also observed as behaviors. Environments encapsulating collaboration are independent reuse components to be deployed separately from objects. In this paper, the Epsilon model and the language are explained with some examples. The effectiveness of the model is illustrated by a case study on the problem of integrated systems. Implementation of the language is also reported.

An aspect-oriented (AO) program consists of aspects and a base program into which the aspects are woven. Base programs usually exist beforehand, and test cases have been made for them. It is useful for programmers to grasp the impact of weaving into the base program. The impact analysis is effective for problem determination of the defects inserted by the weaving, and for determination of the scope of the regression tests after weaving. This paper proposes an analysis method for the potential impacts on a base program by weaving.

We present a parameterized interpreter for modeling aspect-oriented mechanisms. The interpreter takes several parameters to cover different AOP mechanisms found in AspectJ, Hyper/J, and Demeter. The interpreter helps our understanding of the AOP mechanisms in two ways. First, its core part represents the common mechanical structure shared by different AOP mechanisms. Second, by reconstructing the existing AOP mechanisms and using parameters to configure the interpreter, we can illustrate the differences and similarities of those mechanisms clearly. This will also be helpful in rapid-prototyping a new AOP mechanism or a reflective AOP system that supports different mechanisms.

Many methods for XML processing have been proposed in the last few years. One popular approach is to process XML documents by using existing programming languages. Another popular approach is to create a new programming language specialized to the domain of XML processing. We propose a new approach of constructing XML processors: embedding XML processing language on Lisp. Owing to this approach, we may seamlessly invoke the functions of XML-specific language from Lisp. The other novel features of our approach are shuffle expression pattern matching and dynamic validation of XML documents. A shuffle expression is an extension of a regular expression; it supports a shuffle (interleave) operator that is useful, for example, to represent unordered records such as bibliography data. Dynamic validation makes it possible to validate XML documents with respect to the schema or patterns at run time.

A number of interesting phenomena can be observed when lifelong processes of object-oriented software are analyzed from the viewpoint of software evolution. This paper proposes a framework of software evolution studies and reports the results of empirical case studies and evolution patterns discovered through the analysis.

Engineers have little time for requirements elicitation and their validation, because they still have to make a great effort to write down concrete use cases. Although concrete use cases are important for deriving test cases, it is possible to free engineers from the routine work of defining similar use cases repeatedly and at the same time keeping consistency in requirements elicitation. We propose one solution concerning these difficulties. The requirements description metamodel called RD-metamodel integrates the activity graph metamodel and use case metamodel. It supplies a mechanism of use case writing with multiple perspectives: resource-reference, resource-structure, activity-sequence, process, and the actor's perspective.

A trial software engineering accreditation system is being applied in Japan. The authors give a brief overview of the standard curriculum model that is followed by most computer science programs in Japanese universities today, and the current status of the accreditation systems now being applied to them. They report on the way in which they have tried to bridge the gap between industrial needs and undergraduate education in software engineering. Their plan for the trial software engineering accreditation system now being applied to one of these software engineering programs is outlined. Finally, the authors' efforts to build a body of knowledge for software engineering education are summarized.

A family of well-known problems on graphs, including the shortest path problem and the data flow analysis problem, can be uniformly formulated as a fixed-point problem on graphs. We specify this problem and its solution algorithm in a highly abstract manner, fully exploiting the parametrized module construct of CafeOBJ, an algebraic specification language. The objective of our research is to explore the effectiveness of formal methods, applying them not just to specific safety-critical programs but to general problems covering a wide range of applications.

A class evolves to address new user requirements and enhance reusability. The evolution processes can be analyzed statistically by tracing quantitative characteristics of object-oriented software development cases. In our case studies, increasing phenomena have been observed by four layers: a system layer, a class tree layer, a class layer and a method layer. Quantitative data, the value of mean lines of code per method over classes belonging to the same inheritance tree, can be considered to represent a characteristic of the inheritance tree over evolution and to affect class evolution as a constraint. Another type of data, the distribution pattern of size data at the system layer, is fitted to the negative binomial distribution model, and the parameters of the model can be interpreted to disclose some development intentions. This paper reports the results of empirical case studies and discusses evolution patterns and laws of objects.

A framework in which a group of objects collaborating with each other evolve their functions dynamically is presented in this paper. We call the framework evolutional cooperative computation and present an environment-adaptive computation model for its foundation. Then, a programming language Epsilon/0, which supports the computation model and has the reflection mechanism, is presented. In this paper, the concept of environments that give objects collaboration fields is introduced. An object evolves itself and changes relations among other objects by adapting itself to environments or seceding from environments.

Software tends to change itself according to user requirements changes. In the object-oriented technology, it is important to find a way how classes evolve to cope with new user requirements or to obtain reusability. The authors propose that developers need to know the class evolution processes and to forecast their future evolution according to the system, growth. Class specifications and class structures change inevitably, and classes may also be replaced during the class evolution processes. They classify classes into three categories the boundary species, the domain species and the common species, and discuss their evolution processes.

It is noted that the software evolution process does not end at the death of an individual software system but usually continues over generations through being replaced by newly built software. To explore this research topic, the authors conducted a survey, collecting data of software lifetimes, replacement practices, and factors of replacement. They report the results of the survey and discuss some possible long-range strategies for software life cycle planning and control based on the findings. The following issues related to such strategies are discussed; management by lifetime characteristics, monotonicity of size growth, and reuse.>

The author considers applying conventional approaches to validate OOS (object-oriented systems) and then investigates new aspects caused by the properties of OOS. He also focuses on two issues, each representing a typical property of the static aspect and the dynamic aspect. The issues examined are abstraction hierarchy consistency and concurrent behavior correctness.>