Media And Microcode

Get-ComputersNearMe

2010-01-06T02:16:37Z

Today I learned a little bit about how to get to some of the data stored within special shell folders. You can get a list of all of the easy-to-get-to special folders here. I noticed one folder in particular that a bunch of systems administrators I know want to read, and that’s the Nearby Computers page. Here’s a quick 23-line function that will go and get all of the computers from the Nearby Computers page, ping them, and return the Win32_PingStatus objects.

function Get-ComputersNearMe            
{            
    <#
    .Synopsis
        Returns the Computers Near Me
    .Description
        Returns all of the computers listed in the "Computers Near Me" or "Access the computers and devices tht are on your network" shell
        namespace.  Uses the Shell.Application API to get the computers folder, and then uses Test-Connection to return the machines and their
        response times.
    .Example
        Get-ComputersNearMe
    #>            
    param()            
    $computersFolder = 0x12            
    $shell = New-Object -ComObject Shell.Application            
    $shell.NameSpace($computersFolder).Items() |            
        Where-Object { $_.Path -like "\\*" } |            
        ForEach-Object {             
            Test-Connection $_.Name -AsJob            
        } |             
        Wait-Job |            
        Receive-Job             
}

As you can see, the whole first half of the script is the help. $computersFolder is set to one of the magic constants listed on the MSDN page, and then I simply use the COM Object Shell.Application (which should be familiar to anyone that’s done a decent amount of VBScript) to get the folder. Two types of items will be returned from this: UNC paths to a machine and links to specific devices (like a media player library). I filter out only the UNC paths with Where-Object, and then I do Test-Connection –AsJob to try to ping the machines. The last bit of the script waits for all of the pings to come back, and returns the results to the user. Since Win32_PingStatus already has a formatter that displays the source, destination, IPV4 address, IPV6 address, and time to ping, so there’s really nothing else I want to add.

Get-ComputersNearMe should be easy enough to use in small businesses, workgroups, or wherever else you find yourself using that screen.

Hope this helps,

James

Write-Progress & WPK

2009-12-28T21:10:43Z

A nifty trick that you can do in WPK is create a WPF progress bar to show the Write-Progress output from a PowerShell script. I was reminded that people actually wanted to do this when I ran across a question on StackOverflow, and posted this answer.

In case you don’t want to follow the link, here’s a quick script to show progress from a background runspace in WPK. The top half set ups a bunch of data bindings that will bind to whatever DataContext is found, and the second half of the script is a small sample of Write-Progress output.

New-Grid -Columns 2 {            
    New-TextBlock -Margin 10 -TextWrapping Wrap -ZIndex 1 -HorizontalAlignment Left -FontWeight Bold -FontSize 12 -DataBinding @{            
        "Text" = "LastProgress.Activity"            
    }            
    New-TextBlock -Margin 10 -ZIndex 1 -TextWrapping Wrap -Column 1 -VerticalAlignment Bottom -HorizontalAlignment Right -FontStyle Italic -FontSize 12 -DataBinding @{            
        "Text" = "LastProgress.StatusDescription"            
    }            
    New-ProgressBar -ColumnSpan 2 -MinHeight 250 -Name ProgressPercent -DataBinding @{            
        "Value" = "LastProgress.PercentComplete"            
    }            
} -DataContext {            
    Get-PowerShellDataSource -Script {             
        foreach ($n in 1..100) {            
            Write-Progress "MajorProgress" "MinorProgress" -PercentComplete $n            
            Start-Sleep -Milliseconds 250            
        }            
    }            
} -AsJob

Hope this Helps

James Brundage [MSFT]

Test-Spelling

2009-12-09T08:54:41Z

The Integrated Scripting Environment has many things: A rich debugger, a nifty object model, and support for multiple runspaces, but it doesn’t have spell check. Since I end up writing a lot of documentation in the ISE for my functions, I decided to write a quick Spellchecker function.

