1. INTRODUCTION
Smalltalk is the pioneer in the object-oriented programming. Many inventions in Smalltalk programming languages, such as the virtual machine, debugging by inspection, IDE, Model-View-Controller architecture, have become prevailingly adopted in other programming languages. Java was born later and influenced by Smalltalk though, the language is supplied with distinct features including interfaces, abstract classes, anonymous classes and so on. The Java language has profoundly evolved since the introduction of lambda expression and the functional interface in the latest version 1.8.

In this paper, we introduce the comparison of Java and Smalltalk. The discussion does not limit on direct comparison of their own distinguishable traits, but also examine how developers would utilize facilities – such as the class-instance variables in Smalltalk or the anonymous classes and virtual extension methods in Java – and the drawbacks, benefits behind of the language designs such as the collection API.

2. SYNTAX

Smalltalk offers a minimal syntax. Smalltalk syntax is mainly about message sending. Java syntax is similar to C and much more complicated compared to Smalltalk.

Java developers would be impressed to know that Smalltalk only has a few keywords including self, super, true, false, nil, thisContext, and local variable declara- tion (|. . . | ). Everything else (such as the assignment op- erator (:= ), the return operator (↑ )) are merely syntactic sugar. For example, the return operator is equivalent to thisContext return: anObject , or #(1 2 3)  can be expressed by Array with: 1 with 2: with 3 .

A brief comparison of syntax between Smalltalk and Java is supplied in the Table 1.

3. TYPES

Smalltalk actually does not have types. Because everything in Smalltalk is an object, new object can be created in the same manner as creating new instance of a class. Because Smalltalk has dynamic types, we can send all messages to a Smalltalk ob ject. In case the object does not understand the received message, the message doesNotUnderstand: #message  will be send to the current ob ject.

Smalltalk provides duck typing happening at runtime [29]. The behaviors of objects are called by sending any messages to the ob jects. Thus, if the ob ject understands the message we send to, we can assume its type even we do not know what class is involved.

Java type system is both static and dynamic [2]. Built-in types or primitive types, such as number or characters, are the rock bottom of the Java type system. They are fixed and not objects. On the other hand, Java data types can also behave similar to Smalltalk when new data types can be constructed as new classes, which can be dynamically loaded at runtime. While primitive types are passed by values, class types are passed by reference.

4. EXPRESSIONS
4.1 Keyword message/method invocation

Smalltalk uses message sending, not method invocation. To invoke a method of an object, the programmer sends corresponding message to it with all necessary parameters. Strictly speaking, the only way to interact with objects in Smalltalk is through their sets of messages, called the interfaces. When the object receives the message, it will search its method dictionary. If the sending message is not found in its dictionary, it will continue the search in the dictionaries of its superclasses. If no matching message is found, the receiver will send to itself the doesNotUnderstand  message.

Java calls functions of a class by the method invocation. Java method invocation is typically like a.bar() , which is to invoke the method bar()  inside the object a.

From the usage point of view, Smalltalk keyword message is more useful than Java function call because the keyword message adds meanings and descriptions to both methods and arguments.

4.2 Message precedence

One of the most variation between two languages is the message precedence. For example, the calculation 1 + 2 * 3  would be 9 in Smalltalk instead of 6 in Java. Programmers should be cautious in using, otherwise it may lead to inconsistent logics.

4.3 Message chaining/cascading

Both Smalltalk and Java have method chaining. However, method chaining in Smalltalk is modest because it is not comfortable for readers to follow the chaining of more than two message sendings. Java programmers do not restrict method chaining. Since Java 8 was released, method chaining has turned to be more effective in providing better readability and conciseness of the code.

Smalltalk has message cascading, which Java lacks. However, message cascading is not necessary in Java because Java uses function invocation rather than keyword message.

4.4 Object creation

Smalltalk allows to create new object by sending message new  to the class. Notice that new  is not a language keyword. It is indeed an ordinary method named new . However, unlike Java, Smalltalk does not have constructor. In order to initialize the new instance, we have to pass the parameters to the created objects indirectly by getter or setter messages.

Java new object can be created using new  keyword to return the reference to new object. The required argument to new  is class constructors. We can also pass parameters directly to the class constructors. In the Section 5.3.1, we will discuss in detail about the class constructors.

