Pre-Thesis and Current Research
I’ve presented my PhD pre-thesis on the past 2 of July, and I’m glad it has been accepted by the Jury: “Adaptive Object-Modeling: Patterns, Tools and Applications”. I was also honored to have Joseph Yoder, from Refactory Inc., as my external supervisor. His contribution and ideas will be, undoubtedly, extremely useful during my doctoral research. I’m now officially a PhD. ABD (All But Dissertation).
For those who are wondering, the Adaptive Object-Model (AOM) is a software architectural style which allows for runtime adaptivity of the domain model. It succinctly consists on using an object-based metamodel as a first-class artifact from where all concerns are inferred, or derived from; classes, attributes, relations and behavior are represented and stored as data. At runtime this information is interpreted, instructing the system which behavior to take. Changing the model data immediately results on the system following a different business domain model.
The fact is, while an AOM defines a software architecture and design, any particular implementation of an AOM results in a Domain Specific Language (DSL). There are no standard DSLs for AOMs, and probably there will never be; the strength of AOMs rely in the fact that they are built bottom-up, instead of the top-down approaches other MDSE (Model Driven Software Engineering) methodologies and tools are based upon.
Actually, my thesis will be exactly about that: the study and documentation of a set of patterns, recipes and tools, together forming the basis which any developer can pick and use in its system. The validation of the thesis will, in part, be evaluated by the construction of a prototype framework that lies upon the theoretical models inferred (which, incidentally, is progressing fast enough to already have some production-level commercial applications built on top of it!)
For those who are not following along, let me put things this way: imagine you pick up any semi-formal notation, like UML + OCL, and you feed it to a program. This program will adapt itself, from structure to interface, resulting in a new application ready to use, without any further programming from the developer. You feed it the model that represents an Archeological Heritage Information System, and done! But there’s more: while the system is running, you change the model: you create new objects, new business rules… All applications will react according to the new model, and will evolve automatically, while maintaining their integrity, without any kind of code-generation or shut-down.
Do this seem like a dream? Well, it isn’t. It’s reality, right here, right now. But, somehow these theories never became mainstream. I intend to change that… or at least, give a small contribution 
And this is my thesis on a nutshell (details are always boring).
While writing this post, I also received an email from a friend suggesting that I should read Martin Fowler’s latest blog posts. It’s interesting that DSLs and MDSE is gaining so much attention these days. Martin, we are all anxious to lay our hands in that new book of yours 
Tags: Computers, PhD, Programming
July 15th, 2008 at 9:02 am
Sounds great but this excerpt scares me a bit:
“… while the system is running, you change the model: you create new objects, new business rules… All applications will react according to the new model, and will evolve automatically, while maintaining their integrity, without any kind of code-generation or shut-down.”
How can you ensure the integrity when you’re changing the rules on the fly? What about ongoing transactions on objects which are being modified in runtime? And context (sessions) becoming obsolete or invalid after some data rearranging?
July 15th, 2008 at 11:22 am
Taking something Martin Fowler says in the post you are linking to:
I think we are definitely part of that second bunch
I’ve been changing my mind about DSLs lately. I think a programming language that would include a DSL for expressing domain models would have a lot of advantages.
The C# / LINQ combination is an example of something of the sort, where a general purpose programming language is extended with a querying language.
Adding such an extension to express domain models would be great. I don’t think plain classes are enough for this any more.
July 15th, 2008 at 12:10 pm
Alves,
We currently have a paper under reviewing for this year’s PLoP conference, where we show how to maintain the integrity of the model during a system evolution. Just stay tuned for more
July 21st, 2008 at 5:22 pm
I too have long been a fan of Yoder’s (and Foote’s) work and I also wonder why Adaptive Object Models have not caught on. I based my Capstone research on the subject and have used them successfully on several projects. I encourage you to do what you can to raise awareness. The benefits are significant.
I have taken to describing AOMs using the phrase “Code as Data”. Here is my reasoning. In an Adaptive Object Model one uses meta-data to describe objects and, more importantly, the relationships between objects. Once these relationships are captured in meta-data, it then is very easy to think abstractly about the design and to play out “what if” scenarios. Accidental complexity becomes obvious as redundancies in the object model become more apparent. The result being that Software Engineers can do a better job of reasoning about a design. This happens in much the same way that the Database Engineer will use the meta-data of an Entity Relationship Diagram to reason about the design of his or her database.
Please keep posting about your work.