Jeffrey Schlimmer's Blog

Standardizing the Devices Profile for Web Services

jeffrey-schlimmer — Wed, 17 Sep 2008 01:57:00 GMT

Today the WS-DD Oasis technical committee convened to start standardizing the Devices Profile for Web Services, WS-Discovery, and SOAP over UDP. It was like coming home to rub shoulders with the committee members at a reception this eventing. This community has made terrific, consistent progress building implementations -- and products, and I'm sure they're going to produce a great set of specifications.

http://www.oasis-open.org/committees/tc_home.php?wg_abbrev=ws-dd

VSX: How I Extent VS

jeffrey-schlimmer — Wed, 17 Sep 2008 00:03:00 GMT

The last session of the conference was a happy menagerie of speed talks.

Aggiorno: Improving the web one tag at a time. Cleans up HTML source (and will show you what it did). http://www.aggiorno.com/
Atalasoft: Imaging (pictures, scanners) tools for .NET. Populate an assortment of VS integration points with their libraries. http://www.atalasoft.com/
Clarius Consulting: T4 (Microsoft Text Templating Transformation Toolkit) editor. Language services in VS for the text templating language. http://www.clariusconsulting.net/, http://www.t4editor.net/
ComponentOne: Long-time Micorsoft component/control provider. Their latest are components for Silverlight 2.0. (Exciting demo but not particularly related to VS.) http://www.componentone.com/
dynaTrace: Performance monitoring across app lifecycle, tiers, technologies. Integrated with VSTS's load testing, collects and summarizes performance data, and can "pinpoint problematic code." http://www.dynatrace.com/en/
SharpLudus: Combining game development and sofware factories. Put another way, they're building game DSLs that generate XNA. http://www.cin.ufpe.br/~sharpludus/
looksoftware: Modernizing front- and back-end systems. http://www.looksoftware.com/
PreEmptive Solutions: dotfuscator (in the VS box). Think of dotfuscator as a post-build instrumentation platform (Runtime Intelligence Service) that can, e.g., make your app send feature-level tracking to the cloud, self-administrator shelf life, &c. http://www.preemptive.com/, http://www.preemptive.com/images/documentation/runtime%20intelligence.pdf
Rally Software: Help agile teams succeed. Embedded panels within VS IDE and integration with Team Foundation Server. http://www.rallydev.com/
Shunra Software: WAN emulation for development and testing. Run tests under emulation in VS. http://www.shunra.com/
Studio works software: VS plug in for designs and design catalogs. Whatever you drop onto a surface (e.g., WinForms), you can capture (drag) in folders, edit as a design, and reuse. http://www.studioworkssoft.com/
Typemock: Next generation of unit testing for .NET. They sang a song. http://www.typemock.com/

It's time to pray to the QA
That all my bugs will never see the light of day

It's hard to test
My code at best
Because it uses
Sharepoint, ASP, and REST

I just want to know my code works
I can't test it -- I don't know where to start
I just want to know my code works
And I mean it from the bottom of my heart

And threading goo
It's hard to do
I keep on getting deadlocks
Race conditions too

I wish there was
Something out there
That told what I did and how to solve it where

I just want to know my threads work
It is far to hard than it should be

I just want to know my threads work
And my QA isn't willing to talk to me

VSX: External prototype of a new Managed Package Framework

jeffrey-schlimmer — Tue, 16 Sep 2008 22:43:00 GMT

Bravo to the VSX team for inviting István Novák who articulately speaks to the importance of the developer experience and the limitations of the current Managed Package Framework.

Small coverage of Core IDE services
Requires a lot of plumbing code (2,500 lines for custom editor)
Does not use modern .NET features like generics or LINQ
Tasks in common with other parts of the .NET FX are not consistent with it (e.g., WinForms)

He's started a remarkably-complete OM called "VSXtra" that wraps MPF and other parts of the Core IDE. http://www.codeplex.com/VSXtra

The OM is _so_ much better. It terrifically cuts down on the busywork/busycode of defining an extension (and the horribly frustrating process of finding/fixing many of the magic bits). I can pick nits with it, but that might distract from how important and valuable it would be to have a modern framework like this.