4.5 Self/this

Both keywords self in Smalltalk and this in Java are similar. However, this is usually omitted in Java when calling the functions of this. For example, calling this.foo()  is the same to foo() . It is different in Smalltalk when we cannot abbreviate self from self foo.

4.6 Instance variables

Smalltalk instance variables cannot be accessed from outside of an instance. In the words, objects need to use accessing messages in order to access or modify instance variables of other instances of the same class. Compared to Java, instance variables in Smalltalk are Java protected variables since developers are able to access them directly by name inside instance methods of their defined classes as well as the subclasses.

Instance variables in Java can be retrieved straightforwardly using (.)  operator. It makes the classes become the encapsulation boundary of Java, while in Smalltalk we have the instance.

4.7 Pragmas/annotations

As said, everything in Smalltalk is an object, except some primitives. When browsing the message whatIsAPrimitive  in the Object  class, one might get some information “A primitive response is performed directly by the interpreter rather than by evaluating expressions in a method. The methods for these messages indicate the presence of a primitive response by including ⟨primitive: xx⟩  before the first expression in the method”. So, what is ⟨primitive: xx⟩ ?

What we have seen is not a regular message in Smalltalk. It is known as the pragmas. In a nutshell, the pragmas are used to tag the methods in Smalltalk by carrying the metadata of the methods.

Take a look at the body of the method basicAt in the Object class.

basicAt: index
<primitive: 60>
index isInteger ifTrue: [self

errorSubscriptBounds: index]. index isNumber

ifTrue: [^self basicAt: index asInteger]

ifFalse: [self errorNonIntegerIndex]

The method basicAt  is a primitive, which is invoked by the pragma ⟨primitive: 60⟩ . In case the pragma fails, the following Smalltalk code will be evaluated.

Smalltalk pragmas share common characteristics with Java annotations. Both of them are to provide metadata to the compiler, and sometimes instruct the compiler to generate comments, codes, etc. However, there are two major differences between them. Firstly, annotations can be used at runtime when pragmas cannot. Secondly, Java developers are allowed to define their own annotations whereas Smalltalk developers cannot.

5. OBJECT MODEL

5.1 Classes

Classes in both Smalltalk and Java are blueprints used to manufacture objects. The class has its own methods and variables, which should be distinguished from methods and variables of instances. In detail, a class can contains a set of information which is distinctly compared in the Table 2. There are important points need to be remarked:

• Both languages offer a set of variable names to their class instances. The instance variables, however, are private to every instance.
• Class variables in Smalltalk are equivalent to static field variables in Java.
• There is no class-instance variable in Java. This unique feature results in different inheritance implementations between Java and Smalltalk, which we will discuss in the Section 6.
• Java offers the class constructor, which Smalltalk lacks.

5.1.1 Abstract class

In Java, an abstract class and interface share similarities, such as requiring subclasses to implement methods, they still have differences:

• Abstract classes can define concrete methods, whereas interfaces cannot. In Java 8, by using virtual extension methods, interfaces are allowed to define concrete methods like abstract classes. We will discuss about virtual extension methods of Java in the Section 6.3.2.
• Abstract classes can declare non-public methods, interfaces cannot.
• Abstract classes are meant to be inherited while interfaces can be implemented multiple times.

Smalltalk does not dedicate any particular syntax for abstract classes like Java. If one of methods in classes contains the expression self subclassResponsibility , the class is considered as an abstract class. The marker self subclassResponsibility  indicates subclasses have responsibility of defining its own method.When compare abstract classes in Smalltalk and abstract classes in Java, they are similar in conceptual model, except that all methods in Smalltalk abstract class must be public. In case all methods in abstract classes are abstract, the abstract classes will be similar to Java interfaces, but note that interfaces cannot bed declared with field variables like Smalltalk abstract classes.

5.2 Methods

Both Smalltalk and Java define methods in the class body. In the methods, programmers can declare local variables and expressions to be executed when the methods are called. However, there are some differences between two languages:

