May I ask who has used this combination and how good that has worked?
What about ease of deployment also? Especially interesting would be in conjunction with either Seaside or Aida/Web...
Watched some MountainWest RubyConf 2014 talks and noticed an interesting theme. Many dynamic programming environments back in the old days used to be self-contained VM images, e.g. SmallTalk, GemStone/S.
One could checkpoint, modify, and ship these images wholesale and have it up and running with very little effort. Fast forward to now and I'm still using Make files to configure and install binaries. What happened?
Web applications usually have a database.
The code and the database work hand in hand together.
Therefore Frameworks like Ruby on Rails and Django create migration files
Sure there are also servers written in Self or Smalltalk or other image-based systems that face the same problem: Code is not written on the server but in a separate image of the programmer.
How do these systems deal with a changing schema, changing classes/prototypes.
Which way do the migrations go?
Example: What is the process of a new attribute going from programmer's idea to the server code and all objects?
I found the Gemstone/S manual chapter 8 but it does not really talk about the process of shipping code to the server.
Transparent persistence allows you to use regular objects instead of a database. The objects are automatically read from and written to disk. Examples of such systems are Gemstone and Rucksack (for common lisp).
Simplified version of what they do: if you access foo.bar and bar is not in memory, it gets loaded from disk. If you do foo.bar = baz then the foo object gets updated on disk. Most systems also have some form of transactions, and they may have support for sharing objects across programs and even across a network.
My question is what are the different techniques for implementing these kind of systems and what are the trade offs between these implementation approaches?