These are the things that I haven't seen in any other language, and are the
reason that I'm doing this project.
- built-in support for persistent objects (being able to refer to objects
on disk much like you would refer to global variables)
- built-in support for non-fifo execution
(e.g., event-based or interrupt-based execution)
These are things that are already present in several other languages, but not
necessarily mainstream yet.
- a safe language where it is impossible for any program to even try to
scribble on arbitrary objects in memory
- a developer-friendly language
MiniMe is a research project to try to answer the following questions:
How practical is it to have to specify the region to store each created
How can patterns be generalized?
How can security be built-in?
How can synchronization be built-in?
How practical are coroutines and other non-fifo execution?
Simplifying the Language
While there may be several other goals that one might want to see in an
industrial strength programming language, trying to handle a full blown
language all at once proved too overwhelming for me (one person). So, in
an effort to focus on the unknown stuff (the research goals), I was forced
to simplified the language in several ways.
I tried to simplify the
language as much as possible by eliminating as much as I could from the
language that would not require any research in order to implement. I
tried to leave just enough in the language so that useful programs could be
written in it to be able to determine whether the research ideas are valid
or not. Also, I've cut out complexities that would be necessary to maximize
CPU performance or minimize memory usage.
The idea is that if this "mini" project works and the research ideas prove
useful, then a larger project might be started that would not take these
shortcuts in order to achieve the language's full potential.
The list of simplifying assumptions are:
Don't use a concurrent garbage collector.
Don't do any concurrent stuff (at least to start with).
Don't have compile-time types, all types are run-time.
also means no parameterized types.
also means we don't need to allow internal pointers.
Simplify numbers: only integer.
Forget internationalization, use ASCII chars.
Use textual representation for permanent storage.
Do large hash tables in the file system and don't manage permanent storage.
when traversing the filesystem, each directory is treated as a hash table