Sven Kloppenburg

Learn More
Dependencies between program elements need to be modeled from different perspectives reflecting architectural, design, and implementation level decisions. To avoid erosion of the intended structure of the code, it is necessary to explicitly codify these different perspectives on the permitted dependencies and to detect violations continuously and(More)
We study the problem of detecting general global predicates in distributed systems where all application processes and at most t < m monitor processes may be subject to crash faults, where m is the total number of monitor processes in the system. We introduce two new observation modalities called negotiably and discernibly (which correspond to possibly and(More)
A fundamental problem in testing and analysis of distributed systems is detecting whether the global state of a system satisses some predicate throughout a computation. There exist some well-developed methods for detecting predicates in fault-free systems (e.g., the predicate transformers possibly and deenitely of Cooper, Marzullo and Neiger), but for(More)
Implementing static analyses of machine-level executable code is labor intensive and complex. We show how to leverage model-driven engineering to facilitate the design and implementation of programs doing static analyses. Further, we report on important lessons learned on the benefits and drawbacks while using the following technologies: using the Scala(More)
To improve the productivity of the development process, more and more tools for static software analysis are tightly integrated into the incremental build process of an IDE. If multiple interdependent analyses are used simultaneously, the coordination between the analyses becomes a major obstacle to keep the set of analyses open. We propose an approach to(More)
Modern development environments integrate various static analyses into the build process. But, analyses that analyze the whole project whenever the project changes are impractical in this context. We present an approach to automatic incrementalization of analyses that are specified as tabled logic programs and evaluated using incremental tabled evaluation,(More)
To support developers in their day–to–day work, Integrated Develoment Environments (IDEs) incorporate more and more ways to help developers focus on the inherent complexities of developing increasingly larger software systems. The complexity of developing large software systems can be categorized [24] into inherent complexity that stems from the complexity(More)
  • 1