Release Notes for LITTLE Preliminary Release V0.8.0b

What's New in Release 0.8.0b

Since V0.8.0, the VM finally includes a native JIT for Intel x86 IA32 (this JIT does not yet achieve optimum speed - currently, you can expect a maximum acceleration of factor 2-2.5, compared to the all-platform fast evaluator).

Fixed Issues

• little.io output format mapping issue has been solved now: inherited mappings are now aggregated, i.e., if a class does not register a mapping of it's own, all inherited mappings are used to output instances of that class. This may be desirable or not - however, it can be easily changed by registering specialized output formats for each affected class.
• a compiler bug, which led to problems with superclass method invocations in class methods has been fixed
• little.lang.PackedArray now clears allocated memory
• Exception handling: bug in Throwable:dump fixed
• Exception handling: crash on errors in little_perror fixed

What's New in Release 0.7.9.7

This release contains some fixes and enhancements for the macro system:

• macros now may expand to macros
• expressions like ((foo 1 2 3):bar) are now correctly expanded
• 'while' now allows a 'break' statement (this was needed to allow other loop constructs be implemented as macros

Furthermore, several macros have been added. Among them are:

• short-circuit boolean operators and, or, not
• add, mul
• loops until, do

What's New in Release 0.7.9.6

The macro system has been undergone complete redesign. Macros are now classes, which extend the abstract base little.compiler.macro.Macro. They have to define the method replace(), which has to do whatever needed to transform the input SExpr into the desired output expressions.

Additional minor enhancements:

• Double precision floating point numbers are now implemented
• The little.net package provides basic networking via socket interface

What's New in Release 0.7.9.5

This release enables the REP feature. It is now possible to 'work' with the read-eval-print loop.

Additional fixes:

• Macro expand on array literals failed (this bug has not been previously described).

What's New in Release 0.7.9.4

V0.7.9.4 is a bugfix release. It fixes the following major issues:

• InternalError or VM crash on try-catch, which encloses return expressions in the try-part
• Major GC memory leak fixed - littlec now compiles all runtime classes with about 30Meg memory in use

What's New in Release 0.7.9.3

V0.7.9.3 is mainly a bugfix release. It fixes the following major issue:

• Compiler may crash the VM for big compiles (all runtime libraries in one run, for example) - probably a GC/dynamic object allocation issue located in runtime libraries

This problem actually was caused by erratively garbage collected objects.

The VM command line tool little has been modified. It has been renamed to .little, and is invoked via wrapper script little, which takes care of setting up a suitable environment (setting LITTLE_HOME, adding $LITTLE_HOME/lib to library path etc). The interpreter default behaviour, if started without a class name as entry point, now is to silently quit. The read-eval-print facility is entered via -i-option to the wrapper script.

Additionally, this is the first release, which includes a native code JIT. This feature is available on SGI/MIPS platforms only. Currently, it leads to a performance increase of close to factor 2 for applications, which are well cacheable.

What's New in Release 0.7.9.2

Several classes and methods have been added to allow more convenient container handling. These include:

• little.lang.Comparator
• little.lang.Array:sort
• little.lang.container.InfiniteSet
• little.lang.container.Map:keys
• little.lang.container.Map:values

What's New since Initial Release 0.7.6

This release provides the following new features and capabilities:

• Support for class libraries: an archive format for distributing library packages via single files, avoiding naming conflicts caused by file system restrictions (ie. HFS/HFS+)
• Rudimentary source code documentation system
• Stream classes, which read from strings (and thus the ability to dynamically compile code from strings)
• Aliasing for all members of a package: (using (package <packagename>))
• Abstract classes and methods: enforce implementation of certain features as pendant to final, which prevents overriding of existing method implementations; additional advantage: it is possible to make use of source code documentation forms to describe abstract base class interfaces
• ltl_env_set_debughook() function added to C API - this allows to set a debug hook function, which will be called, whenever a bytecode is hit, which has it's debug flag field set

Fixed Issues

• little.util.SysInfo without args causes sporadic crashes
• Compiler seems to generate incorrect code for exception handlers under some circumstances
• Compiler doesn't yet successfully compile itself and the system library classes
• Compiler: references by short names to classes within current package, but defined outside current file, don't work
• Compiler line number info is sometimes incorrect or missing
• Naming conflicts on non-case-sensitive file systems
• GC lock-in-memory routines ltl_gc_lock(), ltl_gc_unlock() fixed

Not Yet Implemented Features

LITTLE is still at an early development stage, so this list is certainly too short, as many features are still behind the horizon and will be missing for a long time - like a decent UI class library, or DB access.

The feature whose absence hurts most surely is some kind of API documentation. Currently, you have to take a look at the demo code included in the distribution and/or available online. The release of some kind of API doc strongly depends on the maturity of the little.compiler package, as the doctree generator will be included here. Release 0.8 of the language will include this functionality and, at least, rudimentary class library reference.

The list below just mentions missing features of the core language & libraries:

• Compiler: parsing of exponential notation for floating point constants
• Compiler: some kind of closures - lambdas, or SmallTalk-like blocks
• Compiler: builtin source-documentation-feature (doc), which will generate API documentation from LITTLE source files
• Debugger
• little.lang.Double - double precision floating point constants
• Stream classes, which write to strings
• little.lang.System:eval () - allow runtime evaluation of strings and maybe containers

Known Bugs & Issues

• LITTLE is a memory hog (this probably is somehow related to next issue in list)
• VM or GC is still loosing memory somewhere
• Some more performance tuning
• Handling of class names is inconsistent: sometimes, the LITTLE language notation is required (dot-separator), sometimes the internal VM notation is used (slash-separator)
• String classes might need a redesign
• Design flaw in little.io.Text*Stream-classes sometimes causes errative format instances to be selected

Remarks

This demo release uses synchronous garbage collection to avoid performance penalties due to locking overhead.

Later releases will contain the async-multi-threaded runtime as well.