Why do we need a successor to Java?
Java was invented in the early nineties. At the time, all
existing languages in wide use had significant usability issues and were
platform-dependent. Java largely solved both of these
problems. It is clean, simple, object-orientated, easy to read,
easy to document and it comes with a large number of relatively well
designed class libraries.
However, Java has its drawbacks. To be accepted by developers,
it necessarily had to be constrained to look a lot like languages of the
time (basically C++) which prevented some more radical language changes
and meant that Java inherited some bizarre limitations (e.g. the
statement). The way programming languages are used has changed
since 1991, as have the requirements on the software being
developed. Modern software systems need to be more secure,
distributed and far more complex than the systems of ten years ago and
these demands will only increase in future. Java is becoming
increasingly hard to apply because of a number of fundamental problems:
- The Java language can only be used to describe
classes/interfaces, not other software elements e.g. transforms,
enterprise beans, servlets etc. Instead additional information is
stored in a separate descriptor file or through the mis-use of JavaDoc.
- Java provides no standardised long term persistance
- Extending the Java language to add new features is hard.
- Java source code/class files cannot easily be read or written by
Java programs. This makes the creation of automatic development
tools (e.g. graphical development environments) much harder.
The lack of such tools make Java quite intimidating to the novice
developer (compared to e.g. Visual Basic).
- Java doesn't allow for restricted types.
- Design patterns cannot be applied automatically and cannot be
- Java libraries have overlarge interfaces (e.g. List) which are
poorly abstracted. Although many classes share common
functionality, they rarely implement common interfaces.
- Reflectance was added as an afterthought, could be much better
integrated into the language and does not allow for code
generation. Java doesn't (currently) support generics.
- Java doesn't allow for methods on primitive types, or the
creation of new primitives.
- JavaDoc is not validated and cannot be made accessible at run
- The grammar for the language is not programmatically
Jura aims to address all of these issues. Furthermore, its
extensibility will allow it to evolve as demands on the language change.