TL;DR: This paper illustrates how experimental research can be applied to technologies enabling enterprises to coordinate their business processes and to associate them with related artifacts and resources and discusses threats for the validity of the experimental results.

TL;DR: A feature algebra is presented that captures the key ideas of feature orientation and that provides a common ground for current and future research in this field, on which also alternative options can be explored.

TL;DR: How collaborative configuration can be described in terms of a workflow-like plan that safely guides stakeholders during the configuration process is discussed and a preliminary set of reasoning algorithms tailored to the feature modelling domain are proposed that can be used to provide automated support for product configuration.

TL;DR: It is observed that there is a simple linguistic characterization of the grammar ambiguity problem, and it is shown how to exploit this by presenting an ambiguity analysis framework based on conservative language approximations.

TL;DR: A new method for defining the meaning of tabular expressions using indexation to decouple the appearance of a tabular expression from its semantics and the use of the new model to build a suite of tools that faithfully implement the semantics is discussed.

TL;DR: The presented design and implementation of language support for lambda expressions in C++ is included in the draft specification of the forthcoming major revision of the ISO C++ standard, dubbed C++0x, and observed clear benefits, such as reduced code size and improved clarity.

TL;DR: This paper presents Churrasco, a tool to support collaborative software evolution analysis through a web interface and describes the tool and its architecture.

TL;DR: Key technical issues in the approach are discussed, including performance, the amount of code generated, correctness, and adaptability, in addition to a comparison of the proposal with existing alternative approaches.

TL;DR: This work uses a state machine based approach to robustness testing to detect the vulnerabilities of a component under unexpected inputs or in a stressful environment and applies this approach to several components, including open source software, and compares the results with existing approaches.

TL;DR: This work describes a more natural style of programming that yields code that is impervious to injections by construction, and can be applied with relative ease to any combination of context-free host and guest languages.

TL;DR: An experimental ambiguity detection tool for GNU Bison is presented, and it is illustrated how it can assist a grammatical development for a subset of Standard ML.

TL;DR: This paper proposes a process for mining early aspects, i.e. identifying crosscutting concerns at the requirements level, based on a crosscutting pattern where two different domains are related.

TL;DR: A key observation of this work is that type equivalence of instantiated nominally typed generics in C++ (as well as other languages, e.g., Java) is structural rather than nominal, which makes it possible to embed the structural type system, characteristic to persistent data management, in the nominal type system of C++.

TL;DR: A modified worst-case cubic GLR algorithm is given, that, for any string and any CFG, returns a binarised SPPF representation of all possible derivations of a given string.

TL;DR: It is shown that downward and upward simulations in the blocking interpretation, where domains are ''guards'', are not jointly complete, which contradicts earlier claims in the literature.

TL;DR: The Cadena Architecture Language with Meta-modeling (CALM) is presented - that uses multi-level type systems to specify and enforce a variety of architectural constraints relevant to the development of large-scale component-based systems.

TL;DR: This paper demonstrates that a well known algorithm, described by David Pager and implemented in Menhir, does not always achieve the full power of canonical LR( 1) when the given grammar is non-LR(1) coupled with a specification for resolving conflicts, and demonstrates the relevance of this deficiency for several real-world parser specifications.

TL;DR: The Intensional Views Environment (IntensiVE), presented in this article, is a tool suite for specifying relevant structural regularities in an (object-oriented) software system and verifying them against the current and later versions of the system.

TL;DR: A multi-player semantics for constraint automata is presented which serves to reason about controllability, interaction and cooperation facilities of individual components or coalitions of components in a given network.

TL;DR: A novel encryption scheme is presented that allows tuple matching on completely encrypted tuples and can be guaranteed even when the data space is deployed on malicious hosts (or an adversary gains access to the host).

TL;DR: An architectural model to guide the formal specification of concurrent fault-tolerant systems and provides built-inCommunicating Sequential Processes and predefined channels to coordinate exception handling of the user-defined components.

TL;DR: The approach introduced in this paper resorts to slicing techniques to extract coordination data from source code to recover a coordination model either in the form of an Orc specification or as a collection of code fragments corresponding to the identification of typical coordination patterns in the system.

TL;DR: A new space of abstractions for pointer analysis-an important component of static analysis for C and similar languages is proposed, and experimental results show the flow-aware abstraction for statement ordering both runs faster and produces more precise results than traditional flow-insensitive analysis.

TL;DR: This work proposes a novel event algebra with intuitive operators and presents an efficient detection algorithm that correctly detects any expression with bounded memory, which makes this algebra particularly suitable for resource-constrained applications such as embedded systems.

TL;DR: This paper focuses on the problem of automating the process of building translators between operations languages, a family of DSLs used to program satellite operations procedures, and exploits their similarities to semi-automatically build transformation tools between these DSLs.

TL;DR: This work introduces a set of high-level strategies for specifying locality of aspect propagation and activation, and shows that, given some extensions to their original execution model, scoping strategies are directly applicable to the expressive scoping of distributed aspects.

TL;DR: This work presents the rationale, design, implementation, performance, programming guidelines, and experiences of working with a language feature, called open multi-methods, for C++, and describes a model implementation that is simpler to use, catches more user mistakes, and resolves more ambiguities through link-time analysis.

TL;DR: Some of the methods used in the FermaT transformation system for analysing and migrating assembler systems are described, to combine a simple dynamic slice, computed with virtually no overhead, and a static slice implemented using program transformation technology, to generate very concise high-level descriptions of the sliced code.

TL;DR: This work proposes some conformance notions to predict the precise nature of some forms of composition, considering coordination patterns used in the integration of components, and illustrates the application through a systematic composition strategy of software frameworks, and mechanically verify the preservation of behavioural component properties in these compositions.