v 0.1 – released 3/26/2005

I’m a bit behind in doing this, but my plan is to document each release of Bloo in the “Bloo Release Notes” category in this blog. This is for those of you with an “inner-geek”, so the rest of you can ignore this post 🙂

0.1 is the first release of Bloo. So we should start with some philosophical design-goals:

Bloo should be:

• Object-oriented
• Massively flexible when it comes to the front-end interface, database interface, etc
• Fully separated, code-wise, between the front-end interface (web) and the back-end (currently MySql)
• Built of components, called “SnapOns” and “Overlays”. In Bloo, everything you see is a SnapOn or an Overlay – more on that later
• Secure from the start
• Full of the prime features of mature blog software (posting, comments, trackback, rss, spam-control and many more).
• Other things that I’m certainly forgetting at the moment (I’m a little tired 🙂

Bloo v 0.1 was a long time a-borning. As a developer I tend to look for the “Platonic Ideal” in software – surely there’s always a way to make it better! What you see here represents the third iteration of a basic PHP framework I’ve written for user interfaces (Phoo or “Php Object Oriented”) with an object-oriented blog (Bloo – or “Blog Objects”) on top. I believe I’ve finally got it, because programming the Bloo framework has just flowed. It’s a good feeling. I’ve been experimenting with various ideas for how to do this for about a year – in my spare time, of course. I think I’m finally there.

My reasons for wanting to take this project on?

Well – first off, there is some great software out there for Blogging (B2, WordPress, Moveable Type, pMachine, etc). The problem I’ve had with the software I’ve used is that it hasn’t been object oriented. It’s written as procedural code and the various elements (HTML, SQL, etc) are scattered hither and yon throughout the code. In short – very hard to maintain.

Now, I’m not running these packages down. In functionality they currently blow Bloo away, because what I have released in version 0.1 is just bare-bones functionality: basic (but good) security, ability to post, edit and delete posts, comment, edit and delete comments, etc.

But the beauty of Bloo – to me at least – is that it is built on an object oriented framework that really provides separation between the front and back end. For instance, everything you see before you is what I call an “Overlay” – an Overlay is a template with dynamic elements – this page is an overlay. The left and right sidebars are overlays. The post layout is built from an overlay. Comments – overlays. Everything. Overlays are contained in what I call “SnapOns” – these are little intelligent objects that know how to do something, such as load posts, display comments, edit comments, etc. Overlays themselves can contain SnapOns which can in turn contain more Overlays which . . . OK – I realize this sounds confusing. But in practice it’s been a joy – truly.

For instance – I originally wrote this on top of the B2 table structure. I access that structure through a set of SQL overlays (stored as commands in SnapOns). When I created the Bloo table format it took me – no lie – about 30 minutes to completely convert over the posts and comments to the new structure. I did it on a laptop on the bus ride home. And that included creating the new tables. It was, no pun intended, a snap. It helps that, as a philosophical decision, all overlays are stored in one place, rather than scattered. They are each referred to in the code by their name. Bloo has a Bloo-specific table structure but, without much trouble, new sets of overlays could be created to allow it to ride on top of pretty much any blog’s table structure. Somewhere down the road I am going to create overlay sets for WordPress and B2 at least – giving anyone who wants to the ability to switch to Bloo without having to migrate their data.

I am familiar with and have worked with the concept of the “plugin” – the difference between a plugin and a SnapOn is this: a plugin basically “plugs in” to something already built – in my experience they are not implemented in a standard way and they do not represent the ability to touch all functionality. In Bloo, everything’s a SnapOn. Picture a bunch of legos – you can build something cool out of legos, and it’s all legos. So if you know how to make a new lego you basically can snap it on anywhere. No need to look for those few special “sockets” to plug in to. Again, I’m not here to run down other blog packages – all of which are far more successful than this project will probably ever be. Just here to try something new.

I will give a lot more detail on how SnapOns and Overlays work in later posts. I also plan on taking this software public domain when I hit some major functionality milestones. I’m a few major releases away from that.

Thanks for listening to me babble. I am really enjoying the software these days and I guess my excitement shows through.