Semantics for Xtext Languages

Many languages defined with oAW Xtext have aspects in common. One way of exploiting this is to modularize language definitions and then composing specific languages from these modules. However, because of limitations of the current (4.3.1) version of Xtext, this is not necessarily a very viable approach.

The semantic annotation toolkit provides support for another approach. Languages are built from scratch (i.e. there is no reuse between grammar fragments), but the semantics of various language building blocks are still reusable. By annotating grammar elements with semantic annotations, the necessary Xtext infrastructure can be generated to make those grammar elements behave in a specific way.

Technically, this is implemented by generating extensions and checks as well as by model transformations and extensions of the meta- model.

Take a look at the latest documentation on the download page or watch this introductory screencast.

Labels: eclipse, openarchitectureware

  permalink    1 comments

 

OSLO Video Comments: Customizing and Extending the Visual Design Experience

So here's my comments on the second video, Customizing and Extending the Visual Design Experience. Notice that the comments really are based on just watching the videos, not on working or playing with anything.

I guess the stuff isn't really finished yet, but if Microsoft continues down this road, this stuff will be *very* interesting.

Also, if you're an Eclipse E4 person: take a look at this stuff - this is very related!

Based on Videos - didn't work with tool!
E4 - look at that!

So here we go.

Don Box calls stuff "Data Driven". That sounds more like I would call what they do...

Don Box, as well as Doug Purdy in the previous video, always talk about data being "dynamic and transparent" vs. code being "opaque and static"... what does that mean?

MS wants to get to a world where "software is data"... I wonder what the Lispers and generally, the dynamic languages guys will say about this. I also think this not quite the right focus. Models are about the "right" abstraction level... it doesn't really matter whether you interpret or generate... this depends on a number of non-functional requirements... Imagine running a data driven app (with an SQL server as a repository :-)) on an embedded device... I do agree that "data driven" is a good idea for many enterprisey apps, but it is not the right approach for all kinds of systems. Models - I think - *are* the right approach for all kinds of systems. It's just the question what you do with the code: interpret, or generate?

Hehe, the property form he shows on the canvas really does remind me of Naked Objects now :-)

The Quadrant stuff really does look very nice....

Now he shows a diagram right inside the workspace... Nice, but not overwhelming... Wow, now he nests the property view inside the tree. Nice -- but you'll run out of real estate quickly. I wonder whether they can also embed an editor for a textual DSL inside Quadrant, imaging some calculation rules as part of the data, you want to show them as text, with a nice editor, right inside Quadrant.

Looking at quadrant as he shows it, yes, it looks like an efficient way to interact with data. But I see now real consistent "language" yet. Maybe that's not the intent, but that's what I'd like to see.

Ok, becomes more interesting ... they now have a workflow diagram right inside the workspace. You can of course also author it directly in the workspace. Nice!

Question is, of course, if I want to build my own (graphical) languaga and want to integrate that into Quadrant, do I do this with "regular code", or with DSLs, too? (I guess, the latter, since they said previously that the tool itself id "data driven")

Florian mentions something quite interesting. And that is, that once *everything* is a model you can connect everything. For example, if implementation artifacts are models, and requirements ("goals") are also models, you can easily trace between these different things. Janos Stipanovits mentioned a similar potential for integration: software architecture and systems engineering.... very nice :-)

Ok, Don says it again .... Quadrant itself is Model-Driven. Nice!

Ok ... now they will show how "the data drives the tool" and how to customize it. Now it becomes interesting :-)

Flovo shows a diagram that is basically a "meta model" ... and ... he says they will integrate Intellipad into the Quadrant workspace. Cool!

He now shows the way how to customize the tool.... nice, completely reflective. And it updates in real time, no recompilation or redeployment. Everything is dynamic. Nice.

Sorry to repeat myself, but it's really a bit like "Naked Models" :-)

They repeatedly say "Smalltalk-like" ... interesting.

They use LINQ inside the tool to define queries from which to build diagrams and stuff.

Still seems quite simplistic how the define the diagrams via queries. But I guess this can be improved over time.

