> The LoLa runtime is designed to be saved to disk at any point not executing any code. This means that you can let your script execute for 1000 instructions, save the runtime state to disk and resume execution a week later on another computer, not having any problems with script resumption. This is especially useful for games which often want to embed the state of their scripts into the save files.

This seems pretty cool. Don't know if this is more common in game scripting languages, but I've never seen it before

These are indeed rare features, only very few languages have them:

Stackless Python: https://stackless.readthedocs.io/en/2.7-slp/library/stackles...

Also Tcl and some special versions of Java and WebAssembly VMs, Lua with some ugly hacks. I tried to find systems like these: https://github.com/void4/notes/issues/16

Challenge for language designers: make this kind of sandboxing work recursively, and 100% securely: https://www.reddit.com/r/ProgrammingLanguages/comments/jxo92...

"10.4 The image file provides a frozen in time snapshot of a running Pharo system. This is the file where all objects are stored and as such it's a cross platform format. An image file contains the live state of all objects of the system (including classes and compiled methods, since they are objects too) at a given point. An image is a virtual object container."

https://ci.inria.fr/pharo-contribution/job/UpdatedPharoByExa...

When the Smalltalk implementation provides lightweight processes, snapshot saves the state of the lightweight processes — so when Smalltalk is restarted, the lightweight processes restart and continue doing whatever they were doing.

Unfortunately, Smalltalk will never have the protection aspect simultaneously due to its global access system.

Many Common Lisp implementations allow you to dump the program state to an image, which can then be loaded later.

What do they do about open file descriptors?

Store the path, position and open mode. Pipes will fail. Dynamic modules (shared libs) are also tried be re-opened.

R does something like that, it's pretty cool.

Could you elaborate?

R has this concept of workspaces. A workspace contains the loaded modules as well as the state of all user-defined variables, their values, etc. And a common workflow is that the entire workspace state is persisted in an RData file. It's like you were working in some REPL, but the last state of the REPL is persisted in between your sessions. So it's a different kind of programming, it's more interactive if you don't need to start from scratch every time. That means if something takes a while to compute, it's OK, because you only run it once, not every time you "run the program".

Ah. I use R a lot but gotten so used to not saving RData and Rhistory that I forgot why they were useful.

Different of course, but virtual machines do this.

> I've never seen it before

Common e.g. in Smalltalk VMs

Name collision with https://en.wikipedia.org/wiki/Lola_(computing).

I also thought this would be about Wirth's Lola (which I like as a simpler alternative to Verilog or VHDL.)

The focus on the IR and encodability is quite interesting. If I'm understanding this FAQ item correctly

> Why does the language not allow user-defined objects?

it has a Lua-ish arrangement where "modules" and "objects" overlap.

Seems neat. Added to my weekend reading to look more closely at the implementation.

1) the language looks cool, seems very easy to learn. 2) Shudders in Nobakov.

Love the simplicity of this language, and written in Zig!

That is interesting too. Zig seems cool. I get good vibes from it. It almost makes me wish I was a systems programmer, rather than a business software programmer.

These serialization and protection features are _awesome_!