But as all neat little editors in its infancy go, it is a little premature.  For example there is no out of the box CoffeeScript support.  Since I have been hacking some CoffeeScript, I needed to correct this.  So with some googling and the fact that Sublime Text supports TextMate bundles, I discovered how to start CoffeeScript development with Sublime Text.  The following are my findings.

Syntax Highlighting

We will make use of Jeremy Ashkenas CoffeeScript TextMate Bundle to add syntax highlighting support.

• Create ~/Library/Application Support/Sublime Text 2/Packages/CoffeeScript/
• Copy CoffeeScript.tmLanguage and CoffeeScript.tmPreferences to ~/Library/Application Support/Sublime Text 2/Packages/CoffeeScript/

Build System

To setup the Sublime Text Build System to work with CoffeeScript you just need to create a file (CoffeeScript.sublime-build) with the following contents and place in ~/Library/Application Support/Sublime Text 2/Packages/User/

{
    "cmd": ["coffee", "$file"],
    "selector" : "source.coffee",
    "path" : "/usr/local/bin"
}

Note that I have CoffeeScript installed in /usr/local/bin on my Mac.  Edit the above path appropriately to match your system.

Script

Obviously the above is aching to be automated so I hacked up a quick bash script and associated sublime build file.  They can be found here in my git sandbox repo.

Credit

Credit where credit is due.  Much of the info from this post was garnered from the following sources:

http://soenkerohde.com/2011/11/coffeescript-with-sublime-text/
http://www.sublimetext.com/forum/viewtopic.php?f=4&t=2022

To take some shavings off of the top top of the iceberg that is why I use Powershell, I’d like to share a recent experience of Powershell delivering for me.

Setup for Failure

As a co-orgranizer for the New York .NET Meetup I was tasked with getting the list of attendees off of meetup.com and over to the lovely people at Microsoft who kindly give us space to meet. Now, you might think there’d be some nifty “export attendee list to CSV” function the meetup.com website, but like a lot of software, it doesn’t do half the things you think it should and this is one of those things. Usually my colleague David assembles the list, but this particular month he was out on vacation. He did, however, point me over to a GitHub repository of a tool that would do the extraction.

Following his advice, I grabbed the repository and brought up the C#/WinForms solution in Visual Studio. Looking at the project structure, I was a bit stunned at the scale of it all. The author had divided his concerns very well into UI, data access, the core infrastructure, and, of course, unit testing. I thought that was pretty peculiar considering all I wanted to do was get a CSV of names and such off of a website. Far be it for me to criticize another developer’s fastidiousness. Maybe it also launched space shuttles; you never know.

In what I can only now describe as naivety, I hit F5 and expected something to happen.

I was rewarded with 76 errors.

Right off the bat, I realized that the author had botched a commit and forgot a bunch of libraries. I was able to find NHibernate fairly easily with Nuget, but had no luck with “Rhino.Commons.NHibernate”. I tried to remove the dependency problem, but didn’t have much luck. And the whole time I was wondering why the hell you needed all these libraries to extract a damn CSV from the internet.

The Problem

Rather than throw more time after the problem, I decided to forge out on my own. Really, how hard could it be to

1. Get an XML doc from the internet
2. Extract the useful data
3. Perform some heuristics on the names
4. Dump a CSV file

Being a long-time C# programmer, my knee-jerk reaction was to build a solution in that technology. Forgoing a GUI to spend as little time as possible in building this, I’d probably build a single file design that ostensibly could consist of a single method. And if that were the case, why not script it?

So if I was going to write a script, what to use? I could write a JavaScript and run it on node.js, but it’s lacking proper CSV utilities and I’d have to run it on something other than my main Windows box. Not to mention I don’t particularly writing in JavaScript, so I’d probably write it in CoffeeScript and have to compile it, etc, etc.

I briefly considered writing an F# script, but I suspect only about ten people would know what on earth it was, and, at the end of the day, I would like to share my script to others.

The Solution

In the end, I concluded what I had known already: Powershell was the tool to use. It had excellent support for dealing with XML (via accelerators) and, as a real scripting language, had no pomp and circumstance.

Here’s the script I ended up writing:

function Get-MeetupRsvps([string]$eventId, [string]$apiKey) {$nameWord = "[\w-']{2,}" $regex = "^(?'first'$nameWord) ((\w\.?|($nameWord )+) )?(?'last'$nameWord)|(?'last'$nameWord), ?(?'first'$nameWord)( \w\.|( $nameWord)+)?$" function Get-AttendeeInfo {process {$matches = $null $answer = $_.answers.answers_item if(-not ($_.name -match $regex)) { $answer -match $regex | Out-Null }return New-Object PSObject -Property @{ 'FirstName' = $matches.first 'LastName' = $matches.last 'RSVPName' = $_.name 'RSVPAnswer' = $answer 'RSVPGuests' = $_.guests }} }$xml = [Xml](New-Object Net.WebClient).DownloadString("https://api.meetup.com/rsvps.xml?event_id=$eventId`&key=$apiKey") $xml.SelectNodes('/results/items/item[response="yes"]') `| Get-AttendeeInfo `| select FirstName, LastName, RSVPName, RSVPAnswer, RSVPGuests }

To dump this to a CSV file is then really easy:

Get-MeetupRsvps -EventId 1234 -ApiKey 'MyApiKey' | Export-Csv -Path rsvps.csv -NoTypeInformation

And because of this design, it’s really extensible. Potentially, instead of exporting to a CSV, you could pipe the information into another processor that would remove anyone named “Thorsten.” Actually, that would look like this:

Get-MeetupRsvps -EventId 1234 -ApiKey 'MyApiKey' `| ? { %_.FirstName -ne 'Thorsten' } ` | Export-Csv -Path rsvps.csv -NoTypeInformation

It’d be pretty difficult to do that if I’d written a C# executable – you’d have to go into Excel to do that. Or write a Powershell script. Just saying.

Here’s the real kicker: I spent all of five minutes writing my Powershell script and then spent minutes tweaking my regex to identify as many names as possible. I didn’t need to recompile, just F5 again in Poweshell ISE, which you have installed already if you’re on Windows 7. Since I left the Export-Csv part off during debugging, I could just read the console output and see what I got.

When I was happy with my output, it was dead simple to distribute: throw it in a GitHub Gist and move on with my life. If you decide to use it, all you need is Powershell installed (again, are you on Windows 7?) and the ability to copy and paste. No libraries. No worries. If you don’t like my regex, it couldn’t be easier to figure out how to replace it. If you want more fields, it’s easy to see where they should be added.

