Comments
This project appears to have gone dormant. It will be removed from the list soon unless new activity is noted.
Actor-based distributed language for programs deployed in mobile ad hoc networks.

AmbientTalk is an experimental object-oriented distributed programming language developed at the Software Languages Lab at the Vrije Universiteit Brussel, Belgium

Ambient-Oriented programming is a programming paradigm whose properties are derived from the characteristics of hardware platforms for mobile computing. Mobile hardware devices are often provided with wireless networks facilities, allowing them to engage in collaboration with their environment. However, the autonomous nature of these devices as well as the volatile connections over their wireless infrastructure has its repercussions on the software that employs them. The basic assumption of the Ambient-Oriented Programming paradigm is that languages should incorporate possible network failures at the heart of their programming model.

From this observation, several characteristics of programming languages can be derived. Our own experimental language, AmbientTalk, differs from most traditional languages because:

  • It employs a purely event-driven concurrency framework, founded on actors.
  • It abandons the RPC abstraction in favor of asynchronous, non-blocking message passing. Because the system automatically buffers such messages while the receiver of the message is disconnected, the programmer can abstract over temporary network failures by default!
  • It has built-in programming language constructs for objects to discover one another in the local ad hoc network. Peer-to-peer service discovery is built into the language.
  • It features a dynamic OO kernel language built upon the principles of prototype-based programming. More importantly, the kernel language is reflective and hence extensible from within the language itself.
def sort(table, cmp := { |e1,e2| e1 < e2 }) {
  def quickSort(table, low, high) {
    def left := low;
    def right := high;
    def pivot := table[(left+right) /- 2];
    def save := nil;
    while: { left <= right } do: {
      while: { cmp(table[left], pivot) } do: { 
        left := left + 1 
      };
      while: { cmp(pivot, table[right]) } do: { 
        right := right - 1 
      };
      if: (left <= right) then: {
        // swap elements
        save := table[left];
        table[left] := table[right];
        table[right] := save;
        left := left + 1;
        right := right - 1;
      };
    };
    if: (low<right) then: { quickSort(table,low,right) };
    if: (high>left) then: { quickSort(table,left,high) };
    table;
  };
  quickSort(table, 1, table.length);
};

sort([2,37,6,4,5,8]) //[2, 4, 5, 6, 8, 37]
Information updated 08/24/15
View Comments