Skip to main content
    • Aa
    • Aa

Acute: High-level programming language design for distributed computation


Existing languages provide good support for typeful programming of stand-alone programs. In a distributed system, however, there may be interaction between multiple instances of many distinct programs, sharing some (but not necessarily all) of their module structure, and with some instances rebuilt with new versions of certain modules as time goes on. In this paper, we discuss programming-language support for such systems, focussing on their typing and naming issues. We describe an experimental language, Acute, which extends an ML core to support distributed development, deployment, and execution, allowing type-safe interaction between separately built programs. The main features are (1) type-safe marshalling of arbitrary values; (2) type names that are generated (freshly and by hashing) to ensure that type equality tests suffice to protect the invariants of abstract types, across the entire distributed system; (3) expression-level names generated to ensure that name equality tests suffice for type safety of associated values, for example, values carried on named channels; (4) controlled dynamic rebinding of marshalled values to local resources; and (5) thunkification of threads and mutexes to support computation mobility. These features are a large part of what is needed for typeful distributed programming. They are a relatively lightweight extension of ML, should be efficiently implementable, and are expressive enough to enable a wide variety of distributed infrastructure layers to be written as simple library code above the byte-string network and persistent store APIs. This disentangles the language run-time from communication intricacies. This paper highlights the main design choices in Acute. It is supported by a full language definition (of typing, compilation, and operational semantics), by a prototype implementation, and by example distribution libraries.

Linked references
Hide All

This list contains references from the content that can be linked to their source. For a full set of references and notes please see the PDF or HTML where available.

A. Buckley , M. Murray , S. Eisenbach & S. Drossopoulou (2005) Flexible bytecode for linking in .NET. Electr. Notes Theor. Comput. Sci., 141 (1), 7592.

L. Cardelli (1995) A language with distributed scope. In Proc. 22nd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Language (POPL), San Francisco, California, ACM Press, pp. 286297.

S. Drossopoulou S. Eisenbach & D. Wragg (1999) A fragment calculus — towards a model of separate compilation, linking and binary compatibility. In Proc. 14th IEEE Symp. on Logic in Computer Science (LICS). IEEE Computer Society Press, pp. 147156.

D. Grossman , G. Morrisett & S. Zdancewic (2000) Syntactic type abstraction. ACM TOPLAS 22 (6), 10371080.

R. Harper & M. Lillibridge (1994) A type-theoretic approach to higher-order modules with sharing. In Proc. 21st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL). Portland, OR: ACM Press, pp. 123137.

A. Heydon , R. Levin , T. Mann & Y. Yu (2006) Software Configuration Management Using Vesta. New York: Springer-Verlag.

X. Leroy (1994) Manifest types, modules, and separate compilation. In Proc. 21st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL). ACM Press, pp. 109122.

M. Odersky , C. Zenger & M. Zenger (2001) Colored local type inference. ACM SIGPLAN Notices 36 (3), 4153.

A. Ohori & K. Kato (1993) Semantics for communication primitives in a polymorphic language. In Proc. 20th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL). ACM Press, pp. 99112.

J. H. Reppy (1999) Concurrent programming in ML. Cambridge, UK: Cambridge University Press.

T. Sekiguchi & A. Yonezawa (1997) A calculus with code mobility. In Proc. 2nd IFIP TC6 WG6.1 International Conference on Formal Methods for Open Object-based Distributed Systems (FMOODS). Chapman and Hall, pp. 2136.

P. Sewell (2001) Modules, abstract types, and distributed versioning. In Proc. 28th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL). ACM Press, pp. 236247.

A. Unyapoth & P. Sewell (2001). Nomadic Pict: Correct communication infrastructure for mobile computation. Proc. 28th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL). ACM Press, pp. 116127.

Recommend this journal

Email your librarian or administrator to recommend adding this journal to your organisation's collection.

Journal of Functional Programming
  • ISSN: 0956-7968
  • EISSN: 1469-7653
  • URL: /core/journals/journal-of-functional-programming
Please enter your name
Please enter a valid email address
Who would you like to send this to? *


Full text views

Total number of HTML views: 0
Total number of PDF views: 9 *
Loading metrics...

Abstract views

Total abstract views: 149 *
Loading metrics...

* Views captured on Cambridge Core between September 2016 - 23rd September 2017. This data will be updated every 24 hours.