Differences

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

--- at:tutorial:symbiosis [2007/06/19 10:22] – jdedecker
+++ at:tutorial:symbiosis [2007/06/19 10:54] – jdedecker
@@ Line 8: / Line 8: @@
 This chapter explains how both sides of this symbiotic relationship between Java and AmbientTalk can be leveraged. The goal of this symbiotic relationship is to complement the advantages of both languages and to alleviate their disadvantages.  For example, AmbientTalk can use the extensive class library from Java and Java can benefit from AmbientTalk's superior concurrency abstractions.
+===== Symbiosis Architecture =====
+AmbientTalk has been implemented in Java. Because of this, Java plays two roles: it is both a symbiont language and the implementation language of AmbientTalk (and hence of the linguistic symbiosis itself). Figure \ref{fig:wrappers} illustrates the different objects that play a part in the AmbientTalk/Java symbiosis, according to the implementation model of Inter-language reflection. AmbientTalk objects are physically implemented as Java objects. This is illustrated by means of the ``represents'' relationship. To enable symbiosis, additional objects are required which denote the //appearance// of objects from one language in the other language. At the implementation level, such appearances are implemented as //wrapper// objects, which wrap an object from a different language and which perform the protocol mapping which translates between the semantics of the symbiont languages.
+{{:at:tutorial:wrapper-architecture.png?450|Symbiotic representation of AmbientTalk and Java Objects}}
 ===== Accessing Java classes =====
@@ Line 34: / Line 39: @@
 ===== Invoking methods on Java objects =====
-In a similar fashion to calling constructors on Java classes we can also call other methods defined in the Java class.  For example, adding a elements to the vector can be done by invoking the add method.
+Java objects appear as AmbientTalk objects whose field and method slots correspond to public instance-level fields and methods in the Java object. These are accessed or invoked as if they were plain AmbientTalk slots.  In the example, this means that all public methods and fields of the **Vector** class are accessible from within AmbientTalk.  Hence, to add elements to the vector we can simply invoke the add method on the AmbientTalk wrapper object.
 <code>
@@ Line 43: / Line 48: @@
 </code>
+The AmbientTalk/Java symbiosis treats message sends from AmbientTalk to Java as follows: if a message is sent to a class wrapper, only static fields or methods of the Java class are considered. If the message is sent to an instance wrapper, only non-static fields or methods of the Java class of the wrapped object are considered. If the AmbientTalk selector uniquely identifies a method (i.e. no overloading on the method name is performed in Java), the matching method is invoked. All AmbientTalk arguments are converted to Java objects.  This is done by wrapping them into Java objects in the case of custom objects or by converting them to native Java values if possible (e.g. for the different number types). The Java return value is mapped back to an AmbientTalk value.
 ===== Overloading =====
+In Java methods can be overloaded based on the number of arguments and the types of the arguments.  Invoking an overloaded method from within AmbientTalk requires special consideration.
+If the Java method is overloaded based on arity (i.e. each overloaded method takes a different number of arguments), the number of arguments in the AmbientTalk invocation can be used to identify a unique Java method. Hence, overloading based on arity does not require special attention. If the Java method is overloaded based solely on argument types, the interpreter may derive that the actual arguments can only be converted from AmbientTalk to the appropriate Java types for one of the matching overloaded signatures. Again, if only one match remains, the unique match is invoked. In the remaining case in which the actual AmbientTalk arguments satisfy more than one overloaded method signature, the symbiotic invocation fails. It is then the AmbientTalk programmer's responsibility to provide explicit type information in the method invocation.
+<code>
+TODO
+</code>
 ===== Concurrency =====