In order to write this I used some functions from IsePack and some functions from WPK. Both IsePack and WPK can be found as part of the PowerShellPack

WPF text controls actually all have a spell check built into them, which saves almost all of the trouble of getting this to work. Unfortunately, it means that the spell check as it is written pops up a small UI for each thing you want to check.

Import-Module IsePack, WPK            
            
function Test-Spelling {            
    <#
    .Synopsis
        Tests the spelling on some text
    .Description
        Launches a text box with spell check enabled to highlight any spelling errors.
    .Example
        Test-Spelling "Can I speel?"
    .Example
        # Uses IsePack's Add-IseMenu to add a spellcheck hotkey to the Ise
        Add-IseMenu -Name "SpellCheck" -Menu @{
            "Test-Spelling" = {
                Select-CurrentText -NotInOutput | 
                    Where-Object { $_ } | 
                    Test-Spelling
            } | Add-Member NoteProperty ShortcutKey F7 -PassThru
        }
    #>            
    param(            
    # The phrase to check for spelling errors            
    [Parameter(ValueFromPipeline=$true)]            
    $phrase            
    )            
                
    process {            
        New-TextBox -Resource @{Phrase=$phrase} -On_Loaded {            
            $phrase = $this.Resources.Phrase            
            $this.Text = $phrase            
            $this.SpellCheck.IsEnabled = $true            
        } -ASJob            
    }            
}            
            
Add-IseMenu -Name "SpellCheck" -Menu @{            
    "Test-Spelling" = {            
        Select-CurrentText -NotInOutput |             
            Where-Object { $_ } |             
            Test-Spelling            
    } | Add-Member NoteProperty ShortcutKey F7 -PassThru            
}

The script imports IsePack and WPK, writes the test spelling function Test-Spelling (with an example from the command line and an example that adds the menu item), and adds it to the IseMenu all in a scant 42 lines. Go ahead and give it a try. F7 becomes the shortcut key for spell check, just as it is in Word.

Hope this helps,

James Brundage [MSFT]

New WPK Video Online: Multitouch Fingerpaint in 30 Lines of PowerShell Script

2009-10-30T20:32:21Z

The 2nd video about WPK just hit Channel9. The first video was a video walk thru of How to Write User Interfaces with WPK, and this video walks thru How to Write a Multitouch FingerPaint with WPK.

Enjoy,

James Brundage [MSFT]

Microcode: PowerShell Scripting Trick: Fun With Parameter Binding: The Fake Parameter Set Trick

2009-04-10T10:00:04Z

I’ve been hearing a lot of questions recently about what things you can do with advanced functions. People seem to be aching for good examples of using PowerShell V2 functions, and, since I’ve discovered a few handy tricks for advanced functions, I thought I’d start to share them there in a series called “Fun with Parameter Binding.”

Here’s volume one: The Fake Parameter Set Trick

I found myself wanting to make an advanced function that took something strongly typed (in this case, the CommandInfo object, which is the base object for what you see when you run Get-Command) from the pipeline and returned items that matched a certain characteristic. If I didn’t pipeline in any items, I wanted to get all of the commands and check for the same characteristic.

What I really wanted was the function to act two ways, one parameterized, one unparameterized (like how you can run Get-Process or Get-Process PowerShell*)

I know of one way to approach this, using the $psBoundParameters variable (see this enlightening post by Marcel Ortiz Soto), but I recently happened upon another approach that I find kind of novel. I call it the fake parameter set trick.

Here’s an example:

[CmdletBinding(DefaultParameterSetName="All")]            
                
    param(            
    [Parameter(Mandatory=$true,            
        ParameterSetName="Command",            
        ValueFromPipeline=$true)]            
    [Management.Automation.CommandInfo]            
    $command            
    )            
                
    process {            
        $psCmdlet.ParameterSetName               
    }

