Simple persistence …

I was notified about a posting about simple persistence in Smalltalk. The original posting was more than 2 years old. It was said, that in most cases only a simple persistency approach is needed.

Perhaps the right words would be “easy” instead of “simple”. Perhaps Smalltalkers should look for modelling tools – creating the basic code and persistence code, then you get the persistency more or less for free – or “simple”.

Using modellers in the Smalltalk community is not very wide spreaded – and very often seen as a bad programming style.

Other systems have very easy persistency approachs and can fullfill these needs without these problems. Perhaps time to switch the language ?

This entry was posted in Smalltalk and tagged . Bookmark the permalink.

2 Responses to Simple persistence …

  1. Friedrich says:

    Please tell me of very easy persistence approaches for OO languages. I want to use inheritance were it may help. AFAIKT there are hundreds of wrappers for ORM but they are not just more than kind of “glorified” relations.

  2. schrievkrom says:

    Well, I am no aware of *general* easy approaches for OO languages (meaning language independent). But when looking at specific languages/systems there are solutions available, giving you uncomplicated persistence approaches.

    I would not say, that these approaches works under all circumstances or under all data load or under all user expectations, but some of them fit the needs.

    Under .NET there are solutions, which uses the available user-defined attributes to define the persistency.

    For our system under CSharp we used the recording changes approach, where we record all changes and write them to files using a “special micro assembler language”. This is a very special approach and the system is an all-in-ram system, but the advantage is: speed. The disadavantage is: an upper limit of the data load (not because of 4GB, but because of the initial loading speed).

    But to get this handy in usage one needs a modelling tool, which generates most of the code you need to get the persistence you want – assuming a special programming model.

    We did not have one, but we wrote on in (VA-)Smalltalk, which produces the CSharp source code.

    We also changed the modeller to generate VASmalltalk code and use the internal swapper, assuming a special programming model we use.

    In general (and special under .NET) we got the speed because we automatically generate the code special for our programming model and no meta programming stuff was needed.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s