10,341 research outputs found
Abstract Diagnosis for Timed Concurrent Constraint programs
The Timed Concurrent Constraint Language (tccp in short) is a concurrent
logic language based on the simple but powerful concurrent constraint paradigm
of Saraswat. In this paradigm, the notion of store-as-value is replaced by the
notion of store-as-constraint, which introduces some differences w.r.t. other
approaches to concurrency. In this paper, we provide a general framework for
the debugging of tccp programs. To this end, we first present a new compact,
bottom-up semantics for the language that is well suited for debugging and
verification purposes in the context of reactive systems. We also provide an
abstract semantics that allows us to effectively implement debugging algorithms
based on abstract interpretation. Given a tccp program and a behavior
specification, our debugging approach automatically detects whether the program
satisfies the specification. This differs from other semiautomatic approaches
to debugging and avoids the need to provide symptoms in advance. We show the
efficacy of our approach by introducing two illustrative examples. We choose a
specific abstract domain and show how we can detect that a program is
erroneous.Comment: 16 page
Open Programming Language Interpreters
Context: This paper presents the concept of open programming language
interpreters and the implementation of a framework-level metaobject protocol
(MOP) to support them. Inquiry: We address the problem of dynamic interpreter
adaptation to tailor the interpreter's behavior on the task to be solved and to
introduce new features to fulfill unforeseen requirements. Many languages
provide a MOP that to some degree supports reflection. However, MOPs are
typically language-specific, their reflective functionality is often
restricted, and the adaptation and application logic are often mixed which
hardens the understanding and maintenance of the source code. Our system
overcomes these limitations. Approach: We designed and implemented a system to
support open programming language interpreters. The prototype implementation is
integrated in the Neverlang framework. The system exposes the structure,
behavior and the runtime state of any Neverlang-based interpreter with the
ability to modify it. Knowledge: Our system provides a complete control over
interpreter's structure, behavior and its runtime state. The approach is
applicable to every Neverlang-based interpreter. Adaptation code can
potentially be reused across different language implementations. Grounding:
Having a prototype implementation we focused on feasibility evaluation. The
paper shows that our approach well addresses problems commonly found in the
research literature. We have a demonstrative video and examples that illustrate
our approach on dynamic software adaptation, aspect-oriented programming,
debugging and context-aware interpreters. Importance: To our knowledge, our
paper presents the first reflective approach targeting a general framework for
language development. Our system provides full reflective support for free to
any Neverlang-based interpreter. We are not aware of any prior application of
open implementations to programming language interpreters in the sense defined
in this paper. Rather than substituting other approaches, we believe our system
can be used as a complementary technique in situations where other approaches
present serious limitations
Hidden Action, Identification, and Organization Design
Incentives often fail in inducing economic agents to engage in a desirable activity; implementability is restricted. What restricts implementability? When does re-organization help to overcome this restriction? This paper shows that any restriction of implementability is caused by an identification problem. It also describes organizations that can solve this identification problem and provides conditions under which such organisations exist. Applying the findings to established and new moral hazard models yields insights into optimal organization design, uncovers the reason why certain organization designs, such as advocacy or specialization, overcome restricted implementability, and formalizes a wide-spread type of multi-tasking problem.moral hazard, hidden action, implementation, multi-tasking, identification by organization design
Debugging Scandal: The Next Generation
In 1997, the general lack of debugging tools was termed "the debugging scandal". Today, as new languages are emerging to support software evolution, once more debugging support is lagging. The powerful abstractions offered by new languages are compiled away and transformed into complex synthetic structures. Current debugging tools only allow inspection in terms of this complex synthetic structure; they do not support observation of program executions in terms of the original development abstractions. In this position paper, we outline this problem and present two emerging lines of research that ease the burden for debugger implementers and enable developers to debug in terms of development abstractions. For both approaches we identify language-independent debugger components and those that must be implemented for every new language. One approach restores the abstractions by a tool external to the program. The other maintains the abstractions by using a dedicated execution environment, supporting the relevant abstractions. Both approaches have the potential of improving debugging support for new languages. We discuss the advantages and disadvantages of both approaches, outline a combination thereof and also discuss open challenges
- …