The CmdletBinding attribute at the top of the function is one of the markers that the function is an advanced function, and it specifies the DefaultParameterSetName. If no default parameter set name is specified, it would go ahead and default to whichever ParameterSetName it found on a parameter. If you didn’t every mention a ParameterSetName, then the parameter set name would implicitly be __AllParameterSets.

In my case, I’ve set the DefaultParameterSetName to All. But there aren’t any parameters at all in All. In fact, for All intents and purposes, All is nothing. All is a fake parameter set.

This lets me mark the $command parameter as mandatory and from pipeline, and lets me easily figure out if the parameter is there or not. This is ideal for building good Get- advanced functions, because Get- cmdlets and functions tend to either be able to retrieve all of the data or retrieve a filtered subset of the data.

Hope this Helps,

James Brundage

Microcode: A Quick Trick to turn regular XML into Xaml

2009-01-22T13:07:36Z

MSDN has tons of examples about XAML. Nearly everything in WPF has an example in XAML, but not all of these XAML examples actually reference the namespace that is required for this Xaml to be loadable by WPF. It's still valid XML, just not valid XAML.

Here's a quick example of what I mean. I just copied and pasted this chunk from the MSDN topic on LinearGradientBrush:

<Rectangle Width="200" Height="100">
<Rectangle.Fill>
    <LinearGradientBrush StartPoint="0,0" EndPoint="1,1">
      <GradientStop Color="Yellow" Offset="0.0" />
      <GradientStop Color="Red" Offset="0.25" />
      <GradientStop Color="Blue" Offset="0.75" />
      <GradientStop Color="LimeGreen" Offset="1.0" />
    </LinearGradientBrush>
</Rectangle.Fill>
</Rectangle>

Now if I try to simply load that up as XAML, XamlReader barfs

$x =[xml]'
<Rectangle Width="200" Height="100">
<Rectangle.Fill>
    <LinearGradientBrush StartPoint="0,0" EndPoint="1,1">
      <GradientStop Color="Yellow" Offset="0.0" />
      <GradientStop Color="Red" Offset="0.25" />
      <GradientStop Color="Blue" Offset="0.75" />
      <GradientStop Color="LimeGreen" Offset="1.0" />
    </LinearGradientBrush>
</Rectangle.Fill>
</Rectangle>
'
[Windows.Markup.XamlReader]::Parse($x.OuterXml)

Exception calling "Parse" with "1" argument(s): "'' XML namespace prefix does not map to a namespace URI, so cannot resolve property 'Width'. Line '1' Position '79'."
At line:14 char:35
+ [Windows.Markup.XamlReader]::Parse <<<< ($x.OuterXml)
+ CategoryInfo : NotSpecified: (:) [], MethodInvocationException
+ FullyQualifiedErrorId : DotNetMethodException

Obviously, that's not ideal. Luckily, with CTP3, there's a cmdlet called Select-Xml, which will allow me to query a document with xPath, regardless of namespaces.

This means that I can check to see if the fist element has a reference to the WPF namespace, and add it if it's not there.

$t = $x |
    Select-Xml //* |
    Select-Object -First 1 |
    Foreach-Object {
        if (-not $_.Node.xmlns) {
            $_.Node.SetAttribute("xmlns", 'http://schemas.microsoft.com/winfx/2006/xaml/presentation')
        }
        $_.Node.OuterXml
    }

I'll stop and explain this pipeline a little. $x is the XML, I pipe it into Select-Xml, with the xPath parameter of //*. //* roughly translates to any node. I pick out the first node (with Select-Object -first 1) and then I check to see if the Node contains an xmlns attribute. If it doesn't, I add it. Either way, I emit the first node's OuterXml, which basically means I emit the entire XML chunk as text. That's what $t is when I am done.

Then I use this chunk to display it:

$w = New-Object Windows.Window
$w.Content = [Windows.Markup.XamlReader]::Parse($t)
$w.SizeToContent = "WidthAndHeight"
$w.ShowDialog()