It’s really just that easy.

In this post I’ll use ShowUI and port Sean’s example. The challenge, ShowUI is a PowerShell Module that needs to be xCopy deployed to the users machine so I can create these WPF GUI applications.

ShowUI

ShowUI is a PowerShell module to help build WPF user interfaces in script. ShowUI makes the complicated world of WPF easy to use in PowerShell.

Sean steps through creating a simple GUI for capturing a user’s first and last name so it can be used with PowerGUI’s Get-QADUser cmdlet. First up, is a simple form with an ‘UNLOCK Account’ button.

Button "Unlock Account" -Show -Margin 10 -On_Loaded {
    $Window.Title = "Our Help Desk"
}

Now, Capture the User Information

I’ll wrap the ShowUI code in a function Get-UserInfo. I like this practice because it makes the GUI widget reusable. In an upcoming post I’ll drill down on how to create custom controls. For now I will reproduce Sean’s user info screen.

I use a WPF Grid which lets me lay out controls in Rows and Columns. I use 3 rows, one row for the labels, one for the text boxes and the last for the button. Every control in ShowUI supports a Row and Column parameter, so they can all be laid out this way.

I write fewer lines of code using a WPF grid container. For example, when I resize the window all the controls resize automatically. Give it a try.

Next up, I show the magic to returning the data entered on the form as PowerShell Hashtable.

function Get-UserInfo {
    Grid -Rows 3 -Columns 2 -Show -On_Loaded {
        $Window.Title = "Our Help Desk"
    } {            

        Label "First Name" -Row 0 -Column 0 -FontWeight Bold
        Label "Last Name" -Row 0 -Column 1 -FontWeight Bold              

        TextBox -Row 1 -Column 0 -Margin 5 -Name FirstName
        TextBox -Row 1 -Column 1 -Margin 5 -Name LastName            

        Button "Unlock Account" -On_Click {
            $Window | Set-UIValue -passThru | Close-Control
        } -IsDefault -Margin 5 -Row 2 -Column 0 -ColumnSpan 2
    }
}            

Get-UserInfo            

# Returns and Prints the hashtable
@"
Name      Value
----      -----
FirstName Mister
LastName  Trouble
"@            

Pressing the button returns a Hash Table

Here is I how I set this up to work. I named the TextBox controls FirstName and LastName. Then in the Button –On_Click event, I pipe the $Window automatic variable to the ShowUI Set-UIValue cmdlet. Set-UIValue takes the content of the TextBox and copies it to the Tag properties. Then, when the form is closed, via Close-Control, the Tag properties are scanned and the name and tag of that control are added to the  hash table as a key value pair.

Variable Splatting

Hashtables (aka associative arrays) are great data structures. Plus, in PowerShell you can use them to do variable splatting.

This is a term taken from the Ruby scripting language and affects how argument variables are passed to commands. – Bruce Payette Windows PowerShell In Action 2nd Edition

To do this is, when referencing the variable that you want to pass to the command, you use @ instead of $ as the prefix to the variable.

Conclusion

So, I can squirrel away my Get-UserInfo function and reuse it. Then, calling the Get-QADUser cmdlet becomes even simpler.

$userInfo = Get-UserInfo
Get-QADUser @userInfo

This approach has another benefit. I can add another TextBox to my GUI, name it the same name as a parameter on Get-QADUser and it will seamlessly work.

These are some of the high order abstractions I and my fellow ShowUI authors, James Brundage and Joel Bennett, are building into ShowUI.

Give it a try and drop us line on CodePlex or our blogs if you have questions or suggestions.

Highlights

I ported his code to ShowUI and focused on the elements he did:

• Control resizing (Using the Grid)
• Adding controls to a Window
• Attaching events (On_Click parameter for the button)
• Changing control fonts (FontFamily parameter for the text box)

Using WinForms and PowerShell are a great approach to building GUIs. One advantage WinForms has over ShowUI is it is available on any machine you deliver your PowerShell script to.

ShowUI leverages WPF and while it requires investment and a module, the value per line of code is compelling.

PowerShell Code

Import-Module ShowUI            

$windowAttributes = @{
    Title = "ShowUI Form"
    WindowStartupLocation = "CenterScreen"
    SizeToContent = "WidthAndHeight"
}            

