Aspects and Objects
OK - I'm biased, but I'll say without a doubt that the Bowstreet Factory is the easiest to use, and most powerful "aspect-weaving" tool available. Why?
First, if you're wondering what aspects are, it's pretty simple, in concept. Aspects are features that exist within the fabric of a program. In other words, the code that comprises an aspect is sprinkled throughout a program. This is different from "objects", which are assembled in discreet places within a program. Think of "logging enabled" as an aspect that touches many areas of code. Think of "detailed reporting" as an aspect that touches many tables in a set of reports. Apsects aren't just blocks of code that you drop in and remove, the way you do with objects.
This might sound lame, but aspects and objects can be compared to things in a house - in order to clarify their differences a bit more. Think of an aspect as something like "green rooms", or "high ceilings", whereas an object would be something like a "water heater", or "doorbell". It's easy to add and remove objects, but it's hard to add and remove aspects - for obvious reasons. Removing the "green" from all your walls is harder than removing a water heater.
This brings us to my earlier point that the Factory is the easiest and most powerful aspect weaving tool available. The reasons are as follows: First of all, the Factory formalizes the concept of an "aspect" into something we call a "builder". Users create parametric models out of collections of builders that they snap together. The builders execute in sequence to produce customized outputs in the form of application code, data, whatever. The Factory makes it easy to use aspects by providing users with a palette of builders. Each builder has its own UI for gathering input parameters, and each builder has a regeneration mechanism that triggers it to "weave" its aspects into the application code. This is far easier to use than other "aspect weaving" techniques where users have to write their own programs to perform the aspect code writing. You can think of the Factory as an Eclipse-based tool for creating parameterized "aspect weaving" models.
Second, the Factory is by far the most powerful aspect weaving tool available, because it lets users do a whole bunch of powerful things with collections of aspects. Users can turn on and off collections of builders, and drive this with user profiles. Users can also build their own builders that invoke sets of other builders. The Factory is the only "composition tool" that enables developers to create their own aspects out of other aspects.
So, if you're looking for a way to start harnessing the power of weaving aspects into your applications, and, at the same time, controlling the way you turn on and off different aspects, then check out the Factory. It's a lot easier and more powerful than trying to learn something like AspectJ...
9:40:00 AM 
|
|
