[Haskell-cafe] Consensus about databases / serialization

[Peter Verswyvelen]

As I'm a selfmade man, I never really studied relational databases in
detail. My intuition told me that the "relational" part was not really
suitable for the 3D data, 2D images, animation curves, state machines, and
other data I encountered in the videogame and animation business. I could
always get away with files, and for the applications I needed to deploy,
plugging in a couple of extra gigabytes of RAM and serializing the "object"
state to disk was more practical, cheaper and faster. 

 

However, a couple of years ago I started studying computer science (I seem
to do the theory after the practice, weird behavior ;-) at the Open
University, and one of the exams I did was about databases. Initially this
course convinced me that databases are actually very nice, but the course
ended with a topic on object oriented databases, which were designed to make
storing data like "3D models, graphs, networks, and complex datastructures"
more practical. Duh.

 

Since then, I did deploy a few commercial applications for customers using
databases, which worked fine for the typical "simple/flat" database data. I
hated embedding a dynamic untyped language like SQL, as much as I hated
embedding code in HTML or XML. IMHO it feels UGLY and unsafe. Regarding the
other popular data storage format - XML - I did use that a lot, but it seems
like going back to the stone ages, when hierarchical stores/databases got
invented (and ditched?)

 

Now, initially after an introduction to Microsoft's LINQ, and recently
having read a very brief overview of HAppS, it seems I'm not the only one
with those "feelings". 

 

Ouch, this introduction got way to long, sorry about that ;-)

 

Finally some practical questions:

.        regarding Haskell and databases, the page
http://haskell.org/haskellwiki/Libraries_and_tools/Database_interfaces
describes a few, but which are the ones that are stable and practical? Any
user experiences?

.        HApps is not listed in the page above, because it does not use
databases? Is HApps reliable or experimental, and does it scale well? Any
success stories?

.        regarding Haskell and serialization, I don't think that
implementing Read/Show is a good way for real serialization, so what other
options exist? I could find some libraries at
http://hackage.haskell.org/packages/archive/pkg-list.html#cat:Data, but
again which are the most practical and stable? When programming in C++/MFC
and C#/.NET, I tended to develop my own serialization frameworks because I
used that for many things, like logging commands to disk, performing
undo/redo, intra and inter process cut/copy/paste, save/load, etc.

.        Regarding serialization, I'm kinda curious how ADTs and even GADTs
are stored and retrieved in a relational database? I guess it could be done
using BLOBs and serialization to ByteStrings, so bypassing a lot of the
database table structures?

.        If I would want to experiment with say HAppS, the way I understand
it, I first would first have to study "Scratch your boilerplate" and
Template Haskell, and maybe some other language features? I'm still new to
Haskell, and the road to understanding all language elements and extensions
is very long, so sequentially learning it would be insane I guess. I have no
practical experience with TH, but I spent a long time trying to do "aspect
oriented programming" in C# without success, so TH looks uber to me.

 

Thanks a lot and best wishes for 2008?

 

Peter

-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://www.haskell.org/pipermail/haskell-cafe/attachments/20080102/46a08795/attachment.htm