122 research outputs found
Recovering Grammar Relationships for the Java Language Specification
Grammar convergence is a method that helps discovering relationships between
different grammars of the same language or different language versions. The key
element of the method is the operational, transformation-based representation
of those relationships. Given input grammars for convergence, they are
transformed until they are structurally equal. The transformations are composed
from primitive operators; properties of these operators and the composed chains
provide quantitative and qualitative insight into the relationships between the
grammars at hand. We describe a refined method for grammar convergence, and we
use it in a major study, where we recover the relationships between all the
grammars that occur in the different versions of the Java Language
Specification (JLS). The relationships are represented as grammar
transformation chains that capture all accidental or intended differences
between the JLS grammars. This method is mechanized and driven by nominal and
structural differences between pairs of grammars that are subject to
asymmetric, binary convergence steps. We present the underlying operator suite
for grammar transformation in detail, and we illustrate the suite with many
examples of transformations on the JLS grammars. We also describe the
extraction effort, which was needed to make the JLS grammars amenable to
automated processing. We include substantial metadata about the convergence
process for the JLS so that the effort becomes reproducible and transparent
Scrap your boilerplate with object algebras
International audienceTraversing complex Abstract Syntax Trees (ASTs) typically requires large amounts of tedious boilerplate code. For many operations most of the code simply walks the structure, and only a small portion of the code implements the functional- ity that motivated the traversal in the first place. This paper presents a type-safe Java framework called Shy that removes much of this boilerplate code. In Shy Object Algebras are used to describe complex and extensible AST structures. Using Java annotations Shy generates generic boilerplate code for various types of traversals. For a concrete traversal, users of Shy can then inherit from the generated code and over- ride only the interesting cases. Consequently, the amount of code that users need to write is significantly smaller. Moreover, traversals using the Shy framework are also much more structure shy, becoming more adaptive to future changes or extensions to the AST structure. To prove the effectiveness of the approach, we applied Shy in the implementation of a domain-specific questionnaire language. Our results show that for a large number of traversals there was a significant reduction in the amount of user-defined code
Design patterns and pspects : modular designs with seamless run-time integration
Some solutions proposed in the original design pattern literature were shaped by techniques as well as language deficiencies from object-oriented software development. However, new modularity constructs, composition and transformation mechanisms offered by aspect-oriented programming address deficiencies of object-oriented modeling. This suggests classical design pattern solutions to be revisited. In our paper we point out that aspect-oriented programming not only allows for alternative representations of proposed solutions, but also for better solutions in the first place. We advocate a native aspect-oriented approach to design patterns that emphasizes on improving design pattern solutions both during development and at run-time. We use a simple yet effective method to analyze and describe different solutions on the basis of variation points, fixed parts, variable parts, and optional glue, employing dynamic run-time weaving
Seamless Variability Management With the Virtual Platform
Customization is a general trend in software engineering, demanding systems
that support variable stakeholder requirements. Two opposing strategies are
commonly used to create variants: software clone & own and software
configuration with an integrated platform. Organizations often start with the
former, which is cheap, agile, and supports quick innovation, but does not
scale. The latter scales by establishing an integrated platform that shares
software assets between variants, but requires high up-front investments or
risky migration processes. So, could we have a method that allows an easy
transition or even combine the benefits of both strategies? We propose a method
and tool that supports a truly incremental development of variant-rich systems,
exploiting a spectrum between both opposing strategies. We design, formalize,
and prototype the variability-management framework virtual platform. It bridges
clone & own and platform-oriented development. Relying on
programming-language-independent conceptual structures representing software
assets, it offers operators for engineering and evolving a system, comprising:
traditional, asset-oriented operators and novel, feature-oriented operators for
incrementally adopting concepts of an integrated platform. The operators record
meta-data that is exploited by other operators to support the transition. Among
others, they eliminate expensive feature-location effort or the need to trace
clones. Our evaluation simulates the evolution of a real-world, clone-based
system, measuring its costs and benefits.Comment: 13 pages, 10 figures; accepted for publication at the 43rd
International Conference on Software Engineering (ICSE 2021), main technical
trac
"Last-Mile" preparation for a potential disaster
Extreme natural events, like e.g. tsunamis or earthquakes, regularly lead to catastrophes with dramatic consequences. In recent years natural disasters caused hundreds of thousands of deaths, destruction of infrastructure, disruption of economic activity and loss of billions of dollars worth of property and thus revealed considerable deficits hindering their effective management: Needs for stakeholders, decision-makers as well as for persons concerned include systematic risk identification and evaluation, a way to assess countermeasures, awareness raising and decision support systems to be employed before, during and after crisis situations. The overall goal of this study focuses on interdisciplinary integration of various scientific disciplines to contribute to a tsunami early warning information system. In comparison to most studies our focus is on high-end geometric and thematic analysis to meet the requirements of small-scale, heterogeneous and complex coastal urban systems. Data, methods and results from engineering, remote sensing and social sciences are interlinked and provide comprehensive information for disaster risk assessment, management and reduction. In detail, we combine inundation modeling, urban morphology analysis, population assessment, socio-economic analysis of the population and evacuation modeling. The interdisciplinary results eventually lead to recommendations for mitigation strategies in the fields of spatial planning or coping capacity
Integration testing of heterotic systems
Computational theory and practice generally focus on single-paradigm systems, but relatively little is known about how best to combine components based on radically different approaches (e.g. silicon chips and wetware) into a single coherent system. In particular, while testing strategies for single-technology artefacts are generally well developed, it is unclear at present how to perform integration testing on heterotic systems: can we develop a test-set generation strategy for checking whether specified behaviours emerge (and unwanted behaviours do not) when components based on radically different technologies are combined within a single system? In this paper, we describe an approach to modelling multi-technology heterotic systems using a general-purpose formal specification strategy based on Eilenberg's X-machine model of computation. We show how this approach can be used to represent disparate technologies within a single framework, and propose a strategy for using these formal models for automatic heterotic test-set generation. We illustrate our approach by showing how to derive a test set for a heterotic system combining an X-machine-based device with a cell-based P system (membrane system)
A two-species continuum model for aeolian sand transport
Starting from the physics on the grain scale, we develop a simple continuum
description of aeolian sand transport. Beyond popular mean-field models, but
without sacrificing their computational efficiency, it accounts for both
dominant grain populations, hopping (or "saltating") and creeping (or
"reptating") grains. The predicted stationary sand transport rate is in
excellent agreement with wind tunnel experiments simulating wind conditions
ranging from the onset of saltation to storms. Our closed set of equations thus
provides an analytically tractable, numerically precise, and computationally
efficient starting point for applications addressing a wealth of phenomena from
dune formation to dust emission.Comment: 23 pages, 9 figure
Generic Model Refactorings
Many modeling languages share some common concepts and principles. For example, Java, MOF, and UML share some aspects of the concepts\ud
of classes, methods, attributes, and inheritance. However, model\ud
transformations such as refactorings specified for a given language\ud
cannot be readily reused for another language because their related\ud
metamodels may be structurally different. Our aim is to enable a\ud
flexible reuse of model transformations across various metamodels.\ud
Thus, in this paper, we present an approach allowing the specification\ud
of generic model transformations, in particular refactorings, so\ud
that they can be applied to different metamodels. Our approach relies\ud
on two mechanisms: (1) an adaptation based mainly on the weaving\ud
of aspects; (2) the notion of model typing, an extension of object\ud
typing in the model-oriented context. We validated our approach by\ud
performing some experiments that consisted of specifying three well\ud
known refactorings (Encapsulate Field, Move Method, and Pull Up Method)\ud
and applying each of them onto three different metamodels (Java,\ud
MOF, and UML)
- …