Applying the reactive programming paradigm: Toward a more declarative application development approach

After almost 10 years from “The Free Lunch Is Over” article, where the need to parallelize programs started to be a real and mainstream issue, a lot of stuffs did happened: • Processor manufacturers are reaching the physical limits with most of their approaches to boosting CPU performance, and are instead turning to hyperthreading and multicore architectures; • Applications are increasingly need to support concurrency; • Programming languages and systems are increasingly forced to deal well with concurrency. This thesis is an attempt to propose an overview of a paradigm that aims to properly abstract the problem of propagating data changes: Reactive Programming (RP). This paradigm proposes an asynchronous non-blocking approach to concurrency and computations, abstracting from the low-level concurrency mechanisms.

Analisi del film L'appartamento spagnolo: multilinguismo e comunicazione interculturale

The present research study focuses on intercultural communication and how its dynamics are portrayed in the Italian version of the movie L’appartamento spagnolo (original title: L’auberge espagnol) by Cédric Klapisch. The first chapter introduces the movie in all its main features, such as plot, setting, characters, languages, main themes, and sequels. The second chapter focuses on the dynamics of intercultural communication through the analysis of the most representative scenes of the movie. It is worth noting that the notion of intercultural communication comprises a lot of different kinds of communication, meaning not only communication among people coming from different countries and speaking a different language, but also among different generations, people with different social backgrounds, with a different social status, etc. However, language is indeed crucial to mutual understanding and it plays a fundamental role in communication. For this reason, the third chapter focuses on the multilingual dimension of the movie, since the issue of intercultural communication is also conveyed through a variety of languages. The aim is to analyze the different strategies used in the Italian dubbed version in order to manage the presence of different languages and to examine how such strategies affect the overall consistency of the dialogues and the effect achieved on the audience.

La comunicazione aziendale tra redazione e traduzione: Il caso di ipack srl.

This dissertation is the result of my participation in the Language Toolkit project, a recent collaboration between the Chamber of Commerce of Forlì and the School of Foreign Languages and Literatures, Interpreting and Translation at the University of Bologna, which aims to make students meet with the companies of our territory, in this case Ipack, based in Mercato Saraceno (FC). My dissertation is a specialized translation work from Italian into English of two documents that were entrusted to me: the declaration of compliance of Ipack’s products and a summary of the quality manual. They are two high technical texts and, therefore, the translation task required a preliminary phase of research on the topics and on the terminology of this specific domain. The dissertation consists of five chapters. The first chapter briefly introduces the company with which I collaborated for my dissertation project and provides an overview of business communication and a brief classification of Ipack’s communication tools. The second chapter covers the background topics, namely food packaging and quality management systems within companies. The third chapter concerns the analysis of the two texts, describing the intra-textual and extra-textual aspects, as well as the morphosyntaxical and lexical features. The fourth chapter is dedicated to the revision work on one of the two texts, the one about quality procedures. In the commentary following my review, I explain the methodology and the strategies that I used and I also provide some extended examples of the main changes applied to the original text, with respect to both content and linguistic features. Finally, the fifth chapter focuses on the translation of the texts followed by a commentary that explains the work methodology, resources and my translation choices, accompanied by practical examples.

Pinocchio: Bringing Reflection to Life with First-Class Interpreters

To support development tools like debuggers, runtime systems need to provide a meta-programming interface to alter their semantics and access internal data. Reflective capabilities are typically fixed by the Virtual Machine (VM). Unanticipated reflective features must either be simulated by complex program transformations, or they require the development of a specially tailored VM. We propose a novel approach to behavioral reflection that eliminates the barrier between applications and the VM by manipulating an explicit tower of first-class interpreters. Pinocchio is a proof-of-concept implementation of our approach which enables radical changes to the interpretation of programs by explicitly instantiating subclasses of the base interpreter. We illustrate the design of Pinocchio through non-trivial examples that extend runtime semantics to support debugging, parallel debugging, and back-in-time object-flow debugging. Although performance is not yet addressed, we also discuss numerous opportunities for optimization, which we believe will lead to a practical approach to behavioral reflection.

Modeling Features at Runtime

A feature represents a functional requirement fulfilled by a system. Since many maintenance tasks are expressed in terms of features, it is important to establish the correspondence between a feature and its implementation in source code. Traditional approaches to establish this correspondence exercise features to generate a trace of runtime events, which is then processed by post-mortem analysis. These approaches typically generate large amounts of data to analyze. Due to their static nature, these approaches do not support incremental and interactive analysis of features. We propose a radically different approach called live feature analysis, which provides a model at runtime of features. Our approach analyzes features on a running system and also makes it possible to grow feature representations by exercising different scenarios of the same feature, and identifies execution elements even to the sub-method level. We describe how live feature analysis is implemented effectively by annotating structural representations of code based on abstract syntax trees. We illustrate our live analysis with a case study where we achieve a more complete feature representation by exercising and merging variants of feature behavior and demonstrate the efficiency or our technique with benchmarks.

Domain-Specific Program Checking

Lint-like program checkers are popular tools that ensure code quality by verifying compliance with best practices for a particular programming language. The proliferation of internal domain-specific languages and models, however, poses new challenges for such tools. Traditional program checkers produce many false positives and fail to accurately check constraints, best practices, common errors, possible optimizations and portability issues particular to domain-specific languages. We advocate the use of dedicated rules to check domain-specific practices. We demonstrate the implementation of domain-specific rules, the automatic fixing of violations, and their application to two case-studies: (1) Seaside defines several internal DSLs through a creative use of the syntax of the host language; and (2) Magritte adds meta-descriptions to existing code by means of special methods. Our empirical validation demonstrates that domain-specific program checking significantly improves code quality when compared with general purpose program checking.

Run-Time Evolution through Explicit Meta-Objects

Software must be constantly adapted due to evolving domain knowledge and unanticipated requirements changes. To adapt a system at run-time we need to reflect on its structure and its behavior. Object-oriented languages introduced reflection to deal with this issue, however, no reflective approach up to now has tried to provide a unified solution to both structural and behavioral reflection. This paper describes Albedo, a unified approach to structural and behavioral reflection. Albedo is a model of fined-grained unanticipated dynamic structural and behavioral adaptation. Instead of providing reflective capabilities as an external mechanism we integrate them deeply in the environment. We show how explicit meta-objects allow us to provide a range of reflective features and thereby evolve both application models and environments at run-time.