stuart kent's blog

Extending UML designers in VS2010 Beta2

2009-11-02T13:37:27Z

As mentioned in this post, the UML designers in VS2010 Ultimate now come with a set of APIs that makes them easy to extend. I see that Peter Provost has now posted the first of a series of articles (going by the title of this one) explaining how to get started: Extending Visual Studio 2010 UML Designers – Part 1- Getting Started.

Jean-Marc blogs about DSL Tools in VS2010 Beta2

2009-11-02T13:31:47Z

Back from holiday (in Cyprus, 30 degrees C, very relaxing thanks), and as I suggested might happen in my previous entry, I see that Jean-Marc has blogged about DSL Tools in VS2010 Beta2: We released the DSL SDK for Visual Studio Beta2 this morning.

VS2010 Beta2 Available, Links to posts on Arch Tools in Beta2

2009-10-21T19:31:36Z

VS2010 Beta2 is available for download. Install Ultimate and you’ll be able to give the architecture tools a spin, which have been much improved since Beta1. In particular, a lot of work has been put into making it easy to extend the UML designers using Managed Extensibility Framework (MEF). It’s now easy to add your own context menu commands (no need for a VS Package or VSCT definitions), drag drop and double-click gestures and validation constraints. They then get deployed using VSIX, the new, much easier way to extend Visual Studio. You’ll need to download the corresponding VS SDK, for this.

When I get back from holiday I hope to be able to point you at more information on how to create extensions, and samples of extensions.

You’d also do well to take a look at Cameron Skinner’s blog, in particular:

and Chris Lovett’s new blog, in particular:

Chris has some great videos for you to look at.

Also available is the DSL SDK. Between Beta1 and Beta2 a fair amount of work was done on the designer authoring component of DSL Tools, as well as on further improving the quality of the runtime. You’ll find much improved templates for building forms-based designers, support for DSL libraries (now you can share components of a DSL definitions between designers), and MEF extensibility points injected into the Dsl Designer itself, to enable us and the community to extend and customize DSL authoring through simple VSIX extensions. I’m sure that Jean-Marc will blog about all this some more soon.

[Nov 2nd: Changed Microsoft Extensibility Framework to Managed Extensibility Framework. Sorry for the original error.]

Most influential paper award

2009-08-14T19:33:07Z

Life can throw up surprises, some nasty some rather pleasant. Well this week I received an email which was a pleasant surprise. A paper I co-wrote ten years ago, when I was a researcher before joining Microsoft, just received an award from the VL/HCC conference series: Most Influential Paper from approximately one decade ago. See http://eecs.oregonstate.edu/vlhcc09/mip.html

I’m immensely proud to find that work I contributed to has been judged to have had such an impact by research colleagues. And, having been out of research and working on product for the last five years, this came as a real surprise. I had no idea.

And the paper? It’s about formalizing a subset of a graphical notations based on Venn diagrams for visualizing navigation paths, constraints and object structures in OO systems. The paper describing the full notation appeared in the 1997 OOPSLA conference and is called Constraint Diagrams: Visualizing Invariants in Object Oriented Modelling. You can get a copy from http://www.cs.kent.ac.uk/archive/people/staff/sjhk/publications/OOPSLA97/index.html.

Perhaps one day we’ll see these kinds of notations appearing in Microsoft’s tools…

Pedro on the Code Generation Conference

2009-06-23T19:47:06Z

Pedro Molina has blogged about his experience at the code generation conference in Cambridge. Pedro was one of the folks with whom I had some great discussions, and his commentary on the conference is well worth reading.

So what is a DSL anyway?

2009-06-23T15:48:28Z

The term Domain Specific Language (DSL) is a popular buzz-word at the moment. If you look at wikipedia you’ll see the following definition:

“In software development, a domain-specific language (DSL) is a programming language or specification language dedicated to a particular problem domain, a particular problem representation technique, and/or a particular solution technique. The concept isn't new—special-purpose programming languages and all kinds of modeling/specification languages have always existed, but the term has become more popular due to the rise of domain-specific modeling.

The opposite is:

a general-purpose programming language, such as C or Java,

or a general-purpose modeling language such as the UML.”

The problem I have with this definition is that it’s hard to draw the boundary between what is general purpose and what is domain specific. Instead, I prefer to think of a language having different dimensions, and to categorize a language we need to place it on each of the dimensions relative to other languages. This leads to a much more fluid categorization system, but makes it easier to identify the similarities and differences between languages. Below is a diagram I produced recently for a talk showing three dimensions. I think there are more, but these three seem quite important. I put some examples on the diagram to illustrate.

