njin Lu

Quality-driven architecture development using architectural tactics

This paper presents a quality-driven approach to embodying non-functional requirements (NFRs) into software architecture using architectural tactics. Architectural tactics are reusable architectural building blocks, providing general architectural solutions for common issues pertaining to quality attributes. In this approach, architectural tactics are represented as feature models, and their semantics is defined using the Role-Based Metamodeling Language (RBML) which is a UML-based pattern specification notation. Given a set of NFRs, architectural tactics are selected and composed, and the composed tactic is used to instantiate an initial architecture for the application. The proposed approach addresses both the structural and behavioral aspects of architecture. We describe the approach using tactics for performance, availability and security to develop an architecture for a stock trading system. We demonstrate tool support for instantiating a composed tactic to generate an initial architecture of the stock trading system.

A backward analysis for constraint logic programs

One recurring problem in program development is that of understanding how to re-use code developed by a third party. In the context of (constraint) logic programming, part of this problem reduces to figuring out how to query a program. If the logic program does not come with any documentation, then the programmer is forced to either experiment with queries in an ad hoc fashion or trace the control-flow of the program (backward) to infer the modes in which a predicate must be called so as to avoid an instantiation error. This paper presents an abstract interpretation scheme that automates the latter technique. The analysis presented in this paper can infer moding properties which if satisfied by the initial query, come with the guarantee that the program and query can never generate any moding or instantiation errors. Other applications of the analysis are discussed. The paper explains how abstract domains with certain computational properties (they condense) can be used to trace control-flow backward (right-to-left) to infer useful properties of initial queries. A correctness argument is presented and an implementation is reported.

A feature-based approach for modeling role-based access control systems

Abstract: Role-based access control (RBAC) is a popular access control model for enterprise systems due to its flexibility and scalability. There are many RBAC features available, each providing a different function. Not all features are needed for an RBAC system. Depending on the requirements, one should be able to configure features on a need basis, which reduces development complexity and thus fosters development. However, there have not been suitable methods that enable systematic configuration of RBAC features for system development. This paper presents an approach for configuring RBAC features using a combination of feature modeling and UML modeling. Feature modeling is used for capturing the structure of features and configuration rules, and UML modeling is used for defining the semantics of features. RBAC features are defined based on design principles of partial inheritance and compatibility, which facilitates feature composition and verification. We demonstrate the approach using a banking application and present tool support developed for the approach.

Polymorphic type analysis in logic programs by abstract interpretation

Abstract In this paper, we first introduce a notion of polymorphic abstract interpretation that formalises a polymorphic analysis as a generalisation of possibly infinitely many monomorphic analyses in the sense that the results of the monomorphic analyses can be obtained as instances of that of the polymorphic analysis. We then present a polymorphic type analysis of logic programs in terms of an abstract domain for polymorphic descriptions of type information and two operators on the abstract domain, namely the least upper bound operator and the abstract unification operator. The abstract domain captures type information more precisely than other abstract domains for similar purposes. The abstract unification operator for the polymorphic type analysis is designed by lifting the abstract unification operator for a monomorphic type analysis in logic programs, which simplifies the proof of the safeness of the polymorphic type analysis. Some experimental results with a prototype implementation of the polymorphic type analysis are also presented.

Inference of design pattern instances in UML models via logic programming

This paper formalizes the notion of a design model structurally conforming to a design pattern by representing the model as a logic program whilst the pattern as a query. The conformance of a model to a design pattern is equivalent to the satisfaction of the query by the logic program. Harnessing logic inference capability of logic programming languages, we obtain an automated method that infers all the instances of a design pattern in a UML class diagram. We use the visitor pattern and a price calculation application to demonstrate the technique.

Forward versus Backward Verification of Logic Programs

One recent development in logic programming has been the application of abstract interpretation to verify the partial correctness of a logic program with respect to a given set of assertions. One approach to verification is to apply forward analysis that starts with an initial goal and traces the execution in the direction of the control-flow to approximate the program state at each program point. This is often enough to verify that the assertions hold. The dual approach is to apply backward analysis to propagate properties of the allowable states against the control-flow to infer queries for which the program will not violate any assertion. This paper is a systematic comparison of these two approaches to verification. The paper reports some equivalence results that relate the relative power of various forward and backward analysis frameworks.

Analysing Logic Programs by Reasoning Backwards

One recent advance in program development has been the application of abstract interpretation to verify the partial correctness of a (constraint) logic program. Traditionally forwards analysis has been applied that starts with an initial goal and traces the execution in the direction of the control-flow to approximate the program state at each program point. This is often enough to verify assertions that a property holds. The dual approach is to apply backwards analysis to propagate properties of the allowable states against the control-flow to infer queries for which the program will not violate any assertion. Backwards analysis also underpins other program development tasks such as verifying the termination of a logic program or proving that a logic program with a delay mechanism cannot reduce to a state that contains sub-goals which suspend indefinitely. This paper reviews various backwards analyses that have been proposed for logic programs, identifying common threads in these techniques. The analyses are explained through a series of worked examples. The paper concludes with some suggestions for research in backwards analysis for logic program development.

Type analysis of logic programs in the presence of type definitions

This paper presents an abstract domain and an abstract unification function for type an al:ysis of logic programs with type definitions. Type information is inferred together with sharing and aliasing information. Aliasing information is used to improve the precision of type analysis.

Required Behavior of Sequence Diagrams: Semantics and Refinement

Sequence diagrams are a widely used design notation for describing software behavior. Many reusable software artifacts such as design patterns and design aspects make use of sequence diagrams to describe interaction behavior. When a pattern or an aspect is reused in an application, it is important to ensure that the sequence diagrams for the application correctly refines the corresponding sequence diagrams for the pattern or aspect. However, reasoning about refinement of sequence diagrams has not been addressed adequately. In this paper, we focus on refinement of required behavior specified by a UML sequence diagram. A novel trace semantics is given that captures precisely required behavior specified by a sequence diagram and a refinement relation between sequence diagrams is formalized based on the semantics. Properties of the trace semantics and the refinement relation are studied.

An Operational Semantics of Starlog

Starlog is a temporal logic programming language that supports declarative specification of reactive systems, input-output behaviour and destructive updates. This paper presents an operational semantics for Starlog. Its correctness and completeness with respect to a model semantics are proved.