This is what I just posted to the iaijutsu-dev list. It may be of wider interest...
It's been quiet on the list, but that's just because life has been crazy lately. But I won't get into that now. :) As it is, ths e- mail might get quite long as I try to convey a bit of what I've been up to in this silence. Here's the breakdown of what I'm going to write about:
- Installation - (Completely rewritten)
- Serializer - (New! and Improved!)
- Tools - (Iaijutsu CoPy and an FTP daemon)
- New home site - (under construction)
- Documentation - (or lack thereof)
- Other projects - (Hivemind, Dentatsu, IO::Filesystem, FTP daemon)
- Thank you!
As for Iaijutsu, it's far from dead. Still pondering a new name, have yet fo find a compelling replacement that encompasses what it is yet is a tasty sound bite for the corporate types I'm possibly getting funding from within my company. (And, of course, will be recognized and remembered by those who are *not* Japanese. :) )
Have completely rewritten the installation scripts (Makefile.PL and added postinstall). No longer using a canned SQL script to dump initial objects into the database. Now, the initial DB schema is contained in the serializer class itself and deployed by the same. So, the particular serializer you will use has contained within itself everything it needs to prep a database.
Also, the initial set of objects stored in the database are created by the postinstall script, using the system's own API. So far, this has meant MUCH easier work toward supporting a wider range of databases-- my roommate is working on getting it working with MS SQL and Access currently, and we're dreaming of getting it working with a CSV text format or something similar in the hopes of creating a test suite with canned data and few assumptions about the host environment.
Speaking of the serializer-- I've almost completely rewritten it. The previous version worked. And that's about all I can say about it. The new version is a bit of a hybrid between the old one and other object-relational mapping and persistence schemes I've seen. Its not quite complete yet, but the idea is there.
First off, storage is separated from indexing now. Before, they were one in the same, which was bad. Now, objects are serialized using Storable BLOBs and indexed by their ids. Indexing for queries is done by a set of tables indexing property values to object ids.
One one hand, there are tables based on classes, mapping columns directly to class properties. On the other hand is a set of tables mapped to datatypes, mapping to object properties not covered by the existing set of defined class tables.
This is a hybrid approach because most systems I've seen require a picture of your class framework at database creation. All classes and their properties must be defined at installation. This leads to a pretty good mapping of properties to columns and any optimizations which come from that. However, in Iaijutsu, some classes themselves may be objects... classes can be created on the fly, AFTER database creation.
So, the hybrid approach I'm currently working toward allows one to specify a set of class-to-table definitions. However, there is an 'extended' set of datatype tables to index all the other properties of classes not covered by the first set of tables. While this is not quite as efficient, it allows a more dynamic system. Once your application classes have stabilized, you can later on alter the database with more class tables.
Make any sense?
I've rewritten most of the tools for use with Iaijutsu. The insert and extract scripts are gone, replaced by a tool named 'icp'.
icp is Iaijutsu CoPy. It's based on the new IO::Filesystem class I'm working on, of which Iaijutsu::Filesystem is a sub-class. In other words, its like /bin/cp, only it lets you copy to and from Iaijutsu and your local filesystem. It also will allow you in the future to copy between Iaijutsu databases (locally, remotely, whatever...), and even between filesystems. So, when this is working perfectly, importing a site will be as easy as 'icp -vur mysite/ @mysite/'
Also, new in CVS is an FTP daemon. This also uses the Iaijutsu::Filesystem class, along with the Perl Object Environment (POE) to give FTP access to Iaijutsu. So far, I've been using this pretty heavily with emacs and Dreamweaver to author templates and document objects within Iaijutsu's database. There are some quirks and bugs I'm working out, but I've been eating my own dogfood and using the daemon pretty productively so far.
By the way, should you want to use these new features from CVS, or a snapshot I'll be posting tomorrow, you'll need the packages available from the following URLs:
Speaking of working productively... There's a new home site for Iaijutsu under construction at: http://www.ninjacode.com:8080/iaijutsu
It may or may not be up when you try to visit it. It may also be broken or in heavy change. But if you like, try the URL, and it'll most likely be up. It's a completely new design and layout, not to mention hosted by Iaijutsu itself.
There is a Slashdot-like news weblog with discussion, as well as sidebar headline syndication components (like Slashdot's Slashboxen) grabbed using RSS objects which (if the scheduler is running) refresh themselves periodically.
So, visit if you like, complain about it, beat it up, tell me what you think. There's not much there yet, but it's a start.
Unfortunately, not much good news here yet. :( Chasing down the bugs, and adding these last few features, I've been holding off and not having enough time in general to document this beast. But I'm only aobut 6 todo list checkboxen away from being done with coding and getting to writing.
I'm horrible about this! But I'm hoping that, after I'm done with these checkboxen, and do this, and release, I'll have the momentum to continue documentation properly from now on. Also, my day job may soon be more directly supporting me in this by demanding whitepapers and manuals to hand to clients who are using this system.
Thanks for hanging in there!!! (If you still are!)
Alternating between stealing time from and enhancing development of the core of Iaijutsu itself are the Hivemind and Dentatsu projects.
Hivemind, if you haven't heard me babble about is before, is a groupware project management, task delegatoin, time recording and reporting, and information collection application. It's currently the first and only long term tested and developed project using Iaijutsu, in heavy use by my department at the day job, and recording about a year worth of departmental activity so far. It's really putting the entire system to huge tests, with about 20 users logging into it and making heavy use of it daily. (Okay, so that does't sound very heavy, but it's putting Iaijutsu through its paces at least. And was what dramatically showed how broken my old serializer was)
Dentatsu is currently behind the new Iaijutsu home site. It is what will eventually run Ninjacode.com. Weblogs, discussion fora, member accounts, content rating, polls, distributed editorial ownership, collaborative authoring, etc and so forth... this will be the online publication toolkit. It seems to be currently about 1/3 complete.
Either of these projects (available in hivemind/ and dentatsu/ paths in CVS) may serve as a semi-decent example of what can be done with Iaijutsu currently. However, they are both even less documented than Iaijutsu itself, but I hope they are well commented for those who want to dig.
Also, as a side note, the IO::Filesystem class and FTP daemon may be showing up in my CPAN directory soon as projects spun off from Iaijutsu.
IO::Filesystem is an object oriented encapsulation of a filesystem and all its actions. ie. copy, delete, rename, open/close for write, open/close for read, test (-d, -f, -e, etc), ls, stat, etc... This seems to be something I really needed, and I think others will too. IO::Filesystem::Plain encapsulates the local filesystem, while Iaijutsu::Filesystem encapsulates a virtual filesystem on the Iaijutsu serializer. Also, the package will eventually have a suite of tools developed like 'icp' where common operations can be done on and between filesystem objects.
The FTPd is an general FTP daemon implemented using the Perl Object Environment (POE) toolkit and the IO::Filesystem. It is not bound to Iaijutsu, and will be useful as a general-purpose Perl FTP daemon. Just make an IO::Filesystem subclass, and the FTP daemon will serve files from it.
For what? Well, for reading this far. And for being on the list. Even quiet, I feel like there are people waiting on me to get this done. And for piping up when I mumble an occasional question. :)
Hopefully this wasn't too much of a brain dump!
Leslie Michael Orchard E-Mail: email@example.com
Senior Application Developer firstname.lastname@example.org (work)
impiric, inc. ICQ: 492905 (home) 11082089 (work)