• Smalltalk methods do not have return types whereas Java requires developers to declare specific return types for methods. Return types of Java methods consist of primitive types, reference types or no returned value void.
• Statements in Smalltalk method are divided by dots (.) whereas in Java the semicolon (;) is used to end a statement.
• Smalltalk methods are considered as public methods in Java because they are completely exposed. One minor difference is Smalltalk uses protocol to group similar methods.
• Both languages offer method overloading or ad-hoc polymorphism. While Java resolves overloaded meth- ods during compilation [11], method overloading hap- pens at runtime in Smalltalk [28].

5.3 Objects

Smalltalk is pure object oriented programming language [30]. Everything in Smalltalk is an object [3]. In contrast, besides reference data types, Java has primitive types, which are predefined by the language and do not as- sociate with any classes [22].

Objects in Smalltalk and Java are derived from the highest superclass called Object  class [20] [4]. To instantiate a new Foo  object in Smalltalk, we could use Java-like expression such as foo := Foo new .

What will happen when we use class message new here, even though, there is no such new method in the code? The answer is there exists a method lookup behind the scenes when we send message new to Foo  class. The lookup then starts from Foo  and goes up to the root class Object .

5.3.1 Constructors

Both Smalltalk and Java use new keyword to allocate memory for new instances. In Java, whenever the new operator is called, the class constructor will be invoked. Java class constructor uses the same name with the class and has no return type [23]. Because class constructor accepts arguments, Java developers use it to initialize the new objects.

For each class, there is always a default constructor. The default constructor will be invoked once we call the new operator without supplied arguments. Because the constructor can be overloaded, one might define a custom constructor for a class. However, Java class constructor cannot be inherited.

Unlike Java, Smalltalk does not support class constructor. Whenever we send the message new to the class, we simply tell Smalltalk allocates space for the instance variables of the object, then set their values to nil. To make the initialization meaningful and accomplished, we need to pass values to the variables in following expressions. For example:

p := Person new.
p name: ’Ngoc Tran’ address: ’Brussels’

This expression works exactly as we want but it is untidy. [1] proposes to use Constructor Parameter Method, which makes our code become:

p := Person name: ’Ngoc Tran’ address: ’Brussels’

The code now becomes more clear and succinct. We firstly need to define a class method name: #aName address: #anAddress  for the Person  class. Inside the method, we send the message new to super. The pseudo-variable super here indicates the receiver to start method lookup from the parent of Person  class. When the method is found, a Person  object is created, which later will receive a set of messages initialize, name:  and address: . Java developers may not familiar with how the method is defined but in Smalltalk, we can “cascade” side-effect calls to the same object.

name: aName address: anAddress ^super new
initialize;name: aName; address: anAddress

Similar to new, name: #aName address: #anAddress  is a class method, and it can only sent to Person  class. It is specialized in Smalltalk when the class can only receive messages from the class methods, and in contrast, instances only take instance messages and variables. To read and write instance variables inside the body of the class method, we have to use messages.

When compare Smalltalk and Java on this feature, we see that Java is much more convenient than Smalltalk. Class constructor not only provides a more extensive meaning for instance instantiation but also helps developers make sure instance variables fully initialized before using.

5.3.2 Is single responsibility principle violated in Smalltalk?

When browsing source code in Pharo, one might see that Object  class contains 339 methods, which is overwhelming when compare to Java. Take into consideration the principle of single responsibility, which states “a class should have only one reason to change” [13], with hundreds of methods inside the class Object , does Smalltalk violate the principle? I am unqualified to answer the question but there is a few comments. Firstly, the Object  class perhaps does not handle as much responsibility as it seems to be because many methods in the class uses double dispatch. Secondly, because Smalltalk uses traditional mirror reflective design, it could be reasonable to put reflection methods, such as inspect, inside the class body.

6. RELATIONSHIPS AMONG CLASSES

6.1 Inheritance

Both Smalltalk and Java feature single-inheritance in order to enhance reusability and extensibility of code. It allows classes to inherit from its superclasses, including both variables and methods. The subclasses can also add new methods or override inherited methods.

6.1.1 Class side inheritance

The most difference between Smalltalk and Java is Smalltalk supports class side inheritance whereas Java does not. For example, if the class Foo  inherits from the class Bar , and foo  and bar  are instances of classes Foo  and Bar  respectively, then foo  class will inherit from bar  class as a result. It would not happen in Java. The method call getClass()  in instances foo  and bar  in Java will return instances of the class Class , which have no relationships to each other.

