Stuart Kent - Software Modeling and Visualization

  • stuart kent's blog

    CodeLens incoming changes indicator

    • 0 Comments

    In case you missed in my recent post about Code @ Scale, Mathew Aniyan has just blogged about the CodeLens incoming changes indicator, an enhancement to CodeLens collaboration indicators that we're shipping in Visual Studio Update 2. This helps the developer see changes in other branches that could impact the code they are currently working on. Try it out and let us have your feedback.

  • stuart kent's blog

    Code @ Scale

    • 2 Comments

    As customers you may not be that interested about how we are internally organized to deliver the tools and services in Visual Studio, TFS and Visual Studio Online. However, it helps to have a little of that background to understand why individuals focus on the topics they do. So, given that I have been quiet so long, I thought I'd say a little about what I and my team are working on just now.

    I've recently changed role, still in the realm of developer tools, but now leading a team focusing on tools and services to help developers understand, maintain and evolve code at scale. The team is split between the UK and India, with one of the team also based in France - we're very familiar with distributed working across timezones and geographies. Before this role, I was worked with the team that is now delivering Application Insights, so expect some occasional articles about that.

    The starting point for code at scale comprises the following existing tools and services, which I've grouped under four high level areas:

    1. Understand code change at scale: CodeLens(TM) collaboration indicators and service for Team Foundation Version Control (TFVC)
    2. Understand code structure at scale: code map, debugger map, dependency graphs, reverse engineering to UML tools
    3. Validate code structure at scale: layer designer
    4. Generate code at scale: DSL tools, code generation from UML models

    For the moment, our main push with (1) is to enhance the overall experience (see e.g. Mathew's blog post on the upcoming CodeLens(TM) Incoming Changes Indicator) and extend CodeLens(TM) support for other VC systems, starting with Git and TFVC in VS Online (the service only works with TFS on premise at the moment). We are also looking to add support for other languages.

    On (2), we are currently focusing our efforts around code map and debugger map. For code map, we are looking at:

    • Improving the experience for filtering and hiding nodes and (especially) links, to reduce clutter and noise when working with maps at scale;
    • Making it easier to create "standard" maps, to take some of the guesswork out of creating maps that are useful for certain kinds of task including, for example: the full inheritance/implements graph for a namespace or keyed off a select set of types, the graph of all code that code be impacted by a change to an interface, the override hierarchy keyed off a method, and so on;
    • Creation of maps across code for whole systems, not just code for individual components or which can wholly be contained within a single Visual Studio solution;
    • Understanding systems comprising services, devices apps and web clients, making use of REST and dependency injection;
    • Using non-diagrammatic ways to explore and understand code structure where that is appropriate.

    Debugger map is actually a code map, whose population is driven from a debugging session, whether that be live debugging or debugging through an IntelliTrace log. As such it will benefit from some of the enhancements to code map. However, we are also looking at a set of improvements which are specific to the debugging experience. In particular, we have worked with the diagnostics team to improve the experience of using code map with IntelliTrace, with the first results of that collaboration appearing in Visual Studio 2013 Update 2 CTP2.

    On (3), we get consistent feedback from customers about the value proposition behind the layer designer, but are also aware of some the limitations of the current tool. To that end, our focus will be on converging the layer designer and code map experience, enabling layer validation at scale - beyond the bounds of a single VS solution, and enabling a richer set of architecture validation rules to be defined.

    We are currently considering how best to take (4) forward.

    As always we can't announce timings and plans are always likely to change, especially as we learn more via telemetry from how customers are using the product, and through informal feedback from customers about the tools and problems that are most important to them. To that end, if you have feedback/questions about your usage of the tools, or about any of the ideas described above, please get in contact, e.g. via a comment on this blog.

  • stuart kent's blog

    Is Model Driven Development Feasible?

    • 1 Comments

    This is the question asked in the title of a post on our modeling and tools forum, and rather than answer directly there, I thought it would make more sense to post an answer here, as it’s then easier to cross-reference in the future.

    The body of the post actually reads:

    Various Microsoft attempts at MDD have failed or been put on the back burner: WhiteHorse, Software Factories, Oslo.

    Does Microsoft have any strategy for Model Driven Development? Will any of the forementioned tools ever see the light of day?

    First we need to clarify some definitions. I distinguish between the following:

    Model-assisted development, where models are used to help with development but are not the prime artefacts – they don’t contribute in any direct way to the executing code. Examples would be verifying or validating code against models or even just using models to think through or communicate designs. UML is often used for the latter.

    Model-driven development, where models are the prime artefacts, with large parts of the executing code generated from them. Custom, hand-written code is used to complete the functionality of the software, filling in those parts which are not represented in the model.

    Model-centric development, where models are the prime artefacts, but interpreted directly by the runtime. Custom, hand-written code is used to complete the functionality, with an API provided to access model data and talk to the runtime as necessary.

    These are not separated approaches, and development projects may use a combination of all three. In fact, I imagine a continuous dial that ranges from model-assisted development through to model-centric development, such as the one illustrated below (starting at the left, the first five tabs are examples of model-assisted development).

    image

    The challenge is to make the movement through the dial as seamless and integrated as possible, and also to make sure that these approaches can be adopted incrementally and in a way that integrates with mainstream development (agile) practices. Only then will we be able to unlock the potential productivity benefits of these approaches for the broader development community.

    In Microsoft, there are a number of shipping products which support or employ one or more of these approaches.

    In Visual Studio, we have DSL Tools and T4, which together support model-driven development. New functionality was added to both in VS2010, and T4, for template-based code generation, continues to see broader adoption, for example in the ASP .Net community as evidenced by this blog post. for example. Many customers use DSL Tools for their own internal projects, and we continually get questions on this forum and through other channels on this.

    Visual Studio 2010 edition introduced a set of architecture tools: a set of UML Tools (built using DSL Tools), a tool for visualizing dependencies between code as graphs, and a tool for validating expected dependencies between different software components (layers). I would place all these tools under the category of model-assisted development, although the VS2010 feature pack 2 does provide some support for generating code from UML models, which allows these tools to be used for model-driven development, if MDD with UML is your thing.

    Visual Studio LightSwitch combines a model-driven (generates code) and model-centric (directly interprets the model) approach to the development of business applications. It is a great example of how models can really make the developer more productive.

    Outside of Visual Studio, the Dynamix line of products, also take a combined model-centric/model-driven approach to the domains of ERP and CRM business applications. For example, take a look at this blog post.

    I am an architect with the Visual Studio Ultimate team, who are responsible for DSL Tools, T4, and the architecture tools. In that team, we are now looking into how to take these tools forward, focused very much on how to make software developers and testers more productive. Part of this will be to consolidate and integrate some of what we already have, as well as integrate better with other parts of Visual Studio and mainstream development practices. Another part will be to add new features and capabilities and target support on specific frameworks and domains – as LightSwitch does. We’re focused on addressing the challenge set out above, and to deliver value incrementally.

    As we start to deliver the next wave of tools, I look forward to a continued conversation with our customers about the direction we’re headed.

    Addendum (8/4/2011): I forgot to mention that another problem we’re currently focused on is how deliver a much more seamless integration between models and code, which is essential to meet the challenge described above.

  • stuart kent's blog

    Sprinkling the MEF fairy dust on DSLs

    • 0 Comments

    We’ve been enjoying injecting MEF extension points in our tools to make it easy for customers to write extensions using very simple code. Jean-Marc has just posted a sample demonstrating how MEF-enable your own DSL so you too can add MEF extension points for customers. See http://blogs.msdn.com/jmprieur/archive/2010/05/17/enabling-your-dsl-for-mef-extensions.aspx for details.

  • stuart kent's blog

    Useful blog on VS2010 Architecture Tools

    • 0 Comments

    Cameron Skinner has recently been on tour in the US giving talks about the new architecture tools in VS2010. He was touring with a developer evangelist Jennifer Marsman, who has followed up with a load of informative blog posts giving more detail on teh material that Cameron presented. A good entry point is http://blogs.msdn.com/jennifer/archive/2010/05/10/visualization-and-architecture-tools-in-vs2010-cameron-skinner-tour-summary.aspx.

  • stuart kent's blog

    Extending UML sequence diagrams to cover LINQ

    • 0 Comments

    Just catching up on blog reading and came across this post from Cameron: http://blogs.msdn.com/camerons/archive/2010/05/08/sequence-diagram-re-linq-and-lambdas.aspx

    It gives the details of of a small extension to UML sequence diagrams introduced in our VS2010 implementation to cope with deferred execution of LINQ expressions. And gives a real insight into the lazy execution strategy used for LINQ expressions.

  • stuart kent's blog

    Tech Days UK videos now available

    • 1 Comments

    Videos of the VS2010 launch and deep dive sessions at the recent Tech Days UK event are now available. Also See my earlier post about this event.

    Goto http://www.microsoft.com/uk/techdays/ click on the Resources tab and then choose the video you’re interested in watching.

    I’ve embedded the video of my session below:

  • stuart kent's blog

    Tech Days in London

    • 0 Comments

    Writing this as I come back from speaking at Tech Days in London, in a series of deep dive sessions following the launch of VS2010. The venue was a cinema in Fulham Broadway. The place was full (between 500 and 600 people), indeed over-subscribed. I understand that some folks who turned up were turned away (Health and Safety dictates that you can’t go over capacity in this kind of venue); desperately sorry for those unlucky few, but perhaps they enjoyed a day in London instead. It’s great to see so much enthusiasm for the new tools in Visual Studio. Yesterday’s VS2010 launch was packed out as well.

    The decision to use a modern cinema was inspired. The seating is very comfortable, much better than you usually get in conference centres, and I think this must be the largest screen I’ve ever given a presentation on; there were no worries about people not being able to see the text. Though slightly disconcerting to see a few participants tucking into their popcorn! The audience was attentive, and I could see some heads nodding in the front rows, with, of course, the usual politeness and reserve to be expected from a British audience. I’ll be interested to see the feedback scores. A couple of questions: one asking about the version of Visual Studio you need to use these tools (Ultimate for all the functionality, though some limited functionality is available in lower versions), another about the relationship to M and Oslo (M is now part of SQL Modeling Services, and we look forward to being able to hook some of our visualizations to models in databases at some point in the future).

    The speaker after me was Colin Bird, formerly of Conchango and now founder of a new company RippleRock. He gave a very interesting talk on Agile Development, making the point that Microsoft is really providing a tooling platform, with some tools, templates and so on in the box to get you started, but to get the most out of it you need to invest some resource every sprint into building up and maintaining your tools and automation, which should include customizing and extending Visual Studio to fit your own engineering practices and particular circumstances. I couldn’t agree more, and I think that it is our job in Microsoft to make it as easy as possible to implement and deploy those customizations. As an illustration of how far we’ve come, towards the end of my talk I was able to create a new extension to the UML designers and deploy it to VS in less than a couple minutes, as well as create a new DSL from scratch. A few years ago, I’d have been much more careful about demonstrating DSL Tools because of the wait times it took to do the code generation and build. Deployment was also a case of adding another project to create a .msi. And I wouldn’t have dared tried creating other kinds of VS extension during a demo.

    This trip also made me realize how old I must be getting (that and the recently acquired reading glasses). I used to live in London when a PhD student, and would have expected to have needed to go outside at least once to get to my destination. I travelled on the high speed rail service from my home town of Canterbury which takes you straight into St Pancras station. It’s the first time I’ve used this service (I usually take the slower train into Charing Cross), and I have to say that St. Pancras really is beautiful, with a broad arching roof over the platforms. So I arrived under cover, and from there you can walk to Kings Cross tube without stepping outside, then round on the Circle line to Edgware Road, and a step across the platform onto the District line service to Fulham Broadway. The entrance to Fulham Broadway is integrated into the shopping complex and multi-screen cinema, so no need to go outside there, either. The experience was slightly surreal.

  • stuart kent's blog

    Interesting case study in using VS2010 architect tools

    • 0 Comments

    Just came across this. Check it out: http://www.microsoft.com/casestudies/Case_Study_Detail.aspx?casestudyid=4000006781

  • stuart kent's blog

    VS2010 Visualization and Modeling SDK

    • 0 Comments

    It’s great to see that the RTM version of the Visualization and Modeling SDK is also available at the launch and release of Visual Studio 2010. For details check out http://code.msdn.microsoft.com/vsvmsdk. See also Jean-Marc’s announcement of this.

    As well as the DSL Tools which has been much improved in this release (see What’s new), it also includes some project templates to get you started with extending the UML Tools in Visual Studio. Enjoy.

  • stuart kent's blog

    Visualizing work item graphs in VS2010

    • 0 Comments

    In Visual Studio 2010, released today, there is a new visualization tool which, in-the-box allows you to generate a quick graphical view of your code, amongst other things. Chris Lovett was a key architect of this tool, and has some great blogs about it’s features and how to get the most out of it. See http://www.lovettsoftware.com/blogengine.net/

    The tool visualizes data expressed in a markup language called DGML, which means you can visualize any data which can be rendered in this form. I’ve been using it internally to help understand the wealth of project management data we have stored as work items in TFS. In particular VS2010 supports typed relationships, which means you can express much richer information about the relationships between work items, which is great, except that it can be difficult to track what’s going on even by using tree-based queries. So being able to visualize the work item graphs as graphs is a real boost. It’s great, then, to find a project on codeplex which shows you how to visualize your TFS work item data using DGML: http://visualization.codeplex.com/. A screenshot is given below.

    If you think this would be useful to you, you may like to think about other ways of visualizing the data. One thing we’ve managed to do is group stories by area rather than iteration, and then create a graph per iteration which is filtered only to show the stuff for that iteration, as well as a graph that spans all iterations, or some appropriate subset. Then you can nest tasks under stories, and use colouring to indicate % completion of tasks, which can also be aggregated up to stories, and then up to feature areas containing the stories. If there are no tasks, then the estimates against the stories are used to calculate completion and amount of work remaining. This allows us to see, at a glance, how much we’ve completed per sprint and at any time in the sprint, as well as for the whole project.

    By Iteration.png

  • stuart kent's blog

    VS2010 – Useful links on getting started with ALM features

    • 0 Comments

    I just came across this post from Charles Sterling with a bunch of useful links:

    http://blogs.msdn.com/charles_sterling/archive/2010/04/09/getting-started-with-visual-studio-2010-alm-features.aspx

  • stuart kent's blog

    What went wrong with my demo at the Architect Insight Conference

    • 0 Comments

    I recently gave a talk at the Microsoft Architect Insight Conference held in London recently. I gave a demo of the visualization and modeling tools in Visual Studio 2010, and received some very positive feedback about the tools from a number of those attending.

    In the final part of my demo, I showed how to create an extension of the UML tools, but couldn’t work out why the extension seemed not to work when I installed it in Visual Studio. On the train home, I figured out the reason. The extension was designed to work with the Use Case UML designer, but I forgot to change the attribute on the class defining the extension to reference the Use Case Designer. As far as it was concerned, this was an extension registered to be used with the Class Designer. That is, instead of:

    // Custom gesture (drag-drop and/or double-click) extension
    // See
    http://msdn.microsoft.com/en-us/library/ee534033(VS.100).aspx
    [Export(typeof(IGestureExtension))]
    [ClassDesignerExtension] // TODO: Add any other diagram-types on which you want your gesture to work
    class GestureExtension : IGestureExtension
    {

    }

    I should have had:

    // Custom gesture (drag-drop and/or double-click) extension
    // See
    http://msdn.microsoft.com/en-us/library/ee534033(VS.100).aspx
    [Export(typeof(IGestureExtension))]
    [UseCaseDesignerExtension] // TODO: Add any other diagram-types on which you want your gesture to work
    class GestureExtension : IGestureExtension
    {

    }

    I changed this on the train and it worked immediately. I won’t make that mistake again!

  • stuart kent's blog

    Talking about architect tools at VS2010 launch

    • 0 Comments

    Visual Studio 2010 and .Net 4.0 launches today across the world, and I have the pleasure of giving a talk tomorrow at the UK Tech Days event in London as part of a set of deep dive sessions into the new release. For details see http://www.microsoft.com/uk/techdays/daydev.aspx.

    I’m going to be demonstrating the new visualization and modelling tools in Visual Studio, which I’ve helped to build and have been enjoying using on our own development projects.

  • stuart kent's blog

    Empirical assessment of the efficacy of MDE: Can you help?

    • 0 Comments

    I’m lending my support to a research project which is trying to assess the effectiveness of MDE. The project is being led by Jon Whittle, who’s now a professor at the University of Lancaster in the UK. Details of the project can be found at http://www.comp.lancs.ac.uk/~eamde. Personally, I’m hoping this project will not only shed some light on whether or not MDE is effective (I’ve heard enough hearsay evidence to suggest that it is in some situations), but more importantly what are the factors that contribute to it’s effectiveness, and are these factors unique to MDE or do they come into play whatever software development methodology you use.

    The project is just starting up and Jon and his team would now like to interview people with experience of applying MDE (Model Driven Engineering) techniques in practice. The interviews will take no more than 30 minutes and be conducted by phone. If you are interested, please could you contact Jon, or his associate John Hutchinson, giving some indication of your affiliation and experience in applying MDE techniques. Contact details can be found at the above link.

    There’s also an online survey which you can fill out: http://www.comp.lancs.ac.uk/~eamde/site/content_survey.php.

    Thanks in advance for helping.

  • stuart kent's blog

    Extending UML designers in VS2010 Beta2

    • 0 Comments

    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.

  • stuart kent's blog

    Jean-Marc blogs about DSL Tools in VS2010 Beta2

    • 0 Comments

    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.

  • stuart kent's blog

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

    • 2 Comments

    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.]

  • stuart kent's blog

    Most influential paper award

    • 1 Comments

    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…

  • stuart kent's blog

    Pedro on the Code Generation Conference

    • 0 Comments

    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.

  • stuart kent's blog

    So what is a DSL anyway?

    • 2 Comments

    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:

    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.

    image

    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.

  • stuart kent's blog

    More from Code Generation 2009

    • 0 Comments

    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.

  • stuart kent's blog

    IMS Locks Sample for VS DSL Tools 2010 Beta1

    • 0 Comments

    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.

  • stuart kent's blog

    News from code generation 2009

    • 0 Comments

    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.

    image

    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).

  • stuart kent's blog

    ModelBus Adapters Project Template

    • 0 Comments

    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.

Page 1 of 6 (147 items) 12345»