And as a tool platform vendor, I’d like to provide facilities for creating and using languages in as many points in that 3-dimensional (though probably should be n-dimensional) space as possible. I also want to provide ways of moving between languages at different points in the space.

What might other dimensions be? Martin Fowler makes the further distinction between internal and external DSL, so perhaps that might be another, though in that case I might concede that the dimension is binary: external xor internal, and no points between. Another might be formal/informal dimension.

More from Code Generation 2009

2009-06-23T15:22:19Z

Now I’m back from the conference, here’s an update on my first report.

Some highlights for me during the rest of the conference were:

Seeing the second part of the joint keynote by Markus Völter and Steven Kelly, where they got to discuss views, cross-references and interaction between models. It felt good to finally have an answer for this difficult area with the new modelbus in VS2010 (see my previous post on this).
A great goldfish bowl to discuss the question: does modeling = programming? We got as far as agreeing that executable modeling = programming, so programming was regarded as a subset of modeling, and that we need many of the tools we use for programming at the modeling level (debug and test models, anyone?). However, there was some discussion of whether there are some mdoels which aren’t programs (I argued that there were, giving examples such as business & performance models, models showing metrics for coverage, completion and so on), although conceded that these models indirectly influenced the eventual shape of the program. There is a bit of a slippery slope here, because then one could argue that they are part of the description of the program in some way, and therefore then part of the program. Mmm… all getting a bit philosophical for me. One nugget that did come out was the fact that modeling tools (at least graphical and forms-based ones) don’t let you model informally very well, and then incrementally change the informal to formal. You kind of get this for free with a text editor, because you can write pseudo code in comments and then step-by-step formalize that building as you go, until you get a successful build, at which point you can try executing the code which then leads you to a further step of validation.
Lots of interesting conversations, including a discussion on code generation on the MSFT platform with Kathleen Dollard.
Positive feedback received on the DSL Tools and T4 features we’re shipping in VS2010. Jean-Marc gave a session on this, which was well-received with lots of questions afterwards from folks wanting to know more. Folks particularly like the aforementioned modelbus. Indeed I came away with the general feeling that Visual Studio 2010 provides a solid, competitive platform and set of tools for those wanting to do model-driven development, whether it is from their own DSLs, from UML or some integrated combination of the two.
Feedback received from a number of people, who have tried using both Eclipse GMF and DSL Tools, and who told me how much easier it was to build graphical designers using DSL Tools than GMF. We’re often told how hard it is to extend Visual Studio in comparison with Eclipse, but here is one area where it looks like we are some way ahead. I think folks will be surprised at the the new functionality put into the core Visual Studio platform in 2010, with the VS Extension Manager and Managed Extensibility Framework. We’ve exploited this already in DSL Tools, and have been working on exploiting it further to make the new Team Architect tools really easy to extend – but you’ll have to wait for the next preview after VS 2010 Beta1 for that. The new editor can also be extended using these mechanisms: see http://editorsamples.codeplex.com/.

[Added on 23rd June 2009]

I missed another highlight. There was a demo of Jetbrains Meta-Programming System (MPS). Although perhaps not for the masses, I thought this was conceptually very clean and nicely done. Great interactive session as well.

IMS Locks Sample for VS DSL Tools 2010 Beta1

2009-06-23T14:47:44Z

I see that Jean-Marc has just posted another sample on the DSL Tools Code Gallery landing page, this time about the new IMS Locks capability. This allows you to make some parts of your models read-only, which is good for situations where some users (say an architect) are allowed to make changes to some aspects of the model (say the core architecture components), and other users (say developers) are only allowed to make changes to other aspects (say the properties specifically focused on driving the code generators). As author of the DSL you have complete control in the locking policy used. More details in Jean-Marc’s post.

News from code generation 2009

2009-06-17T12:17:55Z

I’m at the Code Generation 2009 conference in Cambridge, which started yesterday.

Numbers are a little down on last year, but not much. Attendance is mostly from industry, with some academics. As usual it’s stuffed full of people with tons of experience in building code generators and languages to drive them.

I gave a talk yesterday which placed model driven development and code generation in the wider context of what I called the design cycle (see image below). Perhaps I’ll write it up as an article on this blog someday. I also illustrated this with a demo of some of the features of Visual Studio 2010, including the new tools for visualizing existing code through graphs.