Ok, they prove that the tool itself is model-driven by changing the underlying models that describe the UI... and the UI changes. Really pretty much like Smalltalk :-) And the E4 guys could take a look, too!

cool -- they now show how the tool is built via the tool itself by changing some of the buttons by chaning model data.

Very nice - they were changing the data in the model that describes the ribbons, they used the usual table/form notation for that; then they changed the presentation, and they now have the ribbon display *in the editor*, directly in place. Cool :-)

Labels: eclipse, openarchitectureware

  permalink    0 comments

 

oAW 4.3.1 Release Plan

FYI, the oAW 4.3.1 Release Plan and Release Notes are available.

Labels: eclipse, openarchitectureware

  permalink    0 comments

 

OSLO Video Comments: A Lap Around Oslo

I just (finally!) started watching the OSLO videos from PDC. I started with the over view session A Lap around OSLO. Here are some thoughts:

I don't like the message that "you've done this for years, it's just like XML and [Attributes] and all that..." Why on the one hand side talk about how new, important and ground-breaking OSLO is, and then say that it's all just XML, SQL and other stuff everybody has done for a long time?

Quadrant is actually all the tooling; part of it is the visual DSL designers as well as the textual ones

Why the heck show the SQL that works with the DSL definition when the "database is just a repository"? Seems like an unimportant implementation detail to me. They even say "M is a way to describe stuff stored in a repository". Sounds to me that's beside the point - isn't M about defining languages??

The longer I watch the video, the more all the stuff seems to me like a new database tool ... I know that's not the idea, but it is presented in that way.

I really like that everything is interpeted. Even the grammar/parsing facilties are interpreted. Very nice.

So it seems that the ability to customize editors is really still limited, they "aspire" to making intellisense and all that available to any DSL.

Wow, this Quadrant tool itself is built to interpret models, it is itself defined via M-stuff. Nice!

Hm... but it again looks like a database tool ("Model-Driven Access"). I don't understand how the textual models interact/relate with the graphical Quadrant stuff? Can I get the textual representation out of the database again? Or can I just use it to put stuff "into" the repo?

Somehow the Quadrant stuff also reminds me of Naked Objects...

As I watch the video, I feel like, while it is not yet finished, it looks very promising. However, I have no idea why they don't also include a code generation. Yes, interpretation is useful, no question, but so is code generation. The only explanation I can come up with is to "deconflict" OSLO with the MS DSL Tools.

When they are showing this MService example DSL where they embed (what looks like) C# code into new abstractions for Service description, I wonder what the means of modularization are. Is C# described in M? Can I easily embed "pieces of" C# code in an M DSL? Sure looks like it... very interesting! Actually, it seems like some workflow stuff that's invoked. But then, at least those need to be combinable. And at some point, I am sure C# will be available, too.

Wow! They have a debugger for their DSLs. VERY NICE! I wonder how much of that is automatic (i.e. somehow derived from the grammar) as opposed to having it written manually.

All in all, this stuff really looks nice and I am looking forward to more ... stay tuned for my comments on the other PDC videos :-)

Labels: eclipse, openarchitectureware, OSLO

  permalink    0 comments

 

openArchitectureWare 4.3.1 RC1 available

The Release Candidate 1 of Version 4.3.1 of openArchitectureWare is available at oawbranch.pluginbuilder.org.

Happy Testing :-)

Labels: eclipse, openarchitectureware

  permalink    0 comments

 

New Podcast: Omega tau, science and technology in your headphones

Recently I have started a new podcast: Omega tau, science and technology in your headphones

It can be found at http://omegataupodcast.net (and in iTunes, of course) and covers everything in science and technology that I find interesting. It is a mix of German and English language episodes and will probably average at about one episode per month.

We already have five episodes online:
/1/ Mitflug im Motorsegler (German)
/2/ Wetterdatenerfassung (German)
/3/ Das Multiple Myelom (German)
/4/ Commercial Space and SpaceShipOne (English)
/5/ Earthrace - Around the World in a Powerboat (English)

