Stuart Kent - Building developer tools at Microsoft - @sjhkent

  • stuart kent's blog

    Technical Debt

    • 0 Comments

    I’ve been doing some research on the topic of technical debt recently, and found the following great resources:

    http://en.wikipedia.org/wiki/Technical_debt

    http://martinfowler.com/bliki/TechnicalDebt.html

    http://martinfowler.com/bliki/TechnicalDebtQuadrant.html

    http://www.construx.com/10x_Software_Development/Technical_Debt/

    http://www.ontechnicaldebt.com/

    http://www.slideshare.net/intechnica/technical-debt-101

    https://www.youtube.com/watch?v=ZUYIFLfyxoI

    Anyone know of others that would be worth looking at?

  • stuart kent's blog

    CodeLens & Code Map improvements announced at #VSConnect events

    • 0 Comments

    In case you missed them, there have been some new capabilities announced today in the #VSConnect event held today in New York. For a summary of some of the key new features overall see Announcing Visual Studio 2015 Preview and Visual Studio 2013 Update 4 Availability. And then there are three blog posts on new CodeLens and Code Map capabilities:

    Code Lens for Git "Team Activity View"

    Filter link types on Code Map

    CodeLens in Visual Studio Online enabled as a Limited CTP

    We’ll be blogging some more about other Code Map features over the next few days. You can also check out these videos (yes it’s me doing the presenting):

    http://channel9.msdn.com/Events/Visual-Studio/Connect-event-2014/717 (CodeLens)

    http://channel9.msdn.com/Events/Visual-Studio/Connect-event-2014/213 (Code Map)

    And finally, though not something built by my team, I’m personally really pleased to see Support for debugging lambda expressions with Visual Studio 2015.

  • stuart kent's blog

    Kanban, MMFs and the Goldilocks Principle

    • 0 Comments

    http://agileproductdesign.com/blog/2009/kanban_over_simplified.html really resonates with me.

    The article explores Kanban and how it differs from other agile approaches such as Scrum.

    My experience with scrum was as follows. You peel off a set of stories from the backlog to deliver in that sprint. Because you have a fixed-timebox there is pressure to make the stories quite fine-grained so you can be sure that they’ll fit in the time box, and you don’t have fractions of stories assigned to the sprint. You try and identify a theme to provide a common goal, but that can be a bit artificial, and some of the stories don’t really fit with it. Inevitably you are too greedy and as the end of the sprint draws near everyone feels under pressure to complete stuff, quality goes down, and then there’s a long tale of testing that ends up being done in the next sprint. Often the testing can’t be done anyway because you’ve got to wait for other stories to be completed before you have enough of an e2e experience to test (there’s only so much that can be achieved through unit testing). You try to write stories that are customer facing, but as they are quite fine-grained, this can be a bit of a struggle – stories creep in for backend and engineering work. You have trouble explaining the backlog to your stakeholders because the stories are too fine-grained to see the wood from the trees, and they are also not all customer-facing.

    In order to cure these problems, we started evolving towards a Kanban approach, beginning by adopting the notion of Minimal Marketable Feature or MMF. An MMF is in the Goldilocks zone of granularity – neither too big nor too small, just right. There is a beautiful tension between making the feature marketable yet keeping it minimal, and a lot of hard work goes into designing the backlog and getting this right, as it should. We still have stories – they are used to break down the work to deliver an MMF, and we still try to make them customer-facing to keep the team thinking that way but don’t force it.

    MMFs are marketable, so it became easier to communicate with stakeholders about the functionality being delivered and how it contributes to the business.

    Execution focus turned away from the sprint to the MMF. When is the MMF expected to ship? Is the burndown of stories/tasks for that MMF tracking to that expected date? If not, what’s blocking, can the block be removed? Or is it that it’s just taking longer and expectations need to be reset with stakeholders? Do we need to shift effort from another MMF being done in parallel to one MMF to ensure that at least one gets completed ready for the next release? How is a release (= set of MMFs) tracking? Will all the MMFs make it (not too much of a disaster if they don’t, because all MMFs are designed to be self-contained, marketable in their own right)?

    We found that a Kanban board of MMFs is quite an effective way of tracking progress. Focus shifts towards pushing an MMF across the board as quickly as possible, and lining up MMFs in the queue to feed the continuous delivery pipeline. There is no pressure to finish it against some arbitrary deadline (end of sprint); instead the team pushes itself to get MMFs through the system as fast as possible, though without skimping on quality and in a way that is sustainable long-term: late nights and productivity-sapping long hours are avoided as much as possible.

    We have continued using sprints, but they’ve been demoted to useful planning checkpoints where an engineering team can re-evaluate it’s capacity, communicate with stakeholders about MMFs that have been completed since the last checkpoint, update expectations about when MMFs in flight are likely to finish, and raise awareness of what’s coming next in the queue. There is no longer a need to identify a theme for a group of stories in a sprint, because the MMF is the theme – all stories required to build it are naturally grouped.

    I wouldn’t go back to Scrum.

  • stuart kent's blog

    Nice to tweet you

    • 0 Comments

    I’ve been on twitter for a while, but only recently started to use it actively. Enjoying the experience. You can tweet me @sjhkent.

  • stuart kent's blog

    Direction and changes for Architecture and Design Tools in Visual Studio

    • 0 Comments

    We’ve just posted in this topic over on the VS ALM blog. Please send us your feedback.

    Upcoming Changes in Visual Studio Architecture and Design Tools

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

Page 1 of 7 (152 items) 12345»