New-Window @windowAttributes -Show {            

    Grid -Columns 75*, 75 -Rows 40, 10* {
        TextBox -Name UserId -Row 0 -Column 0 -Margin 5 -Text finked            

        Button _Go -Row 0 -Column 1 -Margin 5 -On_Click {            

            foreach( $record in (net user $UserId.Text) ) {
                $result.appendText("$record `r`n")
            }
        }            

        TextBox -Name Result `
            -Row 1 -Column 0 -ColumnSpan 2 `
            -Margin 5 -IsReadOnly `
            -FontFamily "Courier New"
    }
}

Related

• My  MSDN article: Secrets to Building a WPF Application in Windows PowerShell
• Post: PowerShell, ShowUI and the Twitter API and video tutorial

• More videos on the ShowUI CodePlex page

Wednesday July 20th I’ll be joining fellow ShowUI authors James Brundage and Joel “Jaykul” Bennett on the PowerScripting Podcast.

ShowUI is a PowerShell module to help build WPF user interfaces in script. ShowUI makes the complicated world of WPF easy to use in PowerShell. You can use ShowUI to write simple WPF gadgets, quick front ends for your scripts, components, and full applications.

Related

• My  MSDN article: Secrets to Building a WPF Application in Windows PowerShell

• Post: PowerShell, ShowUI and the Twitter API and video tutorial

• More videos on the ShowUI CodePlex page

PowerShell

Here is an example of a web server written in Node which responds with "Hello World" for every request.

This is a single PowerShell script that saves the JavaScript to a file, launches node and then uses the .NET framework Net.WebClient to make a request.

$ip = "127.0.0.1"
$port = 337
$url = "http://{0}:{1}/" -f $ip, $port            

@"
var http = require('http');
http.createServer(function (req, res) {
	res.writeHead(200, {'Content-Type': 'text/plain'});
	res.end('Hello World\n');
}).listen($port, "$ip");

console.log('Server running at ${url}');
"@ | Set-Content -Encoding ascii c:\example.js            

Start-Process powershell -ArgumentList "C:\node\node.exe c:\example.js"            

sleep 1
(New-Object net.webclient).DownloadString($url)

Result

This question comes from a developer who is using NLog to log messages from his app involving Reactive Framework code.

Get-Content –Wait C:\Test.txt

Get-Content is a PowerShell cmdlet (aliased to type (for DOS people) and cat (for Unix people)). It gets the content of the item at the location specified by the path, such as the text in a file. It reads the content one line at a time and returns a collection of objects, each of which represents a line of content.

The –Wait parameter waits for content to be appended to the file. If content is appended, it returns the appended content.

Out-GridView

You can pipe the results of PowerShell to a grid view window where the output is displayed in an interactive table. Out-GridView is available out of the box.

Features of Out-GridView

• Hide, Show, and Reorder Columns
• Sort
• Quick Filter
• Criteria Filter
• Copy and paste

How To

Get-Content –Wait c:\test.txt | Out-GridView. As the data is updated from the background task (see code below), another line is added to the table. You can even do a quick filter and as the lines are appended to the file, Out-GridView adds them applies the filter to the new information.

Try It Out

del C:\test.txt            

Start-Job -ScriptBlock {
    "Time,Message" | Add-Content c:\test.txt
    while($true) {
        "Testa", "Testb","Testc","Testd" | Get-Random | % {
            "{0},{1}" -f (Get-Date).ToString(), $_
        } | Add-Content c:\test.txt
        Start-Sleep -Milliseconds 1500
    }
}            

sleep 2
Get-Content c:\test.txt -wait |  ConvertFrom-Csv | Out-GridView

Get-Process -Name *Tomcat* -ComputerName somebox.around.here

It may be useful to capture the arguments first, then invoke the command later:

$myArgs = @{ Name = "*Tomcat*"; ComputerName = "somebox.around.here" }
Get-Process @myArgs

It can also be incredibly useful if you’re writing wrapper functions:

Function Import-ModuleForce {
    param(
        [Parameter(Mandatory = $true)]
        [string[]]
        $Name
    )
 
    $PSBoundParameters.Force = $true
    Import-Module @PSBoundParameters
}
 
# unfortunately, aliases can't be set up to script blocks;
# only functions and cmdlets get that honor
Set-Alias imf Import-ModuleForce

It can also be useful when you’re passing in the same arguments to multiple functions consecutively:

$myArgs = @{
    Name = "*Tomcat*"
    ComputerName = "somebox.around.here"
}
 
Get-Service @myArgs
Get-Process @myArgs

But sometimes splatting doesn’t work, notably when you have extra values in the hashtable that the function isn’t expecting:

$myArgs = @{
    Name = "*Tomcat*"
    ComputerName = "somebox.around.here"
    DependentServices = $true
}
 
Get-Service @myArgs
Get-Process @myArgs

A nasty little error is PowerShell’s response:

Get-Process : A parameter cannot be found that matches parameter name 'DependentServices'.
+ Get-Process <<<<  @myArgs
    + CategoryInfo          : InvalidArgument: (:) [Get-Process], ParameterBindingException
    + FullyQualifiedErrorId : NamedParameterNotFound,Microsoft.PowerShell.Commands.GetProcessCommand

The Get-Service cmdlet has a DependentServices argument, but Get-Process does not. Although this can sometimes be a helpful error message, in this case, it would be nice if the command just ignored the arguments it couldn’t understand.

So that’s why I wrote Invoke-Splat:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

Function Invoke-Splat {
    <#
    .Synopsis
        Splats a hashtable on a function in a safer way than the built-in
        mechanism.
    .Example
        Invoke-Splat Get-XYZ $PSBoundParameters
    #>
    param(
        [Parameter(ValueFromPipeline=$true, Mandatory=$true, Position=0)]
        [string]
        $FunctionName,
        [Parameter(ValueFromPipeline=$true, Mandatory=$true, Position=1)]
        [System.Collections.Hashtable]
        $Parameters
    )
 
    $h = @{}
    ForEach ($key in (gcm $FunctionName).Parameters.Keys) {
        if ($Parameters.$key) {
            $h.$key = $Parameters.$key
        }
    }
    if ($h.Count -eq 0) {
        $FunctionName | Invoke-Expression
    }
    else {
        "$FunctionName @h" | Invoke-Expression
    }
}

Rewriting the example from above:

$myArgs = @{
    Name = "*Tomcat*"
    ComputerName = "somebox.around.here"
    DependentServices = $true
}
 
Invoke-Splat Get-Service $myArgs
Invoke-Splat Get-Process $myArgs

And mixing Invoke-Splat with the @ operator:

Function Import-ModuleForce {
    param(
        [Parameter(Mandatory = $true)]
        [string[]]
        $Name,
 
        [string]
        $SomethingElse
    )
 
    $PSBoundParameters.Force = $true
    Invoke-Splat Import-Module $PSBoundParameters
}
 
$myArgs = @{
    Name = "MyModule"
    SomethingElse = "AnotherString"
}
 
Import-ModuleForce @myArgs

I posted PowerShell Clock with ShowUI. Ravi, another PowerShell MVP, tried the sample using the AsJob parameter. The AsJob will run the PowerShell WPF GUI in the background. Unfortunately, the FontSize and other parameters would not set correctly and the clocked was not readable.

After emailing James Brundage, a fellow ShowUI author , he blogged Six Steps for Writing ShowUI Controls and a video tutorial based on this clock example.

Definitely check it out, he kicks it up a notch with data context’s, PowerShell DataSources. splatting, adding event handlers and more.

Here is my updated clock code

Run it with either –Show or –AsJob

HippyDippy-Clock -Show
HippyDippy-Clock -AsJob

function HippyDippy-Clock {
    param (
        [string]$Name,
        [Int]$Row,
        [Int]$Column,
        [Int]$RowSpan,
        [Int]$ColumnSpan,
        [Int]$Width,
        [Int]$Height,
        [Double]$Top,
        [Double]$Left,
        [Windows.Controls.Dock]$Dock,
        [Switch]$Show,
        [Switch]$AsJob
    )            

    begin {ipmo showui}
    process {
        if (-not $psBoundParameters.Background) {
            $psBoundParameters.Background = 'Transparent'
        }                        

        $uiParameters = @{} + $psBoundParameters            

        Border @uiParameters -On_Loaded {
            $this.Child = Grid -Columns 150, 300* {
                Image -Source "http://weaselzippers.us/wp-content/uploads/2011/05/hippie.jpg" -Column 0
                Label -Name Target -FontSize 90 -Column 1 `
                    -FontFamily "Impact, Arial" -FontWeight 800 -Foreground (
                    LinearGradientBrush $(
                        GradientStop -Color Red    -Offset 1
                        GradientStop -Color Orange -Offset 0.85
                        GradientStop -Color Yellow -Offset 0.7
                        GradientStop -Color Green  -Offset 0.55
                        GradientStop -Color Blue   -Offset 0.4
                        GradientStop -Color Indigo -Offset 0.2
                        GradientStop -Color Violet -Offset 0
                    )
                )
            }            

            $this.DataContext = Get-PowerShellDataSource -On_OutputChanged {
                $output = Get-PowerShellOutput -Last -OutputOnly
                $Target.Content = $output
            } -Script {
                while ($true) {
                    (Get-Date).ToString('T'); Start-Sleep -Seconds 1
    }
            }                

        } -On_Initialized {
            $window.SizeToContent         = 'WidthAndHeight'
            $window.WindowStyle           = 'None'
            $window.Background            = 'Transparent'
            $window.AllowsTransparency    = $true
            $window.WindowStartupLocation = 'CenterScreen'            

            Add-EventHandler -EventName "On_Closing" -Handler {
                if ($this.Content.DataContext.Command.Stop) {
                        $this.Content.DataContext.Command.Stop()
                    }
                } -Object $window                                    

                # When the right mouse button is down, close the control            
                Add-EventHandler -EventName "On_PreviewMouseRightButtonDown" -Handler {
                    $_.Handled = $true
                    Close-Control
                } -Object $window            

                Add-EventHandler -EventName "On_PreviewMouseLeftButtonDown" -Handler {
                    $_.Handled = $true
                    $this.DragMove()
                } -Object $window
        }
    }
}

