Java, A Concurrent OOPL

Shares characteristics of both C++ and Smalltalk
- Smalltalk
  - Similar object model (single-rooted inheritance) hierarchy, access to objects via reference only, ...)
  - Compiled to byte-code (initially interpreted)
  - Dynamic memory layout plus garbage collection
- C++
  - Same syntax for expressions, statements, and control flow
  - Similar OO structural syntax (classes, access protection, constructors, method declaration, ...)
- Adds threads and synchronization primitives
  - Objects can force mutual exclusions of threads running inside them

Detailed Description:

"Let's compare Java to Smalltalk. Java is similar to Smalltalk in that it has a singularly-rooted inheritance model. You can only inherit from one class.

Also every variable that's used within the Java language is a reference to an object and not the object itself. These object references are very similar to variables in Smalltalk.

Another thing that's similar to Smalltalk is that Java compiles to byte codes. Unlike C+ + and C, which compile directly to the native code of the machine, Java compiles to byte code, which is then interpreted by the Java virtual machine. If your platform provides a Java virtual machine, then it can execute Java byte code. This gives Java a very portable, architecturally neutral base to run its code on. And it's a great boon to software developers. If they write their code in Java, they can provide code on one primary platform and have their code portable across multiple platforms, improving the size of their market.

In addition to byte code, Java also provides a dynamic memory capability and garbage collection. Dynamic memory capability means that Java allows the memory heap to be manipulated and reorganized, and at the same time, Java can collect any objects that are no longer used (garbage collection). This is very similar to basic Smalltalk capability.

Now there are some differences, but those are some of the similarities."