Electronic Communications of the EASST (European Association of Software Science and Technology)
Not a member yet
887 research outputs found
Sort by
Challenging the Need for Transparency, Controllability, and Consistency in Usable Adaptation Design
Get PDFAdaptive applications constitute the basis for many ubiquitous computing scenarios as they can dynamically adapt to changing contexts. The usability design principles transparency, controllability, and consistency have been recommended for the design of adaptive interfaces. However, designing self-adaptive applications that may act completely autonomous is still a challenging task because there is no set of usability design guidelines. Applying the three principles in the design of the five different adaptations of the mobile adaptive application Meet-U revealed as difficult. Based on an analysis of the design problem space, we elaborate an approach for the design of usable adaptations. Our approach is based on a notification design concept which calculates the attention costs and utility benefits of notified adaptations by varying the design aspects transparency and controllability. We present several designs for the adaptations of Meet‑U. The results of a user study shows that the notification design approach is beneficial for the design of adaptations. Varying transparency and controllability is necessary to adjust an adaptation’s design to the particular context of use. This leads to a partially inconsistent design for adaptations within an application
The VSE Refinement Method in Hets
Get PDFWe present the integration of the refinement method of the VSE verification tool, successfully used in industrial applications, in the Heterogeneous Tool Set Hets. The connection is done via introducing the dynamic logic underlying VSE and two logic translations in the logic graph of Hets. Thus the proof management formalism provided by Hets can be applied for VSE specifications without modification of the logic independent layers of Hets
ModGraph meets Xcore: Combining Rule-Based and Procedural Behavioral Modeling for EMF
Get PDFModel-driven software engineering aims at increasing productivity bydeveloping high-level executable models. The Eclipse Modeling Framework (EMF)significantly contributes toward this goal. Unfortunately, EMF supports only structural models based on the Ecore metamodel. Recently, Xcore has been developed to extend EMF with behavioral modeling. To this end, Xcore provides a single textual language for both structural and behavioral modeling. While Xcore follows a procedural approach to behavioral modeling, ModGraph is an EMF-based tool based on a rule-based paradigm (graph transformation rules, which allow to specify behavior in a declarative way). The combination of EMF, Xcore, and ModGraph results in an environment for model-driven software engineering which provides full-fledged support for both structural and behavioral modeling. Altogether, we obtain an environment in which software engineers are concerned only with models rather than with programs
Annotations on Complex Patterns
Get PDFModelers of systems often want to isolate specific parts of a model to be treated as a whole, for example to protect them from accidental changes,to constrain them to specific policies, or to identify them as instances of a general pattern. In particular, we study here the case in which these parts are annotated with information from some external model.In a previous paper, we have discussed the use of annotations on individual model elements, represented as nodes in a graph; in this paper we model annotation processes involving also annotations themselves or whole configurations.To address the latter problem, we enrich the notion of graph by introducing a third sort of elements, called boxes, encompassing subgraphs, and associate them with annotations, too. We show how annotations on boxes support the modeling of complex policies,adapting the previous constructions for notation-aware rewriting to include boxes.The paper illustrates these concepts on the concrete modeling scenario of an organisation with security and temporal annotations
Co-Transformation of Type and Instance Graphs Supporting Merging of Types and Retyping
Get PDFAlgebraic graph transformation is a well-known rule-based approach to manipulate graphs that can be applied in several contexts. In this paper we use it in the context of model-driven engineering. Graph transformation rules usually specify changes to only one graph per application, however there are use cases such as model co-evolution where not only a single graph should be manipulated but also related ones. The co-transformation of type graphs together with their instance graphs has shown to be a promising approach to formalize model and meta-model co-evolution. In this paper, we extend our earlier work on co-evolution by allowing transformation rules that have less restrictions so that graph manipulations such as merging of types and retyping of graph elements are allowed
An Approach for Model Querying-by-Example Applied to Multi- Paradigm Models
Get PDFScenarios for industry-scale multi-paradigm modelling involve analysis,transformation, or fine-grained manipulation of models. These models are often treatedwholly or in part as trees (e.g. XML or XMI documents, or source code). However,existing facilities for accessing and manipulating models as trees is limited. We present anovel approach to model querying-by-example, treating models as trees. The approachabstracts away from platform-specific concerns (e.g. XML), and exploits tree-basedpatterns in expressing queries; the results of queries are also trees, thus providing meansto compose (conjoin) queries without requiring intermediate manipulations
Learning and Activity Patterns in OSS Communities and their Impact on Software Quality
Get PDFThis paper presents a framework to identify and analyse learning and activity patterns that characterise participation and collaboration of individuals in Open Source Software (OSS) communities. It first describes how participants’ activities enable and drive a learning process that occurs in individual participants as well as in the OSS project community as a whole. It then explores how to identify and analyse learning patterns at both individual level and community level. The objective of such analysis is to determine the impact of these patterns on the quality of the OSS product and define a descriptive approach to quality that is concerned less with standards than with the facts of OSS peer-review and peer-production
Proving Linearizability of Multiset with Local Proof Obligations
Get PDFLinearizability is a key correctness criterion for concurrent software.In our previous work, we introduced local proof obligations, which, by showing a refinement between an abstract specification and its implementation, imply linearizability of the implementation. The refinement is shown via a thread local backward simulation, which reduces the complexity of a backward simulation to an execution of two symbolic threads. In this paper, we present a correctness proof by applying those proof obligations to a lock-based implementation of a multiset. It is interesting for two reasons: First, one of its operations inserts two elements non-atomically. To show that it linearizes, we have to find one point, where the multiset is changed instantaneously, which is a counter-intuitive task. Second, another operation has non-fixed linearization points, i.e. the linearization points cannot be statically fixed, because the operation’s linearization may depend on other processes’ execution. This is a typical case to use backward simulation, where we could apply our thread local variant of it. All proofs were mechanized in the theorem prover KIV
Test-Case Generation for SQL Nested Queries with Existential Conditions
Get PDFThis paper presents a test-case generator for SQL queries.Starting with a set of related SQL views that can include existential subqueries in the conditions,the technique finds a database instance that can be used as a test-case for the target view.The proposal reduces the problem of generating the test-cases to a Constraint Satisfaction Problem using finite domain constraints. In particular, we present a new approach for existential conditions that makes possible to find test-cases for a wider set of queries. The soundness and correctness of the technique with respect to a simple operational semantics for SQL queries without aggregates is proven. The theoretical ideas have been implemented in an available prototype