Change search
CiteExportLink to record
Permanent link

Direct link
Cite
Citation style
  • apa
  • harvard1
  • ieee
  • modern-language-association-8th-edition
  • vancouver
  • Other style
More styles
Language
  • de-DE
  • en-GB
  • en-US
  • fi-FI
  • nn-NO
  • nn-NB
  • sv-SE
  • Other locale
More languages
Output format
  • html
  • text
  • asciidoc
  • rtf
The design philosophy of distributed programming systems: the Mozart experience
KTH, School of Information and Communication Technology (ICT), Electronic, Computer and Software Systems, ECS.
2005 (English)Doctoral thesis, comprehensive summary (Other academic)
Abstract [en]

Distributed programming is usually considered both difficult and inherently different from concurrent centralized programming. It is thought that the distributed programming systems that we ultimately deploy, in the future, when we've worked out all the details, will require a very different programming model and will even need to be evaluated by new criteria.

The Mozart Programming System, described in this thesis, demonstrates that this need not be the case. It is shown that, with a good system design, distributed programming can be seen as an extended form of concurrent programming. This is from the programmer's point-of-view; under the hood the design and implementation will necessarily be more complex. We relate the Mozart system with the classical transparencies of distributed systems. We show that some of these are inherently on the application level, while as Mozart demonstrates, others can and should be dealt with on the language/system level.

The extensions to the programming model, given the right concurrent programming base, are mainly concerned with non-functional properties of programs. The models and tuning facilities for failure and performance need to take latency, bandwidth, and partial failure into account. Other than that there need not be any difference between concurrent programming and distributed programming.

The Mozart Programming System is based on the concurrent programming language Oz, which integrates, in a coherent way, all three known concurrency or thread-interaction models. These are message-passing (like Erlang), shared objects (like Java with threads) and shared data-flow variables. The Mozart design philosophy is thus applicable over the entire range of concurrent programming languages/systems. We have extracted from the experience with Mozart a number of principles and properties that are applicable to the design and implementation of all (general-purpose) distributed programming systems.

The full range of the design and implementation issues behind Mozart are presented. This includes a description of the consistency protocols that make transparency possible for the full language, including distributed objects and distributed data-flow variables.

Mozart is extensively compared with other approaches to distributed programming, in general, and to other language-based distributed programming systems, in particular

Place, publisher, year, edition, pages
Stockholm: KTH , 2005. , 347 p.
Series
Trita-IMIT. LECS, ISSN 1651-4076 ; 05:04
Keyword [sv]
Informationsteknik
National Category
Computer and Information Science
Identifiers
URN: urn:nbn:se:kth:diva-232OAI: oai:DiVA.org:kth-232DiVA: diva2:7989
Public defence
2005-06-03, Sal C1, KTH-Electrum, Kista, 13:00
Opponent
Supervisors
Note
QC 20100928Available from: 2005-05-30 Created: 2005-05-30 Last updated: 2010-09-28Bibliographically approved
List of papers
1. Programming languages for distributed applications
Open this publication in new window or tab >>Programming languages for distributed applications
1998 (English)In: New generation computing, ISSN 0288-3635, E-ISSN 1882-7055, Vol. 16, no 3, 223-261 p.Article in journal (Refereed) Published
Abstract [en]

Much progress has been made in distributed computing in the areas of distribution structure, open computing, fault tolerance, and security. Yet, writing distributed applications remains difficult because the programmer has to manage models of these areas explicitly. A major challenge is to integrate the four models into a coherent development platform. Such a platform should make it possible to cleanly separate an application's functionality from the other four concerns. Concurrent constraint programming, an evolution of concurrent logic programming, has both the expressiveness and the formal foundation needed to attempt this integration. As a first step, we have designed and built a platform that separates an application's functionality from its distribution structure. We have prototyped several collaborative tools with this platform, including a shared graphic editor whose design is presented in detail. The platform efficiently implements Distributed Oz, which extends the Oz language with constructs to express the distribution structure and with basic primitives for open computing, failure detection and handling, and resource control. Oz appears to the programmer as a concurrent object-oriented language with dataflow synchronization. Oz is based on a higher-order, state-aware, concurrent constraint computation model.

Keyword
network transparency, fault tolerance, mobile objects, distributed algorithms, Oz
National Category
Computer and Information Science
Identifiers
urn:nbn:se:kth:diva-24871 (URN)000074486800001 ()
Note
QC 20100928Available from: 2010-09-28 Created: 2010-09-28 Last updated: 2017-12-12Bibliographically approved
2. Mobile objects in distributed Oz
Open this publication in new window or tab >>Mobile objects in distributed Oz
Show others...
1997 (English)In: ACM Transactions on Programming Languages and Systems, ISSN 0164-0925, E-ISSN 1558-4593, Vol. 19, no 5, 804-851 p.Article in journal (Refereed) Published
Abstract [en]

