Abstract
This paper presents the concept of pluggable parallelisation that allows scientists to develop "sequential like" codes that can take advantage of multi-core, cluster and grid systems. In this approach parallel applications are developed by plugging parallelisation patterns/idioms into scientific codes (e.g., "sequential like" codes), softening the move from sequential to parallel programming and promoting the separation between domain specific code and parallelisation issues. Pluggable parallelisation combines three characteristics: 1) parallelisation is performed from "outside to inside", localising parallelisation concerns into well defined modules, reducing changes required to the domain specific code and avoiding invasive parallelisation of base code; 2) control view is separated from data view promoting a stronger separation of concerns which improves reuse of parallelisation concerns across platforms and enables fine-grained refinements; and 3) abstractions can be composed, supporting the development of more complex patterns based on fine-grained features. This paper presents the concept of pluggable parallelisation and shows how some well-known parallelisation strategies can be implemented in this approach. Results show that this is a feasible approach and performance is competitive with traditional parallel programming. Copyright 2009 ACM.

Abstract
This paper presents an aspect-oriented library to support parallelization of Java applications for distributed memory environments, using a message-passing approach. The library was implemented using AspectJ language, and aims to provide a set of mechanisms to make easier to parallelize applications, as well as to solve well known problems of parallelization, such as lack of modularity and reusability. We compare the advantages of this method over the traditional approach, and we discuss differences to recent approaches that address the same problem. Results show benefits over other approaches, and, in most of cases, a competitive performance. © 2012 ACM.

Abstract
A classical approach to program derivation is to progressively extend a simple specification and then incrementally refine it to an implementation. We claim this approach is hard or impractical when reverse engineering legacy software architectures. We present a case study that shows optimizations and pushouts-in addition to refinements and extensions-are essential for practical stepwise development of complex software architectures. Copyright 2012 ACM.

Abstract
This paper presents a framework that allows plugging or unplugging grid-related features to legacy code. Those features can, for example, transform sequential-like code to a parallel version or even a distributed version. With this approach scientists could develop their code as they are used to, that is, they could spent their time programming as they are used to instead of learning new programming paradigms. The framework relies on aspect-oriented programming (AOP) techniques to perform non-invasive enhancements to scientific applications to cope with grid specific issues, such as remote execution, load distribution, fault tolerance and monitoring. In addition, framework components are glued together with AOP, making possible to plug (only) features required for each specific application / target platform.