Relational algebra out of the way, now back to the VM.

[Giancarlo Niccolai]

Hello all,

As I have written, in the last couple of months I have been busy researching "relational algebra". Relational algebra is a sort of lambda calculus with steroid (is actually a combination of lambda calculus and graph theory), and integrating it into the programming language of my choice, Falcon, has been my target for a long time. However, it wasn't formalized enough to "work" as expected, and I never managed to make the engine fully compliant with the theory.

The work on the theory is now complete, even if I am not ready to release the document to the public (it is currently in peer review), so I can now start to work on the virtual machine. The VM will be heavily based on the Organic Virtual Machine of Falcon 1.0, with some addition that shall be in the model from the start, instead of being added later on as an "afterthought", and which I worked at, loosely, while finishing the theory of relation algebra:

1) Heavily parallel-programming oriented. The engine as a whole went a long way in the previous incarnation to be multi-threaded, but now I have worked out some concepts that can be implemented down at VM level and do not require blind multi-treading compliancy. By being parallel-programming oriented, we can focus at providing parallel programming paradigms and drop some blind multi-treading support, as i.e. the need for atomic item updates. I have worked out a concept of locality of operation and consolidation of visibility, that totally obviates for the need of locking.

2) Basically aspect-oriented. Messaging entities will be the primary way to do things at VM level, with OOP Built on messaging instead of the other way around. This makes the point 1 much more easy to achieve, as "consolidation" will be a specific message to a parallel agent.
3) Funcional oriented: That's how the organic machine worked, we just need to copy from there.

4) Relational oriented: With relations built in the VM, we can model knowledge networks (as the one currently used by search engines to do cluster analysis and by AI engines do do similarity analysis) directly at VM and language level.

After the vm will be  basically working, even before starting to work at the language, we will complete virualization around the VM. Basically, it's a small OS, 90% or so written in the previous 1.0 engine, where an embedding program can interact with the engine by providing I/O (either virtual, network or file streams), processes and other shared resources. This will include the basic file, text-streaming (utf-x encode/decoder), module streaming and network API. Of course, this will also include Strings and basic types as vectors and dictionaries.

With this in place, we'll be back on the language. This is where I expect most of the work to be done: the engine is a lot of work but it MUST be kept small and compact -- and the basic concepts are already there. The virtualization is mostly done, even if we might need to refactor some of it to C++14. As for the language, I want to review everything we did for 1.0, adding the relational part, dropping the anachronisms (whatever was grown out of 15 years of usage -- and out of the necessity of the moment), and making everything more coherent and streamlined. 

Then it will be the time for the core module (feathers) and core utilities (mainly WOPI) to be ported. Don't expect much work there, other than refactoring.

Finally, the porting of the other modules.

It's a long road, but... I had been in much worse shape for much of my life, and did much more than this.

Who is in?

[Paul Nema]

Count me in.  I'll always help where I can.

--
You received this message because you are subscribed to the Google Groups "FalconPL" group.
To unsubscribe from this group and stop receiving emails from it, send an email to falconpl+unsubscribe@googlegroups.com.
To post to this group, send email to falc...@googlegroups.com.
Visit this group at https://groups.google.com/group/falconpl.
For more options, visit https://groups.google.com/d/optout.