The SCG will host a full-day Moose Dojo on Tuesday March 4.
Software must be regularly updated to keep up with changing requirements. Unfortunately, to install an update, the system must usually be restarted, which is inconvenient and costly. In this dissertation, we aim at overcoming the need for restart by enabling run-time changes at the programming language level. We argue that the best way to achieve this goal is to improve the support for encapsulation, information hiding and late binding by contextualizing behavior. In our approach, behavioral variations are encapsulated into context objects that alter the behavior of other objects locally. We present three contextual language features that demonstrate our approach. First, we present a feature to evolve software by scoping variations to threads. This way, arbitrary objects can be substituted over time without compromising safety. Second, we present a variant of dynamic proxies that operate by delegation instead of forwarding. The proxies can be used as building blocks to implement contextualization mechanisms from within the language. Third, we contextualize the behavior of objects to intercept exchanges of references between objects. This approach scales information hiding from objects to aggregates. The three language features are supported by formalizations and case studies, showing their soundness and practicality. With these three complementary language features, developers can easily design applications that can accommodate run-time changes.
Simon Marti. A Platform for Second Language Acquisition Through Free Reading and Repetition. Bachelor’s thesis, University of Bern, August 2013. Details.
ZeeGuu monitors the progress of a learner and builds a model of what parts of the vocabulary are already mastered and what parts still need to be learned. The collected data is used to generate personalized exercises to repeat newly acquired knowledge and help retain it.
In Java, System Properties are global variables in disguise: every class can access them and modify their values. Thus, they suffer from the same pitfalls as global variables: it is difficult to reason about their usage, they can introduce hidden dependencies between classes, they can cause naming conflicts, etc. An analysis of several open-source Java systems revealed that System Properties are a common presence. Given the sheer size and complexity of these systems, manually reasoning about System Properties is no longer an option; tool support is required. To address these problems in this thesis we introduce the Property Investigator, a tool for understanding the usage of System Properties. The tool allows developers to identify all System Properties used within an application, inspect their values and determined from where these values were set. To make it accessible to developers we have integrated it into the Eclipse IDE.
This documentation describes the implementation of the Properties Investigator. It introduces the Java Platform Debugger Architecture (JPDA), looks at the Java Debug Interface (JDI) and then presents the two main components of the proposed tool, namely the Analyser and the Visualizer.