[compiz] re-architecting compiz

[David Reveman]

I'd like to start with apologizing for my lack of response to the
mailing list for the last couple of months. I'm working my way through
all posts right now...

Here's what I've been up to lately..

I did a critical review of the state of compiz about 6 months ago. I
realized it was pretty bad (not that there's actually anything better
out there but still), it's hard to maintain, hard to write proper code
for and in some ways not dynamic enough for people to do what they want.
None of the features I need to implement can be done properly in the
current architecture.

I spent a lot of time trying to come up with a way for us to re-engineer
the core of compiz and fix all the issues that exist in the current
architecture. I did a fair amount of research and experimenting before I
got an idea of what would be a good future architecture. What's emerging
in the object-framework branch is the result of this work and what I
believe to be the best way forward. There's still some important pieces
missing before I consider merging it to master a good idea but it's now
at least at a stage where I'm comfortable with people starting to look
at it and start discussing merging it to master.

Even though I've made sure that the rewrite allows existing plugins to
be fairly easily ported, it's still going to be the most significant
change to compiz since the initial version was realized. If we ever had
released a 1.0, this would definitely qualify for a 2.0.

Most of the ground work for this new architecture has already been done
in the object-framework branch but even when we've gotten it to a state
where it can be merged, there's still a lot of work left to make the
existing core functionality and plugins take advantage of it. However,
the considerably more modularized nature of this new architecture would
allow us to move to a much smaller core and get it ready for a 1.0
release in a short amount of time.

I'm going to send a series of posts to the list that explains the
different parts of the new architecture in more detail (hopefully the
first one during the weekend) but here's a few key features of the new
architecture:

A strict hierarchical structure. A very well-defined way for how the
different parts of the system communicate with each other (it's obvious
when some code is doing something inappropriate and it's also hard to
write code that is doing something inappropriate). Whether the code is
in the core or in a plugin is of no significant importance, which means
that pretty much anything can be modularized. Plugins can be inserted
into different parts of the object tree and only affect a sub-tree of
objects. An internal communication system that maps efficiently and
conveniently to various IPC systems.

-David