Adaptive Object Model

Hugo Ferreira is a fellow AOM enthusiast. He and I have collaborated throughout the years, so when he asked me to write a forward for his thesis I did so with honor. I recently traveled to Portugal to sit on the jury of Hugo’s dissertation defense. The experience was a great one and I thought I would share the forward I wrote for his dissertation. He defended his dissertation elegantly and passed with distinction.

Hugo Ferreira’s Dissertation Forward

Over the last decade it has become extremely important for systems to be able to more quickly adapt to changing business requirements. Because of this there has been an evolution of the way we develop and think about building systems. For example, Agile processes have evolved as a means to try to build systems more quickly. But when working on Agile projects, developers can become overwhelmed with the rate of requirements change. The ease with which requirements can change encourages users to overwhelm us with requests for features. The result: Featuritis, which can promotes hasty construction of poorly designed software to support those features. The design of an expressive domain model might get lost in the rush to write working code. Adaptive Object-Models (AOMs) support changeable domain modules by casting business rules as interpreted data and representing objects, properties and relationships in external declarations. At first glance, AOM systems seem to contradict Agile values. Yet we find that under the right conditions, an AOM architecture has made our users happier and has given them the ability to control the pace of change. It can be the ultimate in agility!

This thesis entitled “Adaptive Object-Modeling: Patterns, Tools, and Applications” by Hugo José Sereno Lopes Ferreira has taken the next step in state of art research on best practices on building these types of dynamic systems. This work illustrates the necessity of software to adapt and change at sometimes rapid speeds. Hugo’s addition of seven key patterns brings together years of study and produce formalized patterns as an important contribution to the AOM community. The thesis also brings real world problems to light and centers much of the discussion on the inherent flaws of much of today’s software design practices.

The work reveals much about the current state of Adaptive Object Model practices in industry. I found the thesis to be a quality entry into the current AOM research and very enlightening for in the software community building these types of architectures. The review of AOM architectural style, the patterns catalogue, the outline of the reference architecture for AOMs along with an example implementation makes the work very relevant and informative, as well as a pleasure to read. Additionally the case studies highlight the common issues and problems addressed by AOMs along with proving AOMs exist as a common solution for these types of systems.

I look forward to future collaboration with Hugo on this topic area and it my pleasure to strongly recommend this work to architects and developers that are building these types of dynamic architectures.

I recently traveled to the SATURN 2011 conference in San Francisco. The Software Engineering Institute hosted the conference. Rebecca gave a talk entitled “Agile Adoption, Does It Have To Be All in Or Fold?”

In her SATURN 2011 IEEE Software plenary talk, Rebecca Wirfs-Brock presented case studies of experience reports from the Agile Conference to illustrate various ways in which people perceive what it means to be Agile.

I also gave a Plenary talk entitled, “Big Ball of Mud: Is This the Best that Agile Can Do?”

It’s a myth that Agile doesn’t support design–it’s ok to have good design. Good proven practices and patterns can help. Imitate or use proven quality techniques. You can escape from the spaghetti-code jungle. Have to commit to architecture. “SEI has done more for keeping mud out of our lives than Agile ever has.”

 

Hello! Since this is my first post, let me introduce myself. My name is Reza Razavi. I’m currently heading the research and innovation efforts of AAS that I co-founded in 2007. I’ve been involved in developing industrial AOMs since 1993. In particular, I implemented a software system for calibrating bore gauges that allows domain experts defining new gage types, their attributes and calibration procedure themselves, and make them readily (without compilation) available for use by calibration operators. Calibration procedures are defined as a composition of atomic measurement and calculation services. This allowed our customer to reduce the cost of their maintenance by at least a factor of ten, while being able to easily adapt their gauge calibration procedures to specific customer needs. Then, I switched to academic research and have been collaborating with Ralph Johnson and Joe Yoder since the early days they initiated research on AOMs.

Now, as an early adopter of AOMs for both industrial and academic software projects, I would like to react to the Rebecca’s tweet/retort to Michael Feathers (@mfeathers) where she stresses “Meta-architectures aren’t “old” technology…they’re “proven” technology…”.

For example, here at AAS we have developed a novel software platform that allows developing web-enabled AOMs by reuse and extension. We are currently working on large scale development of such AOMs to address the need for individualized and adaptive web-based solutions to populations like the elderly. The elderly need customized care. Imagine that each person had a computer in the cloud that watched over him or her. We propose adaptive web servers to empower end-users and their communities, like caregivers, to give themselves an active part in the design and customization of their web-based services. So, once more, meta-architectures and AOMs have proven powerful in supporting business applications with highly-demanding dynamic adaptivity requirements.

It should also be emphasized that with AAS-Platform, AOMs figure today at the very heart of a unique solution to the latest approaches to service delivery and business development as explained in The Power of Pull , where end-users and their communities are perceived themselves as valuable actors of service innovation and personalization, and empowered to assume their responsibilities.

