Commissioned work on comparing NativeContinuations (also, Rhino on Satellites)

[Michael Bar-sinai]

Hello Everyone,

I'm working on a research project that allows the programming of very reliable concurrent systems using a novel programming paradigm, and formal verification techniques. We're using Rhino as a main part of the runtime. The project had some early successes, and yada yada yada we got a grant for building a satellite prototype, where the on-board software will be written in Javascript and ran in Rhino. If this phase works, we're supposed to actually launch a cube satellite controlled using this method.

At the moment, we're comparing NativeContinuations using a lot of reflection, which is obviously bad. But - part of the grant money is dedicated to making state-based comparisons between NativeContinuation objects (here's the GitHub issue). This work should end up as a pull request to the main Rhino branch, and later integrated into Rhino.

If anyone here is interested in working on this (especially Rhino committers), please contact me / reply below.

Thanks,

Michael Bar-Sinai

[Attila Szegedi]

Hi Michael,

I’d be happy to work on this. 

For context, I was the person that was fostering getting continuations into Rhino mainline from code originally written by Igor Bukanov. 

Later on I was using them in a proprietary mission-critical system for a pretty big company (can’t really say more :-) ) where we were multiplexing hundreds of thousands of long-running processes on a small number of threads using Rhino continuations. Of particular interest to you might be the fact that we were serializing continuations too, and among other things I implemented a system where I cryptographically fingerprinted the functions (InterpreterData objects if memory serves correctly) and saved the signatures of on-stack functions with serialized continuations and verified them upon loading to make sure the code hasn't changed since the continuation was saved. (The functions themselves weren’t saved as they would be large blobs and also lead to object duplication when loaded, but instead I had a custom serialization replacers/resolvers that were replacing functions with stubs on serialization and resolving them to canonical instances of function code on deserialization.)

Later on I transplanted some of those ideas into the domain of web MVC; producing a Spring MVC component where you could write web flows using continuations (it’s on https://github.com/szegedi/spring-web-jsflow) at the moment.

So, you could say I’ve been doing a lot of work on continuation based systems in Rhino, mostly between 2003 and 2010. Incidentally, I was just modernizing spring-web-jsflow over a weekend sometime last year.

So sure I say, if this is what it takes, let’s help Rhino go to space!

Attila.

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

[Michael Bar-sinai]

Hello Atilla,

It would be great to have you work on this. I'm quite aware of your work - we talked briefly after your JavaOne2018 Nashorn talk. I used your continuation serialization technique to implement the verification system we currently use. We're not hashing functions yet, but we should - memory consumption is already an issue.

Could you please DM me on Twitter (@michbarsinai) so we could finalize the details and get that cubesat (prototype, for now) going.

Thanks,

Michael

[Attila Szegedi]

Oh sorry, I’m terrible at putting together faces and names on initially meeting people; of course I remember our conversation from last year :-)

Attila.