Friday, October 17, 2008
When I first started this blog I naïvely thought that because I have been thinking about this for so long that I had it all firmly clear in my head, and it would pretty much come out in some sensible order.
Instead I have discovered that along the way I will end up going back and documenting something that seems so self-evident that I have forgotten about it completely.
One example of that is really documenting what are the activities I expect to be able to do with the PIM. This is implicit in a lot of the previous posts, but it is definitely worth making it explicit here.
Basic activities that I expect a user to be able to do include the following:
Capturing and evaluating input: Being able to triage and classify events, tasks, contact information, and other references and notes as they come in. Being able to quickly decide what needs to be handled immediately, what can wait, and if something needs to be scheduled immediately the user should be able to do that quickly even if it means classifying it or scheduling it approximately. "oh look, a dinner invitation, I don't even need to look at it until next week, so I will throw it into next week.". Being able to throw a note down into the system to be converted to an action or a task later.
Organizing: Going beyond the initial triage to the point where tasks and events are being scheduled in time (or at least the order is being set), as well as coordinating with others. Being able to overlay your own taxonomy/ontology/organizational structure onto the raw objects in the domain ( events, tasks, promises, actions, contacts, etc.). Being able to extend the raw objects of the domain so that they can be personalized to carry the information that the user needs.
Collaborating: Not only sharing calendars, but tracking conversations associated with shared activities. Tracking the status and progress of projects from organizing your grandmothers birthday party all the way to coordinating the training of a large group of people.
Squirreling things away so the nuts can be found again: one of the biggest battles for users of a PIM is storing the data (documents and pictures and other information) associated with an event, a task,a person, or a group in such a way that it can be easily found when needed.
Finding: Looking through information that you stored off to the side with the intention of finding it again. Being able to reconstruct timelines based on e-mail conversations and scheduled events.
Presenting: Visualizing and reporting on the data in a way that is natural for the user. Being able to generate reports on the status of projects from scheduling birthdays and tracking who is coming all the way to larger projects like the implementation of a training regimen for a group of trainers.
Hello folks, I am back.
I have been working on the PIM for a bit, but without the space to actually blog about it.
I started experimenting with actually code. I have been working on the basic data model classes and how well they model real-world situations. I am not yet at the point of publishing the code, but I'm starting to get to the point where I can actually think about it.
One of the things I've been working on was trying out the java persistence technology Known as DB 4O.
My intention has been to find a database storage technology that handled hierarchical data well. Relational databases manage many situations very well but even the best ORM (Object Relational Mapping) solution tends to break down when handling deep, flexible and higly modifiable hierarchies.
In order to handle the kinds of events and extensibility that I am looking for. I need to be able to store and quickly retrieve objects that are referenced from hierarchies/taxonomies where the objects themselvesstore general attributes.
To give you an example I want to be able to generate taxonomies that have a fairly deep structure ( friends-> college friends->the guys-> the wedding party) and be able to walk that taxonomy and quickly collect all the elements it points to. Then, if necessary, I would like to be able to rearrange the hierarchy. This is doable with a relational database and an ORM but no matter how carefully you balance the design, and inevitably there will be performance corner cases that are drastically inconsistent with the performance of the rest of the system.
In addition, I want users to be able tocreate their own classes of events and tasks. For example, I would like users to be able to create specific events and add their own attributes. if a user would like to distinguish between kids birthday parties and general birthday parties, they should be able to simply create a kid's birthday party event with customized properties and then be able to search within those customized properties.
Generic attributes such as this often present headaches for ORM frameworks, though not nearly as bad as managing hierarchical data.
So I was pretty sold on using a decent object storage framework. If I could find one!
DB4O has pretty much answered my requirements.
Through a mixture of byte code instrumentation and good design the DB40 folks have achieved a minimally intrusive persistence framework that effectively speeds up development, unit testing, and general maintainability of the code.
To give you a code example:
// Open the DB
Configuration configuration = Db4o.newConfiguration();
db = Db4o.openFile( configuration, filename);
// Create a bunch of objects (no matter how deep the hierarchy
- items = methodThatCreatesAllTheObjects();
// Store the objects
// Close the transaction
As you can see there is a minimum of explicit code by default. So I don't have to explicitly open a transaction, that is done when I attempt to store the items.
There are of course, ways to explicitly do all of the actions necessary, but so far I haven't needed to go outside of the defaults.