4 ms·

> while your "average" Lisp might be unsuitable for hard real-time applications (due to the presence of a garbage collector, usually without the hard real-time

> while your "average" Lisp might be unsuitable for hard real-time applications (due to the presence of a garbage collector, usually without the hard real-time constraints that you can get out of garbage collectors with extreme effort), I wonder if they have some equivalently interactive system on-board the while your "average" Lisp might be unsuitable for hard real-time applications (due to the presence of a garbage collector, usually without the hard real-time constraints that you can get out of garbage collectors with extreme effort), I wonder if they have some equivalently interactive system on-board the Hubble. This is fascinating to me. Do you have any pointers to information/research/projects focused on hard real-time garbage collection? A Lisp with hard real-time garbage collection (even if Herculean to implement) would be fantastic.

mietek 5y ago
How about a Lisp without the need for garbage collection at all? http://web.archive.org/web/20020331165324/http://home.pipeline.com/~hbaker1/LinearLisp.html http://web.archive.org/web/20020331165324/http://home.pipeli...
- baryphonic 5y ago
  This is also fascinating. Thank you! :)
- retrac 5y ago
  Ah, Rust's grandparent!
guenthert 5y ago
Not exactly real time (as in proven bounded response time), but a noteworthy effort: https://franz.com/services/conferences_seminars/jlugm00/conference/Talk14_takeuchi.pdf https://franz.com/services/conferences_seminars/jlugm00/conf...
astrange 5y ago
As long as there aren't cycles of course you can do deterministic GC, it's just reference counting. It also helps if the program is single-threaded since otherwise any memory allocation/freeing can be unpredictable (since it probably locks.)
- baryphonic 5y ago
  I've seen Prescheme (a subset of Scheme used to bootstrap a full-fledged dialect of Scheme) that seems to allow only stack-based allocation and therefore forbids certain types of closures that cannot be reduced via hoisting at compile time.[0] Lisp with ref counting (assuming acyclic references) instead of GC could also be interesting to try to hack together. I have a feeling closures would be a particularly quick way to get reference cycles, so some concept of weak references may be necessary. [0] https://thintz.com/resources/prescheme-documentation https://thintz.com/resources/prescheme-documentation
retrac 5y ago
I've seen at least one implementation that uses explicit regions; before doing something with say a bunch of cons operations, you allocate a region, all the evaluation is done in the region, it returns a result to the parent region, and the region is then manually dropped, freeing the space used. Set up another region for the next large evaluation and so on. Almost C style, and I'm sure just as error prone, but it seems like it could work. https://github.com/wolfgangj/bone-lisp https://github.com/wolfgangj/bone-lisp

mietek 5y ago

How about a Lisp without the need for garbage collection at all? http://web.archive.org/web/20020331165324/http://home.pipeline.com/~hbaker1/LinearLisp.html http://web.archive.org/web/20020331165324/http://home.pipeli...

baryphonic 5y ago
This is also fascinating. Thank you! :)
retrac 5y ago
Ah, Rust's grandparent!

guenthert 5y ago

Not exactly real time (as in proven bounded response time), but a noteworthy effort: https://franz.com/services/conferences_seminars/jlugm00/conference/Talk14_takeuchi.pdf https://franz.com/services/conferences_seminars/jlugm00/conf...

astrange 5y ago

As long as there aren't cycles of course you can do deterministic GC, it's just reference counting. It also helps if the program is single-threaded since otherwise any memory allocation/freeing can be unpredictable (since it probably locks.)

baryphonic 5y ago
I've seen Prescheme (a subset of Scheme used to bootstrap a full-fledged dialect of Scheme) that seems to allow only stack-based allocation and therefore forbids certain types of closures that cannot be reduced via hoisting at compile time.[0] Lisp with ref counting (assuming acyclic references) instead of GC could also be interesting to try to hack together. I have a feeling closures would be a particularly quick way to get reference cycles, so some concept of weak references may be necessary. [0] https://thintz.com/resources/prescheme-documentation https://thintz.com/resources/prescheme-documentation

retrac 5y ago

I've seen at least one implementation that uses explicit regions; before doing something with say a bunch of cons operations, you allocate a region, all the evaluation is done in the region, it returns a result to the parent region, and the region is then manually dropped, freeing the space used. Set up another region for the next large evaluation and so on. Almost C style, and I'm sure just as error prone, but it seems like it could work. https://github.com/wolfgangj/bone-lisp https://github.com/wolfgangj/bone-lisp