Release Notes for LITTLE Preliminary Release V0.7.9

What's New

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

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

• 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
• 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.