Jean-pierre Briot, Loïc Lescaudron · 2007
This paper describes a programming environment for modeling and visualizing object-oriented concurrent languages. This system focuses on actor-based languages and is named Actalk, which stands for actors in Smalltalk-80. Actalk is based on some minimal kernel introducing actors into Smalltalk-80. The Actalk kernel extends passive and sequential objects activated by synchronous message passing into active and concurrent actors communicating by asynchronous message passing. It is composed of only two Smalltalk-80 classes which could be extended (subclassed) to simulate current object-oriented concurrent languages or design new ones. We extend the standard Smalltalk-80 programming environment in order to customize it to the concurrency specificities of actors. The current system allows visualization and interaction with concurrent objects. In this paper, the motivations and the goals which led to design the Actalk system are first discussed. Then the structure and implementation of the ker...
Cited by 0
M. Papathomas, D. Konstantas, B. Liskov et al. · 2008
The requirements that we formulated for concurrent object-oriented languages provide some guidelines for the design of languages and their mechanisms. However, a framework providing a more rigorous formulation of the requirements and the evaluation of mechanisms would be extremely helpful for the development of better language designs. Our current research [11]
Cited by 0
Rizk, A., Fellous, J.M., Tueni, M. · OpenGrey (Institut de l'Information Scientifique et Technique) · 1989
Cited by 0Open access
Jean-Pierre Briot · 1999
. This paper describes a framework for modeling, classifying, and specializing various object-oriented concurrent programming (OOCP) languages constructs and schemes. This framework, named Actalk, is implemented and integrated within the Smalltalk-80 programming environment. The architecture of the framework is based on the notions of components, parameterization and inheritance. The kernel of the architecture is decomposed into a set of kernel component classes and associated parameter methods, to be redefined in various subclasses. Various extensions, defined as subclasses of the kernel classes, simulate various OOCP languages and constructs. They implement various models of activity (serialized, concurrent, with implicit or explicit message acceptance. . . ), communication (synchronous, eager reply, time stamped. . . ), and synchronization schemes (guards, abstract states transitions, synchronization counters. . . ). At first, our framework helps in classifying and experimenting w...
Cited by 12
Agha, Gul · 2001
Cited by 2
Eneia Nicolae Todoran, Nicolae Gherman · 2008
In this paper we present a semantic interpreter which implements a dynamic denotational semantics for a small experimental concurrent object-oriented language that we call JoPool. JoPool embodies the modern communication abstractions introduced in the join calculus. It provides the communication primitives of join Java and polyphonic C# together with a generalization of the rendez-vous mechanism that is typical in Ada and POOL. The semantic interpreter is designed with a continuation semantics for distributed computing, introduced by us in previous work. As an implementation tool for the denotational semantics we use C# 3.0 lambda-expressions. As far as we know, this is the first paper that reports a compositional semantics for the communication abstractions of join Java and polyphonic C#.
Cited by 1
柴山悦哉, ETSUYA SHIBAYAMA · Tokyo Tech Research Repository (Tokyo Institute of Technology) · 2006
Cited by 0
Masato Uehara, C. Numaoka, Yasuhiko Yokote et al. · ACM SIGPLAN Notices · 1988
article Free Access Share on Sarek: a window system interface for object-oriented concurrent programming languages Authors: M. Uehara Keio Univ., Yokohama, Japan Keio Univ., Yokohama, JapanView Profile , C. Numaoka Keio Univ., Yokohama, Japan Keio Univ., Yokohama, JapanView Profile , Y. Yokote Keio Univ., Yokohama, Japan Keio Univ., Yokohama, JapanView Profile , M. Tokoro Keio Univ., Yokohama, Japan Keio Univ., Yokohama, JapanView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 24Issue 4April 1989 pp 187–189https://doi.org/10.1145/67387.67440Online:26 September 1988Publication History 0citation139DownloadsMetricsTotal Citations0Total Downloads139Last 12 Months3Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF
Cited by 0Open access
Federico Bergenti, Agostino Poggi, Giovanni Rimassa et al. · 2007
Introduction DisC++ (Distributed C++) is a set of C++ libraries for concurrent programming that provides a comprehensive framework particularly suitable for coarse-grained distributed applications development. It can be considered a good alternative to classical distributed programming libraries, such as PVM and MPI, to develop distributed applications. Code reuse is stimulated by the adopted object model, which provides a solution to the inheritance anomaly problem [1], trying to minimize the redefinition of inherited methods. ActiveObjects library implements the described object model, that is based on a special set of method definitions, allowing method bodies to be defined independently by their synchronization constraints. In fact, two synchronization constraints are defined for each method in order to decouple method body definition from problem-based synchronization requirements.RemoteObjects library supports object distribution on diff
Cited by 0
Silva, Antonio Manuel Ferreira Rito da · OpenGrey (Institut de l'Information Scientifique et Technique) · 1999
The development of concurrent object-oriented programs, from a software engineering perspective, must possess a set of features to allow control of its inherent complexities, such as non-determinism. This dissertation contributes the definition of an approach for constructing concurrent object-oriented programs. The approach is rooted in a divide-and conquer strategy, in which functional and non-functional concerns of concurrent programs are treated separately. The approach defines design patterns for three non-functional concerns: Concurrent Object, Synchronized Object and Recoverable Object. It also defines composition patterns for combining the concerns: Concurrent Synchronized Object, Synchronized Recoverable Object, and Concurrent Synchronized Recoverable Object. The design patterns and their compositions are integrated in an incremental development process for concurrent programs, which is described by a pattern language. The introduction of non-determinism in the development process is delayed so as to facilitate testing and debugging of programs. The design patterns and their compositions are implemented by an object-oriented framework. The framework's architecture is organized in three layers dealing with concerns separation. This architecture simplifies customization and use by the end programmer
Cited by 0Open access
Antonio Manuel Ferreira Rito da Silva · 1999
The development of concurrent object-oriented programs, from a software engineering perspective, must possess a set of features to allow control of its inherent complexities, such as non-determinism. This dissertation contributes the definition of an approach for constructing concurrent object-oriented programs. The approach is rooted in a divide-and-conquer strategy, in which functional and non-functional concerns of concurrent programs are treated separately. The approach defines design patterns for three non-functional concerns: Concurrent Object, Synchronized Object, and Recoverable Object. It also defines composition patterns for combining the concerns: Concurrent Synchronized Object, Synchronized Recoverable Object, and Concurrent Synchronized Recoverable Object. The design patterns and their compositions are integrated in an incremental development process for concurrent programs, which is described by a pattern language. The introduction of non-determinism in the development p...
Cited by 0
Robert Newman · Journal of Systems Architecture · 1998
Cited by 5
Hiroaki Nakamura · 1991
Cited by 1
Alfredo Weitzenfeld · 1993
The Abstract Schema Language (ASL) defines a hierarchical computational model for the development of distributed heterogeneous systems. ASL extends the capabilities and methodologies of concurrent object-oriented programming to enable the construction of highly complex multi-granular systems. The ASL model is described in terms of schemas (concurrent objects), supporting aggregation (schema assemblages), and both top-down and bottom-up system designs. ASL encourages code reusability by enabling the integration of heterogeneous components, e.g., procedural and neural network programs. ASL schemas are designed and implemented in an orthogonal fashion; integrated, either statically, through wrapping, or dynamically, via (task) delegation. Schemas include a dynamic interface, made of multiple unidirectional input and output ports, and a body section where schema behavior is specified. Communication is in the form of asynchronous message passing, hierarchically managed, internally, through...
Cited by 0
Loïc Lescaudron, Jean-pierre Briot, Malik Bouabsa et al. · 1991
This paper discusses the prototyping of programming environments for object-oriented concurrent programming languages. We advocate designing new prototypes starting from existing sophisticated programming environments that we can find in standard (sequential) object-oriented programming languages (namely Smalltalk-80 1 ). Our starting point is a testbed for object-oriented concurrent languages based on Smalltalk80. This system (namely Actalk) focuses on actor-based languages and gives a good integration of actors into the Smalltalk-80 system. We naturally came to reuse the standard Smalltalk-80 programming environment tools and to customize them to the specificities of actors. In this paper, we describe why and how we customize the Model View Controller architecture to provide user-interfaces on actors, and the scheduler to simulate concurrent execution of actors. Other tools such as stepper and chronogram are also discussed. We then summarize our experience in building and using thi...
Cited by 0
Sharma, Vikash · 2018
Cited by 0
Miguel Oliveira E Silva · 2008
This article evaluates several possible approaches for integrating concurrency into object-oriented programming languages, presenting afterwards, a new language named MP-Eiffel. MP-Eiffel was designed attempting to include all the essential properties of both concurrent and object-oriented programming with simplicity and safety. A special care was taken to achieve the orthogonality of all the language mechanisms, allowing their joint use without unsafe side-effects (such as inheritance anomalies). 1
Cited by 0
松岡聡, SATOSHI MATSUOKA · Tokyo Tech Research Repository (Tokyo Institute of Technology) · 1999
Cited by 0
Szabolcs Ferenczi · 2007
The main features of an Object-Oriented Concurrent Programming (OOCP) model called Monads-DP are introduced in this paper. Monads-DP is significantly different from other OOCP systems. Undirected Remote Procedure Calls are used in inter-object communication for which the target objects and methods are found by pattern matching. Objects apply implicit control for messages arriving to an object. Method executions are regarded to be local processes (threads) to an object. Local processes communicate through shared variables and synchronize by an adapted form of Conditional Critical Regions (CCRs). The number of processes in the whole program are controlled by explicit structured process creation. Since CCRs are applied in Monads-DP, control structures can be inherited in classification. 1 Introduction Appeared in: Proceedings of the 2nd Austrian-Hungarian Workshop on Transputer Application Sept 29--Oct 1, 1994, Budapest, Hungary. Eds. by Sz. Ferenczi and P. Kacsuk. KFKI-1995-...
Cited by 0
R. Greg, R. Greg Lavender, Dennis G. Kafura · 1995
A "future" is a typed synchronization mechanism used to represent a value that will come into existence at some point in time after the creation of the future. In this paper, a polymorphic future type is introduced that differs from previous mechanisms in that it provides a first-class, extensible facility for expressing synchronized access to the typed result value of a concurrent computation. The proposed mechanism requires write-once/read-many synchronization, which is implemented in terms of common thread synchronization primitives, thereby ensuring a high-degree of efficiency. The type definition and type specialization features of C++ are used to illustrate how one would implement a polymorphic future type in a strongly typed object-oriented language supporting polymorphic type definitions. 1 Introduction Applications increasily employ multiple threads of control due to the utility of the thread mechanism and its widening availability. The utility of threads is apparent in any a...
Cited by 0