There's a great example of a persistence library for Java that uses snapshots and command logs. It's called "prevayler" and you can read about it at http://www.prevayler.org

--Benji

Benji Smith wrote:
> There's a great example of a persistence library for Java that uses
> snapshots and command logs. It's called "prevayler" and you can read
> about it at http://www.prevayler.org
> 
> --Benji

I don't know about the Java model, but the Ruby implementation of Prevayler is an example of what I was talking about.  It requires a full memory state save of everything persisted.  And you must also roll in everything to use it, even if all you want to do is change a string (or, for that matter, an integer).

"Charles Hixson" <charleshixsn@earthlink.net> wrote in message news:bm4397$cll$1@digitaldaemon.com...
> Benji Smith wrote:
> > There's a great example of a persistence library for Java that uses snapshots and command logs. It's called "prevayler" and you can read about it at http://www.prevayler.org
> >
> > --Benji
>
> I don't know about the Java model, but the Ruby implementation of Prevayler is an example of what I was talking about.  It requires a full memory state save of everything persisted.  And you must also roll in everything to use it, even if all you want to do is change a string (or, for that matter, an integer).
>

I have been talking about this for a long time. Here is my last reply on Slashdot:

http://slashdot.org/comments.pl?sid=79683&cid=7042606

Objects need to be persistent. The main memory must be a cache between the hard disk and the CPU. The O/S must handle object orientation, class management and persistent.

All that a language needs is a 'persistent' attribute...each member marked as persistent will be automatically saved to/loaded from disk; if it contains other persistent members, they would be saved too in the order they are declared. The layout of the class (known to the whole system by the O/S) would be the format that the data are saved into.

Sorry if this seems slightly offtopic, but people don't seem to realize how a true object-oriented operating system would change our lives.

(And object-oriented languages would be a natural for it).

Charles Hixson wrote:

> how you would implement persistence.

The MyLang *core* will not only support low-level objects.  It won't
even directly support inheritance since there will be no need to.  See
section 3.13 "Low Level Objects" in the expanded MyLang overview at
http://kevin.atkinson.dhs.org/mylang/.  Inheritance and all OO conceps
can be implemented by the user using Compile Time Functions (see section
5.1).  The default library will provide an OO implementation which
will be as easy to use, if not easier, than C++.  I do not know if how
much persistence support will be provided.  However, if you are not
satisfied with what is provided you can implement it yourself since
MyLang provides you with the necessary tools to do so.  And it will be
just as easy to use as if it was built into the language.

Jan-Eric Duden wrote:
> yep.
> Really nice are for example the windows macros:
> 
> from windows.h
> #ifdef _UNICODE
> #define CreateFile CreateFileW
> #else
> #define CreateFile CreateFileA
> #endif

> Great, isnt it?

Not really great. We have "alias" for that. Macros make the semantics of the substitution blur and disappear. Alias stands for another identifier only in the context where it has been defined, while the macro will replace the same identifier in any other context. Think of Namespaces and Classes, which can have the same identifier refer to unrelated things. Heck, think of König lookup!

There has been some university project which made a context-sensitive pre-processor, which didn't expose problems of the C preprocessor, and had immense power. This is actually near to the direction Kevin is going, and was an effort to create something much simpler than OpenC++.

BTW, Kevin: I come to think that (among other things) i like your definition of inner classes a lot - because they are a generalisation of *properties*, making them so much more flexible! Like, you can have not only read and write, but also increments, decrements, all other operators defined directly, and with unrestricted access to the containing class!

-eye