Furthermore, as it is emphasized by David Siegel in his Open Letters to Apple Board Members, and Sergey Brin, Larry Page, and Eric Schmidt (Google), “the future of media, entertainment, productivity, and business tools is in the cloud”. However, “the power shift of the 21st century is not to use the cloud to re-create our desktop tools but to build data-driven ecosystems that take us far beyond what we could have done without the power of the cloud.”. David Siegel, urges that to build “data-driven ecosystems”, and to “empower people to collect and use their own data for themselves” (in alignment with the “pull” model), web technologies shall start by “getting the data out of the apps”.

AAS-Platform has been designed and implemented with these requirements and service delivery model as primary considerations. It enables the large-scale development of websites like Yahoo! Pipes by regular application developers, where the active and collaborative participation of end-users (even non-technical people) as partners in the service innovation and delivery processes is supported by design.

Specifically, AAS-Platform allows Web-based AOMs that maintain an “open user activity flow model”, and allow end-users to interact with and modify that model (which is otherwise “hard-coded” by programmers). Every piece of meta-data and data that end-users care about may be accessed via dedicated atomic services and reused when assembling new services, thereby contributing to the concept of “data-driven ecosystems”. Read more …

My name is Atzmon Hen-tov and I am the Chief Software Architect at Pontis (www.pontis.com).  I would like to share with you my experience with AOM and the business benefits Pontis gains from using AOM. Pontis was lately nominated as the fastest growing company in the Telecommunication sector in Europe (see Deloitte Technology Fast 500 EMEA).

First, some background about Pontis. Pontis provides Targeted Marketing in the Telecommunications and Cable-TV domains.  Targeted Marketing means that end-users get only offers and promotions that are relevant to them and they get them at the right time.  For example, just before you load money to your pre-paid phone, we’ll offer you to extend the amount and get a special bonus (e.g., 100 free short messages).  We deploy our systems at the customer premises and typically integrate with 10-15 customer systems.  Each customer has a distinct set of systems we need to integrate with and a lot of other differences from other customers.

In Pontis, we follow the rule – “if it changes a lot, move it to the GUI”.  The motivation behind this rule is to reduce changes in Java/Scripting/Technical code and allow our system users to define, configure, tune and operate the system without needing to get help from technical people.  Getting help from technical people often means a new, full blown software delivery.  Although many companies practice Continuous-Delivery these days (See this book for a great reading on the subject), it is better to avoid code changes and the consequent risks and project overheads.

We discovered that “what changes a lot” is the customer domain model.  That is, each customer has different attributes for the subscriber (“Subscriber” is “customer” in Telco slang), different types of price-plans, and different structure of events (e.g., for voice-call, money charge, short-message send).   At first, we developed the generic part of the system (the part that is used by all customers) in Java and then defined the customer specific parts in DSLs (Domain Specific Languages) from which we generated Java code.  When the model grew to more than 1000 classes, this proved to be a poor choice.  After every change in a DSL you had to wait 20+ minutes for code-generation, compilation, packaging, deployment, etc.  In other words, the Edit-Execute Cycle became really bad.

Enter AOM.

AOM is an interpretive approach; the model (meta-data) is interpreted and executed at runtime.  No code generation, no more “let’s make a coffee or two and come back to see if the build is done”.  This doesn’t come out easily.  You need to write sophisticated code that accounts for all the variability you give the end-users in defining the domain model.  Luckily the Adaptive Object Model site provides you with handful of patterns to do just that.

We started with a few variability points, that is, model classes that can be extended in the AOM GUI and added more as needs were identified.  Today we have a rich AOM application with 50+ variability points that allow non developers to fully customize the application model for each new customer.

AOM is so critical to our business model that we have an official AOM Engineer role in Pontis whose responsibilities are to customize the generic product and to maintain the customer’s AOM metadata in configuration management.  By having non-developer AOM engineers we gain better communication between the stakeholders; AOM engineers are not occupied with technical stuff (Java, Patterns, Performance, third-party libraries, etc.) and talk the language of the business.  But since they are the actual implementer they close things up with the developers to the very last detail (e.g. when a new generic feature is required to implement a business use-case).

Looking back at the last year or so, I can confidently say that AOM made a big difference in Pontis. A difference in the way we work, in the way we deliver software, and in the way we think; most notably in the frequency and quality of our deliveries.   Whenever a new requirement arises, the first thing we do is try to figure out how it can be satisfied by AOM-only changes. If it’s indeed possible (and an impressive amount of times it is; I actually have some numbers on this, but it’s a story for another day), the AOM engineer can implement the change via the GUI and spare the cycle of Java delivery.

We’re still learning as we go. There are many challenges, not all of them technical – in particular, we haven’t worked out the kinks of merging changes between different environments. I invite you to learn together with us – come back here for more!

Last week Joe Yoder and I presented, “When Should You Consider Meta-Architectures?” at QCon San Francisco. We were speaking in the Design at Scale track organized by Michael Feathers. Michael didn’t give us a compelling introduction (in daily overview he said we’d be talking about some older but still useful technologies). So I was pleasantly surprised when the room was nearly full. I’m guessing that Martin Fowler’s earlier keynote where 1/3 was on DSLs, might’ve been the reason some curious folks attended our talk. Or maybe it was my tweet/retort to Michael: @mfeathers Meta-architectures aren’t “old” technology…they’re “proven” technology…that is showing up in many new places….