One of his goals is to influence the Microsoft team to build a modern MPF. I really, really hope he's successful.

http://code.msdn.microsoft.com/Project/Download/FileDownload.aspx?ProjectName=vsxconf&DownloadId=3172

VSX: How to Extend

jeffrey-schlimmer — Tue, 16 Sep 2008 21:41:00 GMT

Fasten your seat belts. Pablo Galiano demoed creating a VS command, creating a tool window (using solution and project hierarchy information), and creating a tool window (using the file code model / CodeClass). The demos were very code focused, albeit using helper frameworks, some skeleton UI code, and some demo-specific snippets.

[I wonder how to publish a file code model for a new language.]

Pablo made extensive use of "VSSDK Assist", which adds a menu that is a portal to number of wizards to create and update various files: http://www.codeplex.com/vssdkassist

Other resources he recommends are:

LinqToCodeModel is a sample library that provides Linq facilities over FileCodeModel object graphs: http://code.msdn.microsoft.com/LinqToCodeModel
The VSCT (Visual Studio Command Table) PowerToy is a read-only viewer that you can use to explore the commands associated with a VSPackage, and with Visual Studio itself. You can quickly search for any existing commands in the Visual Studio IDE. By browsing through the command groups, GUIDs and IDs, priorities, and other properties of existing commands, you can more easily place and integrate the commands of your own VSPackage. http://code.msdn.microsoft.com/VSCTPowerToy

http://code.msdn.microsoft.com/Project/Download/FileDownload.aspx?ProjectName=vsxconf&DownloadId=3174

VSX: Debugger Extensibility

jeffrey-schlimmer — Tue, 16 Sep 2008 20:25:00 GMT

In the category of make-your-daily-life-better, Laura Petersen showed two wonderful extensions to the VS debugger.

First, the DTE object that deserves much attention. DTE.Debugger gives you programmatic (macro (VB)) access to everything you can do with the Visual Studio IDE debugger. Besides the properties on DTE.Debugger, look for properties on DTE.Properties("Debugger", "General").

Second, if you're frustrated by the noisy views the debugger shows for your types, and are ready to move beyond overriding ToString (and hoping the debugger picks it up), you can define a custom debugger view by adding any / all of the following attributes from System.Diagnostics to your class:

DebuggerDisplayAttribute: summary view using a simple template language
DebuggerBrowsableAttribute: view of fields
DebuggerTypeProxyAttribute: a proxy to display instead

Third (and yes, I can count), if you'd like to create a visualizer for a complex (or just large) value, you can create a custom visualizer (which I tried but, as advertised, it's a bit more complicated):

Create a visualizer:

