XAML IntelliSense Presenter for Visual Studio 2013

May 21, 2014

Current Version:  3.0 (21 May 2014)

The Visual Studio 2013 XAML Editor has really come a long way since Visual Studio 2010. You can read up on the new features in this blog post.

I originally released this tool in April 2010 and have rebuilt it for Visual Studio 2013.

FullControls FullProperties



  • Pascal case lookup
  • Optional narrowing list filter
  • Filtering based on item type
  • Toggle narrowing filter Hot Key (ALT + .)  (ALT PERIOD)
  • Toggle namespace filter Hot Key (ALT + ,)  (ALT COMMA)
  • xmlns IntelliSense options
    • Show/hide only solution assemblies
    • Show/hide schemas

Filter settings persist for the current Visual Studio session

Pascal Case Lookup

Pascal case lookup is always enabled regardless of the narrowing filter option.  When all of your text is upper case this feature kicks in to quickly locate the item you are looking for.  Note, this feature requires at least two upper case characters be entered before kicking in.

The feature locates entries that start with the first upper case character you entered, then matches on additional upper case characters.

The below image demonstrates the Pascal case lookup.


Locating an assembly using the xmlns Pascal case IntelliSense is super fast.


Narrowing List Filter

When the narrowing list filter is enabled it provides two features. 

You can enable/disable this feature by clicking the Filter icon or by using the hot key (ALT + .) (ALT PERIOD).

  • Narrows the list of displayed items by only including items that contain your text
  • List item selection priority
    • Selects the first match that starts with your text
    • Selects the first entry that contains your text
Narrowing List Filter Enabled Narrowing List Filter Disabled
NarrowingEnabled NarrowingDisabled
With narrowing enabled, see how easy it is to locate Grid.Row or Grid.RowSpan.  

List Item Type Filter

This was my original driving force behind writing this extension.  Was found myself frustrated when a type in XAML has 2 properties, 4 events and 75 namespaces listed in the IntelliSense listing.  Problem solved.

New in version 2.0 is the addition of the namespace filter toggling hot key (ALT + .)  (ALT PERIOD).  This hot key is tied to the namespace icon, making it faster to show/hide namespaces.

Standard list of items, notice the multitude of namespaces that are listed.


Toggle the namespaces ToolBar button by clicking it and they are filtered for you.


The other ToolBar filter buttons work the same.  The gray background is the enabled state.  The white background with grayscale image is the disabled state.

xmlns IntelliSense

The below image demonstrates the two filter buttons in the xamls IntelliSense presenter.

  • Show only solution assemblies is enabled.
  • Remove schema entries is enabled.


Another way to locate your assemblies very quickly is demonstrated in the below image.  The two filter buttons in the default state and I entered WC to quickly find an assembly in my solution. 

This is another example of the Pascal case filtering.


In the below image I’m taking advantage of the narrowing filter to locate all assemblies that have the word media.  When searching the text with this type of search, the entire entry line of text is searched including the assembly name inside the (…).


Extension Manager

To view your installed extensions use the Visual Studio 2010 menu, Tools, Extension Manager…


From here you can either disable or uninstall extensions.


You can also configure settings for extensions using the Tools, Options dialog.



Visual Studio 2013


XAML IntelliSense Presenter on the Visual Studio Gallery


Enjoy this XAML Editor extension.

Have a great day,

Just a grain of sand on the worlds beaches.

Tucking ViewModels Beneath Views in Solution Explorer in Visual Studio 2013

October 30, 2013


Back when I was using Visual Studio 2010 a few weeks ago I had a cool macro that would allow me to select a view and viewmodel file in the Solution Explorer, run the macro and then the viewmodel would be nested nicely under the view as pictured above.

Well… Beginning with Visual Studio 2012 (which I skipped over), Visual Studio no longer support macros.  Kind of a bummer since many developers wrote macros and depended on them for automating tasks, etc.

The good news is, writing a Visual Studio 2013 VSPackage is not really that difficult and the DTE macro code can pretty much be copied and pasted and with a little editing you’re up and running again. With the VSPackage you also get the benefit of not watching that spinning and dancing macro icon that would occasionally appear in the Windows Taskbar which caused your macro to freeze for awhile.