More updates coming soon.

Updates

This version lets you view multiple Twitter search feeds. Type in a search and press enter and another column is displayed. You can delete a column too.

PowerShell Code

Download it HERE from my repository. Download ShowUI.

Import-Module showui            

function Search-Twitter {
    param (
        [Parameter(ValueFromPipeline=$true)]
        $query
    )            

    Begin { $wc = New-Object Net.Webclient }            

    Process {
        $url = "http://search.twitter.com/search.rss?q=$query"
        ([xml]$wc.downloadstring($url)).rss.channel.item |
            Select *
    }
}            

function New-TwitterFeed ($search) {            

    $guid = "g" + [guid]::NewGuid() -replace "-",""            

    $buttonAttributes = @{
        Margin = 5
        HorizontalAlignment = "Right"
        Height = 25
        Tag = $guid
    }            

    $labelAttributes = @{
        FontSize = 20
        Margin = 5
        Foreground = "White"
    }            

    Grid -Name $guid -Rows 45, 100* -Tag $search {
        Grid -Row 0 -Columns 2 {
            Label -Column 0 $Search @labelAttributes
            Button " X " -Column 1 @buttonAttributes -On_Click {
                $name = "`$$($this.tag)"
                $targetLayout.Children.Remove(($name|iex))
            }
        }            

        ListBox -Background Black -Row 1 -Margin 5 -DataContext {
            Search-Twitter $search
        } -DataBinding @{
            ItemsSource="."
        } -ItemTemplate {
            $tweetTbAttributes = @{
                FontSize = 12
                Margin = 5
                TextWrapping = "wrap"
                Foreground = "White"
            }            

            Grid -Columns 55, 300 {
                Image     -Name Image  -Column 0 -Margin 6
                TextBlock -Name Title @tweetTbAttributes -Column 1
            } | ConvertTo-DataTemplate -binding @{
                "Image.Source" = "image_link"
                "Title.Text" = "title"
            }
        }
    }
}            

function ql {$args}            

$windowAttributes = @{
    WindowStartupLocation = "CenterScreen"
    Width = 1200
    Height = 600
    Background = "Black"
    Title = "PowerShell, ShowUI and the Twitter API"
}            

$scrollViewerAttributes = @{
    VerticalScrollBarVisibility = "Disabled"
    HorizontalScrollBarVisibility = "Auto"
}            

$textBboxAttributes = @{
    Margin = 5
    Background = "DarkGray "
    Foreground = "#FFFFFF"
    FontSize = 14
}            

New-Window @windowAttributes -Show -On_Loaded {
    $search.focus()
    ql PowerShell ShowUI dfinke jamesbru  jaykul |
        ForEach {
            $targetLayout.Children.Add( (New-TwitterFeed $_ $tabcontrol) )
        }
} {
    Grid -Columns 35*, 75 -Rows 35, 100* {            

        TextBox -Name Search -Row 0 -Column 0 @textBboxAttributes            

        Button -IsDefault -Row 0 -Column 1 -Margin 5 "_Search" -On_Click {
            $targetLayout.Children.Add( (New-TwitterFeed $Search.Text) )
            $Search.Text = ""
        }            

        ScrollViewer -Row 1 -Column 0 -ColumnSpan 2 @scrollViewerAttributes {
            UniformGrid -Name targetLayout -Rows 1
        }
    }
}

• A windowless window
• Ticking digital clock
• Moving the window by clicking and dragging even though it doesn’t have a border

The ShowUI Code

Here is the ShowUI code. Note the On_* keys in the hash table. They handle the mouse button events and the windows load event where I register a PowerShell script block that executes every half a second. This updates the time and enables the ticking digital clock.

Richard’s solution has the advantage that he can deploy it and it should work on any windows system that has the latest .NET runtime.

My solution requires the ShowUI module to be installed on the target machine.

The advantages to my solution, IMHO, are no XAML, increased value per line of code and it’s all PowerShell.

Check out both solutions and ShowUI.

Import-Module ShowUI            

$windowAttributes = @{
    WindowStartupLocation = "CenterScreen"
    SizeToContent = "WidthAndHeight"
    WindowStyle = "None"
    Background = "Transparent "            

    On_MouseRightButtonDown = { Close-Control}
    On_MouseLeftButtonDown  = { $_.Handled = $true;$window.DragMove() }
    On_Loaded = {
        Register-PowerShellCommand -ScriptBlock {
            $window.Content.Content = (Get-Date).ToString("T")
        } -Run -In "0:0:0.5"
    }
}            

$labelAttributes = @{
    Content = (Get-Date).ToString("T")
    FontFamily = "Impact, Arial"
    FontWeight = 800
    FontSize = 90
}            

