We propose to search for common abstractions for different concurrency models to enable high-level language virtual machines to support a wide range of different concurrency models. Such extended concurrency support would enable domain-specific solutions for the concurrency problem. Furthermore, advanced knowledge about concurrency in the VM model will most likely lead to better implementation opportunities on top of the different upcoming many-core architectures.

The idea is to investigate the concepts of encapsulation and locality to this end. Thus, we are going to experiment with different language abstractions for concurrency on top of a virtual machine, which supports encapsulation and locality, to see how language designers could benefit, and how virtual machines could optimize programs using these concepts.

A single web page in a complex web application has a huge number of possible runtime states. Therefore functions, like JavaScript event handlers, that operate on such pages are extremely difficult to write correctly. I propose DynXML, a new language for the web which safely and naturally mutates XML trees. Any dynamic web application written in DynXML is statically guaranteed to be free of structural defects — code that transforms the page in a way that is unexpected by other code or relies on an element of the page that is of the wrong type or does not exist. I specified DynXML formally and proved it sound. I intend to show its expressiveness by implementing several web application design patterns and a subsection of a popular JavaScript framework. I will collect and categorize bugs from public web applications to validate the importance of structural defects.

Features in Software Product Lines are often implemented using mechanisms like preprocessors. Virtual Separation of Concerns was introduced as a way to reduce drawbacks of implementing product line variability with preprocessors. Developers can focus on certain features and hide others of no interest. However, these features eventually share elements among them, which might break feature modularity, since modifications in a feature result in problems for another. In this thesis we propose the concept of emergent feature modularization. It establishes contracts among features to prevent the developer from breaking other features, when performing a maintenance task. We also propose a tool that implements the concept. We evaluate our work by using metrics to analyze the gains with respect to modularity. Later, an experiment should be conducted to better evaluate the work.

Making assertions about program's control flow is important for reasoning purposes. Base modules obliviousness to aspects in Aspect-Oriented languages like AspectJ makes it difficult to make such assertions in a modular manner. Base-aspect interfaces like crosscutting interfaces (XPIs) with blackbox behavioral contracts, although save modularity of reasoning process to some extent, are not expressive enough to specify base-aspect control interactions in their full generality. Translucid contracts are proposed to enable specification/enforcement of typical control flow properties.

With the rapid development of model-driven engineering (MDE), domain-specific modeling is becoming a popular software development technique. In MDE, a metamodel represents a schema definition of the syntax and static semantics in a similar manner to how a grammar defines a programming language. In most cases, a schema undergoes evolution resulting in problems like failure of applying existing instances. The research described in this paper makes a contribution toward metamodel driven evolution.

Capturing knowledge is one of the main activities of software developers. Recorded knowledge assumes the form of software artifacts, of multiple types, but all may be seen at two different levels (information and structure), which are difficult to change independently from each other. This research work aims at exploring how the expression of software knowledge using adaptive software techniques will support the creation of adaptive software artifacts, which will improve the effectiveness of capturing knowledge under evolution.

To assess the results of such approach, we intend to use quasiexperiments and case-studies, both with exploratory and confirmatory purposes.

Some very preliminary work already exists on the context of the Weaki Wiki, which will be taken further. We will develop an environment supporting the creation and evolution of software artifacts beyond their initial structure, and validate the approach in academic and industrial settings.

Abstract: Dynamic tainting is a powerful technique that has been used to detect computer attacks, generate test cases, analyze data scopes, and protect memory. However, existing tainting techniques suffer from excessive runtime overheads that can be as high as 30 to 50 times, making them unsuitable for application in deployed systems as a way to perform runtime verification. The goal of our work is to provide an efficient and low-overhead tainting framework that can be used in deployed environments.

To accomplish this goal, we propose to implement a framework that supports dynamic tainting as a feature of a Java Virtual Machine (JVM). In this approach, the tainting code can be injected and then optimized by the dynamic compiler inside the JVM; as such it can work without needing the source code. It can also support customizable and configurable tainting. Our framework turns the tainting component on and off according to the runtime information gathered and maintained by the JVM or program analysis. The overhead of tainting can be controlled by sampling and different tainting granularity. For example, the framework can taint all the data as needed when the workload is low. It can also taint only a subset of interesting data to reduce the overhead. Ultimately, we envision that our proposed framework will be instrumental in various dynamic monitoring methodologies including runtime verification.

Keywords Tainting, Java Virtual Machine