This paper reflects on the paper titled Building Hybrid Access Control by Configuring RBAC and MAC Features which was published in Information and System Technology, 2014. The publication presents an approach for building a hybrid access control model of Role-Based Access Control and Mandatory Access Control by defining and configuring them in terms of features. The publication has been cited three times, which shows limited impact. We review the citing papers as to how the publication is cited and discuss possible reasons for the limited impact. We also discuss its position in the current state of the arts since the publication. Then, we describe an ongoing effort for a new approach to address the weaknesses of the publication with expected impact.

In JavaScript, arrays are objects with a property named length that is automatically updated. An index is a property that is a string representation of an integer between 0 and 232- 2. A conventional array is an array that does not have any properties other than indices and length. Do JavaScript programmers use arrays conventionally just like in other object oriented languages? Do they use arrays like regular objects? This paper proposes a static conventionality analysis for JavaScript to help us to find answers to these questions. Conventionality analysis can be useful for program understanding and optimization.

A parametric analysis is an analysis whose input and output are parametrized with a number of parameters which can be instantiated to abstract properties after analysis is completed. We use Cousot and Cousot's Cardinal power domain to capture dependencies of analysis output on its input and present a method for obtaining parametric analyses from non-parametric base analyses. We apply the method to parametrize POS-based groundness dependency and set sharing analyses of logic programs. Experiments with a prototype analyzer shows that generality of the two resulting parametric analyses comes with a small extra cost.

Many reusable software artifacts such as design patterns and design aspects make use of UML sequence diagrams to describe interaction behaviors. When a pattern or an aspect is reused in an application, it is important to ensure that the sequence diagrams for the application conform to the corresponding sequence diagrams for the pattern or aspect. Reasoning about conformance relationship between sequence diagrams has not been addressed adequately in literature. In this article, we focus on required behaviors specified by a UML sequence diagram and provide a semantic-based formalization of conformance relationships between sequence diagrams. A novel trace semantics is first given that captures precisely required behaviors. A refinement relation between sequence diagrams is then defined based on the semantics. The refinement relation allows a sequence diagram to be refined by changing its structure so long as its required behaviors are preserved. A conformance relation between sequence diagrams is finally given that includes the refinement relation as a special case. It allows one to introduce and rename lifelines, messages, and system variables when reusing sequence diagrams. Properties of the semantics, refinement, and conformance relations are studied. Two case studies are provided to illustrate the efficacy of semantic-based conformance reasoning.

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.

This paper presents an approach for embodying nonfunctional requirements (NFRs) into software architecture using architectural tactics. Architectural tactics are reusable architectural building blocks, providing general architectural solutions for commonly occurring issues related 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 elected and composed. The composed tactic is then used to instantiate an initial architecture for the application where the NFRs are embodied. A stock trading system is used to demonstrate the approach.

We present a new analysis that infers polymorphic type dependencies in logic programs. The analysis infers more precise information than previous type dependency inference analyses. The improvement in precision is achieved by making use of set union as a type constructor and non-deterministic type definitions.

Abstract This paper presents a new type analysis for logic programs. The analysis is performed with a priori type definitions; and type expressions are formed from a fixed alphabet of type constructors. Non-discriminative union is used to join type information from different sources without loss of precision. An operation that is performed repeatedly during an analysis is to detect if a fixpoint has been reached. This is reduced to checking the emptiness of types. Due to the use of non-discriminative union, the fundamental problem of checking the emptiness of types is more complex in the proposed type analysis than in other type analyses with a priori type definitions. The experimental results, however, show that use of tabling reduces the effect to a small fraction of analysis time on a set of benchmarks.

A description in the Jacobs and Langen domain is a set of sharing groups where each sharing group is a set of program variables. The presence of a sharing group in a description indicates that all the variables in the group can be bound to terms that contain a common variable. The expressiveness of the domain, alas, is compromised by its intractability. Not only are descriptions potentially exponential in size, but abstract unification is formulated in terms of an operation, called closure under union, that is also exponential. This paper shows how abstract unification can be reformulated so that closures can be collapsed in two senses. Firstly, one closure operation can be folded into another so as to reduce the total number of closures that need to be computed. Secondly, the remaining closures can be applied to smaller descriptions. Therefore, although the operation remains exponential, the overhead of closure calculation is reduced. Experimental evaluation suggests that the cost of analysis can be substantially reduced by collapsing closures.

This paper presents an inversion of the abstract unification operator for forward set-sharing analysis of logic programs. The inverted operator, called a backward abstract unification operator, computes all maximal pre-conditions for a given equation and its post-condition. It is a key operator in a backward analysis. The maximal preconditions are obtained by first calculating a superset of all preconditions and then generating all maximal pre-conditions from the superset. The latter step is transformed to the problem of finding all maximal models of a Boolean formula.

This paper presents an abstract semantics that uses information about execution paths to improve precision of data flow analyses of logic programs. We illustrate the abstract semantics by abstracting execution paths using call strings of fixed length and the last transfer of control. Abstract domains that have been developed for logic program analyses can be used with the new abstract semantics without modification.

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.

This paper presents a new type analysis for logic programs. The type information in a set of substitutions is described by a disjunction of variable typings each of which maps a variable to a non-deterministic regular type. The use of non-deterministic regular types, set union and intersection operators, and disjunctions of variable typings makes the new type analysis more precise than those found in the literature. Experimental results on the performance of the new analysis are given together with comparable results from an existing type analysis. The fundamental problem of checking the emptiness of non-deterministic regular types is more complex in the new analysis. The experimental results, however, show that careful use of tabling reduces the effect to an average of 15% of execution time on a set of benchmarks.

This paper presents an abstract domain and an abstract unification function for type analysis 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. 1 Introduction Prolog is a type-free language. The programmer does not have to specify the types of variables, functions and predicates. This may make it simple to write simple programs. However, it also makes it difficult to debug programs because type errors cannot be detected by Prolog systems. A type error will manifest itself in the form of a wrong result or a missing result rather than an indication of a type violation. There have been many efforts to augment Prolog with type systems in the forms of type checking systems [2, 11, 27] and type analysis systems. Type analysis systems infer types from the text of a program. Some type analysis systems infer a type for the program and the type is meant to ...