More rapid deployment of VS extensions

More rapid deployment of VS extensions

  • Comments 5

Over on Deep's blog I came across the following comment to his post on Tools for Tools.

I had looked at creating a DSL for one of our projects a while ago, and in the end decided against it because the deployment was too complicated. In particular, here is how I want deployment to work:

In my normal solution of my project, I add a new DSL project, along with my other C# projects that constitute my end piece of software. In the DSL project I define a new DSL that I can then use right away in the C# projects that are part of the solution as well. That is, I don't want any setup at all, but rather want the DSL to be loaded as for example WinForm custom controls and the designers that go along are loaded from a dll project that is simply part of the solution of the consuming project.

Why is this so important? First, this would automatically solve the version problem. In my case we would rapidly (or shall I say "agile" ;) change the DSL as the project goes along. With a model where the DSL is installed wia a setup program on a machine wide basis, we run into huge trouble when we want to work with a previous version of our source code (say a branch from the source code repository that corresponds to a previous version). We would need to make sure that our DSL project can always load old versions, i.e. we would need to be super backword compatible. But I don't want that, I want the DSL versioned along with the source code so that I get a predictable match of tools and source code artefacts.

Also, of course, deployment via setup is just a pain, I really just want my solution file to have all the info about tools (be it DSL, compilers what have you) needed to build it and take care of that.

Any chance that we might end up with something like that?

Generalizing this scenario a bit, I think what the commenter is asking for is the following two capabilities:

1) For VS extensions (in this case DSLs) to be checked in the rest of the code on a project, so that you can manage the tools used to build your code just in the same way that you manage the code itself.

2) Not to have to go through an expensive process (e.g. install an MSI) every time you want to reconfigure VS with the tools (extensions) needed for a particular project, or when you want to update those tools.

There are things you can do now to get over these two problems.

For (1) you can have a separate tools authoring solution that is checked in and used to rebuild the tools. You can do this now, and I don't see any issues around this. Indeed I would argue that it's not a good idea to mix your tools authoring solution and application development solutions, just because I think it's a good idea to keep these two concerns separate. However, you still need a way of getting revisions of tooling quickly out to developers, rolling back to past versions and so on. And making sure that before you build your application code, the right version of the tools is built and installed.

For (2), if you don't want to go to the trouble of installing an MSI, then, today, you could do the application building in the experimental version of VS (though you'll need to have the VS SDK installed for that). Building the authoring solution will install the tools in the experimental hive, and then you just need to remember to launch VS Exp rather than VS to do your work. So once you've updated your machine from source control, you'd go an build the authoring solution, then you'd go an open the experimental version of VS and continue with your development. You can reset the experimental version of VS anytime to mirror main VS, when you want to switch projects.

An alternative is to work in virtual PCs (our team does much of its development this way). Then to roll out a new version of the tools to your team, you build a new VPC with the tools installed and distribute this. The advantage of this approach is that you can set up multiple VPCs for different projects and then it's very easy to switch between them. Of course there is more upfront cost taking this approach. This is a good solution if you are distributing tools to a team of developers, you want to retain some stability in the toolset they are using, and you expect developers to be needing to switch context between projects.

Ideally, what I'd like to see happen is that when a developer signs up for a Team System project, they get their machine configured automatically with the necessary tools, and, further, that designated members of the team (which could be anyone) can go and make changes and rebuild those tools, which then get pushed out to other members of the team via Team System. When you switch to a different project, VS reconfigures itself with the tools required for that project. This won't be achieved overnight - it requires some platform changes to VS - but it's certainly on the radar.

  • PingBack from http://msdnrss.thecoderblogs.com/2008/02/08/more-rapid-deployment-of-vs-extensions/

  • Hi,

    thanks for taking this issue up, I think it was me who wrote it orginally :)

    You last paragraph nails it, that is exactly what I would like to see: When I open a solution from Team Foundation Server, the platform takes care to get the proper version of the tools at the same time. I think you have a good point that the tools should be in a seperate solution from the final software project, the link between a solution and the version of the tools it uses should really be in the Source Control System.

  • I think you are going down the right road, but maybe we can think of things in simpler terms.  Creating software that relies on tools is very similar to taking a dependency on an external component or framework.  If the dependency is developed in-house, then you may be rapidly iterating the dependency along with your application.  If DSLs (or any VS extension) could be just an assembly that you reference instead of an installed tool then life would be great!  Just treat the DSL as you would any dependency--version it to your heart's content.  

    I think the ideal solution is to have a seprate references node in  VS projects for VS Add-ins.  Then you could add a tool dependency to your project just like you add an assembly reference.  When you use a VS add-in like a DSL Tools DSL, aren't you taking a dependency on a specific version of that DSL?  Shouldn't the project author be able to declare which version of the DSL the project requires?

  • Hi,

    As I am (still) catching up on the VSX/DSL Tools' team's blogs, I've found many topics of great interest to think about in order to go on improving the DSL Tools. I believe a good deal of those topics eventually involve sooner or later, more or less, the introduction of "agility" in the design, implementation, and user experience of the tools/VS extensions built upon the DSL Tools, whether code generation is the end goal or not (code generation being an important use case of the DSM/DSL approach, in the software production line, but far from being the only one, of course).

    I am going to share my experience about how I tried to provide agility in my little AppBuilder, especially regarding code generation in the context of the elaborationist approach I've chosen (though I didn't know it was called like this until an hour ago) :

    http://blogs.msdn.com/stuart_kent/archive/2004/06/14/155132.aspx

    I'll make sure to include links to the relevant posts of your blogs in my paper.

    "See you" soon. :)

  • I think DSL tool should not be part of VS extensions, rather it should be a stand alone product like wwf.

    DSL's potentials is limited by only being able to be hosted in visual studio shell.

Page 1 of 1 (5 items)