These are the things that I haven't seen in any other language, and are the reason that I'm doing this project.

1. built-in support for persistent objects (being able to refer to objects on disk much like you would refer to global variables)
2. 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.

1. a safe language where it is impossible for any program to even try to scribble on arbitrary objects in memory
2. a developer-friendly language

1. How practical is it to have to specify the region to store each created value at?
2. How can patterns be generalized?
3. How can security be built-in?
4. How can synchronization be built-in?
5. How practical are coroutines and other non-fifo execution?

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