Differences

This shows you the differences between two versions of the page.

--- at:tutorial:preface [2007/03/31 12:41] – moved ambient
+++ at:tutorial:preface [2025/06/19 16:04] (current) – [History and design rationale] elisag
@@ Line 1: / Line 1: @@
 ==== Preface ====
-AmbientTalk is a distributed programming language especially geared towards developing applications deployed on mobile networks. The language is a combination based on the actor programing paradigm and prototype-based programming.
+AmbientTalk is a distributed programming language especially geared towards developing applications deployed on mobile networks. The language combines elements from languages such as Scheme (closures), Smalltalk (pure OO), Self (prototypes and delegation) and actor languages.
-==== A bit of history and design rationale... ====
+==== History and design rationale ====
-AmbientTalk was originally built as a distributed extension on the Pic% language. Pic% is a prototype-based object-oriented extension of the language Pico. Both languages were originally developed in an educational and research context. Pico borrowed many of its design principles and concepts from the language Scheme. The foremost design concern of Pico was indeed building a simple and extensible language based upon simple rules.
+The AmbientTalk language saw the light in 2005, when it was implemented by Jessie Dedecker as part of his PhD research. AmbientTalk was originally built as a distributed extension of another language named Pic% (pronounce: Pic-oh-oh). Pic% itself is a prototype-based object-oriented extension of the language [[http://pico.vub.ac.be|Pico]], a language developed by Prof. Theo D'Hondt in 1996. Both Pico and Pic% were originally developed for education purposes in the context of introductory programming courses for students in the faculty of sciences.
-Despite of keeping Pico's spirit in mind, AmbientTalk differs from Pic% in some profound ways being the most significant that AmbientTalk is a true object-oriented language where everything one can manipulate is an object. The integration of concurrency and distributed aspects was also a main concern in the design of AmbientTalk's object model. The concurrent and distribution model of AmbientTalk are inspired by the model of ABCL/1 and E.
+Pico borrowed many of its design principles and concepts from the Scheme programming language. The foremost design concern of Pico was indeed to build a simple and extensible language based upon simple rules. Since its original conception in '96 and its use in teaching, Pico has also been used as a research artifact. Many offspring exist in which particular language features have been investigated. AmbientTalk is one such offspring, used in the context of exploring distributed programming abstractions for mobile ad hoc networks.
-==== About this tutorial... ====
+The AmbientTalk language described in this tutorial is actually AmbientTalk/2, a successor of the original 2005 implementation by Jessie Dedecker. Although AmbientTalk/1 was successful in terms of providing novel language features for mobile ad hoc networks, it lacked several important language features that hampered the development of larger software applications (e.g. a module system, exception handling, etc.)
-This tutorial introduces the programming language AmbientTalk from the basics up to the distribution model. The tutorial does not attempt to be a comprehensive reference manual but a hands-on experience to get familiar with the main features of the language and able to read and write AmbientTalk programs.
+In 2006, Tom Van Cutsem and Stijn Mostinckx initiated the AmbientTalk/2 project, which led to the current version of AmbientTalk. They redesigned most aspects of the original language, including the syntax, to make AmbientTalk more accessible to people unfamiliar with the Pico language. AmbientTalk/2's main purpose is still to be used as a research artifact for PhD students at the programming technology lab. On the other hand, from the beginning AmbientTalk/2 was conceived as a usable, practical programming language, which could be used to construct large and real-life software. This design decision motivated the inclusion of such features as a module system and symbiosis with the underlying Java Virtual Machine, for example.
+Perhaps the most significant change from AmbientTalk/1 to AmbientTalk/2 is the incarnation of actor concurrency in the language. In AmbientTalk/1 - inspired by other actor languages such as ABCL/1 - actors were represented as distinct so-called //active objects//, and the language explicitly distinguished those active objects from ordinary, passive objects. AmbientTalk/2, on the other hand, is based on the notion of actors as "vats" or "containers" of ordinary objects as introduced in the [[http://www.erights.org|E programming language]]. As you will read in the subsequent chapters of the tutorial, this design change shifted the emphasis from actors back onto regular objects, which in the general case makes AmbientTalk/2 programs more reusable and easier to understand.
+Since 2014, AmbientTalk/2 has been maintained by [[https://soft.vub.ac.be/disco/|Prof. Dr. Elisa Gonzalez Boix]] and her PhD students and postdoctoral fellows. The language is still being used as an educational vehicle in the Master Computer Science program at VUB. It remains accessible to the general public and can be used to develop realistic distributed applications through [[https://plugins.jetbrains.com/plugin/17635-ambienttalk# |the IntelliJ plugin]].
+==== About this tutorial ====
+The tutorial introduces the AmbientTalk programming language from its basic building blocks (functions, objects, messages) up to its advanced distribution model (remote objects, discovery, failure handling). The tutorial is not a comprehensive reference manual that tries to give the precise semantics of all of AmbientTalk's language features. Rather, it tries to give the reader hands-on experience in using the main features of the language in an example-driven manner.
+The tutorial is subdivided into different chapters that each highlight different aspects of the language. It is recommended to read through the tutorial sequentially, although this does not preclude a reader interested in concurrency and actors to read that chapter early on, and then get back to previous chapters when things are unclear.