Model-Based Adaptation of Software Communicating via FIFO Buffers

Software Adaptation is a non-intrusive solution for composing black-box components or services (peers) whose individual functionality is as required for the new system, but that present interface mismatch, which leads to deadlock or other undesirable behaviour when combined. Adaptation techniques aim at automatically generating new components called adapters. All the interactions among peers pass through the adapter, which acts as an orchestrator and makes the involved peers work correctly together by compensating for mismatch. Most of the existing solutions in this field assume that peers interact synchronously using rendezvous communication. However, many application areas rely on asynchronous communication models where peers interact exchanging messages via buffers. Generating adapters in this context becomes a difficult problem because peers may exhibit cyclic behaviour, and their composition often results in infinite systems. In this paper, we present a method for automatically generating adapters in asynchronous environments where peers interact using FIFO buffers.Universidad de Málaga. Campus de Excelencia Internacional Andalucía Tech

A heuristic-based approach to code-smell detection

Encapsulation and data hiding are central tenets of the object oriented paradigm. Deciding what data and behaviour to form into a class and where to draw the line between its public and private details can make the difference between a class that is an understandable, flexible and reusable abstraction and one which is not. This decision is a difficult one and may easily result in poor encapsulation which can then have serious implications for a number of system qualities. It is often hard to identify such encapsulation problems within large software systems until they cause a maintenance problem (which is usually too late) and attempting to perform such analysis manually can also be tedious and error prone. Two of the common encapsulation problems that can arise as a consequence of this decomposition process are data classes and god classes. Typically, these two problems occur together – data classes are lacking in functionality that has typically been sucked into an over-complicated and domineering god class. This paper describes the architecture of a tool which automatically detects data and god classes that has been developed as a plug-in for the Eclipse IDE. The technique has been evaluated in a controlled study on two large open source systems which compare the tool results to similar work by Marinescu, who employs a metrics-based approach to detecting such features. The study provides some valuable insights into the strengths and weaknesses of the two approache

Automated Workarounds from Java Program Specifications based on SAT Solving

The failures that bugs in software lead to can sometimes be bypassed by the so-called workarounds: when a (faulty) routine fails, alternative routines that the system offers can be used in place of the failing one, to circumvent the failure. Existing approaches to workaround-based system recovery consider workarounds that are produced from equivalent method sequences, automatically computed from user-provided abstract models, or directly produced from user-provided equivalent sequences of operations. In this paper, we present two techniques for computing workarounds from Java code equipped with formal specifications, that improve previous approaches in two respects. First, the particular state where the failure originated is actively involved in computing workarounds, thus leading to repairs that are more state specific. Second, our techniques automatically compute workarounds on concrete program state characterizations, avoiding abstract software models and user-provided equivalences. The first technique uses SAT solving to compute a sequence of methods that is equivalent to a failing method on a specific failing state, but which can also be generalized to schemas for workaround reuse. The second technique directly exploits SAT to circumvent a failing method, building a state that mimics the (correct) behaviour of a failing routine, from a specific program state too. We perform an experimental evaluation based on case studies involving implementations of collections and a library for date arithmetic, showing that the techniques can effectively compute workarounds from complex contracts in an important number of cases, in time that makes them feasible to be used for run-time repairs. Our results also show that our state-specific workarounds enable us to produce repairs in many cases where previous workaround-based approaches are inapplicable.Fil: Uva, Marcelo Ariel. Universidad Nacional de Río Cuarto; ArgentinaFil: Ponzio, Pablo Daniel. Consejo Nacional de Investigaciones Científicas y Técnicas. Centro Científico Tecnológico Conicet - Córdoba; Argentina. Universidad Nacional de Río Cuarto; ArgentinaFil: Regis, Germán. Universidad Nacional de Río Cuarto; ArgentinaFil: Aguirre, Nazareno Matias. Consejo Nacional de Investigaciones Científicas y Técnicas. Centro Científico Tecnológico Conicet - Córdoba; Argentina. Universidad Nacional de Río Cuarto; ArgentinaFil: Frias, Marcelo Fabian. Consejo Nacional de Investigaciones Científicas y Técnicas. Centro Científico Tecnológico Conicet - Córdoba; Argentina. Instituto Tecnológico de Buenos Aires; Argentin

Your Proof Fails? Testing Helps to Find the Reason