Or maybe it is because QCon is a conference where people expect to soak up new technologies, design and architectural ideas, and programming languages. QCon is techno-geek mecca.

In our one hour talk we didn’t have a time to describe details of the different meta-architecture styles. We started out by contrasting two ways that people typical evolve working systems, the traditional programmer-centric way with conventional software architectures, and the end-user/domain-expert enabled way that was possible with meta-data based architectures. The primary difference between these two architecture approaches is that the goal of meta-data driven systems is often to support domain experts who are non-programmers making changes to a domain model using tools that support them in making domain model and rule changes (instead of by programmers who are writing/revising their programs).

We then gave a whirlwind overview meta-data representation techniques and presented the core elements of the adaptive object-model style—the particular meta-architecture approach that builds on good object design skills and well-known patterns.

The last half of our talk presented case studies of production systems built meta-data techniques and primarily using the adaptive object-model architecture style in the telephony, insurance, medical, manufacturing, and archeological artifact tracking.

What shouldn’t be surprising (but often is to those who don’t know the leverage you can get \avoiding writing bulky, dumb code) is that these systems are usually built by a small team of very good developers/designers (on the order of 10¹ people). But these designers are capable of building frameworks, infrastructure and tools, and have a good design skills, design pattern knowledge, and the ability to fathom domain models. For example, Pontis reduced the deployment of a new custom installation of their telephony marketing system from 1 year per installation to 1 month. They also wrote an impressive tool that domain engineers (not programmers) to modify business rules and domain objects without developer intervention.

Not every systems needs to give domain experts the ability to directly make changes to their domain models and business rules, but meta-data based architectures (and in particular, adaptive object model systems) can provide some amazing leverage.

I’ve recently returned from SPLASH 2010 and QCon 2010 held in San Francisco. Both conferences rewarded me with the opportunity to meet and greet plenty of AOM supporters. I was fortunate enough to host a tutorial named: Rulemakers and Toolmakers: Adaptive Object Models as Agile Division of Labor with Rebecca Wirfs-Brock.

Adaptive Object Model Tutorial Description

The tutorial explores the AOM Architecture along with an Agile development process for developing them. At the outset, we encourage our clients to bombard us with feature requests. They rain down the ideas onto the development team, overwhelming them. It’s creates what we refer to as “featureitis”. In order to deal with featureitis, we develop a more adaptable system thus allowing the user to make controlled changes like which features they want to use and the evolution of the rules along with the products and services they need. The AOM architecture results in a very Adaptable system that can ultimately help the organization be very Agile.

Open Source Adaptive Object Model Examples

We plan to have some papers and open source implementations on AOMs updated on the site. We currently offer a few AOM examples, but will be expanding in the near future. If you have any AOM examples you have available online, we would be happy to link out to them.

We are very interested in the AOM examples you have implemented with your work. Further discussion in the comment section of this post.

Joe Yoder and Rebecca Wirfs-Brock

Recently I flew to Brazil to present a talk on AOMs at SugarLoaf PLoP. I did this talk/tutorial with Rebecca Wirfs-Brock.  Afterward, I attended the CBSoft conference in Salvador Brazil to talk about Architecture, including the most predominate software architecture deployed to date; Big Balls of Mud.

This included looking at how Agile relates to Architecture.  Soon I will travel to Reno for PLoP collocated at SPLASH.  I am a co-author on a paper at PLoP called Adaptive Object-Model Metadata Evolver and will also present a tutorial with Rebecca Wirfs-Brock at SPLASH entitled: Rulemakers and Toolmakers: Adaptive Object Models as as Agile Division of Labor. We will be giving a more detailed version of the tutorial at QCon San Francisco which will include hands on experience

The conferences give me a chance to be around other AOM practitioners, meta junkies, and Agile enthusiasts like me. We discuss our projects, papers, and lives. This is how I envision AdaptiveObjectModel.com will be. I want to hear from you, AOM enthusiasts. I want you to write your AOM thoughts out in a blog post and either submit it to our website or ask me for a username and password so you can publish it yourself.

Let’s make AdaptiveObjectModel.com an adaptive, entertaining, meta-discussing, community.  Come and join in on the fun!

Agile Joe

Adaptive Object Models research and implementation has been a passion of mine for a long time, so it was only natural that I build the domain based on this interest. The AOM site has evolved through the years, to its current iteration. I’m excited to begin blogging about Adaptive Object Model development, research, and implementation. I’ll be enlisting the help of many industry leaders in AOM development, design, and integration. You should be able to spot a few of the authors from my Meta-Friends page.

The AOM blog will be discussing all things related to the topic. This will include General news, AOM Applications, Patterns, Tutorials, and Events. We’ll add more topics as we continue.

I want to make this blog a community effort, so we’ll be introducing the ability for visitors to post their own thoughts and experiences with AOM related topics.

For now, you’ll have to grab our RSS feed to stay on top of the developments. Afterall, things may adapt and change.

Keep on Reflecting!