I like to tuck my viewmodels beneath the view.  To me, it makes for nice organization and condenses the number of top level files I have to view in the Solution Explorer.

Most of my viewmodels have a one-to-one relationship with its view.  For those that don’t, I don’t tuck them beneath.

I also like to name my views and viewmodels according to the above pattern. For me, it keeps things clean and consistent.

Introducing Visual Studio 2013 Extension View Model Tuck Away

The below image was captured from the “Extensions and Updates…” dialog after I installed the VSPackage.



The digitally signed package available on the Visual Studio Gallery operates like this:

  • Developer selects a view and viewmodel file in the solution explorer
  • Developer runs the ViewModel Tuck Away command

The VSPackage will verify that:

  • Two files have been selected in the Solution Explorer
  • That one file has a .xaml file extension and contains the word “view”
  • That one file has a .cs file extension and contains the word “viewmodel”

The VSPackage will then tuck the selected viewmodel beneath the selected view.

During the execution of the VSPackage command, the Visual Studio Status Bar text will be updated to reflect the success or failure of the command.

I wrote the VSPackage this way to enforce naming standards at my work and home projects.

I know that some (many) may not like this.  No problem, the source is on GitHub (see Source below) and you can very easily modify it, rebuild the solution and double click on your new VSIX file.

Surfacing the VSPackage Command in Visual Studio 2013

You can surface the VSPackage Command in three ways:

  • Tools Menu, ViewModel Tuck Away
  • Add command to a Toolbar
  • Provide shortcut key for command (not really practical since you used the mouse to select the two files, may as well click a Toolbar icon or text.)

By default the command is added to the Tools Menu as seen below:


To add the command to a Toolbar follow the numbers below. #2 below allows you to select the Toolbar you want the command to appear on.  #7 allows you to position the command on the selected Toolbar.


I added my command to the Standard Toolbar and moved it to the right side as pictured below.  For me, that little icon will do.


However you may want to see the commands text as pictured below. To do this, use the above “Modify Selection” ComboBox just below #7 above and select “Image and Text”.


What is a VSPackage and How Did You Do This?

You can read all about Visual Studio 2013 VSPackages here. According to this MSDN article:

“VSPackages are software modules that extend the Visual Studio integrated development environment (IDE) by providing UI elements, services, projects, editors, and designers.”

To author your own VSPackage you’ll need to download and install the VS 2013 SDK from here, look towards the bottom of the page in the “Additional Software” section for Visual Studio SDK. The documentation for the SDK is here.

After installing the SDK you’ll get some new templates (very good I might add). To fire up a new VSPackage follow the numbers.


I strongly suggest studying the default VSPackage that the template creates.  I adds a Tools menu command that displays a message box.  Simple, but there is a lot of plumbing code it creates for you that you pretty much don’t have to fool with. The VSPackage only has a few files of “plumbing” making it easy to understand how it all fit together.

The below code is the core functionality required to identity two selected items, figure out which is the view and viewmodel and then set the dependency.

Of interest is how much power VSPackages have access to. For example the line of code: var dte = (DTE)GetService(typeof(DTE)); provides access to the DTE.  Most macro programmers are already familiar with the power and features exposed by the DTE. Once your command is invoked, you fire up the DTE and code away.  Not a bad upgrade path from macros or Visual Studio Add-Ins which are depreciated in VS 2013.

In a similar fashion this line of code: var uiShell = (IVsUIShell)GetService(typeof(SVsUIShell)); provides the developer access to the IVsUIShell capabilities.

As I mentioned above, you can use your own custom logic for determining which selected file is the parent and which will be the new child of the parent.  There are many techniques for determining this, like I said I chose to enforce naming standards for my views and viewmodels.

