PLEIAD research:software

research:software:ajp

Anonymous (anonymous@undisclosed.example.com) — 2008-11-28T17:46:04+00:00

AspectJ Plugin Introduction The AspectJ Plugin implements a subset of AspectJ based on SDF, Stratego, and Reflex. The main objective is to provide an extensible and lightweight implementation on AspectJ. The AspectJ plugin works by transforming AspectJ programs into pure-Java versions using the Reflex library. Due to the complex nature of this transformation (imagine obtaining syntactically correct Java code and the correct order for statements), the plugin defines a series of stages to str…

research:software:ambienttalk-ros

Anonymous (anonymous@undisclosed.example.com) — 2013-01-30T15:18:47+00:00

AmbientTalk/Ros The goal of AmbientTalk/Ros is to integrate a reactive version of AmbientTalk into ROS in a clean way. This such that it can be used as a ROS node for programming the behavior of the robot. Existing sensors and actuators (ROS nodes) are reified as Reactive Programming Behaviors and integrate into AmbientTalk in this way.

research:software:aspectmaps

Anonymous (anonymous@undisclosed.example.com) — 2013-09-04T22:16:24+00:00

---------- " " AspectMaps pages navigation: --- Introduction --- Documentation --- Downloads ---" " ---------- " " ---NEWS--- AspectMaps V2 is a port to Moose 4.8 and Roassal, and downloadable from SmalltalkHub. Go to the Downloads page to get it, play with the examples, and start visualizing

research:software:aspectmaps_documentation

Anonymous (anonymous@undisclosed.example.com) — 2013-09-04T22:10:29+00:00

---------- " " AspectMaps pages navigation: --- Introduction --- Documentation --- Downloads ---" " ---------- The introduction page provides a brief overview of how the AspectMaps visualization works, above the screenshot. For more complete written documentation, we refer to the

research:software:aspectmaps_downloads

Anonymous (anonymous@undisclosed.example.com) — 2013-09-04T22:14:05+00:00

---------- " " AspectMaps pages navigation: --- Introduction --- Documentation --- Downloads ---" " ---------- AspectMaps is implemented in Pharo Smalltalk, using the MOOSE platform for software and data analysis. The code is open source and available at SmalltalkHub under the MIT license (see bottom of this page), and is distributed with the tool itself.

research:software:aspectmaps_intro

Anonymous (anonymous@undisclosed.example.com) — 2011-11-10T19:37:53+00:00

Direct download link Here we give a brief introduction to AspectMaps, showing the main elements of the user interface and briefly talk about the example we use. Differences in this screencast with respect to AspectMaps 1.0 In this screencast the differences are mainly cosmetic:

research:software:aspectmaps_jp_shadows

Anonymous (anonymous@undisclosed.example.com) — 2011-11-10T19:40:16+00:00

Direct download link This screencast shows how AspectMaps visualizes join point shadows. Differences in this screencast with respect to AspectMaps 1.0 The same observations made for previous screencasts hold here as well. There is one more difference in that the popup for advice in a join point shadow has been changed from what is shown to make it more legible in AspectMaps 1.0

research:software:aspectmaps_struct_zoom

Anonymous (anonymous@undisclosed.example.com) — 2011-11-10T19:38:50+00:00

Direct download link This screencast is fully dedicated to explaining the structural zoom feature of aspectmaps. Differences in this screencast with respect to AspectMaps 1.0 AspectMaps 1.0 has some differences in how classes and aspects are displayed. However the core behavior of the structural zoom is unaffected. More in detail, this screencast differs from 1.0 in the following:

research:software:aspectmaps_ui

Anonymous (anonymous@undisclosed.example.com) — 2011-11-10T19:39:30+00:00

Direct download link This screencast shows the remainder parts of the AspectMaps UI in more detail. Differences in this screencast with respect to AspectMaps 1.0 In addition to the structural zoom differences detailed in the AspectMaps structural zoom, there are cosmetic changes, also mentioned in the