6.1.2 Class instance variable inheritance

As said in the Section 5, class instance variables only exist in Smalltalk. Class instance variables are private to the class itself, and will be inherited by subclasses.

Suppose we have the class Database which handles the database layer. Because the application use various database sources (such as JSON, SQL), it is necessary to define subclasses that inherit from Database class but also maintain only one single instance of Database class in the whole application. In the class side of Database class we define some class instance variables. However, for the sake of simplicity, we keep it simple as follows:

Database class instanceVariableNames: ’dbName’

We have seen that the Database class has a class instance variable dbName , which should be inherited by subclasses such as SQLDatabase , JSONDatabase . Here we define a method dbName  to get the name of the database

Database class >>dbName ^self dbName

Note that the method dbName  will be inherited by subclasses. We indeed do not need to use keyword self , but in order to illustrate that the class which invokes the message will return its own class instance variables dbName. Therefore, if the SQLDatabase  class invokes the dbName  method, the class instance variable dbName  will be returned, which is different from dbName  variable of Database  class.

6.1.3 Discussion
Both Smalltalk and Java have single inheritance though, they have uncommon attributes including class side inheritance and class-instance variable inheritance. These differences origin from the basic characteristic of Smalltalk – everything is an object. It implies that class is an object, and should have its own variables and inheritance.

6.2 Multiple inheritance

To compensate for the lack of multiple inheritance, Java classes can implement multiple interfaces while Smalltalk classes can reuse protocols of other classes by traits. We will discuss about traits and interfaces in the Section 6.3.

6.3 Interfaces/Traits

6.3.1 Interfaces in Java

Interfaces are the unique feature of Java, which is defined as a set of methods the classes need to implements. The purpose of introducing interfaces in Java is greater since it allows an object to escape from the single inheritance. One, for example, can use composition to simulate multiple inheritances, which do not natively exist in Java.

Java interfaces can be used to establish data types. Suppose we have a class Person  implementing two interfaces IWorker  and IHusband . At work, a Person  instance only care about implementing methods according to IWorker  interface. Being a husband, implementing methods according to IHusband  is more important. Therefore, the type is different depending on different situations.

6.3.2 Virtual Extension Methods in Java 8

Along with lambda expression, Java 8 introduces default methods (defender methods) or virtual extension methods. The purpose is to provide the backward compatibility in the new Java [16]. For example, we have an interface A  and a class Clazz  implements the interface:

public interface A {
void foo();
}

public class Clazz implements A{

@Override
public void foo() {} }

After that we add the new method bar() to the interface A. Now the interface A will look like:

public void void

}

interface A { foo();
bar();

While the class Clazz  implements the interface A , the interface evolves, which results in the compilation error of the class. The virtual extension methods provide the new facility to solve the problem:

public interface A { void foo();

default void bar() {} }

Class Foo {
Class NonStaticBar {}; static class StaticBar {}; void doSomething () {};

}

final int number = 0; AnonymousInnerClass aic = new

AnonymousInnerClass() { public void read () {

System.out.println("number :" +

number); }

}

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);

One might loop over the list by using for statement in Java 7 as follows:

for (Integer number: numbers) { System.out.println(number);

}

numbers.forEach(new Consumer <Integer >() {

@Override

public void accept(Integer value) { System.out.println(value);

} });

numbers.forEach((Integer value)
-> System.out.println(value));

Class c = foo.getClass();
Method m = c.getMethod("saySomething"); // saySomething is a static method, we ignore the first parameter

static methods it is ignored String s = (String)m.invoke(null);

Stream s = numbers.stream()
.filter(x -> x > 5);

foo := [:x :y | x + y ]
bar := [:x :y :theblock | theblock value:x value: y].

student Student name: ’Ngoc Tran’ address: ’Brussels’.
student class. Student
student isKindOf: Student. true student isKindOf: Person. true student isKindOf: Float. false

Integer >>+ aNumber
"Answer a Number which is the sum of the receiver and aNumber"
^aNumber addToInteger: self