Now I have the MSDN sample working, regardless of if it had an xmlns attribute in the first place.

Hope this Helps,

James Brundage [MSFT]

Media: The Moment Obama Got Inaugurated and PhotoSynth Hit Mainstream

2009-01-20T23:12:34Z

Photosynth is a really cool product out of live labs. It's sort of an uber photo collage application. It takes photos taken from different people, at different resolutions and different times, and collects them into a 3d view of a location that you can navigate around.

CNN.com worked with Photosynth to show the world the Moment of Obama's Inauguration. It's a pretty cool way to view history.

Check it out:

http://www.cnn.com/SPECIALS/2009/44.president/inauguration/themoment/

Hope this Helps,

James Brundage [MSFT]

PowerScripting Podcast Online

2009-01-20T00:44:35Z

My interview with the PowerScripting Podcast is now online. Check it out:

http://powerscripting.wordpress.com/2009/01/18/episode-55-jeff-hicks-in-for-hal-and-an-interview-with-james-brundage/

Hope this helps,

James Brundage [MSFT]

Please Join Me for a Power Scripting Podcast Tonight @ 9PM EST (6PM PST)

2009-01-15T21:30:11Z

I’m going to be doing a PowerScripting Podcast tonight @ 9PM EST. There’s a live chat room where you can ask questions and pick the brains of a tester / avid scripter on the PowerShell team.

It should be fun. I hope to see your questions there.

http://powerscripting.wordpress.com/2009/01/14/tomorrow-on-powerscripting-live-james-brundage/

Hope this Helps,

James Brundage [MSFT]

Media: The Future of Newspapers is Pay For Play Journalism?

2008-12-28T03:45:35Z