Upcoming episodes will include discussions on Computational Thinking, Airliner-Maintenance, Robotics, Biochemistry and more.

Omega tau is a real hobby for me and my girlfiend (we do this together) and my personal bias towards aviation will probably shine through. We will also experiment with different styles, ranging from interviews over features to collages with different guests in one episode.

So if you're interested in this kind of stuff and like to listen to audio content, why don't you give it a try and let me know what you think?

Labels: eclipse, openarchitectureware

  permalink    0 comments

 

Eclipse Modeling Symposium 2008

Over the last three days, I was participating in the Eclipse Summit Europe 2008, the Eclipse community's european meeting in Ludwigsburg. Specifically, on Tuesday I moderated the Modeling Symposium. I really liked it this year - the submitted papers were on really interesting topics (model migration, semantics, notation, for example) and not the "usual" trivial stuff. Because every presenter had only 15 minutes (and we really enforced it :-)), people had to get to the point quickly, so the presentation part
was really quite fast-paced.

In the afternoon we had Open Space discussions on some of the same topics, and we recorded a couple of video interviews (stay tuned :-)).

As usual, Ed Merks has created a great blog entry about this event, so I just refer to him for more detail :-)

Labels: eclipse, openarchitectureware

  permalink    0 comments

 

EMF and OSLO?

Lars Corneliussen has written an open letter to Doug Purdy about interop between OSLO and EMF.

Doug has said that he'd be interested in having the two worlds interoperate ("We want to engage, particularly with the Open Source Community, in order to make sure that we can invent the future together."). Personally, I also think that would be very useful.

So please let us know what you think and help spread the word. True interop between Microsoft's OSLO and Eclipse's EMF would be very benefitial for both communities.

Labels: eclipse, openarchitectureware

  permalink    0 comments

 

Eclipse at .NET conference

Today I was speaking at the prio.conference 2008, a conference on .NET technologies. I gave three talks: my Architecture as Language stuff, my talk on Architecture Documentation and - surprise! - on how to build textual DSLs with Eclipse.

Now, I did expect a number of people to show up in the two conceptual talks, but I didn't expect many people to come to the Xtext talk - after all, it is a Microsoft technologies conference. I was wrong! The room was full, some people were standing. I wasn't able to find out whether so many people came because the talk was on Eclipse technologies, or in spite of that :-).

Nonetheless, I was very pleased to see so much interest in Eclipse, Xtext and MDSD in the .NET world

Thanks to Ralf Westphal for inviting me to the conference!

Labels: dsls, eclipse, mdsd, openarchitectureware

  permalink    3 comments

 

Replying to Martin Fowler's recent posts

Martin Fowler, in the context of writing his book on DSLs, recently had two interesting blog posts (this one, and that one.

I agree with some parts (e.g. the MDA stuff), and strongly disagree with other parts.

Now, because I had to go flying for the last two days (yipieeh :-)) I did not immediately reply, and hence, Sven was faster :-). I agree with everything Sven says, and I don't repeat it here.

However, there's one interesting issue that pops up from time to time: repositories. From time to time, people (including me and Sven) point out that it is some kind of problem to store models in repositories. The arguments basically center around the fact that "we want to manage everything as files, in CVS or SVN".

Now, I agree to that, however:

