On Sat, 2 Jul 2016 06:05:47 -0700 David McClain dbm@refined-audiometrics.com wrote:
Hi All,
After having been comfortably isolated in a Lisp atmosphere for more than 20 years, I’m finding myself being dragged into a “new” world centering on Javascript and prototype based programming. It feels like I’m being dragged back by more than those 20 years, but in an effort to overcome the resistance tendencies of aging, I thought I’d delve a bit more deeply into this realm.
I’ve done some investigating and found the genesis in Self. But really, this seems like a trivial kind of pursuit for Lisp. I am aware of the new difficulties in making fast systems with the lack of classes, and troubles deciding inheritance of behaviors.
Does anyone have some interesting insights and pointers to papers regarding prototype programming in Lisp?
There is various documentation available on optimizing JS, i.e. tracing JIT, etc as it's so popular. Unfortunately I don't have exact references on hand without some searching myself, I haven't followed the development in years, but I used to follow the SpiderMonkey to TraceMonkey developments on the Mozilla js-eng mailing list, of which archives are available. I was an avid SpiderMonkey+JS user before I got into Lisp, but for application programming rather than the web. (i.e. http://mmondor.pulsar-zone.net/mmsoftware.html#js-appserv-sh )
A naive system with a prototype chain implemented as a list, and objects implemented as hash-tables, is indeed rather slow. In Javascript, the programmer also should make an effort to not overly use closures and to as possible inherit from the parent prototype objects to avoid unnecessary object creation overhead (i.e. complex constructors doing a lot of object-instantiation setup are slower than a pointer to a parent object). This is also true for functions that are object properties, and closures often cause extra per-instance initialization in this model. Beware that I was still very new to Lisp, but a very naive test implementation: http://git.pulsar-zone.net/?p=mmondor.git;a=blob;f=mmsoftware/cl/test/protot...
There is an interesting similarity for prototype object property references and symbol references in Lisp packages; and an approach that can be used is to create a faster reference like an index ID or pointer when "interning" a property/symbol, such that generated code can use faster indexing instead of hash table lookups at runtime. A small example of what I mean: http://git.pulsar-zone.net/?p=mmondor.git;a=blob;f=mmsoftware/cl/test/vsymbo...
But there also are many cases where inference can allow to eliminate a lot of dynamic code to result in more static code. ECMA also defined extensions for less dynamic objects which are closer to Java classes, for use when optimization is more important than flexibility. I'm not sure if those are currently used in JS as they were in Flash, however.
An approach could be to compile Lisp to Javascript, and to implement the prototype system library to use the native features of the language, and take advantage of currently optimized engines and their dynamically-specialized JIT/VMs. There is also asm.js and WebAssembly which are realistic targets for an existing bytecode compiler. There may actually exist simpler Lisps already targetting Javascript (there are libraries that compile a limited subset for web frameworks at least). Perhaps that extending such, or implementing a temporary simpler Lisp for initial testing might be a realistic investment?