It’s now 2012 and it’s time to put ABSE and AtomWeaver on the map. On the model-driven development map, that is. 2012 will be the real dissemination year for the ABSE approach and the AtomWeaver IDE. The take-off year. Well, it should be…

This year, and for the first time, I’ll be attending the Code Generation Conference (CG2012) in Cambridge, the most important European event in this area. As of today, it’s guaranteed that I will be participating in the 2nd Language Workbench Challenge (LWC) to be held the day before the conference (March 27).

I’ve also submitted three speaker proposals for the conference. The accepted speaker results are not out yet, so the presence of ABSE/AtomWeaver could be extended beyond the LWC.

The Language Workbench Challenge was created to compare the strengths and weaknesses of modeling/language workbenches, based on solutions for a predefined set of cases. These cases are accessible to everyone, on the LWC web site.

See you at CG2012!

For decades, software engineering has “dreamed an impossible dream”, to build software as easily as building Lego houses, says James.

There’s a talk by James Noble on InfoQ about this subject. In this talk, James Noble imagines a world where the dream has been realized, where software parts can be found in worldwide repositories, where most software is built by reusing existing software, and where we’ve “finally been freed from the mundane necessity of programming”.

Of course, it’s a dream but, how close (or how far) are we from such dream? I, for one, have certainly been working in that direction with ABSE:

ABSE allows you to create the building blocks of your software systems that, though simple constraint mechanisms, allow you to build your software by snapping them together, just like Lego.

Specifically, PBE is a specialized approach to asset-based development that focuses on patterns, a specific type of reusable asset. PBE provides guidance and support for using patterns in a systematic, disciplined, and quantifiable way.

You can use these types of patterns to support design, testing, deployment, and other aspects of the software development lifecycle. In performing these tasks, you use patterns in many ways such as documenting, generating, refactoring, and harvesting. As a result, you are able to use patterns to boost productivity, improve quality, leverage expertise, simplify, and improve communication within an organization. The goal is to ensure that as you use and create patterns, you are doing so in a way that adds value and boosts the agility of your projects.

Similarly, ABSE uses reusable patterns (a.k.a. “Atoms”) as the basis of its model-driven approach.

ABSE patterns are coupled with metadata, giving them the necessary variability to deal with real-world applications. ABSE Atoms have borrowed concepts from OOP like inheritance and composition, allowing you to create pattern families, and build “patterns of patterns”. Atoms are glued together like Lego to form a model that has a tree-like structure. A code generator “executes” the model to obtain the desired generated artifacts.

If you want to learn to use and apply ABSE, you may start by introducing yourself to the Patterns-Based Engineering approach. It will give you a thought process and logic foundation that will be quite useful to fully understand and take advantage of ABSE and its IDE, AtomWeaver.

To buy the book, contact the authors or if you are just plain curious about PBE, stop by the PBE site.

AtomWeaver 1.0 is the materialization of an idea I had 10 years ago: Why not creating patterns of my own development skills, so that I don’t have to repeat myself over and over? At that time, I knew nothing about model-driven development, although I have already built a small code generator ten years before that.

This idea kept coming and going over the last decade when finally I decided that I had enough ideas to try and build a “variable-driven” code generator. Three and a half years later, and after three iterations of the ABSE concept, the whole decade-long project faces the outside world.

It has been a long journey. Still, I’ve just reached the “10%” milestone. My vision for ABSE and AtomWeaver is much larger. Version 1.0 is really just the tip of the iceberg.

It has been quite a long journey… so many headaches, so much fun!

The objective of the Early Access Program is to get valuable early feedback from professionals that are actively engaged in Model-Driven Software Generation, or code generation in general. With this controlled alpha release, AtomWeaver has seen the real world, and real developers are putting their hands on this new approach to software development.

While most people have yet to report back, some justifying to be severely constrained by their current work, I am starting to get reactions on their first “impact” with ABSE.

I’ve yet to receive a neutral or negative comment about ABSE, which is encouraging. First reactions have been positive, with adjectives varying from “interesting” to “promising”.

I am also learning a lot about how to properly convey the ideas and philosophy behind ABSE, in terms of documentation and tutorials. As with any new, disruptive technology, newcomers always feel confused about the new concepts, and hardly know where to start or where to go. It is a challenging task to put ourselves in the shoes of a newcomer when we are precisely on the opposite side of the knowledge scale. This is called “the curse of knowledge“.

