Capsule-Oriented Programming

“Explicit concurrency should be abolished from all higher-level programming languages (i.e. everything except - perhaps- plain machine code.).” Dijkstra [1] (paraphrased). A promising class of concurrency abstractions replaces explicit concurrency mechanisms with a single linguistic mechanism that combines state and control and uses asynchronous messages for communications, e.g. active objects or actors, but that doesn't remove the hurdle of understanding non-local control transfer. What if the programming model enabled programmers to simply do what they do best, that is, to describe a system in terms of its modular structure and write sequential code to implement the operations of those modules and handles details of concurrency? In a recently sponsored NSF project we are developing such a model that we call capsule-oriented programming and its realization in the Panini project. This model favors modularity over explicit concurrency, encourages concurrency correctness by construction, and exploits modular structure of programs to expose implicit concurrency.

[1]  Henri E. Bal,et al.  Programming languages for distributed computing systems , 1989, CSUR.

[2]  Hridesh Rajan,et al.  An Automatic Actors to Threads Mapping Technique for JVM-Based Actor Frameworks , 2014, AGERE! '14.

[3]  Douglas C. Schmidt,et al.  Active object: an object behavioral pattern for concurrent programming , 1996 .

[4]  Leslie Lamport,et al.  How to Make a Multiprocessor Computer That Correctly Executes Multiprocess Programs , 2016, IEEE Transactions on Computers.

[5]  Robin Milner,et al.  Definition of standard ML , 1990 .

[6]  Klaus-Peter Löhr,et al.  Object-Oriented Concurrent Programming , 1992, TOOLS.

[7]  Katherine Yelick,et al.  Introduction to UPC and Language Specification , 2000 .

[8]  Martin Odersky,et al.  Capabilities for Uniqueness and Borrowing , 2010, ECOOP.

[9]  Kun-Lung Wu,et al.  CAPSULE: language and system support for efficient state sharing in distributed stream processing systems , 2012, DEBS.

[10]  Dennis G. Kafura,et al.  Garbage collection of actors , 1990, OOPSLA/ECOOP '90.

[11]  Vivek Sarkar,et al.  Habanero-Java: the new adventures of old X10 , 2011, PPPJ.

[12]  Hridesh Rajan,et al.  Concurrency by modularity: design patterns, a case in point , 2010, OOPSLA.

[13]  Monica S. Lam,et al.  The design, implementation, and evaluation of Jade , 1998, TOPL.

[14]  Laurie Hendren,et al.  Soot: a Java bytecode optimization framework , 2010, CASCON.

[15]  Samik Basu,et al.  Behavioral automata composition for automatic topology independent verification of parameterized systems , 2009, ESEC/FSE '09.

[16]  Michael Papathomas,et al.  Concurrency in object-oriented programming languages , 1995 .

[17]  Martin C. Rinard,et al.  Commutativity analysis: a new analysis technique for parallelizing compilers , 1997, TOPL.

[18]  Jayadev Misra,et al.  A Simple, Object-Based View of Multiprogramming , 2002, Formal Methods Syst. Des..

[19]  Doug Lea,et al.  Concurrent Programming In Java , 1996 .

[20]  Katherine A. Yelick,et al.  Titanium: A High-performance Java Dialect , 1998, Concurr. Pract. Exp..

[21]  Peter Sommerlad,et al.  Pattern-Oriented Software Architecture , 1996 .

[22]  Oscar Nierstrasz,et al.  Active objects in hybrid , 1987, OOPSLA '87.

[23]  Hridesh Rajan,et al.  Capsule-oriented Programming in the Panini Language , 2014 .

[24]  Carl Hewitt,et al.  Concurrent Programming Using Actors: Exploiting large-Scale Parallelism , 1985, FSTTCS.

[25]  Jan Vitek,et al.  Flexible Alias Protection , 1998, ECOOP.

[26]  Edsger W. Dijkstra,et al.  Letters to the editor: go to statement considered harmful , 1968, CACM.

[27]  Keshav Pingali,et al.  Optimistic parallelism requires abstractions , 2007, PLDI '07.

[28]  Anoop Gupta,et al.  COOL: An object-based language for parallel programming , 1994, Computer.

[29]  Bruce D. Shriver,et al.  Research Directions in Object-Oriented Programming , 1987 .

[30]  Samik Basu,et al.  Automating Cut-off for Multi-parameterized Systems , 2010, ICFEM.

[31]  Arnd Poetzsch-Heffter,et al.  JCoBox: Generalizing Active Objects to Concurrent Components , 2010, ECOOP.

[32]  Theo D'Hondt,et al.  Ambient-oriented programming in ambientTalk , 2005, OOPSLA '05.

[33]  Haoqiang Jin,et al.  Implementation of the NAS Parallel Benchmarks in Java , 2000 .

[34]  L.A. Smith,et al.  A Parallel Java Grande Benchmark Suite , 2001, ACM/IEEE SC 2001 Conference (SC'01).

[35]  Lieven Eeckhout,et al.  Statistically rigorous java performance evaluation , 2007, OOPSLA.

[36]  Barbara Liskov,et al.  Guardians and Actions: Linguistic Support for Robust, Distributed Programs , 1983, TOPL.

[37]  James Noble,et al.  Ownership types for flexible alias protection , 1998, OOPSLA '98.

[38]  Philip Levis,et al.  The nesC language: a holistic approach to networked embedded systems , 2003, SIGP.

[39]  Hridesh Rajan,et al.  Implicit invocation meets safe, implicit concurrency , 2010, GPCE '10.

[40]  Matteo Frigo,et al.  The implementation of the Cilk-5 multithreaded language , 1998, PLDI.

[41]  Hridesh Rajan,et al.  Panini: a concurrent programming model for solving pervasive and oblivious interference , 2015, MODULARITY.

[42]  D. L. Parnas,et al.  On the criteria to be used in decomposing systems into modules , 1972, Software Pioneers.

[43]  C. A. R. Hoare,et al.  Communicating sequential processes , 1978, CACM.

[44]  Jens Palsberg,et al.  Encapsulating objects with confined types , 2001, TOPL.

[45]  Gul A. Agha,et al.  ACTORS - a model of concurrent computation in distributed systems , 1985, MIT Press series in artificial intelligence.

[46]  Sally Fincher,et al.  Computer Science Curricula 2013 , 2013 .

[47]  David E. Culler,et al.  The nesC language: A holistic approach to networked embedded systems , 2003, PLDI.

[48]  Bran Selic,et al.  Real-time object-oriented modeling , 1994, Wiley professional computing.

[49]  Joe Armstrong,et al.  Concurrent programming in ERLANG , 1993 .

[50]  SahamiMehran Computer science curricula 2013 (CS2013) , 2015 .

[51]  Polyvios Pratikakis,et al.  Transparent proxies for java futures , 2004, OOPSLA.

[52]  Einar Broch Johnsen,et al.  Minimal Ownership for Active Objects , 2008, APLAS.

[53]  Martin Odersky,et al.  Scala Actors: Unifying thread-based and event-based programming , 2009, Theor. Comput. Sci..

[54]  Katherine Yelick,et al.  Titanium: a high-performance Java dialect , 1998 .

[55]  Hridesh Rajan,et al.  Building scalable software systems in the multicore era , 2010, FoSER '10.

[56]  Vivek Sarkar,et al.  X10: an object-oriented approach to non-uniform cluster computing , 2005, OOPSLA '05.

[57]  Gary T. Leavens,et al.  Ptolemy: A Language with Quantified, Typed Events , 2008, ECOOP.