Create new class library
Add a reference to Microsoft.VisualStudio.Debugger.Visualizers.dll [In my install, this is in "C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\PublicAssemblies\"]
Add new DebuggerVisualizer item to the project.
Add code inside the Show method.
Build and copy the visualizer dll to your VS documents Visualizers folder.

To use the visualizer:

Add references to both the Microsoft.VisualStudio.Debugger.Visualizers.dll and the visualizer dll.
Make the to-be-visualized type Serializable (if not already)
Add the DebuggerVisualizerAttribute

Blogs:

Jim Griesmer: http://blogs.msdn.com/jimgries/
Jackson Davis: http://blogs.msdn.com/jacdavis/
Gregg Miskelly: http://blogs.msdn.com/greggm/

Forum: http://social.msdn.microsoft.com/Forums/en-US/vsdebug/threads/

http://code.msdn.microsoft.com/Project/Download/FileDownload.aspx?ProjectName=vsxconf&DownloadId=3175

VSX: Adding Value with Blueprints

jeffrey-schlimmer — Tue, 16 Sep 2008 16:32:00 GMT

The special topics track started on Day 2 with too-modest-to-introduce-himself and Michael Lehman who dove into the deep end with "software factories" and that domain's cute vocabulary (e.g., "unfolding a blueprint").

As near as I can tell, a Blueprint, once defined, is like a hands on lab, providing starter code ("templates") and an automated checklist ("guidance"), but not wizards or validators.

Positioned as moving beyond DSL tools, Blueprints are the next logical version of Guidance Automation Toolkit (GAT) / Guidance Automation Extensions (GAX) [http://msdn.microsoft.com/en-us/library/aa905334.aspx], and builds on the experiences in Glidepath [http://projectglidepath.net/blog/default.aspx] and Software plus Services (S+S) Blueprints [http://channel9.msdn.com/wiki/softwareplusservicesblueprints/].

You can see the previous version of Blueprints in action as a developer uses a blueprint to build an Outlook add in: http://channel9.msdn.com/posts/MichaelLehman/Microsoft-Software--Services-Blueprints-Walkthrough/

http://code.msdn.microsoft.com/Project/Download/FileDownload.aspx?ProjectName=vsxconf&DownloadId=3176

VSX: Visual Studio Extensibility Architecture Part 2

jeffrey-schlimmer — Tue, 16 Sep 2008 11:48:00 GMT

Doug continued, bravely, into the late afternoon with details of the Visual Studio extensibility architecture.

It's not that I don't love COM, but what I want most after this deep dive is the moral equivalent for the managed developer.

Meme: There's a scenario for every extensibility point here.

Editors

If you need to implement your own type of view, use the TextBuffer as your document data object, and then you can be open as the same time as the code editor. (If you don't want to be compatible with the code editor, don't implement the interfaces that it will query interface for.)
A language service is a package that proffers a service that has a VSLanguageInfo and a colorizer interface. Again, to enable demand loading, you register for a file extension. VSLanguageInfo enables this broad range of features:
- Text colorization [see colorizer]
- Statement completion
- Method tips
- Special and red "squiggly" markers [marker client]
- Custom commands
- Context menus
- Hidden text (including concealed and expand/collapse)
- Code window dropdown bar [code window manager]
Whether you are a full language service or not, one of the most general extension points is a TextView filter, where you can insert a handler into a chain to handle each key. The debugger does this to enable Run to cursor.

Project

Provides the context for operating on a set of items as a unit.
Solutions are thin containers around projects, but can express project build dependencies. A *.sln is shared across team members; a *.suo is per user and stores breakpoints.
Coordinate RAD experience: opening, editing, and saving of files; source control (are dependent files checked out as a unit) [IVsSccProject2]; build (is there one, and what does it do) [IVsBuildableProjectCfg]; deployment (say to embedded device, SQL instance); debugging [IVsDebuggableProjectCfg].
Other project examples: set up and deployment projects, and database project.

Hierarchies

Projects are a kind of hierarchy (IVsHierarchy)
Hierarchies generally manage sets of related items; documents are associated with a hierarchy-item ID pair.
Hierarchies have many (optional) properties that are used for display and navigation.
Other solution-related hierarchies include class view, resource view, performance explorer, test explorer, &c.
Non-solution-related hierarchies include server explorer (i.e., SQL), team explorer (VSTS).
Projects can be nested, e.g., VS 2003 had an Enterprise Template Project (ETP) which aggregated other projects and coordinated an enterprise solution with UI, data, and server tiers with projects within each. Solution folders have grown up to support this scenario, and they themselves are projects that can nest other projects.
Project subtypes are a technique (using COM aggregation) to create a subtype of another project, e.g., WPF Project Flavor VB Basic Templates, or device VB templates (which provide deployment behavior where a normal VB project would have none).

Selection

Of project, and of item within project.
Each window manages its own selection context, including active hierarchy-item ID pair.
Selection controls what is shown in Properties window &c. You can access the active selection using IVsMonitorSelection.
Interacts with delayed loading because a selection can turn on a mode.

http://code.msdn.microsoft.com/Project/Download/FileDownload.aspx?ProjectName=vsxconf&DownloadId=3140

VSX: Visual Studio Extensibility Architecture Part 1

jeffrey-schlimmer — Tue, 16 Sep 2008 02:26:00 GMT

Doug Hodges, one of two original architects who built the first, extensible IDE shell from MSFT (Visual Studio 6.0), took up the challenge of two, back-to-back afternoon sessions and launched into "fundamental" (lower-level) architectural concepts. He shared his considerable context, motivating the current design and reflecting a long history of careful attention to detail.

Themes: delay load assemblies, mature COM model, thoughtful versioning story, support many styles of Windows programming including managed interop assemblies and helper libraries.

VsPackage

The initial starting point for a logical set of features in the IDE. Co-created, given a pointer to the IDE for services ("sited"), and used as a factory for its features.
Loading is delayed until functionality is needed, so package must expose metadata (using registry) so IDE knows when to load it.

(COM) Services

The Site call includes an IServiceProvider, and it has a QueryService interface (similar to QueryInterface), and requests to this interface may be routed to another object which actually provides the service.
The Managed Package Framework (MPF) are helpers over blessed interop assemblies to the native IDE.

Note: The language services and shell parts of the MPF are shipped as DLLs, but the project base classes are provided only in source code form, and you compile them into your package.

Sidebar about versioning: Versions ship using an interop assembly and a helper library to facilitate development. When they have to break backwards compatibility, they ship exactly the previous interop assemby plus a new interop assembly that contains only new changes ("delta assembly"); both interop assemblies can be loaded in the same application domain; a new helper library bridges across both interop assemblies. With a few exceptions (e.g., WinForms), these guarantees allow customers to write a single binary that works in two successive versions, either targetting the lowest-common denominator by using the previous helper library, or "light up" on the newest version by using the newer helper library.

Tool Windows/Document Windows

The window architecture supports a broad range of existing UI (which makes adding WPF support less surprising).
Tool windows are typically single instance and can float, doc, tab, or be an MDI child.
Document windows (editor windows) are multi instanced, MDI child, always owned by a project, and associated with a document.

CommandBars/Command Routing

Data and interfaces are similar to Office (branched a while back); using metadata from packages, the IDE merges commands into a complete UI -- without loading the packages. See *.vsct (XML) for definitions of menus, commands, toolbars, and context menus.
Routing determines which commands are visible / enabled in a given context: add-ins first, active window, active project and its parents, and then finally, the global environment and packages.

Standard Editors/Custom Editors

Editor is a document window.
The factory is not the package itself, but another "editor factory". In the simple one view case, you pass an editor document to the service that shows the editor view. In a more general multi-view data vs. view case, there are "document data" and "document view" objects to manage.
Register for your format and use priority to indicate how well you can handle the format. (Highest priority of 50 is default; lowest priority will be lowest on the list.)
There's a range of integration between the editor and the IDE. At least, the editor can be an external EXE, and VS will launch it. At the most integrated, be a hierarchy in a tool window, like the VC Resource Editor. There are examples of nearly each of the 7 ratchets of integration.

Running Document Table

May not need to think about this, but its here to handle the fact that the user might want to edit a document in an incompatible editor, and while the IDE can shut down the views, it needs to talk to the editors, so they can shut down and clean up the document object.

http://code.msdn.microsoft.com/Project/Download/FileDownload.aspx?ProjectName=vsxconf&DownloadId=3136

VSX: Advanced Topics in Domain-Specific Development

jeffrey-schlimmer — Tue, 16 Sep 2008 00:53:00 GMT

I didn't catch this talk (because I was enjoying Doug's history), but you might want to review it if:

(a) You're interested in the "T4" templates used to generate code at the back end of the DSL story.

(b) You wonder about getting back from target code to the DSL, so called "bidirectional DSL".

No magic bullet offered for the latter, but some source that up-levels the low-level abstraction provided by the code editor events.

http://code.msdn.microsoft.com/Project/Download/FileDownload.aspx?ProjectName=vsxconf&DownloadId=3142

VSX: Introduction to the Visual Studio 2008 Shell

jeffrey-schlimmer — Mon, 15 Sep 2008 23:58:00 GMT

James K. Lau walked through a heroic effort to eviscerate Visual Studio 2008 so you can re-use the shell to build your own IDE. Absolutely amazing. Together with the DSL support, this makes fabuluous strategic sense -- after all, here's a way to build your own (graphical) language and your own editor for that language.

If there was one place that could use improvement though, it would be *.pkgdef: Wow. Edit a simple text file to set a sea of registry settings to get the experience you want. Compared to the Properties window used for DSL, this is very primitive. Same for *.vsct which is in XML format.

http://code.msdn.microsoft.com/Project/Download/FileDownload.aspx?ProjectName=vsxconf&DownloadId=3137

P.S. At least some folks at Microsoft think of the VS Shell as the same kind of thing as Eclipse RCP.

http://code.msdn.microsoft.com/Project/Download/FileDownload.aspx?ProjectName=vsxconf&DownloadId=3173

VSX: Books

jeffrey-schlimmer — Mon, 15 Sep 2008 22:19:00 GMT

Can't recommend either yet, but both have been called out at the conference as resources for those who learn best from a book.

Visual Studio Extensibility, Keyvan Nayyeri, Wrox Press: http://www.wrox.com/WileyCDA/WroxTitle/Professional-Visual-Studio-Extensibility.productCd-0470230843.html

Domain-Specific Development with Visual Studio DSL Tools, Cook, Jones, Kent and Wills: http://www.domainspecificdevelopment.com

VSX: A Note About the Slides

jeffrey-schlimmer — Mon, 15 Sep 2008 22:18:00 GMT

I'm sorry the link to the slides has a long license agreement. VSX is a new conference. It will get better.

VSX: Visual Studio Add-ins, Templates and Wizards

jeffrey-schlimmer — Mon, 15 Sep 2008 22:07:00 GMT

I didn't catch this talk by Gabor Ratky. I was little less interested in macros and lighter-weight add-ins, but when I looked at the slides, I realized I made a mistake. At the very least, learning more about the Design Time Extensibility/Development Tools Extensibility (DTE) is going to be extremely helpful when trying to write unit tests for any sort of Visual Studio extension.

http://code.msdn.microsoft.com/Project/Download/FileDownload.aspx?ProjectName=vsxconf&DownloadId=3138

VSX: Domain-Specific Development with Visual Studio DSL Tools

jeffrey-schlimmer — Mon, 15 Sep 2008 21:44:00 GMT

After a break for lunch, Jean-Marc Prieur took the stage again, and explained the recent Domain-Specific Language (DSL) support in Visual Studio 2008 SDK.

First, to show that it is easy, he built a simple DSL with a "graphical syntax" (box and arrows) using first a wizard and then VS diagram and property editing. This demo was hindered a bit by the example DSL (classes and objects) which supports the recursive power of the tool but invited confusion about which level was being demonstrated at any given point in time.

Second, to show that it is powerful, he build bits and pieces of a more sophisticated DSL for a drawing program.

In both cases, the DSL is built using a diagrammatic editor, modifying properties in the Properties window, which is all consistent with progressive elaboration. (A small fly in the ointment, there are two places to look to set properties: Properties window and the DSL Details window.)

In a wonderful stroke of consistency, the experience to develop the DSL is the same as the experience to use the DSL. (And it sure looks like you use the DSL for DSLs to build your DSL.) The generated code determines the final application experience, and this code is produced using templates (*.tt).

My strong impression is that there are hundreds of individual extension points, partly because VS has a rich set of UI bits. How many different conventions do these follow? How do you know if you’ve plugged in to / overridden enough of them?

http://code.msdn.microsoft.com/Project/Download/FileDownload.aspx?ProjectName=vsxconf&DownloadId=3145

VSX: Extend Your Development Experience

jeffrey-schlimmer — Mon, 15 Sep 2008 21:38:00 GMT

Jean-Marc Prieur started off the introductory track with a fairly high-level presentation with two highlights for me:

First, honestly, there's a nest of extensibility options in Visual Studio. Check out Slide 11 of the presentation [1]. Seriously, this slide is scary.

[1] http://code.msdn.microsoft.com/Project/Download/FileDownload.aspx?ProjectName=vsxconf&DownloadId=3139

Jean-Marc ran through an interesting demo using wizard from VS 2008 SDK to create a package and build out code to access the code view of an item in a project. The tool is available in the Visual Studio Gallery [2] and the source is available on Code Plex [3].

[2] http://www.visualstudiogallery.com/ExtensionDetails.aspx?ExtensionID=bea9ed59-8857-4032-9666-9af1c1a33969

[3] http://www.codeplex.com/SourceCodeOutliner