Applying deductive verification to formally prove that a program respects its formal specification is a very complex and time-consuming task due in particular to the lack of feedback in case of proof failures. Along with a non-compliance between the code and its specification (due to an error in at least one of them), possible reasons of a proof failure include a missing or too weak specification for a called function or a loop, and lack of time or simply incapacity of the prover to finish a particular proof. This work proposes a new methodology where test generation helps to identify the reason of a proof failure and to exhibit a counter-example clearly illustrating the issue. We describe how to transform an annotated C program into C code suitable for testing and illustrate the benefits of the method on comprehensive examples. The method has been implemented in STADY, a plugin of the software analysis platform FRAMA-C. Initial experiments show that detecting non-compliances and contract weaknesses allows to precisely diagnose most proof failures.Comment: 11 pages, 10 figure

Taking stock of structural funds implementation : current challenges and future opportunities

This paper highlights several themes which have informed programme management since IQ-Net meeting in June 2002, held in Lulea, Sweden. First, it provides an overview of the main development in programme implementation and the financial execution of programmes, including an exploration of the risks of automatic decommitment faced by the programmes. Second, it describes the progress made with the mid-term evaluations, following on the IQ-Net thematic paper on this subject presented at the Lulea conference. Third, it presents an overview of the current EU-level debate on simplification, highlighting the views of the network's partners as well as, where available, the member state

Stranded Costs, Takings, and the Law and Economics of Implicit Contracts

This paper explores ways in which economic analysis can help resolve the stranded cost controversy that has arisen in debates over electricity market deregulation. "Stranded costs" are costs electric utilities will not recover as power markets move from protected monopolies to an open, competitive environment. The paper begins with a description of the stranded cost problem, its magnitude, and the prominent arguments for and against recovery. We then turn to an analysis of contracts in order to understand whether there is, or should be, a legal duty to compensate utility shareholders for unrecovered costs. The paper also argues that efficient approaches to electricity deregulation will rely on more than an analysis of contracts. In particular, the politics of deregulation should be viewed as an independent constraint that affects the desirability of alternative approaches to stranded costs.

Components Interoperability through Mediating Connector Patterns

A key objective for ubiquitous environments is to enable system interoperability between system's components that are highly heterogeneous. In particular, the challenge is to embed in the system architecture the necessary support to cope with behavioral diversity in order to allow components to coordinate and communicate. The continuously evolving environment further asks for an automated and on-the-fly approach. In this paper we present the design building blocks for the dynamic and on-the-fly interoperability between heterogeneous components. Specifically, we describe an Architectural Pattern called Mediating Connector, that is the key enabler for communication. In addition, we present a set of Basic Mediator Patterns, that describe the basic mismatches which can occur when components try to interact, and their corresponding solutions.Comment: In Proceedings WCSI 2010, arXiv:1010.233

The "Regulatory Compact" and Implicit Contracts: Should Stranded Costs Be Recoverable?

Progress toward electricity market deregulation has brought controversy over whether or not utilities are entitled to compensation for "stranded costs," i.e., costs utilities will not be able to recover due to the advent of competition in their markets. This paper uses a legal and economic analysis of contracts to address the desirability of utility cost recovery. First, underlying principles of law are reviewed to determine whether or not there is a legal presumption of recovery. Then, the analysis considers whether or not an implicit "regulatory compact" between utilities and regulators follows from principles in the economic analysis of law, particularly theories of efficient breach and implicit contracts. The paper concludes that recovery should occur in only a proscribed set of circumstances and that, when called for, compensation should be partial, rather than full.

Understanding smart contracts as a new option in transaction cost economics

Among different concepts associated with the term blockchain, smart contracts have been a prominent one, especially popularized by the Ethereum platform. In this study, we unpack this concept within the framework of Transaction Cost Economics (TCE). This institutional economics theory emphasizes the role of distinctive (private and public) contract law regimes in shaping firm boundaries. We propose that widespread adoption of the smart contract concept creates a new option in public contracting, which may give rise to a smart-contract-augmented contract law regime. We discuss tradeoffs involved in the attractiveness of the smart contract concept for firms and the resulting potential for change in firm boundaries. Based on our new conceptualization, we discuss potential roles the three branches of government – judicial, executive, and legislative – in enabling and using this new contract law regime. We conclude the paper by pointing out limitations of the TCE perspective and suggesting future research directions