High-level language support for programming distributed systems
Ajey P1992
Sign up for access to the world's latest research
checkGet notified about relevant papers
checkSave papers to use in your research
checkJoin the discussion with peers
checkTrack your impact
Abstract
A strategy for simplifying the programming of heterogeneous distributed systems is presented. The approach used is based on integrating a high-level distributed programming model, the process model, directly into programming languages. Distributed applications written in such languages are portable across different environments, are shorter, and are simpler to develop than similar applications developed using conventional approaches. The process model is discussed, and Hermes and Concert/C, two languages that implement this model, are described. Hermes is a secure, representation-independent language designed explicitly around the process model. Concert/C is the C language augmented with a small set of extensions to support the process model while allowing reuse of existing C code. Hermes has been prototyped: an implementation of Concert/C is in development
Related papers
Programming Languages for Distributed Applications
New Generation Computing, 1998
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.
EC : A Language for Distributed Computing
Computer Networks, Architecture and Applications, 1995
Computation intensive programs can utilise idle workstations in a cluster by exploiting the parallelism inherent in the problem being solved. A programming language for distributed computing offers advantages like early detection of type mismatch in communication and offers structured mechanisms to specify possible overlap in communication and computation, and exception handling for catching run time errors. Success of a language depends on its ease of use, expressibility and efficient implementation of its constructs. EC is a super set of C supporting process creation, a message passing mechanism, and exception handling. The pipelined communication constructs and multiple process instances help in expressing concurrency between computation and communication. Data driven activation of EC processes is used for scheduling. EC has been implemented in a Sun-3 workstation cluster. An inter-node message passing mechanism has been built on top of the socket interface using the TCP protocol, and intra-node message passing is done by passing pointers to improve efficiency. However, message_type variables hide the implementation details, improve type safety and location transparency of a program.
Programming languages for distributed computing systems
ACM Computing Surveys, 1989
When distributed systems first appeared, they were programmed in traditional sequential languages, usually with the addition of a few library procedures for sending and receiving messages. As distributed applications became more commonplace and more sophisticated, this ad hoc approach became less satisfactory. Researchers all over the world began designing new programming languages specifically for implementing distributed applications. These languages and their history, their underlying principles, their design, and their use are the subject of this paper. We begin by giving our view of what a distributed system is, illustrating with examples to avoid confusion on this important and controversial point. We then describe the three main characteristics that distinguish distributed programming languages from traditional sequential languages, namely, how they deal with parallelism, communication, and partial failures. Finally, we discuss 15 representative distributed languages to give ...
Language constructs for distributed programs
Distributed Systems, 1985
Invited paper for New Generation Computing 1 Programming Languages for Distributed Applications
1998
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 langu...
NIL: An integrated language and system for distributed programming
Sigplan Notices, 1983
This paper presents features of the NIL programming language which support the construction of distributed software systems: (1) a process model in which no pointers or shared data are visible, (2) interprocess communication via synchronous and asynchronous message passing, (3) compile-time typestate checking, guaranteeing module isolation and correct finalization of data, (4) dynamic binding of statically typed ports under the
DIPC: A Heterogeneous Distributed Programming System
1997
Distributed Inter-Process Communication (DIPC) is a software-only solution to enable people to build and program Multi-Computers. Among other things, DIPC provides the programmers with Transparent Distributed Shared Memory. DIPC is not concerned with the incompatible executable code problem. It also does not change user's data, but DIPC has to understand data produced by its own peer processes in different machines. This paper briefly describes the efforts done to make it a heterogeneous system by enabling it to function under the Linux operating system running on both Intel x86 and Motorola 680x0 processors. Here, different parts of the same application could execute in machines with different architectures
MAGE: A Distributed Programming Model
2001
This thesis explores computation mobility. We view mobility, the selection of an execution environment, as an attribute of a computation. To capture this attribute, we introduce a novel programming abstraction, which we call a mobility attribute, that specifies where computations should occur within a distributed system. Programmers dynamically bind mobility attributes to program components, nonempty sets of functions and their state. Once bound to a component, mobility attributes apply prior to each execution of that component.
Language Constructs for Distributed Systems Language Constructs for Distributed Systems Language Constructs for Distributed Systems Language Constructs for Distributed Systems Language Constructs for Distributed Systems Language Constructs for Distributed Systems
2014
Three language constructs appropriate for the design and pro gramming of distributed systems are described. The team abstracts repeated interprocess activities and isolates processes to the context where they are needed. The interaction provides multiparty synchronization and communi cation. The superimposition defines modules that augment existing teams. Partial correctness proof rules and criteria for correctness-preserving transformations are given. These allow replacing one construct by others during design in order to reduce synchronization and extraneous communi cation.
Language constructs and support systems for distributed computing
… of the first ACM SIGACT-SIGOPS …, 1982
This paper describes language constructs and system support functions intended to facilitate the programming of reliable distributed systems. The new conceptual tool proposed is called an "activity." A model based on activities has been developed to provide a terminology for describing the relationships among objects involved in a distributed task. We outline the design of a system that uses the activity structure of a program to manage its execution network-wide. A preliminary set of high level language constructs for specifying activity-related control features is presented. Finally, the power of this approach is illustrated in an example of a distributed application.
Related papers
High level programming for distributed computing
Communications of the ACM, 1979
Programming for distributed and other loosely coupled systems is a problem of growing interest. This paper describes an approach to distributed computing at the level of general purpose programming languages. Based on primitive notions of module, message, and transaction key, the methodology is shown to be independent of particular languages and machines. It appears to be useful for programming a wide range of tasks. This is part of an ambitious program of development in advanced programming languages, and relations with other aspects of the project are also discussed.
The NIL distributed systems programming language: A status report
Lecture Notes in Computer Science, 1985
D: A Language Framework for Distributed Programming
1997
Two of the most important issues in distributed systems are the synchronization of concurrentthreads and the application-level data transfers between execution spaces. At the design level, addressingthese issues typically requires analyzing the components under a different perspective thanis required to analyze the functionality. Very often, it also involves analyzing several componentsat the same time, because of the way those two
MetaKlaim: a type safe multi-stage language for global computing
Mathematical Structures in Computer Science, 2004
This paper describes the design and the semantics of MetaKlaim, an higher order distributed process calculus equipped with staging mechanisms. MetaKlaim integrates MetaML (an extension of SML for multi-stage programming) and Klaim (a Kernel Language for Agents Interaction and Mobility), to permit interleaving of meta-programming activities (like assembly and linking of code fragments), dynamic checking of security policies at administrative boundaries and "traditional" computational activities on a wide area network (like remote communication and code mobility). MetaKlaim exploits a powerful type system (including polymorphic typesá la system F) to deal with highly parameterized mobile components and to dynamically enforce security policies: types are metadata which are extracted from code at run-time and are used to express trustiness guarantees.
NIL: A high-level language for distributed systems programming
IBM Systems Journal, 2000
Network Implementation Language (NIL) Is a highlevel programming language currently being used for the Implementation ofprototype communication systems. NIL Is designed for writing executable architecture which can be complied Into emc/ent code for the different machines and run-time environments of a family of communicating products. NIL's distinctive features Include (1) highlevel primitive type families supporting constructs needed for concurrent systems, (2) facilities for decomposition of a system Into modules which can be dynamically Installed and Interconnected, (3) compile-time type.tate checking -a mechanism for enhancing language security without Incurring large execution-time overhead.
Languages for programming distributed memory systems
Computing and control engineering journal, 1993
Computer is a powerful machine for assisting human beings in different applications. Programming languages are the tool that makes these computers usable. Every programming language has its own weaknesses and strengths whether old or modern, high or low level. The choice of programming language to be used in building distributed systems depends on what sort of program and kind of computer the program is to run on. The paper presents how the best programming language is selected for distributed systems via the following criteria for language selection (Scalability, Concurrency, Reliability, Security,Performance, Fle xibility, Portability, High Integrity and Ease of Use). The paper concentrates on comparing Java and C++ languages in respect to programming distributed systems and also presents the main criteria for choosing the proper languages for the right system.
Towards A Systems Approach To Distributed Programming
2018
It is undeniable that most developers today are building distributed applications. However, most of these applications are developed by composing existing systems together through unspecified APIs exposed to the application developer. Systems are not going away: they solve a particular problem and most applications today need to rely on several of these systems working in concert. Given this, we propose a research direction where higher-level languages with well defined semantics target underlying systems infrastructure as a middle-ground.
Ordered Ports - a Language Concept for High-level Distributed Programming
The Computer Journal, 1987
A new language concept for high-level distributed programming is proposed. Programs are organised as a collection of concurrently executing processes. Some of these processes, referred to as liaison processes, have a monitor-like structure and contain ports which may be invoked by other processes for the purposes of synchronisation and communication. Synchronisation is achieved by conditional activation of ports and also through port control constructs which may directly specify the execution ordering of ports. These constructs implement a path-expression-like mechanism for synchronisation and are also equipped with options to provide conditional, non-deterministic and priority ordering of ports. The usefulness and expressive power of the proposed concepts are illustrated through solutions of several representative programming problems. Some implementation issues are also considered.
A Domain Specific Language for Securing Distributed Systems
2007
Distributed applications are becoming increasingly common. However, incorporating security in them remains a major challenge. There are currently few choices to express and enforce security in distributed systems. We can either use a special-purpose language which may be too limited to express security requirements, or use a general purpose language that provides the ability to make complicated security policy but makes us reimplement infrastructure code for authorization, interdiction, obligation and so on with each new security policy. In this paper, we introduce a domain-specific language approach that takes the middle road, giving a way to reuse security infrastructure for new policies while also allowing the expression of complicated security policy easily. We present our DSL approach and and apply it to a real-world scenario: specification and implementation of security policy. 1
Loading Preview
Sorry, preview is currently unavailable. You can download the paper by clicking the button above.