Interesting panel yesterday on migrating to model driven development. There is real, concrete data out there which demonstrates the productivity benefits of an MDD approach. Why is it, then, that everyone isn’t doing it? Lots of discussion, with the top reason being social and cultural issues. It was also suggested that tooling isn’t good enough for broad use.

I’m sitting in the keynote which has an interesting format: the two invited keynote speakers (Markus Völter and Steven Kelly) decided to join forces and give a joint talk spanning the two sessions. I like it, especially when the speakers argue (e.g. textual DSLs, which Markus favors, versus graphical DSLs, which Steven favors; actually they concluded that a platform which integrates and supports both would be best).

ModelBus Adapters Project Template

2009-06-17T09:49:46Z

Jean-Marc has just posted a ModelBus Adapters project template on the Visual Studio Gallery. This template makes it easy to a modelbus adapter and adapter manager to your own DSL, which exposes your DSL for reference and access from other DSLs. This compliments the sample recently posted, as described in my last post.

DSL Tools VS2010 Beta1: ModelBus Sample

2009-06-04T01:07:42Z

One of the most common asks from customers of the DSL Tools has been support for integrating models and designers, that is the ability to have models of the same or different DSL cross-reference one another, and the ability to write simple code that exploits these cross-references to implement interesting interactions between designers.

In VS2010 we’re providing this support which can now be previewed in VS2010 Beta1 release. Jean-Marc has just posted a sample (StateMachineOverModelBus.zip, documentation) that illustrates how the modelbus can be used to achieve the behaviors described above, and I’ve just posted a short video demonstrating the behaviors and giving a quick insight into what you need to do to realize them in your own designers.

Details on how you can provide feedback can be found on our the DSL Tools Code Gallery landing page. Or by all means provide feedback on this blog.

Much simpler deployment of DSLs in VS2010

2009-05-23T01:54:51Z

In Visual Studio 2010 you’ll find a new extension manager that makes it much easier to package and deploy extensions to Visual Studio. Pedro has more information: Early Buzz on the VS SDK and Extension Manager, Introducing VS Extension Manager.

We’ve exploited this to deploy DSL Tools. Gone has the DSL Setup project which used WiX to create and MSI. Instead, a DSL authoring solution builds a VSIX package and uses that to install the DSL in the experimental instance of Visual Studio. But even better, to install the DSL in the main instance of Visual Studio, all you have to do is open the VSIX file in windows explorer and respond to the prompts. Restart Visual Studio and your DSL is installed! How easy is that?

I’ve captured all this on video.

Speaking at Code Generation 2009

2009-05-23T00:49:03Z

I’m speaking at the Code Generation 2009 conference in Cambridge in June on the topic of Code-Centric or Model-Centric – Approaches to developing software.

Jean-Marc is also speaking on What’s new in the DSL Tools and T4 in Visual Studio 2010.

I’m really looking forward to going to this conference which is at the cutting edge of model-driven and code generation techniques. It will be great to meet up again with folks I haven’t seen for some time, especially colleagues I used to work with before I joined Microsoft.

And beware: “LATE BOOKING FEES APPLY FROM JUNE 1ST”

T4 Roundup

2009-05-23T00:39:25Z

Gareth has been posting a lot about T4 over the past few months. In case you missed it, here’s a roundup of all his posts, in chronological order. Lots there to get your teeth into.

You can now try out the VS2010 features mentioned above with the release of VS2010 Beta1, VS2010 SDK Beta1, and VS2010 DSL SDK Beta1: see Dsl Tools for Visual Studio 2010.

I’ll also add one more link:

http://tangibleengineering.blogspot.com/2009/05/tangible-t4-editor-for-visual-studio.html

As you can see, T4 is getting popular!

And for VS2010 there’s more to come on top of the features that Gareth describes. Not available in Beta1, but in Beta2 we’ll be providing support for accessing models in T4 via the modelbus. This will enable text templates to access models created with the new UML designers in Visual Studio and more enterprise-scale orchestration of code generation.

Migrating DSLs to VS2010 Beta1

2009-05-23T00:12:31Z

When we released DSL Tools for VS2008, the migration story from VS2005 was not great: basically we provided a sheet of manual instructions which led to a fragile and long-winded experience. This time we’ve done a lot better. In the VS2010 DSL SDK Beta1 you’ll find a migration tool that converts your projects and solutions for you automatically. We’ve been using this internally to convert samples, test projects and so on, and it does a lovely job. There are links to a video showing the tool in use, and some documentation on the Downloads tab of the DSL Tools Code Gallery. Life is good.