research:software:classboxes

Anonymous (anonymous@undisclosed.example.com) — 2008-03-25T16:27:33+00:00

Classboxes Introduction Classboxes are modules that restrict the visibility of changes to selected clients only, thereby offering more freedom in the way unanticipated changes may be implemented, and thus reducing the need for convoluted design anomalies.

research:software:effectiveaspects

Anonymous (anonymous@undisclosed.example.com) — 2014-03-03T16:08:38+00:00

Effective Aspects: A Typed Monadic Embedding of Pointcuts and Advice This is the main page for our research on pointcut/advice model of aspect-oriented programming (AOP) in monadic setting. We have developed a Haskell AOP library that provides the full pointcut/advice model of AOP into a monadic setting. Read below for further details.

research:software:effscript

Anonymous (anonymous@undisclosed.example.com) — 2015-08-19T14:02:27+00:00

EffScript: Practical Effects for Scala accepted at OOPSLA 2015 EffScript is a small domain-specific language for writing tailored effect disciplines for Scala. In addition to being customizable, the underlying effect system supports both effect polymorphism (as developed by Lukas Rytz in his PhD thesis) and gradual effect checking (following the theory of Bañados, Garcia and Tanter).

research:software:ghosts

Anonymous (anonymous@undisclosed.example.com) — 2011-10-27T15:17:53+00:00

The Sixth Sense: Programming with Ghosts Following programming best practices typically implies coding against classes and interfaces that are not (fully) defined yet. However, interactive development environments (IDEs) do not support such incremental development seamlessly: instead, they get in the way by reporting many error messages. Ignoring these messages prevents the programmer from getting otherwise useful feedback regarding actual inconsistencies and type errors. But attending to these…

research:software:gradual-unions

Anonymous (anonymous@undisclosed.example.com) — 2019-06-24T19:09:37+00:00

Gradual Unions: A Gradual Interpretation of Union Types See A Gradual Interpretation of Union Types (SAS 2017) Union types allow to capture the possibility of a term to be of several possibly unrelated types. Traditional static approaches to union types are untagged and tagged unions, which present dual advantages in their use. Inspired by recent work on using abstract interpretation to understand gradual typing, we present a novel design for union types, called gradual union types. Gradual un…

research:software:gradualtalk

Anonymous (anonymous@undisclosed.example.com) — 2014-06-11T15:21:28+00:00

A Practical Gradual Type System For Smalltalk Gradualtalk is a gradually-typed Smalltalk, which is fully compatible with existing Smalltalk code. Following the philosophy of Typed Racket, a major design goal of Gradualtalk is for the type system to accomodate existing programming idioms in order to allow for an easy, incremental path from untyped to typed code. The design of Gradualtalk was guided by a study of existing Smalltalk projects, and incrementally typing them in Gradualtalk.

research:software:grev

Anonymous (anonymous@undisclosed.example.com) — 2025-11-25T17:33:11+00:00

GrEv: Compiling Gradual Types with Evidence description github repo evaluation repo (submission)

research:software:gsf

Anonymous (anonymous@undisclosed.example.com) — 2018-10-18T16:58:26+00:00

GSF: Gradual System F GSF is a gradual counterpart of System F, ie. it is a core functional language with explicit polymorphism and gradual types. Crucially, GSF satisfies all the expected properties of a gradual parametric language such as type safety, the static gradual guarantee, and parametricity. We show in the paper that the dynamic gradual guarantee is incompatible with parametricity, and GSF favors parametricity. Nevertheless, GSF satisfies a weaker property of

research:software:haskellaop

Anonymous (anonymous@undisclosed.example.com) — 2013-06-14T16:32:35+00:00

This page has been moved to: effectiveaspects.

research:software:lrp

Anonymous (anonymous@undisclosed.example.com) — 2018-04-02T21:51:52+00:00

