Towards a Decoupled Context-Oriented Programming Language for the Internet of Things

Easily programming behaviors is one major issue of a large and reconfigurable deployment in the Internet of Things. Such kind of devices often requires to externalize part of their behavior such as the sensing, the data aggregation or the code offloading. Most existing context-oriented programming languages integrate in the same class or close layers the whole behavior. We propose to abstract and separate the context tracking from the decision process, and to use event-based handlers to interconnect them. We keep a very easy declarative and non-layered programming model. We illustrate by defining an extension to Golo-a JVM-based dynamic language

Semiautomatic generation of CORBA interfaces for databases in molecular biology

The amount and complexity of genome related data is growing quickly. This highly interrelated data is distributed at many different sites, stored in numerous different formats, and maintained by independent data providers. CORBA, the industry standard for distributed computing, offers the opportunity to make implementation differences and distribution transparent and thereby helps to combine disparate data sources and application programs. In this thesis, the different aspects of CORBA access to molecular biology data are examined in detail. The work is motivated by a concrete application for distributed genome maps. Then, the different design issues relevant to the implementation of CORBA access layers are surveyed and evaluated. The most important of these issues is the question of how to represent data in a CORBA environment using the interface definition language IDL. Different representations have different advantages and disadvantages and the best representation is highly application specific. It is therefore in general impossible to generate a CORBA wrapper automatically for a given database. On the other hand, coding a server for each application manually is tedious and error prone. Therefore, a method is presented for the semiautomatic generation of CORBA wrappers for relational databases. A declarative language is described, which is used to specify the mapping between relations and IDL constructs. Using a set of such mapping rules, a CORBA server can be generated automatically. Additionally, the declarative mapping language allows for the support of ad-hoc queries, which are based on the IDL definitions

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

Synthesis of Model Transformations from Metamodels and Examples

Model transformations are central elements of model-driven engineering (MDE). However, model transformation development requires a high level of expertise in particular model transformation languages, and model transformation specifications are often difficult to manually construct, due to the lack of tool support, and the dependencies involved in transformation rules.In this thesis, we describe techniques for automatically or semi-automatically synthesising transformations from metamodels and examples, in order to reduce model transformation development costs and time, and improve model transformation quality.We proposed two approaches for synthesising transformations from metamodels. The first approach is the Data Structure Similarity Approach, an exhaustive metamodel matching approach, which extracts correspondences between metamodels by only focusing on the type of features. The other approach is the Search-based Optimisation Approach, which uses an optimisation algorithm to extract correspondences from metamodels by data structure similarity, name syntax similarity, and name semantic similarity. The correspondence patterns between the classes and features of two metamodels are extracted by either of these two methods. To enable the production of specifications in multiple model transformation languages from correspondences, we introduced an intermediate language which uses a simplified transformation notation to express transformation specifications in a language-independent manner, and defined the mapping rules from this intermediate language to different transformation languages.We also investigated Model Transformation by Examples Approach. We used machine learning techniques to learn model transformation rules from datasets of examples, so that the trained model could generate target model from source model directly.We evaluated our approaches on a range of cases of different kinds of transformation, and compared the model transformation accuracy and quality of our versions to the previously-developed manual versions of these cases.Key words: model transformation, model-driven engineering, transformation syn-thesis, metamodel matching, model transformation by example

Model Transformation Languages with Modular Information Hiding

Model transformations, together with models, form the principal artifacts in model-driven software development. Industrial practitioners report that transformations on larger models quickly get sufficiently large and complex themselves. To alleviate entailed maintenance efforts, this thesis presents a modularity concept with explicit interfaces, complemented by software visualization and clustering techniques. All three approaches are tailored to the specific needs of the transformation domain