The PBnJ tool let you mingle imperative java code and declarative statements (aka specifications) in the same place. This allows developers to write robust and resilient code that automatically “fall-backs” to its intended behavior when things go wrong. For example, when exceptions are thrown or unexpected conditions prevent the program to terminate correctly.
At the current status, the PBnJ tool provides only a manual and console-based interface, but lacks full support at the IDE level.
IDEs implement features such as code completion, code suggestion, syntax checks, and syntax highlighting that improve developers’ productivity and quality of java code.
The Eclipse platform is the “de-facto” standard when it comes to IDE, and it has extensibility core concept: by implementing small plugins the IDE can offer additional features to the programmers. Therefore, we choose Eclipse as our target platform for this project.
The project consists in the design and implementation of a plug-in that enables IDE support for the PBnJ tool.
This job fits nicely into a Praktikum or a Bachelor thesis; nevertheless, it might become a by-product of a regular Master Thesis.
Applicants are required to have good Java programming skills and a basic understanding of the Eclipse platform, and will be advised during the project.
Contact me if you are interested
 Falling Back on Executable Specifications
Dynamically adaptive systems (DAS) may change their inner business logic, software architecture, or quality of service as a reaction to changes in the environment or user requirements. DAS can also self-manage, that is, monitor their own behavior and plan suitable adaptations to achieve high level goals that are specified by their designers.
In many cases, the variables monitored by such systems are aggregated according to some specific operator. For example, their are averaged over a sliding window.
However, if systems can adapt while monitoring this variable they may introduce distortions that eventually will result in degraded performance of the system, or even critical failures.
Elastic applications are internally implemented by combining an adaptive application and an elasticity controller. The controller is usually build by making assumptions on the environment, and as long as these assumptions hold the behavior of the controller is predictable. In reality, situations may arise that invalidate these assumptions. For example, the incoming workload oscillates more frequently and with different intensity than the expectation.
Elastic computing systems can be described via models that capture their elastic nature.
We seek a way to derive elasticity models using a data-driven and iterative approach: We run experiments to collect data about the behavior of elastic computing systems under different execution conditions, we elaborate on these data to build systems elasticity models, we evaluate the models to find flaws or potential improvement, and we define new experiments to be run. We repeat this process to refine our initial models in an incremental fashion.
Developing high quality elastic computing systems is not an easy job. Specific tools and well tailored development methodologies are at the basis of development processes that result in software with a good quality.
We are investigating new development methodologies and tools that focus on elastic computing systems and are specifically designed for the Cloud.