Live Robot Programming Live Robot Programming (LRP) is a live programming language designed for the creation of the behavior layer of robots. It is fundamentally a nested state machine language built with robotics applications in mind, but it is not bound to a specific robot middleware,

research:software:obsec

Anonymous (anonymous@undisclosed.example.com) — 2017-05-18T03:54:53+00:00

ObSec: Declassification policies using type abstraction ObSec is a simple object-oriented language that supports type-based declassification. ObSec was introduced in the paper This tutorial covers: * how to install a web interpreter (ObSec Pad) for the ObSec language.

research:software:old-ajp

Anonymous (anonymous@undisclosed.example.com) — 2008-11-28T17:37:06+00:00

Old AspectJ Plugin (by Leonardo Rodriguez) Introduction The AspectJ Plugin (AJP) translates an AspectJ program into a equivalent program in Reflex. The current version of the plugin is a proof of concept implementation, it supports a subset of the AspectJ language, mainly the dynamic crosscutting language. The implementation is based on the mapping presented

research:software:phantom

Anonymous (anonymous@undisclosed.example.com) — 2013-09-24T08:18:43+00:00

PHANtom PHANtom (PHaro Aspect laNguage) is a modern Aspect Language for Pharo Smalltalk. For more info, feel free to contact Johan NEWS: * We are starting work on a new version of PHANtom that will use the Opal compiler and/or the upcoming reflectivity framework.

research:software:pom

Anonymous (anonymous@undisclosed.example.com) — 2007-10-22T14:46:29+00:00

POM Introduction POM (Parallel Object Monitors) is a concurrency abstraction for the coordination of parallel activities over single objects and groups of objects in shared memory systems. It allows a clean separation of the coordination concern from the base application code.

research:software:reflex

Anonymous (anonymous@undisclosed.example.com) — 2012-10-26T17:11:27+00:00

Reflex Reflex: Multi-Language AOP for Java Reflex is a versatile kernel for multi-language AOP . This means that Reflex provides, in the context of Java, building blocks for facilitating the implementation of different aspect-oriented languages so that it is easier to experiment with new AOP concepts and languages, and also possible to compose aspects written in different AOP languages. It is built around a flexible intermediate model, derived from reflection, of (point)cuts, links, and meta…

research:software:reflexd

Anonymous (anonymous@undisclosed.example.com) — 2011-09-20T08:29:51+00:00

What is ReflexD? ReflexD is a versatile kernel for distributed AOP in Java. ReflexD is implemented as an extension of Reflex, making use of Reflex itself and Java RMI as a base for remote invocation. ReflexD allows distributed AOP providing means to specify:

research:software:relax

Anonymous (anonymous@undisclosed.example.com) — 2011-09-20T08:30:54+00:00

Introduction ReLAx is the implementation of the KALA domain-specific aspect language on top of Reflex. KALA is a domain-specific aspect language (DSAL) designed by Johan Fabry during his PhD thesis. KALA is specific to the domain of advanced transaction management

research:software:secdart

Anonymous (anonymous@undisclosed.example.com) — 2017-12-05T18:05:49+00:00

Gradual Security Typing in Dart This page will describe artifacts associated to SecDart which is an extension to the Dart programming language with gradual security typing. Installation instructions We will provide three ways to interact with the SecDart's security analysis (currently just the first one is available!):

research:software:som

Anonymous (anonymous@undisclosed.example.com) — 2007-10-22T14:47:29+00:00

SOM Introduction SOM (Sequential Object Monitors) is a model for concurrent programming based on a thread-less scheduler. SOM makes it easier to develop concurrent programs because: * SOM enforces a sequential view on multi-threaded program by ensuring individual methods are always run-to-completion, and

research:software:tod

Anonymous (anonymous@undisclosed.example.com) — 2007-10-22T15:02:52+00:00

TOD TOD is a tool that helps understand a program's behavior by recording a trace of the events that occur during execution (method calls, object creation, field access...) and letting the user navigate in predefined and custom views of this trace.