You’ve probably heard about Microsoft’s Visual Studio Code editor. It was announced at the 2014 online Connect event. It is a free, light-weight, cross-platform code editor supporting Windows, Linux and MacOS.
I’ve been a big fan and user of the built-in PowerShell ISE for years. It is still the best “debugger” out there. However the ISE editor limitations, lack of customization, lack of source control integration and general atrophy (ISE hasn’t been significantly updated since it shipped with V2) was really starting to get to me.
As a user of Visual Studio, I really appreciate its extensibility support and more importantly the active ecosystem built around that extensibility. I use VS extensions, often referred to as VSIXs, to improve the editor’s capabilities. I use the Microsoft Productivity Power Tools, Web Essentials and C# Essentials. A number of these tools, like the Productivity Power Tools, add editor enhancements that would work in any language. If only PowerShell ISE had this sort of an extension ecosystem.
Unfortunately, the reality is that a editor such as ISE, dedicated to a “single” language, is very unlikely to ever gain such momentum as VS has with its extensions. And it doesn’t help that the ISE extension API is sorely lacking. You do however see such extensibility and momentum around light-weight code editors such as Sublime and Atom.
So I was really excited by the prospect of Visual Studio Code when it was announced. I figured VSCode had the following advantages over PowerShell ISE:
- VSCode is being actively developed and enhanced.
- It is already a more powerful text editor with features like multicursor support.
- Version control support via Git is built-in.
- You can use it on Linux. Yeah, I’m still hoping we will see PowerShell running on Linux at some point.
The downside to VSCode’s PowerShell support at that time were poor syntax highlighting and Intellisense but more importantly no debug suppport and no REPL. I tried to help improve the syntax highlighting by sending some regex changes to the VSCode team. That helped a little but unknownst to me at the time, the whole VSCode PowerShell support landscape was about to change.
At the 2015 online Connect event, Microsoft made two huge announcements about VSCode. First, Microsoft open sourced VSCode on GitHub. Second, Microsoft finally announced a supported extensibility API for VSCode. As a PowerShell MVP, I was made aware of an effort to build a PowerShell Editor Services extension for VSCode. I immediately signed up to help as the extension would be made open source on GitHub as well.
This extension addresses many issues with PowerShell support in VSCode. First, it adopts a syntax colorization grammar format called TextMate that other light-weight editors use. Second, it provides a mechanism to hook into the editor to provide all sorts of features such as Intellisense, Symbol searching & highlighting, alias expansion, etc. Third, there is a debugging API to provide debug support for a language.
David Wilson and others on the PowerShell team did a ton of work to get the very capable PowerShellEditorServices extension off the ground. Since then, some MVPs including myself, Doug Finke and Adam Driscoll have been submitting PRs to improve the extension.
I have submitted a number of PRs in the last couple of months. The first was to support Symbol search in PowerShell e.g. type Ctrl+P, then “@:” to see all the symbols in your open script files. Note that as you move the selection amongst the different symbols in the list, the associated script is highlighted in the editor e.g.:
The rest of my PRs have been to enhance the debugger’s Variables display to provide more and better representations of PowerShell and .NET types. For instance, PSCustomObjects now display their properties in the Variables window. Collections display their contents and .NET objects wrapped in a PSObject are unwrapped to show the underlying object’s properties. Here is what the Variables window looks like now when debugging a PowerShell script in VSCode:
The Variables window for this extension shows four top level containers. The Script and Global containers are fairly obvious in terms of what they contain. The Local container contains the local variables for the currently selected stack frame i.e. the selected line in the “Call Stack” section.
The Auto container attempts to show you the variables you are likely to be interested in for any particular stack frame. The idea is shamelessly borrowed from Visual Studio’s excellent debugger. The heuristics for determining what gets displayed in the Auto window will likely change as we get more experience using this debugger. If you have suggestions, please leave them at https://github.com/PowerShell/PowerShellEditorServices/issues.
As you explore the variables in any of the four containers, you will note that collections show not only their type but the number of elements in the collection. For example, see the variable $Process in the image above under the Auto container. It displays as $Process: [Process] and when you open that node you see each element displayed (only one in this case).
Also note that the debugger in VSCode has sections (windows) to show breakpoints and variables you are “watching”. There is even a “REPL” window that is active while debugging.
I’m very excited by how much richer this extension makes both the PowerShell editing and debug experience in VSCode. I’m currently in “dog-fooding” mode with VSCode as my primary editor for PowerShell. I’m sure we will find many things that need to be improved as we use the extension and VSCode together. But the really cool thing is that since the extension is open source, we don’t have to wait for someone on the PowerShell team to fix a bug or implement a new feature. We can do that ourselves!
I expect big uptake for PowerShellEditorServices extension for VSCode in 2016. Heck, the extension was made public on the VSCode Marketplace only a little over a month ago and it’s already approaching 9000 downloads. That’s pretty impressive!
I’ll sign off with one last tip. If you are a Pluralsight subscriber, you should check out John Papa’s course on Visual Studio Code. It is excellent! If you are not a subscriber, you can sign up for a free trial and get 10 free days (or up to 200 minutes) to start watching this course. BTW there are also some pretty awesome PowerShell courses on Pluralsight from notable PowerShell luminaires such as Don Jones, Jeff Hicks, Jim Christopher, Adam Bertram, Thomas Lee and many others.