Boolean IsView(String targetFileName) {
    var extension = Path.GetExtension(targetFileName);
    return !String.IsNullOrWhiteSpace(extension) && extension == ".xaml" && 
            targetFileName.IndexOf("view") > -1;

Boolean IsViewModel(String targetFileName) {
    var extension = Path.GetExtension(targetFileName);
    return !String.IsNullOrWhiteSpace(extension) && extension == ".cs" && 
            targetFileName.IndexOf("viewmodel") > -1;

/// <summary>
/// This function is the callback used to execute a command when the a menu item is clicked.
/// See the Initialize method to see how the menu item is associated to this function using
/// the OleMenuCommandService service and the MenuCommand class.
/// </summary>
void MenuItemCallback(Object sender, EventArgs e) {
    try {
        //get access to the familar DTE object.
        var dte = (DTE)GetService(typeof(DTE));

        if (dte.SelectedItems.Count == 2) {
            String fileNameOne = dte.SelectedItems.Item(1).ProjectItem.FileNames[1].ToLower();
            String fileNameTwo = dte.SelectedItems.Item(2).ProjectItem.FileNames[1].ToLower();
            ProjectItem viewProjectItem;
            ProjectItem viewModelProjectItem;

            //need to figure out which select items are the view and viewmodel
            if (IsView(fileNameOne) && IsViewModel(fileNameTwo)) {
                viewProjectItem = dte.SelectedItems.Item(1).ProjectItem;
                viewModelProjectItem = dte.SelectedItems.Item(2).ProjectItem;
            } else if (IsView(fileNameTwo) && IsViewModel(fileNameOne)) {
                viewProjectItem = dte.SelectedItems.Item(2).ProjectItem;
                viewModelProjectItem = dte.SelectedItems.Item(1).ProjectItem;
            } else {
                dte.StatusBar.Text = "Must select a view.xaml file and a viewmodel.cs " +
                                     "file in the solution explorer.";

            //line of code that creates the dependency between files.

            //show the tucked into viewmodel
            dte.StatusBar.Text = "Your viewmodel is now dependent on its view.";
        } else {
            dte.StatusBar.Text = "Must select a view.xaml file and a viewmodel.cs file in " +
                                 "the solution explorer.";
    } catch (Exception ex) {
        var uiShell = (IVsUIShell)GetService(typeof(SVsUIShell));
        var clsId = Guid.Empty;
        Int32 result;
        var message = String.Format("Exception occurred in VmTuckAway: {0}", ex);
            ref clsId,
            "VmTuckAway Exception",
            0, // false
            out result));

VSIX Manifest Files and VSPackage Assets

If you want to make your own VSPackages you’ll also want to understand the, “source.extension.vsixmanifest” file and how to properly edit it.

You need to read the VSIX Extension Schema 2.0 Reference found here. Very easy read with good examples.

One tip I remembered the hard way was the file property “Include in VSIX” which must be True for VSPackage assets you include in the “source.extension.vsixmanifest.”

These Large and Small icons provide a nice UI for your VSPackage in the “Extensions and updates…” dialog.


GitHub Source

The source code can be downloaded from GitHub here:


Download Signed VSPackage Extension on Visual Studio Gallery



Hopes this helps someone and have a great day,

Just a grain of sand on the worlds beaches.

Prism Application Core Scenario Broken In Visual Studio 2013 XAML Designer

October 29, 2013

Since the beginning of October 2013 I’ve been doing a lot of spiking using Visual Studio 2013 and have discovered this is a great product and also has some differences between Visual Studio 2010.

Anyone following this blog knows that I love WPF and patterns & practices Prism Library. Not only the library but the documentation (guidance) for creating composite applications.

As I was converting VS 2010 solutions at work to VS 2013 I started running into problems with my Prism applications and the module views not loading in the XAML Designer and the XAML Editor displaying errors that were not in VS 2010.

I have reported my findings to the XAML Tools Team.

I have a logged a connect bug here:  https://connect.microsoft.com/VisualStudio/feedback/details/806969/prism-application-core-scenario-broken-in-visual-studio-2013-xaml-designer

After a few days I found a workaround for the problem and will share it at the bottom of this post.

Working Prism Core Scenario Visual Studio 2010

See Source Control section below.  The WorkingCoreScenario.zip file should be unzipped and opened using Visual Studio 2010 w/SP1.

A core design practice of composite applications is to break the application into discrete modules (assemblies).  The main application executable will discover the modules at runtime and load them.  The main executable does not have any references to its modules. This very loose coupling of the application and its modules is a core design principle of Prism and composite applications. See Modular Application Development chapter.

The below image shows the pieces of the scenario. Notice that the WorkingCoreScenario assembly does not have a reference to the NotReferencedFormsLibrary. This forms library represents a Prism module that would have all the views and viewmodels for a module.


The above App.xaml file contents are shown below.  (NOTE:  I’ve had to break the Source line below because the text is too long to fit.)

Below I’m merging a resource dictionary from the Control Library. This allows the main executable and all modules to reference resources in that compiled assembly.  I typically put images and common resources in a compiled assembly so that the XAML Designer parser does not have to keep parsing the resource dictionary each time it loads a XAML file.

                            ControlLibraryResourceDictionary.xaml" />
            <SolidColorBrush x:Key="redBrush" Color="Red" />
            <SolidColorBrush x:Key="yellowBrush" Color="Yellow" />

If you open NotReferencedFormsLibrary UserControl1.xaml in the XAML Designer you’ll see:


If you open NotReferencedFormsLibrary UserControl1.xaml in the XAML Editor you’ll see:


Broken Prism Core Scenario Visual Studio 2013

See Source Control section below.  The BrokenCoreScenario.zip file should be unzipped and opened using Visual Studio 2013 RTM.

If you open NotReferencedFormsLibrary UserControl1.xaml in the XAML Designer you’ll see that neither of the resources App.xaml are available in the XAML Designer.


If you open NotReferencedFormsLibrary UserControl1.xaml in the XAML Editor you’ll see that none of the resources in App.xaml are available.


Discussion and Workaround for Visual Studio 2013

The differences between VS 2010 and VS 2013 have broken a core Prism application scenario. I really like the Prism guidance for creating modules that are not referenced by any other assembly. This very loose coupling promotes well structured and designed applications that are not brittle and will stand the test of time and change.

For now, the only workaround I’ve got to work is to have the main assembly reference each of the modules.  Adding the reference then allows the modules to have access to resources in App.xaml including merged resources.

Source Code

The two above scenarios are in separate zip files on my Oceanware GitHub account.


The above repro contains:

  • The BrokenCoreScenario.zip file should be unzipped and opened using Visual Studio 2013 RTM.
  • The WorkingCoreScenario.zip file should be unzipped and opened using Visual Studio 2010 w/SP1.

To create the BrokenCoreScenario solution I simply copied the WorkCoreScenario solution to a machine with VS 2013 and opened it.  No other changes were made.

NOTE:  Prism is not required to open these demo solutions.


Hopes this helps someone and have a great day,

Just a grain of sand on the worlds beaches.

Moving WPF Applications From Visual Studio 2010 to 2013 – Some Gotchas and Solutions

October 24, 2013

I have spent the better part of two weeks trying to move my WPF Prism application from Visual Studio 2010 to Visual Studio 2013. As of 10 minutes ago, the application has been moved and is super shape.

Problems That Had To Be Solved

1.  The new XAML Designer would not load any resources or merged dictionary resources in App.xaml resulting in errors for all StaticResources in my views.

2.  FXCop settings from VS 2010 causes CA00053 warnings in the Code Analysis Window.  I’ve already blogged about this and possible options here:  Visual Studio 2013 Fixing CA0053 : Unable to load rule assembly

3.  I also wrote about the inability to remove source control binding in VS 2013 in the above blog post.

4.  I keep getting errors when building that my application .exe is locked. I have written that up in this blog post: System Process is Locking .exe Files that Visual Studio Builds.  Microsoft has logged a bug for this.

Moving VS 2010 Solution to new VS 2013 Folder

All of my Visual Studio 2010 applications have always had zero designer load issues.  All resources loaded and were rendered in the designer as expected. Not the case in VS 2013, let’s see what we can do about this.

I copied my VS 2010 application to a VS 2013 folder structure.

I then opened the copied solution in VS 2010 and broke it from source control.  (gets around problem $3 above)

I also uncheck the settings that invoked FxCop in all the projects.  (gets around #2 above)

I also ran the tool I created in step #2 above to clean all my .csproj files, removing the toxic legacy FxCop settings from them.

I followed the steps in #4 above to limit file locked build errors.

Built solution, all is well.

Close VS 2010.

Open solution in VS 2013.

Visit each project and target .NET 4.51.

Visit each reference in each project to ensure that the references were pointing to .NET 4.5 or 4.51 assemblies.  Many references had to be manually removed and re-added.  Some moved by themselves.

For Prism and Unity, I built my own private build of Prism 4.0 that targeted Unity 3.0 and the new Common Service Locator included in Unity 3.0. My Prism version is now Prism 4.51 that targets .NET 4.51.

Built my solution, no errors, time to open a XAML file in one of my Prism Modules.

When I open any XAML file located in a Prism Module, none of the App.xaml resources were available. (It took me almost two weeks of building spikes, debugging, troubleshooting, etc. to find the answer.)

Background: Many Prism developers do not have their Shell (main .exe) reference many assemblies, including any Prism Modules (UserControl libraries with views and viewmodels). The Prism application is composed at run-time and the modules are loaded into the application domain as part of bootstrapping the application. This type of application development is fully supported in VS 2010 at both run-time and design-time.

Getting the Visual Studio 2013 XAML Designer to Load

The above Prism development model is not supported by the VS 2013 XAML Designer.  I think it has to do with the new way the dependent resources are shadow copied and made available to the designer. Yes, the team is now aware of this scenario.

For now, what I had to do was to set a reference to all my modules from my Shell (main .exe) and set Copy Local = true.

After doing this for all your modules you must close VS 2013 and reopen your solution because that critical change is not always picked up by the XDesProx.exe side process that the XAML Designer runs in.  However, after reopening your solution, you can open any module and your App.xaml resources are available and show up in the designer.

Problem worked around.  In a future update to Visual Studio 2013, I hope that I’ll be able to remove hard references to my modules and the App.xaml resources will be made available in the designer.

Copy Local = false is Your Friend

The below image pictures the references my Contacts module requires.  The Boyd assemblies are either local to solution or are file reference to our framework.  The others you recognize.

Notice that every assembly has Copy Local = false.  Check out the \bin\Debug folder for Contacts after a build.  Only two files.

This is HUGE savings in time on builds.  Now VS does not have to copy all those files to every \bin\Debug folder for every project in the solution.

NOTE: In order to pull this off, your main .exe must reference the Boyd…, Microsoft… and System.Windows.Interactivity and set Copy Local = true so that these assemblies will be resolvable at run-time and design-time.



Hopes this helps someone and have a great day,

Just a grain of sand on the worlds beaches.

System Process is Locking .exe Files that Visual Studio Builds

October 23, 2013

This has been happening for a while not and I decided to get to the bottom of this very annoying problem.


I build a solution in Visual Studio, then I rebuild that same solution and get the very familiar error message:

Error 1 Unable to copy file “obj\x86\Debug\MainApplication.exe” to “..\bin\MainApplication.exe”. Access to the path ‘..\bin\MainApplication.exe’ is denied. MainApplication

Root Cause

After many, many of these dumb messages I wanted to see what process would be so aggressive as to want to lock my newly compiled file.

So I fired up Process Explorer (procexp.exe).

First thing you must do is Show Details for All Processes. This action is on the File menu.

The use the Find menu, select Find Handle or DLL…. 

In the Process Explorer Search, enter the full name (no path) of the .exe reported in your above Visual Studio build error message. 

Why Is This Happening

So my questions is, why is the System process PID:4, locking my .exe file?

Currently I have to wait several minutes until the file is no longer locked.  I have noticed that if I have an instance of Windows Explorer open in the build output folder that files get locked more often.

Hint:  Don’t kill System PID:4, your computer will lock up. 



I started thinking about what could be doing this:  Virus, Search Indexer?  Bingo!

I searched for how to throttle the search indexer.  Turns out someone already figure this out.


One last step may be required.  After performing the above steps, you may need to reboot your computer. 

(Windows team, please provide a setting on the Indexer UI to set throttling, needing a registry entry is not a good solution to this problem.)

So far, this has solved my problem by enabling Indexer Backoff as explained in the above tutorial.


Hopes this helps someone and have a great day,

Just a grain of sand on the worlds beaches.

After Installing Visual Studio 2013 RTM – Some Visual Studio 2013 RC Turds Remain

October 22, 2013

I had been working with Visual Studio 2013 RC and when the RTM version came out I did an in-place upgrade and had zero issues.

Today, I notice that the Windows Explorer, “Open with” feature pictured below was still indicating the RC versions for Blend and Visual Studio.


So I started hunting around the registry and found MANY Visual Studio 2013 RC registry entry turds are still in my registry.  Time to pave the box for sure.

But for now, I did locate the offending turd.  Notice that I’ve edited the two registry entries and removed RC from the end of them.


Registry Key is:  Computer\HKEY_CLASSES_ROOT\Local Settings\Software\Microsoft\Windows\Shell\MujiCache

Now where I use the, “Open with” feature I get the correct versions of the products listed.



Maybe in the future Visual Studio 2013 Update they can fix these entries and remove all of the RC turds from the registry.

Have a great day,

Just a grain of sand on the worlds beaches.

Microsoft Windows 8.1 – Corporate Policies and Common Sense

October 19, 2013

Dear Microsoft Corporate Executives,

Yesterday I was working an idea with Brian Lagunas to start a new developer user group at Boise State University. The positives for group members and local business looking for bright talent can’t be understated; not to mention all the other benefits of getting plugged into a local developer user group.

As I was thinking about the first meeting topic, unfortunately Windows 8.1 sideloading bubbled straight to the top of this list.

Please see the blog post links at the bottom of this post on sideloading by Regional Director and MVP Rockford Lhotka. Microsoft Executives, if you have not read these, please do so.

Goggle’s stock just crept past $1,000 yesterday (10-/18/2013). Microsoft stock has hovered in the low to mid $30’s for many years.

In light of this you have to ask, why is this? Seems to me that if the company I worked for has to fight an uphill battle to regain Wall Street’s and market investor’s confidence that I would implement policies that don’t hinder or shipwreck the impressive work of my company employees.

The policy to prevent users, developers, and businesses from freely loading Windows Runtime software onto their own Windows 8.1 machines that does not come from the Windows Store, has to be in the all-time Top 10 List of “Poor Self-Destructive Corporate Decisions.”

Under the current policy, I can’t write a Modern Application for Windows 8.1 and give it to my family members or friends. Mr. & Mrs. Executive, if you can’t see the huge negative side-effect of this let me help you.  You are hurting the company you’re working for and have no understanding of Microsoft culture (inside and outside the company).  Time for you to join a developer user group, start attending code camps and get enlightened.

Under the current policy, I can’t write a Modern Application for my new Surface 2 Pro and use it except for testing. No need to write more verbiage, if you don’t understand this, you should probably turn in your blue badge.

Under the current policy, non-volume license small-medium businesses can’t write Modern Applications and deploy them to their own company Windows 8.1 systems without spending $3,000 for 100 license keys and jumping through a bunch of other hoops.  If my business has 10 users, why would I spend $3,000 to just load my internal applications? If this is the long-term prognosis for Windows 8.1+ my company will be on Windows 7 forever or migrate to another operating system.

Mr. & Mrs. Executive you are killing the adoption of Windows 8.1 in the business world, not be mention again that your stock is stagnant. People have been complaining about this policy for years now. What are you waiting for? Don’t you want to regain consumer and business confidence in the direction and policies of your flagship Windows 8.1 operating system?

Common Sense

Yes, I’m making a reference to the world changing pamphlet written by Thomas Paine in 1775-1776 that inspired people to rise up against Great Britain.

Microsoft Corporate common sense is long overdue. Continue on this path, and Microsoft will see Apple or Google computers continue taking over households and possibly business desktops. Google executives have to be drooling over policies like this.

You see, this senseless policy actually pushes businesses towards writing their internal applications using HTML5 and JavaScript. Now, all business users can access the application from any device, including an Apple or Google devices.  Really, who needs Office? There are other productivity options and operating systems for desktops.

BTW:  My entire family switched over to Apple years ago for their home computers.  Why, because Apple delivered a first-rate home eco system that never has any issues. (iMac, iPad, iPhone, MacBooks, Apple TV, iTunes, and no sideloading non-sense on non-IOS devices.  Yes, I own all of them. Why, because they just work and if you have a question you get first-rate phone support or can go to the local Apple Store.)

Continue policies like this, making it difficult for home users, business users, and developers and you’ll see continued decline from which there will be little chance of long-term recovery. Monitus es.  (it’s Latin).

When I worked in the retail industry we had a saying, that it only takes one stupid action by a store employee to drive the customer to another retailer.  People don’t want to deal with non-sense and headaches.  If this is your story your long-time customers will go to other places, even if you have great products like Surface 2 Pro.

What are Apple’s Policies?

Mac Application Distribution:  Apple Store, and non-Apple Store Deployment at no extra costs or hoops.

iOS Distribution:  Apple Store, Business B2B, and Ad Hoc distribution to 100 iOS devices using email or a server at no extra costs or hoops.

Apple lets developers develop for themselves, family, friends, their business, etc. while at the same time protecting users from harmful software. For example the Mac OS has the Gatekeeper feature which is turned on by default, great for home users.

What About You Karl?

I know that corporate policy takes time and legal review (lawyers move at glacier speed) before it can be changed.

So for now, I’m giving this one more go (pray for me) before I jump off the Titanic and join the Apple developer world and learn Objective-C (sigh).

Microsoft, I want to light my hair on fire, supercharge my passion for development, and release it. I want to feel that electrifying passion running through my veins like it once did.

I’ve ordered my Surface 2 Pro and will be attending VSLive in Orlando in November 2013. I really want to program against the Modern Windows 8.1 Runtime. I love the Microsoft community and cherished working at Microsoft. My recent trip to Redmond to see my former team was a real joy.

(The main reason I left Microsoft two years ago was because I couldn’t get behind many of the new policies at that time and the shunning of WPF.  Passion that I was hired for died; time to go.)

I think Microsoft Windows Servers and server products rock. I say that without equivocation. Since SQL Server version 7, it has been the only database I’ve used.  Why? Its fantastic, its fast, it works, and I’ve never lost a single byte of data.

If only these Modern Windows 8.1 policies didn’t block and stifle me as a creative and boundary pushing developer. A developer that likes to write blog posts about Microsoft technologies and ways to use them.

You see I come from the VAX/VMS, Alpha/VMS world.  VMS had only one set of API’s that all programming languages targeted. Super for developers and DEC as well.

I really believe in the concept of the Windows Runtime; a single API that all languages can target.

This is a grand-slam for the Microsoft Windows platform. The reason that this achievement is getting drowned out for business users is all the noise and frustration around sideloading and the tablet UI of Modern Windows.  (I’ll save that for another post, because there are workarounds for the usability problems for business desktop users.)

I would gladly migrate my .NET applications and do green field development against Modern Windows Runtime if I could deploy my applications.  (deploy from webserver, network share, USB, or local drive)  But, under the current policy I can’t. Neither can the majority of business users and developers around the world.


This is not a personal attack against any single person at Microsoft, especially Mr. Steve Ballmer. I have no knowledge (first hand, second hand, third hand, deep background, etc.) of who or how these above policies were implemented or why they remain in-force.

This is a very strong opinion (universally shared by most of the private and corporate developer community) that points out the self-destructiveness of these policies.

Microsoft, the ball is in your court.  You have legions of developers, MVP’s, and RD’s that would gladly provide constructive feedback and alternatives to enable these scenarios and also meet Microsoft business and security requirements.

Have a great day.  I appreciate feedback or corrections to this post.

Just a grain of sand on the worlds beaches.


Rockford Lhotka’s Thoughts on Sideloading





Get every new post delivered to your Inbox.

Join 253 other followers