One of the first things that came to mind was the lack of DELETE
CASCADE and foreign key constraints. That one was a required feature
for the project, so I’ve poked around a bit, and it didn’t seemed to
be hard to do. Hands at work, and one hour later I had a very basic
working version. I sent a patch to the mailing list and asked for some
ideas, because I wasn’t 100% sure if my approach made sense. Ian
Bicking pitched in asking some questions, which made me realize
that I had misunderstood the way that DROP TABLE xxx CASCADE
worked.

Hands at work again, and I’ve got some working tests which
seemed fine to me. Then I’ve tried running the tests with SQLite,
which I found out to be a very nice database. I’ve had heard of it a
couple times since I started with SQLObject, but never got the time to
figure out what it was about. It ends up that installing and setting
up SQLite was a snap. Ready to go, run the tests. Two failing. Ops, I
had forgot to implement the DELETE RESTRICT constraint for the other
databases. It worked for Postgres because it was handled by the
database. Fixed that one and checked in the work so far to
cascadegeddon-branch (suggestive name eh?).

This morning I felt that it would be interesting to put my app to use
the constraints and see how it would behave. The app itself is a
complete rewrite of an application to keep track of samples in a
laboratory (I’m not sure if I’m allowed to mention the lab name), and
has a fairly large set of classes. The old app was a
Powerbuilder-based app, using Sybase. During the development, we used
PostgreSQL, and this week we are working on getting Sybase support
working on SQLObject to move the app over. I received a couple of CSV
files, which I had to massage to get into a reasonable shape for later
import into the system. For massaging and importing, I wrote a small
class behaved like a mix of list and dict. I used python’s csv module
to parse the files and populate an instance of this class, modify the
table structure and then dump back to another file. Then, after all of
this, I was able to use the same class, together with SQLObject to
import record by record (instead of using the database features) so
that it works cross-database. After adding the constraints, my import
script failed to import 145 records out of around 60k, because they
failed to pass the constraints. That was a very good thing, at least worth
the time I spent to implement the constraints ;)

So, if that wasn’t enough fun, I used postgresql_autodoc, which is a
perl script to dump a database to some interesting formats like
Dia, HTML, XML and dot (part of the graphviz package) for documentation purposes, and then used
dot to generate this image, which shows the tables and their
relationships (in this case, the foreign key constraints).

School is working out fine as well, except that is boring to do so
much homework. Sometimes I really think about dropping it
alltogether. Oh well…

Yesterday, there was a seminar on J2EE, on my Analysis class, and I
didn’t liked it. IMHO Zope 3 can go much further with some whipping on
the developers. One thing that made me feel a bit uncomfortable though
was the level of documentation that there is about J2EE on Sun’s
site. Humm… we really need to improve on that.

I started reading the Planning Extreme Programming book yesterday,
and I really enjoyed it. Really smooth reading, and with a twist of
humor that is really needed if you want to catch the developer’s
attention. Though the book is not primarily directed to developers
(they say the main target are the management people), I really
recommend any developer to read it, as it also helps you to understand
why that management guy keeps pushing you more and more and how to get
him off of your neck (I have too much to do!).

Also this week, I’ve been fixing DAV issues in Plone and the Word ->
HTML transform in Archetypes, which by coincidence I had tried just the week
before. Got it running on my box and then helped some long time
friends to fix it on their Red Hat (blargh!) box, where wvWare didn’t
want to cooperate. If you have ArchExample, Archetypes,
PortalTransforms, Plone, Zope, CMFQuickInstaller, wvWare
(phew!) and a swiss army knife, you can try it out. Just get the
ArchExample package installed (using CMFQuickInstaller, of course) and
see it at work. If you setup the content_type_registry to create
an Article for .doc extension, you can happily mount your Zope in,
say, Windows Webfolder stuff and drag-and-drop a Word doc for your
publishing pleasure. Personally, I use cadaver, which seems to be the
only stable way to get some conversation with all the WebDAV
implementations out there. If you don’t know what the heck I’m talking,
don’t mind. I may probably provide an External Method for setting up
this. Still don’t know what I’m talking about? Man, you should join
the folks at Zope-PT (that is, if you can read portuguese) and grow
your knowledge with them. I’ve seen
that group jump from a mere 0-3 messages a week to a whooping 10
messages a day in a matter of weeks! I wonder if it has something to
do with the fact that the government opened the doors to Free
Software, and lots of people are looking for a Zope programmer around
here. Humm…

But the great news is that I’ve got a thumbs up from my ‘manager in
law’ to spend a weekend with the folks at Async, doing all sort of
crazy stuff, from ZODB hacking to PyGTK ramblings. I can’t forget to
discuss with them a PyGTK frontend for Zope 3, which is a planned
feature for this Zope 3 project I’m doing.

TODO:

• Buy a backpack
• Check if my brother can take me to the airport on the Wed evening
• Write a facade folder implementation for Mr. Everitt and his crazy
  requisites. (He wants to make it possible for designers to see
  extensions on the skin files from Plone — which have no
  extensions by default and that breaks stupid Dreamweaver)
• Finish security parts 2-17 of Zope 3 project
• Finish reading the XP book
• Don’t fall apart!

• A object would need to have a category
• Depending on the category, different additional fields would be
  needed to be filled by the user
• The site manager should be able do control what fields are required
  for a given category

It sounds simple to you? Guess what: It took me almost a week to get
it implemented. Here’s what we did:

• Created a ‘Persistent Schema Utility’ object, which is registered
  as a utility and contains Fields. It also implements IInterface.
• Modified the local and global interface services to query the
  utility service for utilities providing a given interface when asked
  for a given interface

So at this point, you would be able to use a Persistent Schema Utility
as an interface. Of course it required some fixes on the
InterfaceWidget and a few other places that always assumed an
interface could be named after its __module__ and __name__, which is
not true on our case.

Next step was to do some work on the View service to get it working
with this. Nicely enough, it had only one problem: the ‘attribute’
field was not showing up on the addform view, so we added it. Then I
could test it by assigning the persistent schema to an existing object
and trying to use the registered local view (with a special
EditView-based class and template) to show an edit form for the
persistent schema. Guess what? It worked! I had to make some
adjustments on fields interfaces and register some zcml for fields but
that was mostly it.

Then Stephan Richter jumped in to help me, and built a Content
Component Utility, that lets you choose a schema and builds a content
object from that. It also allows you to set permissions for each field
of the schema, which is amazing!

An finally, to finish it all, Stephan wrote a local version of the
BrowserMenuService, to allow registering menus ttw, much the same way
as we register fields for persistent schema.

All I have to say is that this is looking extremely nice. Far more
nicer than I expected. Next step is finishing up some UI nitpicks and
getting Paul to make one of those amazing movies he does, explaining
how things work.

Just so you know, I’m working on the following stuff:

• Archetypes (trying to get 1.0 out of the door)
• Zope 3 (a project for another company, doing integration with
  SQLObject and having only one object in the ZODB)
• CMFCommerce refactoring (we’re making a local mini-sprint over the
  weekend on this)

Lots of cool stuff, but it sucks your time so badly it makes it hard
to follow the cool stuff that is going on out there.

For an example, see the RDF TALES Syntax that Arnia is
proposing. That’s really cool stuf and I would love to see this
working in the near future.

It does also fit on a bigger idea that we have been discussing in the
background for a few months, of a big repository of content (how-tos,
bug trackers, news items, people information) organized semantically,
and managed with a XUL-based GUI. Neat stuff. I can’t wait to get it
started.