less in the order in which they should be done.
There are many, many small items to work on as well.
And documenting everything is an ongoing task.
The intermediate result needs to be stored in a file, using a protocol buffer.This has been partly implemented: zui.proto is now used for the parser output.
But the parsing is still done every time.
Testing
The compiler itself needs extensive tests. This should also locate any
ambiguities in the language. Currently there is a set of tests to verify
the compiler works correctly. However, the main test is building the compiler
itself, and that binary then has to pass the compiler tests.
We need a nice way to test Zimbu programs. Mocks and more.
In a test access is always allowed, avoids "visible for testing" stuff.
Templates
Templated classes and methods work. But they are produced for every set of
template types, even though the resulting code is identical. Need a mechanism
to produce the code only once, e.g. for all reference types.
ZWT - Zimbu Web Toolkit
The basic things are working. This is also about producing JavaScript code.
- all the generate methods that only work for C need to be found and fixed
- the layout mechanism must be separated from styles (e.g. margins)
- more widgets are to be added
- need a way to set a theme
Protocol buffers
This is a solid method for communicating between programs and a clever way
to store structured data.
Status: This is implemented as a compiler plugin. RPC is working between
a ZWT UI and a server,using JSON format.
Need to support more types, options and "import".
Need to support MessageSet.
Need to support RPC between two Zimbu programs (RPC from ZWT is working).
Strings
Four string types have been implemented.
The "varstring" and "varbytes" types can be made more efficient by storing
cords and using copy-on-write.
Access control
Need a way to make items immutable. Also recursively for composite
types. Something like "const" or "final".
Threading
Most processors have multiple cores now. Basic threads are working, but we need much more:
- simple ways to spread work over multiple threads: work pool
- implement WITH
- simple way to make a data structure thread safe, synchronized.
Database support
Many programs need to store data. Add at least one database, probably SQlite.
For now protocol buffers can be used to store and retrieve data.
Memory management
A first reference-counting mechanism has been implemented. It adds quite a bit of overhead,
but it is predictable. There is no unpredictable garbage collection freeze.
The next step is to use a separate thread to manage memory. The main threads write
information about references to the manager thread, so that management does not slow
down the main work.
An alternative is to use another mechanism: A multi-threaded sweep through used items,
after which one thread releases unreachable items.
Translations
We need support for multiple languages. Both to have the strings in the binary
and with runtime files that can be installed separately. And for ZWT generating
multiple versions for browser+language combination.
Builtin modules
We need to have a solid set of libraries, so that we can make them work
nicely together and be consistent.
- Make an example of how to wrap an existing C library.
- Write the documentation first to be able to make it consistent
- The HTTP module needs more work.