I hope this series to be a very simple and easy way for developers to get acquainted with ABSE, to know what it can do, and what they can accomplish with it. It won’t take you more than two minutes per day.

New post announcements will be added to ABSE/AtomWeaver’s twitter account, and the fact pages can be found inside the ABSE section of the community site.

I take the opportunity to invite those that want to learn about ABSE and follow its evolution, to join its official community at http://atomweaver.ning.com.

OK, so the current website is a little short on details, but not short on propaganda ! That’s because the first task will be to evangelize the developer community and not to have the technology reviewed by industry experts. ABSE is still in its infancy, and a lot will evolve and change in the coming years. However, ABSE 1.0 will give you plenty of rope to play with (and hang yourself as some would say) and give you a glimpse of the future.

Some people in the software engineering community are now saying that model-driven software development will be mainstream in three years from now, and I am happy to be one of the visionaries that is working on that edge.

For now the ABSE website contains a lot of details about the methodology’s meta-metamodel, the Atom, and many application scenarios. I guess explaining a new philosophy to the crowds will require lots of tinkering with the message I want to pass on, so I’ll have to keep working on the site’s content improvement.

Also AtomWeaver is not far away. Participants in the Early Access Program will receive an alpha version in November, while a beta/CTP version is expected for January 2010.

The start of the coming decade will see a turning point in software engineering. I am happy to be contributing for that with ABSE and AtomWeaver.

People on the Early Access Program can have a first look at this new technology. In return I ask for some neutral feedback.

The first material to be available was a combined slide-style presentation of ABSE and AtomWeaver. The presentation gives a rather limited view of ABSE, and trying to understand ABSE through some slides is still a challenge at this point. However, feedback has been essentially positive, with some people having some doubts about its effectiveness due to their lack of understanding of ABSE’s mechanics.

Most feedback ranges from “promising” to “impressive”, which leaves me confident about ABSE’s official debut in Q1 2010. Stay tuned!

I’ve been for years researching ways to develop software in a way that I would be more productive, more organized, more effective. After a first attempt in 2000-2001, and with limited, isolated ideas for a couple of years, a “click” came around 2005 that took me on a trip to a new way of thinking about software development.

I was thinking of a more declarative way to do things. I was thinking in not doing the same things over and over again. I was thinking of transforming my development experience into an automated library. Essentially, I wanted to duplicate myself. I wanted to have the work strength of a small team.

This was the initial rationale behind the development of ABSE. I wanted to have a model of my software project and then, by the switch of some buttons, I would be able to change code, and this code would adjust itself to the specification I ordered. And things could be specified at an unlimited higher- or lower-level. A project would be made of some or millions of small things… and the ABSE Atom was born.

ABSE first evolved as CodeGen4, a simple string-substitution template-based system. Then I thought it would be much powerful if each Atom could be a program in itself. This way the model could “think” according to the specification. Cool! Many new things could now be done.

In January 2007 I started building an IDE that would help me fulfill this dream of mine. A few months later I abandoned the IDE’s development and started again. But this time I wanted to do it right: The IDE should be built using an ABSE model! But how? I didn’t have a tool to build an ABSE model… So I used Leo, a scriptable outline editor. After many hours building scripts and auxiliary tools, I was able to develop AtomWeaver, an IDE that implements ABSE, using ABSE!

I knew that many hours would be spent developing code and scripts that would be thrown to the electronic dumpster once AtomWeaver would become usable. But software development is sometimes like that: you must give one step backward so that you can give two steps forward.

ABSE and AtomWeaver are currently being polished to a point that they can be understood, used, supported, (and I hope) loved by the community. The initial release is near. Stay tuned!

I’ve started research on this subject around 2000. In 2006, I’ve finally developed a generic modeling methodology that I labelled ABSE (Atom-Based Software Engineering).

What could be the most curious aspect of ABSE is that it was developed isolated from the global MDSD circles: I’ve learned about stuff like DSLs, DSM, DDD, Sofware Product Lines and Software Factories *after* I devised ABSE. So ABSE is probably unlike what you have seen so far in the MDSD scene (whether that is good or bad remains to be seen).

For now, ABSE has its home, at www.abse.info. Keep watching that space for new developments that will happen in the next months!