Stuart Kent - Building developer tools at Microsoft - @sjhkent

  • stuart kent's blog

    Great links from Gareth

    • 1 Comments

    Gareth is obviously settled in the US now, because he's starting to become a prolific blog poster again. Unlike me, who only manages it in spurts.

    He's recently put up a series of posts with some great links. So for those of you who don't already read Gareth's blog here's some stuff worth investigating:

    On code generation:

    Fun use of T4 to generate strongly-typed web navigation

    More general-purpose T4 goodness

    Help in tackling the hard problem of model -- code synchronization

    On using DSLs as part of Software Factories:

    Wojtek at Wicsa

    Team Architect Case Study with Software Factories

    On evolving DSLs:

    Gerardo explores domain-specific language evolution tools

    On getting started with VSX:

    Inovak learns VSX - Now!

    And finally, a video of a situation which I find myself in many times as part of distributed development team in Microsoft...

    Too much of life wasted on this soundtrack

  • stuart kent's blog

    Great posting on distributed development

    • 0 Comments

    One of my colleagues (thanks Blair) pointed me at this:

    http://blogs.msdn.com/eric_brechner/archive/2008/02/01/so-far-away-distributed-development.aspx

    Our team is distributed between the US and UK and many of the points mentioned ring true in our experience. Eric stresses the need to maintain as high bandwidth communication as possible.

    We try and make maximum use of livemeeting and office communicator and use video cameras with those which makes a huge difference. And, by the way, I've discovered that connecting wirelessly to the newtwork introduces impedance which can really impact the reliability of those channels. Since I've stopped using wireless at home, I find I can trust those tools now.

    If any of you have your own experiences of distributed development which you'd like to share, pleas add a comment. 

  • stuart kent's blog

    Jobs on our team (in UK and US)

    • 1 Comments

    Our team is continuing to expand. We now have jobs available in both Redmond (US) and Cambridge (UK). Gareth provides the details.

    Technorati Tags: ,
  • stuart kent's blog

    Hiking in the snow

    • 2 Comments

    I've been visiting Redmond to work with the team over there. I stayed over the weekend and got to go hiking in the snow with Andy Bliven, a developer in Team Architect. We were blessed with a gloriously sunny, but bitterly cold day between two snow storms. First time I've experienced my hair freezing. I'm now looking forward to planning the next expedition with Andy on my next trip. I'm the short one on the left...

    Technorati Tags:

    clip_image002

  • stuart kent's blog

    Sample of hosting a DSL in the VS2008 isolated shell

    • 0 Comments

    A new sample has been published of a hosting a DSL in the VS2008 isolated shell. See http://www.codeplex.com/storyboarddesigner.

    The isolated shell is a stripped out VS shell who's UI and splash screen you can customize. VS packages, including DSLs, can be hosted in both full VS and in your own customized shell without change. This sample shows how to do this specifically in the case where you want to host a DSL in a custom shell, for example to distribute to a designer to non-developer stakeholders. See the VSX development center for more details.

    This sample shows a storyboarding DSL, which a product manager or business analyst might do to envision the requirements of an application. In addition to demonstrating hosting in the shell, the sample also shows a couple of cool customizations on a DSL, including a very simple approach to linking diagrams, generation of web pages for the storyboard, and export of images off the design surface.

    Here's a screenshot:

    StoryboardDesigner

    Thanks to Clarius for putting this up.

  • stuart kent's blog

    Help with using the VS2008 Shell

    • 1 Comments

    Pablo has written a series of posts that should be of help to anyone thinking of hosting their applications in the VS2008 shell:

    Customizing a VS Shell application

    Integrating a VS Package with a VS Shell application

    VS Shell application deployment

    Creating a bootstrapper for a VS Shell application

    VS Shell and the registry

    VS Shell application switches

     

     

  • stuart kent's blog

    Three things to know when using Visual Studio 2008 DSL Tools

    • 1 Comments

    In preparing for my presentation at TechEd, I got a chance to try out a couple of new things with DSL Tools on VS2008:

    • The T4 editor from our friends over at Clarius, available at http://www.t4editor.net/. I installed the VS2008 beta 2 version on a VS2008 release candidate and it seemd to work fine. Makes editing text templates much easier. Nice job, Clarius. Can't wait for the other features promised in the future.
    • Using LINQ to write validation constraints. I was blown away by the power of LINQ. Steve has a series of posts about using LINQ for this purpose - well worth a read.

    Also for those of you who have wanted to automate the code generation step as part of the build process inside VS, here's a handy hint from one of our own MCS consultants, Jelle Druyts:

    Add the following definition to the EnvironmentEvents macro (open Macro Explorer, MyMacros, EnvironmentEvents):

    Private Sub BuildEvents_OnBuildBegin(ByVal Scope As EnvDTE.vsBuildScope, ByVal Action As EnvDTE.vsBuildAction) Handles BuildEvents.OnBuildBegin
            DTE.ExecuteCommand("TextTransformation.TransformAllTemplates")
    End Sub

    Then build and it’s done. This will now always transform the templates before any build. Very neat.

     

  • stuart kent's blog

    What's new for DSL Tools in VS2008 / VS2008 SDK

    • 4 Comments

    VS2008 and VS2008 SDK have just shipped. The announcement about the SDK over on the VSX blog didn't get into much detail about changes in DSL Tools for VS2008, so I thought it would be worth summarizing them here:

    • The runtime is now part of the VS platform. There is no need for a DSL author to redistribute a separate DSL runtime.
    • The authoring experience now works with Vista RANU (Run as Normal User). You don’t have to run VS as an admin in order to develop a DSL.
    • We’ve added a path editor to the DSL Designer. Paths are used largely to express mappings between domain classes / relationships and shapes / connectors. The new editor provides UI that allows you to select valid navigation paths through domain classes and relationships in the domain model.
    • LINQ can be used in code written against the code generated from a domain model, for example when writing validation constraints or text templates for code generation. For those of you familiar with UML / MOF, LINQ gives you OCL-like querying capability (actually its far more powerful than that) against domain models.
    • We’ve fixed a large number of bugs, in both runtime and authoring.
  • stuart kent's blog

    DSL Tools beyond VS2008

    • 22 Comments

    I promised a while ago to publish a roadmap for what we're doing with DSL Tools, post VS2008. Now that VS2008 and the VS2008 SDK have just shipped (thanks Gareth for providing a post which points at both announecements) now seems a good time honour that promise.

    There are two main themes in how we expect DSL Tools to develop in the future:

    • Evolve the graphical designer and code generation platform to provide more capabilities, to integrate better with other parts of the VS platform, to componentize it so it is easier to choose which parts you want to use, to better support extensibility and customization, and to improve performance.
    • Generalize the authoring approach pioneered in DSL Tools, to the creation and maintainence other kinds of Visual Studio extension, and integrate the DSL authoring experience with that. These are the tools to build tools that I've used as a tagline for my blog, although, in the context of Visual Studio, VSX Tools might be a better term.

    I mentioned the second theme soon after the DSL Tools team joined the Visual Studio platform team. That is still in our sights and will be part of our roadmap for the VS SDK as a whole, which we'll publicize when it's ready. For the remainder of this post, I’ll focus on the first theme.

    Roadmap for VS codename Rosario

    Below is a list of features we have in the backlog for Rosario. We’re not promising to complete all of them, but expect to complete a significant subset. Some of the features may appear earlier in a service pack for VS2008.

    • DSL extensibility. This enables you to extend a designer that has already been deployed – i.e. without cracking open the source. An extension defines a set of domain class extensions (adding new domain properties, new relationships, new domain classes), which appear on elements of that domain class when the extension is enabled. An extension also defines a root domain class and a scope. You activate an extension on an element of the root domain class, and then all elements in scope also get that extension enabled. Extension activation is dynamic through the UI of the designer (we’ll provide some standard UI, and the base designer author will be at liberty to write their own custom UI). Multiple extensions may be activated on the same element. The root domain class for an extension may be the root of the domain model of the DSL being extended, which then allows an extension to apply to the whole model. Extensions may also define additional validation constraints, in the usual way. I’ll write a separate blog entry on this with more detail a bit later. The authoring experience for extensions will require support for referencing one dsl definition from another, which will also benefit customers who want to build a set of designers that share some parts of their definition (e.g. a common core set of domain classes).
    • Support for databinding of domain model to Winforms. Although it is possible to create a custom editor with a placeholder for you to write your own forms-based editing surface, and it is also possible to add new tool windows to supplement the graphical design surface, there is currently no support for easily binding the form to underlying model elements. This feature involves generating the appropriate APIs from a domain model so that the standard Winforms databinding experience can be used.
    • Nested shapes. Although there is some support for nested shapes, it is harder work than it should be to get them to work. This feature involves improving the overall experience and fixing some bugs in the runtime which currently need to be worked around.
    • Various fit & finish items, for example:
      • Print preview. Enable the print preview menu for designers built with DSL Tools, so that you do not have to print to a file in order to preview the page layout. Page setup already provides some control on how to layout the pages.
      • Search and replace. Enable search and replace to work with designers built with DSL Tools. You should be able to search for a text string and replace that string throughout the model.
      • Sticky tools on the toolbox. Once a tool is sticky, you don't need to keep going back to the tool to use it repeatedly on the design surface.
      • Standard layout options. The underlying framework supports a number of layout options. This feature would surface it through some standard UI in the generated designer.
      • Pan/zoom control. A pan/zoom control provided as part of the standard UI in the generated designer, rather than having to custom code this as you do now.
    • Provide better support for orchestrated code generation. At present we have a button in the solution explorer for executing all templates in a solution. It is possible, with a little custom code, to hook templates up to a menu command (there's an example in our book), and then write code which does things like apply the same template multiple times to a model, generating a new file for each application. One option for improving this (though we're not fully decided yet) is to hook code generation into the build system, using MsBuild to coordinate it, and make it easy to write custom build actions that do the kind of things you can do when you launch code generation off a menu command. 

    Post-Rosario

    The two main investments we’re considering post-Rosario are:

    • WPF-based design surface. We'd like to replace the current graphical design surface with one founded on WPF (WIndows Presentation Foundation). Not only will this open up many new possibilities in the quality of visualization that one can achieve, we also believe it will make it much easier to customize the graphical notation. At the same time, we'd take the opportunity to componentize the architecture, so that it would be possible to bind a graphical design surface built on top of this component to other data sources, such as XML or a database.
    • First class support for cross-referencing between different models and multiple views. This has been requested many times by customers, although it's also interesting to note that many customers have been able to achieve their scenarios by writing custom code.

    Well, that's all for now. Please provide your feedback on this. What do you like? What don't you like? What's on your wish list?

  • stuart kent's blog

    Other talks involving DSL Tools at TechEd Europe

    • 2 Comments

    Yesterday I posted about VSX talks at TechEd Europe, including one I'm giving on DSL Tools.

    I forgot to mention a couple of other talks involving the use of DSL Tools in software factories. Jezz Santos gives the details. Unfortunately Jezz can't be there himself, but Don Smith, from patterns and practices, will be giving the talks. I had the opportunity to work with Don a few months back on an assignment, and the work his team has been doing on a modeling version of the service factory is impressive. If you want to see a very real, practical application of graphical DSLs in taking some of the grunt out of the development process, then Don's talk on the service factory is a 'must see'.

  • stuart kent's blog

    Speaking at TechEd Europe in Barcelona

    • 3 Comments

    I'm speaking at TechEd Europe in Barcelona on DSL Tools. Go here and look me up under the list of speakers to see details of my session on DSL Tools. There's also a talk from the VSX (VS Ecosystem) team on the new VS Shell given by James (including a demo of hosting a DSL in that shell), and James and Steve are participating in a Q&A session on customising Visual Studio. The ecosystem team will also be running a booth on Visual Studio Extensibility.

    I'm arriving Sunday night, and leaving Friday evening. Come to the booth if you want to talk. See you there.

  • stuart kent's blog

    What future for DSL Tools?

    • 1 Comments

    I've recently received a number of questions about DSL Tools, making me realize that our messaging about the future of this technology has not been very clear. One such question has just appeared on the DSL Tools forum, so I've spent a little time replying to it - take a look here. I've restated the important bit of my answer below:

    "DSL Tools has recently moved from Team Architect to the Visual Studio platform, together with some of the team that developed it. This has been announced in various places including on my blog.

    We are still adjusting to the move and producing a roadmap that makes sense in the new context. Please be patient for a few more weeks. I'll begin by publicising what we're doing to support Visual Studio Team System codename 'Rosario'. For VS2008 (Beta 2 available), the main change is to move the runtime into every Visual Studio box, including the new VS2008 shell (redist of run time no longer required). We've also fixed bugs and improved the path editing experience in the Dsl Designer."

  • stuart kent's blog

    Visual Studio Ecosystem team is hiring

    • 0 Comments

    See Gareth's post for details.

  • stuart kent's blog

    Graphical design of cuncurrent applications

    • 1 Comments

    I was sent email by Alastair McKeeman from Connective Logic Systems, a UK based company.

    They've done some cool work on tools to build concurrent apps targeted at multi-core processors. They have a graphical designer hosted in Visual Studio, implemented using DSL Tools. Take a look at http://www.connectivelogic.co.uk/toolset.html which contains a screenshot. They've also built graphical analysers and debuggers.

    Fascinating stuff.

  • stuart kent's blog

    Microsoft Moves Ahead with Software Modeling

    • 2 Comments

    That's the title of an article in e-week reporting on an interview with Soma. Thanks to Gareth and Pedro for pointing this out.

    When I joined Microsoft four and half years ago, I left a career as a reasearcher in model driven development to join a company that was not recognized as a player in this approach to software development. Now, as Soma points out, there are a range of initiatives across the company looking at model driven development. It wil lbe an exciting ride ahead...

    One of those initiatives is Software Factories (mentioned in Soma's article), and DSL Tools has been instrumental in supporting that vision - see for example the web services software factory, modeling edition, as described in this article by Don.

    As mentioned in my earlier post, DSL Tools, and our team, have moved into the VS Platform, and it's great that we are now in a position to support the adoption of this technology by more teams inside Microsoft, as well as continued adoption by external partners and customers. We're working on our roadmap, but the general direction is to continue to evolve and enhance the DSL Tools to support richer modeling scenarios, and at the same time generalize our model-driven approach to creating designers (the tools in DSL Tools are built using DSL Tools) for creating other kinds of tools and extensions to Visual Studio, not just modeling tools.

  • stuart kent's blog

    Broadening focus

    • 3 Comments

    James and Gareth have posted about the move of the DSL Tools team to VS Ecosystem team.

    Gareth provides some of the reasoning behind this move. Here's a bit more.

    One of the most innovative aspects of DSL Tools is the model-driven approach we take to building a graphical designer which brings the cost of creating such tools to the point where it is cost-effective to invest in building the tools within the first project that they are used. This move opens up the opportunity to broaden this approach to creating other kinds of Visual Studio Extensions. I'm looking forward to the challenge, and to mark this broadening of focus, I've provided a new one-liner to describe my blog: tools to build tools. If you have ideas of software development tools you'd like to be able to build on top of Visual Studio then I'd love to hear from you. Just send email or add a comment.

    The move also makes it easier for us to exploit the new VS2008 shell, in providing a way to deliver DSL-based tooling to folks involved in software development who are not in the engineering role, and so don't need or want all the capabilities that Visual Studio has to offer. This has been requested over and over by customers, and it's great that we'll now be able to address that need.

    And, of course, we'll be using DSL Tools ourselves to build the VSX authoring tools: there's nothing like dogfooding your own stuff to drive improvements! 

    I'm also pleased that I still get to work with friends in Team Architect albeit in a different capacity: they are building some exciting products using DSL Tools, and we'll be making some enhancements to help them. Watch this space.

  • stuart kent's blog

    Presentation from DevDays 2007 in Amsterdam now available

    • 1 Comments

    As mentioned in this earlier blog post: http://blogs.msdn.com/stuart_kent/archive/2007/06/01/talking-at-dev-days-in-amsterdam.aspx

    The presentation is at http://download.microsoft.com/download/1/9/5/195c1f00-bc52-44d8-9950-a00b4a7bc751/Track06__%2014.track6_sessie5_16h30_Stuard_Kent.pdf

  • stuart kent's blog

    Talking at Dev Days in Amsterdam

    • 2 Comments

    I'm giving a talk on Extending Visual Studio with tools for Model Driven Development at Dev Days in Amsterdam on Thursday June 14th.

    I should be there for the whole day on Thursday (my talk is at the end of the day), so if you want to meet just contact me through this blog.

    I'm looking forward to meeting the vibrant Software Factory community in the Netherlands, just outed by Jezz.

  • stuart kent's blog

    Cool shapes with DSL Tools

    • 1 Comments

    Olaf has an interesting post on how you can use fonts as shapes in a DSL Tool using a little bit of custom code. Here's the screenshot:

    using fonts as shapes

  • stuart kent's blog

    Extending the capabilities of DSL Tools

    • 0 Comments
    In my most recent post, I mentioned that the DSL Editor powertoy shows how you can exploit the openness of the DSL Tools architecture to extend the capabilities of the tools. Jezz pointed out to me that he has written up a general approach to extending DSL Tools in his blog, and indeed did so some time ago. I should pay more attention.
  • stuart kent's blog

    Next milestone of DSL Editor powertoy reached

    • 1 Comments

    Jezz has just announced the release of the next milestone in this project. To quote:

    <quote>We released the next milestone of the DSL Editor PowerToy today on CodePlex.

    "A means to add multiple editors to your DSL, either hosted in a tool-window, or replace the graphical designer of your DSL"

    </quote>

    Thanks Jezz for implementing my suggestion of allowing the editors to be hosted in a a window that replaces the graphical design surface. When this powertoy is complete, it will be really easy to produce a forms-based DSL for languages which either don't suit a graphical representation, or where the effort of designing the graphical syntax is deemed not worth the investment. That's in addition to using the tool window in conjunction with a graphical surface. I'm really looking forward to the next milestone where we start to see some generated UI for the content.

    Also, related to my last post, it's great to see Jezz exploiting our approach of generating code from a dsl definition then allowing that code to be further extended through custom code. This has allowed Jezz to look for patterns in custom code you would need to write to implement his editors, and then add new code generators (and, his case, a new DSL as well) to generate to those patterns. This allows the capabilities of the tools to be extended by third parties, to cover all those bits we haven't thought of yet or haven't had time to implement.

  • stuart kent's blog

    Steven Kelly bashing us again

    • 2 Comments

    I see that Steven is having another go at Microsoft's DSL Tools.

    Not for the first time, my impression is that he makes it look worse than it actually is. To quote:

    "As long as Microsoft thing of building modeling languages as a programming project, it's going to be impossible for them to make the changes they need to, without breaking existing modeling languages built with their tools. If they have the possibility to make major improvements to DSL Tools, my suggestion would be to go right ahead: the important market is those who have not yet been reached. Those brave enough to use CTPs, betas and version 1.0 knew what they were letting themselves in for.

    This is of course a problem with tools that require programming to build modeling languages, or a separate compilation step between the definition of the metamodel and using it to model with. In MetaEdit+, the metamodel is specified directly in the tool, with no programming, and models are made based directly on it, with no intermediate compilation. In other words, the metamodel is expressed as pure data, which makes both metamodel updates and tool updates easy and painless for the users."

    In DSL Tools, a large proportion of the code for a designer is generated from a dsl definition. If we make changes to the code generators, then to migrate to a new version is a matter of regenerating the code. If we make changes to the designer definition, then, in the case where those changes are not pure extensions to the designer definition language, we can provide a tool to migrate existing definitions across to the new format. If the designer author has written custom code to finish off their designer, then we could break that custom code if we make sigificant changes to the APIs it is written against, although there are various techniques that can be used to mitigate some of the pain (for example, deprecating APIs over versions). Now, as we add more features to DSL Tools, we will do our best to reduce the amount of custom code that designer authors will feel the need to write, but I think we'll always want to provide that outlet, as authors will always want to push the boundaries of the designers they wish to create beyond what we have thought about in advance when designing the dsl definition format.

    Now, I wonder what happens in the MetaEdit+ case. If the format in which the metamodel (dsl definition) is expressed changes (which it might if they want to add new features), then there has to be code somewhere which migrates metamodels expressed using previous versions to the new version. And I don't see how this is any different to us providing a tool (which may be integrated with the DSL designer itself) that migrates a dsl definition expressed in previous versions of the dsl definition language into newer versions. The difference in the two situations is that with DSL Tools, the extra custom code needs to be converted, but I wonder how much effort that really is, given appropriate guidance and the fact that significant changes to the APIs are not exactly frequent occurrences.

  • stuart kent's blog

    Published at last...

    • 0 Comments

    Our book on DSL Tools is now available. Available at amazon and other online stores. You can also read it online at http://safari.informit.com/9780321398208.

    BTW, if you're interested in meeting with the authors, then you can find Gareth at Tech Ed in the USSteve at Tools Europe, and me at ECMDA and Microsoft Developer Days in the Netherlands.

  • stuart kent's blog

    Orcas version of DSL Tools now available

    • 0 Comments

    A version of the VS SDK (download from http://www.vsipmembers.com/), which includes DSL Tools, is now available for Visual Studio Orcas Beta 1. Gareth has the details.

  • stuart kent's blog

    Different ways of interacting with a DSL

    • 1 Comments

    There's a nice post from Steven Kelly which contrasts different ways of interacting with a DSL in a tool.

    I say 'interacting with a DSL', to stress the difference between that and working with a static syntax on a piece of paper. Working through a tool provides you with many more options not only in how you view and browse expressions in your language, but how you create and update those expressions.

    However, I'd like to pick Steven up on a couple of points:

    • He says that graphical languages are much slower for data entry than text. Whilst this has been true in the past, I'm wondering if it will remain so. I think that some of the mindmapping tools out there are showing that you can achieve rapid data entry through a graphical surface by minimizing mouse movement and using keyboard shortcuts much more.
    • We've also found that there is often rich data in a DSL that is not amenable to graphical representation (or at best adds considerable clutter to the diagram, thereby reducing it's value) and also isn't that well served by an explorer (tree view) and/or properties window. In these case, you really want to design domain specific forms for dealing with that data. So it's nice to see Jezz kick off a project along those lines: check out http://www.codeplex.com/dsltreegrideditor.

     

Page 3 of 7 (152 items) 12345»