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 switch 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 support. 
• 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 validated automatically.
• 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 time.
• The grammar for the language is not programmatically available. 

Jura aims to address all of these issues.  Furthermore, its extensibility will allow it to evolve as demands on the language change.