I love my news. For whatever reason, I find catching up on the world to be one of the most relaxing and rewarding things you can do in your spare time. Even though I like to read the news, I rarely read a physical newspaper or magazine or watch a news program . My cell phone and web browser are my gateways to the news world. I make an exception for especially good local weeklies (Seattle's The Stranger) and very insightful magazines with a broad range of news ( like The Economist ). But times are tough for newspapers and magazines alike. Local small-market newspapers are dropping like flies, and even big outfits like The New York Times are struggling. Digitization has been a painfully slow paradigm shift with major publications.

This is primarily because of a loss in advertising revenue on many fronts. It's harder to convince a businessman to buy a 6" ad for hundreds of dollars upfront with limited tracking and return when they can buy a search keyword for a fraction of that. It's also very hard to convince someone to put a classified ad in at a dollar a word when Craigslist will do it for free. So it's no suprise that there have been any number of propositions about "the future of newspapers." Most are still advertising focused, and the general mind set in publishing still seems to ignore what happens when the Long Tail effect hits news and ignoring the peril of wire services. By this I mean that if finding the news I am interested in is no longer restricted by where I am, then I'll end up reading publications from wherever news comes that interests me, and it becomes harder for any publication to really gain a mental foothold. Further more, if every time I pick up a newspaper, 80% of the content comes from a news wire service, then that newspaper is no different from any other newspaper I'd run across, and I'm no more or less likely to pick it up in the future.

This is a very tricky situation, that presents no great way out. But today, I ran across a way that is so worrisomely bad that I've decided to talk about it here.

Ironically, I ran this very bad answer to the problems newspapers are facing on Good, through a link on MSN title "When Newspapers Are Gone". This is an article about a web site called Spot.Us, where a few community minded individuals pay a reporter to write a news story.

In my personal opinion, this is a very, very bad idea.

Why?

First and foremost, it's "pay for play" journalism. If this is the future of news, then the future of news will mean that people who cannot afford to be covered will not be. What's that mean? Well, unless you get a lot of donations from a lot of people, no coverage of any danger zone, so most likely no international coverage whatsoever. If this sort of news becomes popular, than suffering becomes a "tree falls in a forest" problem. If 1,000 people are killed in an earthquake due to shoddy infrastructure, and no one can afford to report on it, do their deaths mean anything?

The second problem is what I call NIMBY journalism (NIMBY is Not In My Backyard). An individual can provide up to 20% of the amount required to cover a story, which means that a small group of individuals can fund a story of their own liking. Don't like that eyesore building going up across the street? Pool 5 of your neighbors and have someone you've never met run a news story about the decline and fall of your neighborhoods look. Concerned about increasing homelessness in your area? Fund an article pushing for a homeless shelter far away.

The third problem is funding transparency. If only a few people can fund a story on Spot.Us, which pitches the story to other major outlets, then it's possible to get stories written that back up your political beliefs. While Spot.Us does have "fact-checking editors" (a freelance journalist can turn down the first two if they choose), there's little on who watches the watchdogs, less on how retractions work, and nothing that I can see that would prevent individuals with different political slants from funding a story. As the story is picked up by other outlets, both patent lies and innuendo can seep into the news cycle with a significantly greater pedigree than information recycled from blogs. While you can see the individuals that sponsored the article on Spot.Us, you do not have any information about their affiliations with companies, and it's unlikely that whoever would pick up a story from Spot.Us would list the individuals who paid for the article.

The fourth problem is that pitch-based news doesn't come up with the news no one wants to hear. A simple and sarcastic example of this was my time (12 years) writing film reviews. During this time, I saw a lot of movies I suspected would be awful, not because I particularly wanted to, but because someone has to and my editor gave me marching orders to cover the movies. Some of them were awful, some of them were unexpectedly great. When journalists do their own pitching of stories entirely, the editorial process is greatly degraded, because people simply do not go out to cover many things, like violent crime (or exceedingly bad movies), without being told to do so. Sometimes the best stories start from the most mundane pieces of information.

The fifth problem is the transparency in the expenses of a story. Salaried employees of a newspaper can sometimes expense costs of the story to a newspaper, but there is a lot of transparency in the process. Receipts must be kept. Purchases must be justified. As much as I wish journalists were paid better for their work, I do not believe that they should be their own accountants or set all of their own rates.

A quick look of the story pitches on Spot.Us gives a lot of foundation for these concerns. Right now, I see a pitch about problems with state adopted children ($500 required), a pitch about a retirement community residents who had to resign from a community board because they formed their own online paper ($25 required), a pitch about why the VOA takes too long to process claims ($1000), a pitch to cover the poor in San Francisco ($500), a pitch about the digital future of Bay Area newspapers ($1000), a pitch about the electricity sources in the Bay Area ($1500), a pitch about if Oakland can survive the next quake ($450), and a pitch about how the recession is hitting bay area hookers ($500). Each of these pitches raises a lot of questions about what the money's being spent on (especially the last one) and why the rates are so wildly different. I'd go out on a limb and guess that the community board pitch ($25) is someone who wants to give more legitimacy to their community association dispute. That there's even a pitch for a digitization of news story on an online news site raises obvious conflict of interest questions. Several of the stories seem wildly overvalued, and others incredibly under expensed (how can someone assess is Oakland is ready for the next quake for $450?). Magazines with great readership (hundreds of thousands or even millions) will generally not pay more than a few thousand dollars a story to a freelancer. Why is a story that can be researched from a laptop while sipping a latte worth $1000?

I apologize to veer off my normal course of technical information and highlighting interesting information that I find online, but the idea of journalism as funded by the angry mob makes me very worried. Journalism should help the mob become incensed about what they do not know, not become the voice of the angry mob to recruit more members. Journalists should calm the mob when it is irrationally angry, and not owe their paycheck to the mob. Journalists should show be a check and balance to the world, instead of balancing their checkbooks by what their neighborhood says is right.

Hope this Helps,

James Brundage [MSFT]