What if you don't have any text at all, if you store everything in models and repositories, don't all the integration problems go away then? Of course you still need a diff/merge facility (based on the models' concrete syntax, not XML!) and a way to version things, but assuming your infrastructure provides that, wouldn't that be ok?

Also, what is a repository in the first place? A couple of text files in a file system clearly isn't a repository. A database storing an AST clearly is.

But what about a CVS/SVN? What about a bunch of text files arranged in a specific directory structure, with an index file rebuilt from time to time by an indexer?

My point is that a repository is not per se a bad thing, provided the following criteria: (1) you store all your relevant stuff in it (2) it provides versioning facilities (3) supports diff/merge on a meaningful abstraction level.

As it happens, CVS/SVN provides all of this for text files. Hence, it is the lowest common denominator "repository".

Any comments or thoughts? I would really like to get a somewhat better grasp on this repository thing, to find out what *really* is the problem.

Labels: eclipse, openarchitectureware

  permalink    15 comments

 

Video: Managing Variability in Product Lines

The JAOO folks have kindly recorded my 2007 presentation on managing variability in product lines (slides). Among other things, it showcases some of the PLE features available in openArchitectureWare.

Labels: eclipse, openarchitectureware

  permalink    0 comments

 

Prefuse Visualization - Code

Until we find a place for the visualization stuff, here's snapshot of the code for you to play with. It contains a bunch of Eclipse projects; it also includes Prefuse itself. Note that this is not a distribution of Prefuse, I just kept it in the ZIP to make it easy for you to play with it. Here is the code.

There's a demo project in the ZIP that creates a graph for Ecore itself.

You can find the transformation in /net.ample.adsl.prefuse.demo/src/ecore2prefuse.ext.

The oAW workflow to run it is /net.ample.adsl.prefuse.demo/src/visualizeEcore.oaw.

After running that workflow, open a runtime workbench and open the Model Visualization/Model Visualization View.

There open the WORKSPACEROOT/net.ample.adsl.prefuse.demo/src-gen/data.xml.xml file.

Have fun!

Labels: eclipse

  permalink    3 comments

 

Visualizing EMF, now with Prefuse

After playing around with Graphviz, I looked at Prefuse next. In contrast to Graphviz, Prefuse is an interactive toolkit, i.e. you can manipulate the graphs. It is done completely in Java.

I integrated it into Eclipse (using SWT_AWT) and also provided an EMF meta model so you can easily map your own models to the Prefuse meta model. If you're interested, take a look at this screencast.

Labels: eclipse

  permalink    4 comments

 

Visualizing EMF models with Graphviz

Michael Clay and I have built an integration (currently proof of concept) between EMF and Graphviz. Actually, this is especially relevant for textual models (created via Xtext) since GraphViz has very good auto-layout facilities; so it becomes realistic and useful to automatically render a diagram from a specification (textual model) that has no layout information in it.



Here's the way it works: Michael has created an EMF representation of the dot language (GraphViz's language for describing the to-be-rendered graph). He has also built a generator (using oAW's Xpand) that actually generates the dot file. This can then be rendered by the GraphViz dot renderer.

Here's how you render your own model: you write a model-to-model transformation that maps you meta model onto the dot meta model. To do that, I wrote a bunch of oAW extension functions that make this job easy.

To render the example picture above from my textual spec, I had to write about 30 lines of Xtend code -- not much.

If you're interested, we're currently in the process of figuring out where and how to make it available.

Labels: eclipse

  permalink    13 comments

 

oAW News

Here are some news from today's oAW team telecon:

Work on the new oAW/M2T infrastructure (the new back/front/middleends) is progressing nicely. Most of the work is done by Arno, the itemis lab in Kiel and Bernd. The languages will be source compatible with oAW 4.2 but will be based on a more stable and much more performant architecture. A couple of minor syntactic enhancements will be added - details later. This work is also the basis for Eclipse M2T.

Don't forget that at this year's EclipseCon Bernd and Markus will do three Tutorials and one Long Talk on modeling and oAW. In addition to those two, Sven, Wolfgang and Achim will also be present.

We're also working on a new release of oAW 4.2. There will be a a bug fix release without Xtext called 4.2.1, as well as a release of ONLY Xtext called 4.3 beta. We separate those two because Xtext has more new features, but is not as well tested as the other parts. Expect to see these releases next week.

New Xtext features include: viewpoints (several different tree view structures), Ctrl-O support (show the outline as a popup), styles (render keywords with different color and font), imports (seamlessly separate you model into several files), grammars for existing meta models, referencing external (meta)models, an EMF resource implementation for Xtext files. You can see some of those features in this and this screencast. Note that these features are things that will be in TMF, but some API aspects will be incompatible with the current implementation in the upcoming Xtext 4.3 beta.

We're also currently working on an oAW planet, i.e. an aggregate blog that collects all the blogs of all oAW team members into a single feed. More on this once everything is running.

Labels: eclipse, openarchitectureware

  permalink    0 comments

 

oAW Xtext and PLE: Interesting Developments

I have recorded a screencasts that shows some of the recent developments of Xtext that Bernd and I have done. The screencasts looks at working with multiple files, extended outline views and integration of non-Xtext metamodels into code completion and constraint checking.

The article uses as an example an architecture DSL (like the one introduced in my most recent article). The example shown in the screencasts extends an architecture DSL with ways to express feature variability and provides a nice tool integration with pure::variants.

There's actually more to the PLE stuff that is shown in this screencast. Stay tuned for more :-)

And while you're at it: why don't you look at this screencast from the itemis oAW team in Kiel. Very nice stuff.

Labels: eclipse

  permalink    0 comments

 

Architecture As Language - A story

Here's the abstract of the most recent article I wrote:

Architecture is typically either a very non-tangible, conceptual aspect of a software system that can primarily be found in Word documents, or it is entirely driven by technology ("we use an XML architecture"). Both are bad: the former makes it hard to work with, and the latter hides architectural concepts behind technology hype.

What can be done? As you develop the architecture, evolve a language that allows you to describe systems based on this architecture. Based on my experience in a number of real-world projects, this makes the architecture tangible and provides an unambiguous description of the architectural building blocks as well as the concrete system while still staying away from technology decisions (which then can be made consciously in a separate step).

Read on at InfoQ...

Labels: eclipse, openarchitectureware

  permalink    0 comments

 

TMF Creation Review Successful

Sven Efftinge reminded me through his blog that the Eclipse Textual Modeling Framework project proposal has successfully gone through the creation review.

The co-leads Sven Efftinge and Frédéric Jouault made this happen (thanks guys!).

According to Sven's blog, one of the attendees already had experience with Xtext and was very excited to hear about Xtext becoming an Eclipse project.

Labels: eclipse, openarchitectureware

  permalink    0 comments

 

oAW at OOP

It's interesting to see that a whole bunch of companies are actively advertising for oAW at the OOP conference. A similar thing happened at W-JAX last year. This time we took some photos :-)

Labels: eclipse

  permalink    2 comments

 

DSL Day @ JAX 2008

This year's JAX 2008 conference will feature a full day on Domain Specific Languages. DSLs are a wide field. During this DSL Day we will try to cover many important aspects of DSLs, although there can be no hope of capturing everything.

In the first session (run by Juha Pekka Tolvanen from Metacase) we will learn how to define a domain meta model and a nice graphical syntax using the MetaEdit+ tool. In addition, we will learn how to to generate executable code from the models created with the domain-specific modeling language.

The second talk (by somebody from NoMagic) we will look at how a modern UML tool can be customized with a domain-specific profile. Creation of the profile, customization of a UML diagram and code generation from that UML model will be covered in this session.

Talk number three (by Sven Efftinge of itemis) will turn slightly towards textual DSLs. They will discuss the tradeoffs between textual DSLs and graphical DSLs and show an example with the Xtext tool (a part of openArchitectureWare). To make sure it's not either-or, they will show how textual and graphical syntax can be combined sensibly.

Continuing down the route to textual DSLs, we will look at internal textual DSLs in talk number four (by Guillaume Laforge, Groovy Proejct Lead). Internal DSLs are especially useful in dynamic languages such as Ruby or Groovy. In this session we will learn about the advantages of internal DSLs and how to build them using meta programming in Groovy.

The final presentation (by Markus Voelter and Bernd Kolb) looks at the alternative to code generation in the context of external DSLs: Interpretation. We will briefly construct a textual DSL and then write a nice interpreter for the DSL. The interpreter will be written in Scala. We will also use a model transformation to transform between different languages.

The day will be concluded with a panel that includes all the speakers from the various sessions. Since we have advocates for each of the different flavours of DSLs, the panel should be educating as well as entertaining -- there's nothing more boring than a panel where everybody agrees

Labels: eclipse, openarchitectureware

  permalink    3 comments