New-Window @windowAttributes -AllowsTransparency -Show  {
    Label @labelAttributes -Name Clock -Foreground (
        LinearGradientBrush $(
            GradientStop -Color Red    -Offset 1
            GradientStop -Color Orange -Offset 0.85
            GradientStop -Color Yellow -Offset 0.7
            GradientStop -Color Green  -Offset 0.55
            GradientStop -Color Blue   -Offset 0.4
            GradientStop -Color Indigo -Offset 0.2
            GradientStop -Color Violet -Offset 0
        )
    )
}

Related Topics

• My “Hello World” video tutorial of ShowUI
• PowerShell, ShowUI and the Twitter API
• Other ShowUI video tutorials from James Brundage, one of the authors of ShowUI

Secrets to Building a WPF Application in Windows PowerShell

Special bonus

Windows PowerShell creator Jeffrey Snover weighs in on the Ad Hoc development model and origin of the language.

Related Topics

• ShowUI: Write-UI –in PowerShell – A PowerShell module to help build WPF user interfaces in script
• My “Hello World” video tutorial of ShowUI
• PowerShell, ShowUI and the Twitter API
• Other ShowUI video tutorials from James Brundage, one of the authors of ShowUI

Thank You

I want to thank Jeffrey Snover, Distinguished Engineer, Lead Architect for Windows Server and father of PowerShell. He eagerly and graciously agreed to write the sidebar for the article and offered great feedback.

Also, thank you to James Brundage, founder and lead developer of Start-Automating, creator of the PowerShell Pack and WPK. He provided excellent insight on my drafts. Hat tip to Joel Bennet, author of PowerBoots.

Finally, thank you to my colleagues who took the time to read and offer suggestions.

ShowUI: Write-UI –in PowerShell

While the article was going through technical and copy editing, the authors of WPK and PowerBoots merged the two frameworks, WPK + PowerBoots => PowerShell ShowUI.

Video Tutorials

I put together a “Hello World” demo of ShowUI. Plus this post PowerShell, ShowUI and the Twitter API.

Definitely check out these other ShowUI video tutorials.

Updated PowerShell Script for the Article

Here is the ShowUI version of the PowerShell script I did in the MSDN article.

The Result

I built this WPF application using PowerShell and ShowUI. I used a single Url to get the data back from the Twitter API, sliced and diced the XML in PowerShell, used WPF Databinding, Templates, a Grid and ListBox (and a little more) to get this visual.

The Video

The Code

Import-Module ShowUI            

function Search-Twitter ($q = "PowerShell") {
    $wc = New-Object Net.Webclient
    $url = "http://search.twitter.com/search.rss?q=$q"
    ([xml]$wc.downloadstring($url)).rss.channel.item | select *
}            

$ws = @{
    WindowStartupLocation = "CenterScreen"
    SizeToContent = "Width"
    Height = 550
    Title = "PowerShell, ShowUI and the Twitter API"
}            

