m i n d c o d e

A paper I submitted this year to PLoP, “Patterns for Data and Metadata Evolution in Adaptive Object Models”, co-authored with Filipe Correia and Leon Welicki, has been accepted for publication. I’ll be attending both PLoP and OOPSLA this year in Nashville, Tennessee, USA. Meet you guys there

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

As I finish my paper for submission tomorrow (PLoP’08), the following strips start to give me that sense of deja-vu:

I guess one day I will laugh out loud about this… but not today

AOMs.Equals(42)

My thesis proposal has been approved by the scientific comitee yesterday, and it will be on:

“Adaptive Object-Modelling: Patterns, Tools and Applications”

Also, the first semester is gone. Here comes the second semester and my pre-thesis evaluation in July

Goes to Edmund M. Clarke, Allen Emerson, and Joseph Sifakis:

“Model Checking is a type of “formal verification” that analyzes the logic underlying a design, much as a mathematician uses a proof to determine that a theorem is correct. Far from hit or miss, Model Checking considers every possible state of a hardware or software design and determines if it is consistent with the designer’s specifications. Clarke and Emerson originated the idea of Model Checking at Harvard in 1981. They developed a theoretical technique for determining whether an abstract model of a hardware or software design satisfies a formal specification, given as a formula in Temporal Logic, a notation for describing possible sequences of events. Moreover, when the system fails the specification, it could identify a counterexample to show the source of the problem. Numerous model checking systems have been implemented, such as Spin at Bell Labs.”

For those interested in Model Checking and Formal Specification, you can take a peek at lectures from my PhD, specifically the courses Program Semantics, Verification and Construction and Model-Driven Software Engineering.

There you have: I wrote the first page of my thesis…

Today I’ve received the official result of my PhD application: I’ve been accepted to the MAP-i Doctoral Programme and classes are going to start this September. The programme structure includes a first year of studies, composed as seen here.

I’m still digesting the news…