language & compiler
Lotta is a modular, simple
language, in the spirit
of oberon and modula-2
Compiler written completely in oberon-2, using
optimizing oberon compiler
First compiler target will be Oric Atmos microcomputer with MOS 6502
Port to other 6502 based cpu's and
PIC/Atmel microcontrollers are planned.
PC/Linux port also will be available.
Lotta language full documentation
is not available, but will be published
I can write only few things about Lotta yet:
Lotta designed to produce very
small and fast code. I hope it will even be useful to participate
programming competitions with size limit 1 or 4 kb (like one at http://ffd2.com/minigame)
Because of that, information available at runtime should
be minimized as possible. No pointers, no dynamic arrays, only
static variables are allowed. Heap usage minimized as
possible. In fact, heap is useless for Lotta
Compiler should allow generating code which will use zero
page intensively. This will allow extremely
decrease resulting code size. In this case, returning to
host operating system (for instance Tangerine Basic)
may be impossible.
Lotta compiler should use new
technique, introduced by fpc
called smart linking.
That means, only procedures which called from the other
parts of code are compiled.
Difference is, that in case of fpc that is done by
translating each procedure into one object file.
In Lotta, it is done on the parser
level, parser just ignore unused procedures and does not translate them.
This allows decreasing code size efficiently.
Lotta is a modular, strong typed language. It
performs strong type checking at compile time.
Module procedures, variables, types and constants may be exported or
exported as read-only 
Aliasing of module names is not possible.
Function procedures may return
two results, possibility to return array or record variables.
Because Lotta is not object oriented, enumerated types are allowed 
When calling procedure, only variable parameters accepted, not
expressions, because it is easier to make mistakes, and
there is no possibility to view expression result while debugging,
because it isn't assigned to any of declared variables
Procedure parameters could be by pointer (VAR) and read-only.
One pass easily retargetable compiler
In the past, two main types of compilers were avaiable.
In first case, parser generates an object code (or assembler source)
In second case, parser generates intermediate representation. It
thereafter at second pass parsed again and translated to the target
machine native code.
In this case compilation are more time consuming because of second
pass, but on the other hand task of writing another backend simplified,
because there is no need to change parser part of compiler, instead
only new backend should be written.
At that time, memory was limited, so, there was many multipass
compilers even for languages, which design allows to write one pass
compiler. First Modula-2 compiler made 7 passes to compile source code.
Per Brinch Hansen wrote a book about how he wrote multipass pascal
compiler for computer with only 64 kb ram available. 
Now memory is not that limited and now possible to translate
intermediate representation into target code on the fly
"FreePascal BuildFaq", Marco van de Voort
Modula to Oberon", Niklaus Wirth
 "Brinch Hansen on pascal compilers", Per Brinch Hansen
"Oberon-2 report", H. Mössenböck, N. Wirth
 "Pravetz-8D manual"