New-Window @ws -Show {
    ListBox -Background Black -ItemTemplate {
        Grid -Columns 55, 300 {
            Image -Name Image -Margin 5 -Column 0
            TextBlock -Name Title -Margin 5 `
            -Column 1 -TextWrapping Wrap -Foreground White
        } |
            ConvertTo-DataTemplate -binding @{
                "Image.Source" = "image_link"
                "Title.Text" = "title"
            }
    } -DataContext {Search-Twitter PowerShell} `
      -DataBinding @{ItemsSource="."}
}

My demo covers

• Cmdlets
• Piping
• Working with XML
• Compiling C# on the fly in a script
• Using the object just created in the same PowerShell
• Configuring the Debug tab in VS 2010 for launching ISE (Integrated Script Environment)
• Setting a break point in that C# file, run a script and step through both the C# and PowerShell
• I conclude with ShowUI, a PowerShell module to help build WPF user interfaces in script. ShowUI makes the complicated world of WPF easy to use in PowerShell

The talk ran over by more then 30 minutes with questions and scenarios. I done this talk several times and this time round the questions were deeper and broader than usual.

Two new questions I got, “How can you embed PowerShell in C#?”, “Can I use PowerShell in a web page like JavaScript?”

It was a great time.

More ShowUI Resources

• Download it HERE
• PowerShell ShowUI Video Tutorial–Hello World
• More Videos
• ShowUI: the tutorial walkthrough

Basic Building Blocks

In the video I demo the basic building blocks you’ll reuse over and over. New-Window, New-StackPanel, New-Label, New-Button and more.

Take a look and let me know what questions you’d liked answered. I’ll include them in the next set of video tutorials.

The Cisco Unified Computing System is the  next-generation data center platform accelerates the delivery of new services simply, reliably, and securely through end-to-end provisioning and migration support.

UCS PowerShell Toolkit (PowerTool) and .NET SDK for UCSM

UCS PowerShell PowerTool helps customers integrate, automate, and orchestrate all aspects of UCS management including network, storage and hypervisor management with their existing IT management processes.   Microsoft PowerShell is fast becoming a defacto standard for automating and integrating many functions of systems management within the datacenter.

ShowUI is a PowerShell module to help build WPF user interfaces in script. ShowUI makes the complicated world of WPF easy to use in PowerShell. You can use ShowUI to write simple WPF gadgets, quick front ends for your scripts, components, and full applications.

History

Back in 2008 I blogged about Ruby Shoes and the start of a PowerShell version. Shoes is a GUI framework for Ruby. I figured why not a WinForms GUI framework for PowerShell.

Here is the Ruby Shoes example in ShowUI today:

Joel ‘Jaykul’ Bennett figured the same, but using WPF,  leaving a comment on my post about working on something he called PowerBoots.

Meanwhile James Brundage, founder of Start-Automating and former member of the Microsoft PowerShell Team, was working on WPK, that was released as the part of the PowerShell Pack.

I was lucky enough to get an early look at both of these excellent frameworks. These two powerhouse PowerShell guys decided to merge them, taking the best of both and kicking it up a notch. Once again, I am lucky enough to be involved, hear the discussions and contribute to the project.

CodePlex Projects

Here are two other WPF/PowerBoots projects I have. I’ll be doing more blogs and updating these projects to ShowUI soon.

• Try PowerShell
• OData PowerShell Explorer

If you care at all about how data is accessed–and you should–understanding the basics of OData is probably worth your time.

Dave Chappell’s post, Introducing OData, does a great job walking through what OData is. Covering REST, Atom/AtomPub, JSON, OData filter query syntax, mobile devices, the Cloud and more.

Our world is awash in data. Vast amounts exist today, and more is created every year. Yet data has value only if it can be used, and it can be used only if it can be accessed by applications and the people who use them.
Allowing this kind of broad access to data is the goal of the Open Data Protocol, commonly called just OData. This paper provides an introduction to OData, describing what it is and how it can be applied.

OData PowerShell Explorer

I open sourced an OData PowerShell Explorer complete with a WPF GUI using WPK. The PowerShell module allows you to discover and drill down through OData services using either the command line or the GUI interface.

Other Resources

• OData Primer
• RunAs Radio podcast on the OData PowerShell Explorer
• Open Data Protocol
• Download TechEd Sessions Automatically by Using PowerShell

Marco points out in his Hey, Scripting Guy! post PowerShell 2.o does not support OData out of the box. He used my PowerShell OData implementation HERE on CodePlex to automate the downloading of sessions in a flexible way.

Thanks for the great write up Marco and demonstrating how PowerShell can save you time by automating key tasks.

Other Resources

• OData Primer
• OData PowerShell

This is Jon Bentley’s opening line to his chapter “A Spelling Checker” in his book “Programming Pearls”.

The PowerShell Invoke-SpellCheck script loads a custom dictionary and only checks the spelling of strings in a PowerShell script.

This PowerShell script is an extension of my port of Peter Norvig’s “How to Write a Spelling Corrector”, he is Director of Research at Google. He wrote the post to examine statistical language problems, like spelling correction, used in search engines at Google, Yahoo and Microsoft.

Download the PowerShell script  HERE.

Script Highlights

• The script parses a PowerShell file using the built-in PowerShell Tokenizer. It finds strings in the script, such as Write-Host “The quick brown fox” or $result = “Jumps over the lazy dog” and spell checks them
• You can spell check a single file
  • Invoke-SpellCheck .\spell.ps1

   

  Misspelled Corrections              StartLine StartColumn FullName
  ---------- -----------              --------- ----------- --------
  thex       {the, them, then, they}          1          10 .\spell.ps1
  plansx     {plans}                          1          10 .\spell.ps1
  fox        {box, fix, fog, for}             2          12 .\spell.ps1
  muse       {use, ruse, must, amuse}         3          12 .\spell.ps1

• You can spell check an entire directory of scripts
  • dir . –Recurse *.ps1 | Invoke-SpellCheck
• This script loads/parses/indexes over 100K words, then parses the two PowerShell scripts, extracts the strings, parses them, looks up each word and proposes corrections to words not found, in under a half second
• You can add words to the dictionary using Notepad
• You can pass in your own dictionary of words
• If you want to learn more about implementing a probabilistic, statistical spelling correction algorithm, visit Mr. Norvig’s post and site. Plus his latest post “On Chomsky and the Two Cultures of Statistical Learning” is an interesting read

Invoke-SpellCheck

function Invoke-SpellCheck {
    <#
        .Synopsis
            Invoke-SpellCheck reads a single or multiple
            PowerShell script files, extracts the strings in it,
            then checks each word against a dictionary
        .Description
            A Detailed Description of what the command does
        .Example
            Invoke-SpellCheck .\spell.ps1

        .Example
            dir *.ps1 | Invoke-SpellCheck
    #>
    param (
        [Parameter(ValueFromPipelineByPropertyName=$true)]
        [string]$FullName = "C:\spell.ps1",
        [string]$Dictionary="$pwd\holmes.txt"
    )            

 Begin {
        $nwords = train ([IO.File]::ReadAllText($dictionary))
 }            

 Process {
  ForEach($token in (Get-StringTokens $FullName)) {
   ForEach ($word in [regex]::split($token.Content.ToLower(), ‘\W+’) ) {
    if(!$nwords.ContainsKey($word)) {            

                    $theSet = (deletion) +
                              (transposition) +
                              (alteration) +
                              (insertion)            

                    $corrections = @()
                    foreach($item in $theSet) {
                        if($nwords.ContainsKey($item)) {
                            $corrections += $item
                        }
                    }            

                    New-Object PSObject -Property @{
                        Misspelled  = $word
                        StartLine   = $token.StartLine
                        StartColumn = $token.StartColumn
                        Corrections = $corrections
                        FullName    = $FullName
                    } | Select Misspelled, `
                        Corrections, `
                        StartLine, `
                        StartColumn, `
                        FullName
                }
            }
        }
    }
}

Download

HERE is the link to the PowerShell cookbook that has been shipped.

I had the opportunity to dive into the Chef cookbooks/recipes and it’s programmatic process. It is written in Ruby which made it an excellent system to study for porting parts to PowerShell. Chef leverages Ruby in interesting ways and makes it well engineered and very flexible. This played well into PowerShell’s strengths.

It would be great if they continue with deeper PowerShell support, for example authoring cookbooks in pure PowerShell.

It will be interesting to see if Puppet Labs responds with PowerShell capabilities. I know about a year and half ago they were tweeting about it.

Chef

Infrastructure Automation for the Masses

Chef is an open source systems integration framework built to bring the benefits of configuration management to your entire infrastructure. You write source code to describe how you want each part of your infrastructure to be built, then apply those descriptions to your servers.

Jesse Robbins is co-founder and CEO of Opscode. Prior to co-founding Opscode, he worked at Amazon.com with a title of “Master of Disaster” where he was responsible for website availability for every property bearing the Amazon brand.

I talk about the four PowerShell cmdlets that handle formatting and when you don’t want to use them. I show how to use the cmdlet New-Module to solve the problem.

Check it out. Handle Formatted Output in PowerShell.

OData and PowerShell go well together, check out my OData PowerShell Explorer.

Using the .NET framework, I can download a string from an OData service using Net.WebClient. OData returns XML, this is a sweet spot for PowerShell. Using the [xml] accelerator and dot notation over the XML nodes ($result.feed.entry) makes quick work of the OData output.

Interacting with OData feeds can be automated with PowerShell

Here I am getting the change set comments for my PSCodeGen CodePlex project.

Get-CodeplexChangeSets 'TFS01' "PSCodeGen"

Get-CodePlexChangeSets creates the correct Url, queries the CodePlex OData service and returns the results as PowerShell objects ready for use and display.

Results

I grab the Date and Comment from the ChangeSet result set, there are other fields to be mined. Be sure to check out the other details returned by CodePlex including the Builds, Changes, Builds, Branches, Work Items, Attachments, Projects, Queries and Area Paths.

From here I can easily generate release notes or filter on dates using PowerShell or analyze a range of scenarios with this data.

# Results
TFSCollectionName Date                  ProjectName Comment
----------------- ----                  ----------- -------
TFS01             8/3/2010 3:44:57 PM   PSCodeGen   Checked in by server upgrade
TFS01             6/12/2010 12:13:50 PM PSCodeGen   Cleaned up comments
TFS01             6/12/2010 12:02:26 PM PSCodeGen   Install-PSCodeGenerator.ps1 handles install/uninstall of vs 2010 templates
TFS01             6/12/2010 9:59:40 AM  PSCodeGen   Moved the templates around
TFS01             6/12/2010 9:58:10 AM  PSCodeGen   Moved the directory
TFS01             6/12/2010 9:47:28 AM  PSCodeGen   Renamed Register-PSCodeGenerator.ps1 Install-PSCodeGenerator.ps1
TFS01             6/12/2010 9:40:27 AM  PSCodeGen   Removed VB registration. Need to look into why it is correctly in the registry but does not work with VB...
TFS01             6/11/2010 2:08:49 PM  PSCodeGen
TFS01             6/8/2010 9:28:26 PM   PSCodeGen
TFS01             6/8/2010 9:28:13 PM   PSCodeGen
TFS01             6/8/2010 9:27:22 PM   PSCodeGen   Initial import
TFS01             6/8/2010 8:08:20 PM   PSCodeGen   Created team project folder $/PSCodeGen via the Team Project Creation Wizard

Query Multiple CodePlex Projects in One Go

Here I setup a script to report on all my existing CodePlex projects.

$(
    New-CodeplexProject 'TFS01' "PSCodeGen"
    New-CodeplexProject 'TFS02' "psodata"
    New-CodeplexProject 'TFS03' "PowerShellJSON"
    New-CodeplexProject 'TFS05' "PoSHDebugVisualizer"
    New-CodeplexProject 'TFS07' "pslog"
    New-CodeplexProject 'TFS08' "trypowershell"
    New-CodeplexProject 'TFS09' "psisecream"
    New-CodeplexProject 'TFS07' "PowerTools"
) | Get-CodeplexChangeSets            

# Results
TFSCollectionName Date                   ProjectName         Comment
----------------- ----                   -----------         -------
TFS01             6/12/2010 12:13:50 PM  PSCodeGen           Cleaned up comments
TFS01             6/12/2010 12:02:26 PM  PSCodeGen           Install-PSCodeGenerator.ps1 handles install/uninstall of vs 2010 templates
TFS02             8/15/2010 9:29:13 PM   psodata             Creates functions on the fly for OData Entity Types
TFS02             8/15/2010 8:31:07 PM   psodata             Start spike testing reading OData metadata
TFS02             8/15/2010 8:27:42 PM   psodata             Added Chris Sells' OData service
TFS03             4/9/2011 9:32:09 PM    PowerShellJSON      Fixed - ConvertFrom doesn't handle email addresses in the data workitem:20473 -- DCF
TFS03             7/26/2009 11:06:54 AM  PowerShellJSON      Quick test of ConvertFrom-JSON
TFS05             12/7/2007 8:24:53 PM   PoSHDebugVisualizer added to example program
TFS05             12/4/2007 7:51:56 PM   PoSHDebugVisualizer change build location
TFS07             4/20/2009 10:13:14 AM  PowerTools          Minor updates to project.
TFS07             4/20/2009 2:15:25 AM   PowerTools          Added code to avoid image duplication. Improved Keep Sections behavior. Check for no items when...
TFS07             5/30/2010 7:39:34 PM   pslog               Added logfileName and loggerName as parameters
TFS07             5/29/2010 3:27:00 PM   pslog               Added console coloring NLog example and support
TFS08             5/1/2010 4:30:38 PM    trypowershell       Added vertical and horizontal GridSplitter, and hyperlinks are represented through hyperlinks.
TFS08             4/26/2010 5:19:16 AM   trypowershell       KeyGesture W+Control for close added
TFS09             4/4/2010 8:54:05 AM    psisecream          This modules ISERemote requires elevated rights. Does't look nice, but the addon menu will only...
TFS09             4/3/2010 10:18:03 AM   psisecream          This is a compact module to play with PowerShell remoting.                                        

PowerShell Code

These 4 PowerShell functions make it happen.

# https://codeplexodata.cloudapp.net/            

function Get-CodePlexODataUri { "https://codeplexodata.cloudapp.net/" }            

function New-CodeplexProject {
    param (
        [Parameter(Mandatory=$true)]
        $TFSCollectionName,
        [Parameter(Mandatory=$true)]
        $ProjectName
    )            

    New-Object PSObject -Property @{
        TFSCollectionName = $TFSCollectionName
        ProjectName       = $ProjectName
    }
}            

function Invoke-WebClient ($url) {
    if(!$global:Credential) {
        $global:Credential = Get-Credential snd\'<your codeplex id here>'
    }            

    $wc = New-Object net.webclient
    $wc.Credentials = $global:Credential             

    $wc.DownloadString($url)
}            

function Get-CodeplexChangeSets  {
    param (
        [Parameter(Mandatory=$true, ValueFromPipelineByPropertyName=$true)]
        $TFSCollectionName,
        [Parameter(Mandatory=$true, ValueFromPipelineByPropertyName=$true)]
        $ProjectName,
        [Switch]$Raw
    )            

    Process {
        $url    = Get-CodePlexODataUri
        $url   += "$TFSCollectionName/Projects('$ProjectName')/Changesets"
        $result = Invoke-WebClient $url            

        if($Raw) { return $result}            

        ([xml]$result).feed.entry |
            ForEach {
                New-Object PSObject -Property @{
                    TFSCollectionName = $TFSCollectionName
                    ProjectName       = $ProjectName
                    Comment           = $_.summary.'#text'
                }
            }
    }
}

In the past I’ve seen Pash, an open source implementation of PowerShell for the Max, Linux etc. That project has been quite for a long time.

This is interesting news. I am looking forward to see who runs with this.

At any rate, it will be fun to geek out on the spec and documentation of the language.

Thanks to colleague Eugene Prystupa for the heads up.

Here are the initial ones that I find interesting:

• Building Data-centric N-tier Applications with jQuery
• Data in an HTML5 World
• Deep Dive Into HTML5 <canvas>
• JavaScript: The Language
• Reactive Extensions for JavaScript (RxJS)
• Script#: Compiling C# to JavaScript using Visual Studio
• Good JavaScript Habits for C# Developers

Plus

• Luke Hoban delivers the JavaScript: The Language, formerly of the F# team.
• Nikhil Kothari, of Microsoft, has been steadily delivering on Script#, a way to compile C# to JavaScript
• Let’s see if Data in an HTML5 World covers OData and data.js (checkout OData Primer). Here are my OData PowerShell resources.

The Select-StringCurrentFile (aliased: sscf) lets me search the entire Visual Studio active document for strings (see Example Usage), returning the line and the line number it is found on. Using the Goto-InCurrentWindow function (aliased: gicw), passing the line number; it jumps to that line in that document.

The Console

The NuGet console, is a PowerShell console which is hooked up to the Visual Studio environment through the DTE. It is accessed via the PowerShell variable $dte.

From the $dte variable, I use properties such as, ActiveDocument, ExcecuteCommand and Windows. There are other properties and methods on the $dte object, I reviewed them in the NuGet console with this:

$dte | Get-Member

The PowerShell Functions

The Select-StringCurrentFile function gets the active document’s full name and passes it to PowerShell’s built in cmdlet Select-String (aka grep, like in Unix). This returns the matches it finds. I extract and emit the Line and LinNumber in a new object. Note, the $pattern can be any valid regular expression.

The Goto-InCurrentWindow function takes a line number as a parameter, Activates the current window and then uses ExecuteCommand. I pass two parameters to ExecuteCommand. “Edit.Goto” and the line number. Edit.Goto is a built in Visual Studio command. I discovered the other Visual Studio commands with this:

$dte.Commands | ForEach {$_.Name}

In the Example Usage I use the aliases I created for the function, sscf and gicw. This lets me type fewer characters than the full function names.

function Goto-InCurrentWindow ($lineNumber) {
    $dte.Windows.Item($dte.ActiveDocument.Name).Activate()
    $dte.ExecuteCommand("Edit.GoTo", $lineNumber)
}            

function Select-StringCurrentFile {
    param($pattern)            

    Select-String $pattern $dte.ActiveDocument.FullName |
        ForEach {
            $line = $_.line.Trim()            

            New-Object PSObject -Property @{
                Line = $line
                LineNumber = $_.LineNumber
            }
        }
}            

Set-Alias gicw Goto-InCurrentWindow
Set-Alias sscf Select-StringCurrentFile

Example Usage

Matt takes a hash table (associative array) and creates a .Net object (PSObject) with properties and values by passing it to the Property parameter on the New-Object.

$peeps = @{
  'Lead'='asmith';
  'Enterprise'='bjones';
  'Edge'='chumperdink';
  'Backend'='dwilford';
  'SED'='fhanns'
}            

$obj = New-Object -Type PSObject -Property $peeps

Turn A PowerShell Object Into a Hash Table

I pipe the newly created object to Get-Member filtering out only the properties using the MemberType parameter (see Results of the Get-Member). I then use the Begin/Process/End block of the ForEach.

In the Begin Block I create the $hash and in the End Block I “return” the $hash. Which in this case prints it out.

In Process Block, I grab the $_.Name from the Get-Member results. In the 3rd line, on the left hand side of the equals I create the hash key using dot notation and then set the value on the right hand side using the same $_.Name and dot notation but using the $obj which contains the value.

$obj | Get-Member -MemberType Properties |
    ForEach {$hash=@{}} {
        $hash.($_.Name) = $obj.($_.Name)
    } {$hash}            

# Results
Name                           Value
----                           -----
Backend                        dwilford
SED                            fhanns
Edge                           chumperdink
Lead                           asmith
Enterprise                     bjones

Results of the Get-Member

$obj | Get-Member -MemberType Properties            

# Results of Get-Member

  TypeName: System.Management.Automation.PSCustomObject

Name       MemberType   Definition
----       ----------   ----------
Backend    NoteProperty System.String Backend=dwilford
Edge       NoteProperty System.String Edge=chumperdink
Enterprise NoteProperty System.String Enterprise=bjones
Lead       NoteProperty System.String Lead=asmith
SED        NoteProperty System.String SED=fhanns

This can also be done a line at a time in the PowerShell command line REPL (Read Eval Print Loop). Meaning, you can create different arrays and multidimensional arrays at the command line and then type and call the Excel functions.

Plus, these are only 4 of the many Excel functions available.

If you want to find out the other Excel math functions available, type this line at the command line (run the first three lines of code up to the WorksheetFunction first):

$wf | Get-Member -MemberType method | Out-GridView

# Calling Excel Math Functions From PowerShell            

$xl        = New-Object -ComObject Excel.Application
$xlprocess = Get-Process excel            

$wf   = $xl.WorksheetFunction
$data = 1,2,3,4
$m    = ((1,2,3),(4,5,6),(7,8,9))            

Write-Host -ForegroundColor green Median
$wf.Median($data)            

Write-Host -ForegroundColor green StDev
$wf.StDev($data)            

Write-Host -ForegroundColor green Var
$wf.Var($data)            

Write-Host -ForegroundColor green MInverse
$wf.MInverse($m)            

$xl.quit()
$xlprocess | kill

# Results
Median
2.5
StDev
1.29099444873581
Var
1.66666666666667
MInverse
-4.5035996273705E+15
9.00719925474099E+15
-4.5035996273705E+15
9.007199254741E+15
-1.8014398509482E+16
9.00719925474099E+15
-4.5035996273705E+15
9.00719925474099E+15
-4.5035996273705E+15

Grab the Code

I put the code up on my GitHub PowerShell Repository.

Two significant industry dynamics have taken shape since [Silverlight was introduced] that cause us to emphasize the role of Silverlight differently as a key tool in the developer toolbox.

MIX 11 kicks off next Tuesday, April 12 and the Silverlight Team posted this announcement on Standards-based web, plug-ins, and Silverlight.

Here are some interesting snippets:

• [Microsoft] has shown an unprecedented commitment to being leaders in HTML5 browsers
• [Microsoft] has probably not emphasized enough the tooling for HTML5. We’re going to emphasize that much more going forward [...]
• Over the coming months we’ll be particularly demonstrative of our emphasis on HTML5

I blogged recently:

• Analyze Microsoft MIX11 Session Data With PowerShell of note, there are as many HTML5 sessions as there are Silverlight at MIX11
• Is Microsoft hedging their bet? Where Microsoft sponsors an HTML5 contest. Stating HTML5 and related technologies can provide what you expect from native applications
• HTML is the only true cross platform solution for everything Bob Muglia responded about Silverlight questions. Back then he was the leader of the Microsoft Server and Tools Business.