Some of the most difficult questions to answer when designing a distributed application are related to mobility: what information to transfer between sites and when and how to transfer it. Network-transparent distribution, the property that a program's behavior is independent of how it is partitioned among sites, does not directly address these questions. Therefore we propose to extend all language entities with a network behavior that enables efficient distributed programming by giving the programmer a simple and predictable control over network communication patterns. In particular, we show how to give objects an arbitrary mobility behavior that is independent of the object's definition. In this way, the syntax and semantics of objects are the same regardless of whether they are used as stationary servers, mobile agents, or simply as caches, These ideas have been implemented in Distributed Oz, a concurrent object-oriented language that is state aware and has dataflow synchronization. We prove that the implementation of objects in Distributed Oz, is network transparent. To satisfy the predictability condition, the implementation avoids forwarding chains through intermediate sites. The implementation is an extension to the publicly available DFKI Oz 2.0 system.

Keyword
latency tolerance, mobile objects, network transparency
National Category
Computer and Information Science
Identifiers
urn:nbn:se:kth:diva-24872 (URN)A1997YH37800005 ()
Note
QC 20100928Available from: 2010-09-28 Created: 2010-09-28 Last updated: 2017-12-12Bibliographically approved
3. Efficient logic variables for distributed computing
Open this publication in new window or tab >>Efficient logic variables for distributed computing
Show others...
1999 (English)In: ACM Transactions on Programming Languages and Systems, ISSN 0164-0925, E-ISSN 1558-4593, Vol. 21, no 3, 569-626 p.Article in journal (Refereed) Published
Abstract [en]

We define a practical algorithm for distributed rational tree unification and prove its correctness in both the off-line and on-line cases. We derive the distributed algorithm from a centralized one, showing clearly the trade-offs between local and distributed execution. The algorithm is used to realize logic variables in the Mozart Programming System, which implements the Oz language (see http://www.mozart-oz.org). Oz appears to the programmer as a concurrent object-oriented language with dataflow synchronization Logic variables implement the dataflow behavior. We show that logic variables can easily be added to the more restricted models of Java and ML, thus providing an alternative way to do concurrent programming in these languages. We present common distributed programming idioms in a network-transparent way using logic variables. We show that in common cases the algorithm maintains the same message latency as explicit message passing. In addition, it is able to handle uncommon cases that arise from the properties of latency tolerance and third-party independence. This is evidence that using logic variables in distributed computing is beneficial at both the system and language levels. At the system level, they improve latency tolerance and third-party independence. At the language level, they help make network-transparent distribution practical.

Keyword
algorithms, languages, theory, distributed algorithms, Oz, Mozart
National Category
Computer and Information Science
Identifiers
urn:nbn:se:kth:diva-24876 (URN)000083593400005 ()
Note
QC 20100928Available from: 2010-09-28 Created: 2010-09-28 Last updated: 2017-12-12Bibliographically approved
4. A fault-tolerant mobile-state protocol and its language interface
Open this publication in new window or tab >>A fault-tolerant mobile-state protocol and its language interface
(English)Manuscript (preprint) (Other academic)
Abstract [en]

Mobile-state protocols are important for distributed object systems. We define a lightweight mobile-state protocol that has a well-defined behavior for site and network failures. The protocol is implemented as part of the Mozart platform for distributed application development based on the Oz 2 language. The protocol provides enough information to the language layer so that we can use the platform to program common fault-tolerant algorithms completely in Oz 2. We formally define the semantics of the network layer and the language interface, and we prove that the protocol correctly implements the language interface.

National Category
Computer and Information Science
Identifiers
urn:nbn:se:kth:diva-24877 (URN)
Note
QC 20100928Available from: 2010-09-28 Created: 2010-09-28 Last updated: 2010-09-28Bibliographically approved

Open Access in DiVA

fulltext(1514 kB)2255 downloads
File information
File name FULLTEXT01.pdfFile size 1514 kBChecksum MD5
cbf2f73e3aed955e247b994eebb39c1fd97224234e3208bd908eddd908d86651b571b19a
Type fulltextMimetype application/pdf

Search in DiVA

By author/editor
Brand, Per
By organisation
Electronic, Computer and Software Systems, ECS
Computer and Information Science

Search outside of DiVA

GoogleGoogle Scholar
Total: 2255 downloads
The number of downloads is the sum of all downloads of full texts. It may include eg previous versions that are now no longer available

urn-nbn

Altmetric score

urn-nbn
Total: 915 hits
CiteExportLink to record
Permanent link

Direct link
Cite
Citation style
  • apa
  • harvard1
  • ieee
  • modern-language-association-8th-edition
  • vancouver
  • Other style
More styles
Language
  • de-DE
  • en-GB
  • en-US
  • fi-FI
  • nn-NO
  • nn-NB
  • sv-SE
  • Other locale
More languages
Output format
  • html
  • text
  • asciidoc
  • rtf