Huddled Masses » Programming

Random News Digest …

Joel 'Jaykul' Bennett — Tue, 16 Sep 2008 16:13:32 +0000

There’s fun stuff happening lately, so here’s a post full of tidbits you may have missed. Like:

Codeplex has announced Subversion support. They will be running a server-side SvnBridge to allow access to all the projects so you can grab source more easily because it supports anonymous access. Amusingly, it’s actually easier to use than TFS, all you need to know is the project name to get in. E.g.: https://PoshConsole.svn.codeplex.com/svn

Clarius has just released of their T4 template editor for Visual Studio. There’s a free version, and a pro ($99) version. It’s excellent, and if you haven’t gotten into generating code using t4, what are you waiting for?

StackOverflow The new programming question-and-answer forum from CodingHorror Jeff Atwood and Joel Spolsky has launched.

Dave Glover wrote a cool post about how simple it is to create a bootable USB install disc for Vista and Miguel de Icasa created a C# Eval statement and console shell for the Mono Project.

Sir Tim Berners Lee launched the world wide Web Foundation to proactively advance the goals that “a single web” should be “open to any device and software” and to extend the capabilities of the web and ensuring they can be accessed securely by everyone on the planet… Hard to say what this all means, at this point.

Present.ly and Yammer launched as attempts at private corporate Twitter implementations. Present.ly looks most promising, they have the concept of “groups” that is missing from twitter, and they have a few different types of posts (questions, urgent messages, group broadcast messages, etc). However, they charge for anything more than the most basic account (ie: no IM without paying). Yammer has a more curious business model (it’s almost like extortion): employees can join for free based on their email address, companies can then pay to take over their (pre-established on-the-fly) corporate network and exert some control over it, but their Jabber/IM is working great already.

SysAdmins, scripters, developers and memes

Joel 'Jaykul' Bennett — Thu, 19 Jun 2008 03:29:15 +0000

So, I’ve been called out on this latest meme posting by /\/\o\/\/ and although I usually just ignore these things,

As with any curious developer, I had to trace this thing back to it’s root cause … it turns out this started as a Software Development thing, and it was altered into a sort of SysAdmin thing.

So, since I’m putting up with this in the first place, I think I’ll go back to that original developer-oriented list of questions, if you don’t mind.

How old were you when you started programming?

I got my first computer shortly after my family moved back to the USA from Costa Rica, just in time for 9th grade … before that I’d never seen a computer better than my Atari 6400 game machine.

How did you get started in programming?

I bought that “computer” second-hand — it was an Atari 800XL, and it came with a cartridge for Atari BASIC, and a stack of magazines with code in them. That’s pretty much all there is to it, I was hooked.

What was your first language?

BASIC. First Atari, then QW, then … well, Visual Basic Script, believe it or not.

What was the first real program you wrote?

You mean BlackJack for the Atari doesn’t count? I guess the first real program I wrote was one I wrote at work to randomize test cases …

What languages have you used since you started programming?

Basic, Visual Basic, C/C++, C#, Java, Perl, PHP, a bunch of automation languages like batch and shell scripts, VB script and VB for Applications, MS Test Basic, Rational’s SQABasic, AutoIt, AutoHotkey, ScriptIt, and a slew of web languages like JavaScript, VB Script, HTML, XML ... and of course, lets not forget SQL (although I kind-of wish I could).

What was your first professional programming gig?

Not counting a few tiny web-sites I did in college … my first programming job was at Xerox, where I started out doing software testing, started automating the testing, and then moved to writing and maintaining apps, web sites etc.

If you knew then what you know now, would you have started programming?

Absolutely. I love what I do, and I love that I work in a job where every year there’s new languages, new tools, new challenges, and new and more clever solutions.

If there is one thing you learned along the way that you would tell new developers, what would it be?

There’s really only three kinds of programmers: Web developers, Database developers, System developers. Take a database class and a web-design class early on and figure out what you want to be — then work hard to make sure you don’t end up being the wrong kind of programmer

What’s the most fun you’ve ever had … programming?

I think I’d have to say that the memory that stands out the most was working on the open source project GeoShell … it’s mostly died off now (although I’m still threatening to ressurect it later this year), but at it’s height it was a near ideal interaction of passionate users, laid back developers, and cool software that made everyone ask: “whoah, what’s that you’re running?”

I guess I should call someone else out, right? That’s how these silly posts become memes. How about Lee Holmes, Jachymko and Mark Schill …

Eight Queens in PowerShell

Joel 'Jaykul' Bennett — Tue, 19 Feb 2008 03:46:31 +0000

Well … my brother called me with an odd compiler problem with his C++ homework today (he’s working on another degree, and taking some programming courses) ... but the homework problem he was working on was the infamous N Queens problem:

Given a chess board of N x N squares, place N queens on the board in such a way than none threatens the others. In chess, a queen can move diagonally or horizontally, so solving this requires placing each queen on her own row and column, and ordered such that none of them are on the same diagonal in either direction.

The problem is solvable using a backtracking recursive algorithm: the program must place a queen on the first row and then find a spot that works for the next row, and continue for each row. If it can’t find a spot for a row, it backtracks to the previous row and uses the next legal spot on that row, and if there is none, it backtracks to the previous row, and so on.

Anyway. There’s lots of information about this stuff out there on the ‘net, including dozens of slides shows and lecture notes from dozens of schools, so I’m just going to move on to the fun part: my solution in PowerShell. I wrote it just to make sure I understood the algorithm correctly, without giving away the C++ answer as much as a quick web search would. In fact, I followed the restrictions my brother’s professor had placed on them to break it up into a specific set of functions…

## N-Queens problem using backtracking

################################################################################

## Backtracking is a problem-solving strategy that, when it reaches an impasse, 

## retraces its steps in reverse order before trying a new sequence of steps.

param($size=8)       # By default, we use a board of size 8

function Check-Queen($r1,$c1,$r2,$c2) {

    return -not (

      # they can't be on the same column

      ($c1 -eq $c2) -or 

      # nor on the same row

      ($r1 -eq $r2) -or 

      # nor on the same diagonal

      ([Math]::Abs($r1-$r2) -eq [Math]::Abs($c1-$c2)));

}

function Out-Board($board){

    foreach($c in $board) {

        switch(0..($board.Count-1)) {

            {$_-eq$c} { write-host "Q" -fore red -nonew }

            default   { write-host "#" -nonew}

        }

        Write-Host

    }

}

function Set-Queen($board,$row,$column) {

    # Set the queen location for this row

    $board[$row]=$column;

   # if this is the last row, then we're done

    if($row+1 -eq $board.Count) { return $true }

   # place the queen in the next row

   # try every column .... 

    for($c=0;$c -lt $board.Count; $c++) {

        $clean = $true

      # check it against every prior row

        for($r=0; $r -le $row; $r++) {

            $clean = $clean -and (Check-Queen $r $board[$r] ($row+1) $c)

            if(!$clean) { break; }

        }

      # if we found the spot, recurse the next row...

        if($clean -and( Set-Queen $board ($row+1) $c )) {

            return $true;

        }

    }

    return $false

}

$board = new-object int[] $size

# if starting in 0,0 doesn't work 0,1 will

if(Set-Queen $board 0 0){

   Out-Board $board

}elseif(Set-Queen $board 0 1){

   Out-Board $board

}

Writing Cmdlets for the PowerShell Pipeline

Joel 'Jaykul' Bennett — Tue, 06 Nov 2007 05:25:57 +0000

In a continuation of what is, sadly, becoming a series on how the PowerShell Pipeline works … Karl Prosser brought to my attention that certain powershell commands which have an -InputObject parameter don’t actually work when you pass something into it … so I thought I should create a cmdlet to show you how to correctly handle the InputObject parameter with the ValueFromPipeline set so you can pass the input in either way.

To demonstrate the problem, try this:

$a = @("A","B","A","C")

$a | Select -First 3 -Unique

Select -First 3 -Unique -InputObject $a 

This should expose two weirdnesses about how the Select-Object cmdlet works:

The -First parameter affects the input before the -Unique parameter does.

When you pass the input in via -InputObject, the whole array is treated as a single object, and the command basically doesn’t do anything.

The big problem with this behavior is that there’s essentially no hint that you’ve done something wrong — there’s actually no way to make Select-Object work properly except by passing the objects in via the pipeline. The bigger problem is that it would have been simple for the Microsoft team to catch this and alert you, but they didn’t — so you probably won’t even notice there’s a problem until you run it on a trivial data set like my example. The even bigger problem is that it doesn’t just affect Select-Object (try it with Where-Object, just for instance).

The simplest fix

When this came up in the #PowerShell IRC channel Oisin initially defended this as an unavoidable side effect of the way the cmdlet system works. However, after playing with the idea for a bit, we found it’s actually trivial to stop, although I found it hard to explain without actually demonstrating an alternative. The simplest possible alternative is just to throw an exception if the value is passed in as an argument instead of via the pipeline. That would preserve the same level of functionality you have now — but cause an error in those cases where it wouldn’t work anyway.

protected override void BeginProcessing()

{

   if (_input != null)

   {

      throw new ArgumentException("You must pass InputObject via the pipeline!");

   }

   base.BeginProcessing();

}

A better way to handle input

Of course, you can do better than that . So, I hereby present the first version of my PowerShell Pipeline Template Cmdlet. It’s pretty simple really (once you get past all the cmdlet overhead): basically, you check in the BeginProcess() method to see if the InputObject parameter has been set, and set an alternate private variable. Then, in the ProcessRecord() method, we have two alternate computation paths: the normal path, and a second path for when the collection is passed in as an argument. In that case, you recurse and call the ProcessRecord method once for each item in the collection.

I’m sure some of you will have some improvements you can make, feel free to continue the development on the PowerShell Central scripts page or by sending feedback in the form below, but for now, here’s the Test-Pipeline Cmdlet Binary and the source code.

The Code

// An improvement! Now we accept a single object (like Select-Object does)

// But, unlike Select-Object, if an array is passed into the argument -InputObject 

// we still manage to process each item in the array, as we would in the pipeline

//

// Try it out:   "a","b","c"| Test-Pipeline -verbose

// Versus this:  Test-Pipeline -verbose -input @("a","b","c")

//

// If you don't set the -verbose flag, you shouldn't be able to tell them apart

// The first way, the "1" invocation hits ProcessRecord for "a" 

// ... before the "2" invocation hits BeginProcessing()

//

// Version History

//    1.0 Just throws an exception

//    2.0 Finds a way to enumerate ProcessRecord from BeginProcessing

//        There is still a slight difference, which you can see if you test these:

//          Test-Pipeline 1 -input @("a","b","c") -verbose | Test-Pipeline 2 -verbose

//          "a","b","c" | Test-Pipeline 1 -verbose | Test-Pipeline 2 -verbose

//    2.3 Recursed from inside ProcessRecord instead of BeginProcessing

//        Makes the execution look identical in the test case from 2.0

////////////////////////////////////////////////////////////////////////////////

using System;

using System.Collections.Generic;

using System.Text;

using System.Management.Automation;

using System.Collections;

namespace Huddled.TestSnapin

{

    [Cmdlet(VerbsDiagnostic.Test, "Pipeline")]

    public class TestPipelineCommand : Cmdlet

    {

        #region Parameters

        /// 

        /// This is just a name parameter for decorating test cases :)

        /// 

        [Parameter(Position = 0,

            Mandatory = false,

            ValueFromPipelineByPropertyName = false,

            HelpMessage = "A Name for Verbose output"), ValidateNotNullOrEmpty]

        public string Name

        {

            get { return _name; }

            set { _name = value; }

        }

        private string _name = "TestPipeline";

        [Parameter(Position = 1,

            Mandatory = true,

            ValueFromPipeline = true,

            HelpMessage = "Help Text"), ValidateNotNullOrEmpty]

        public object InputObject

        {

            get { return _input; }

            set { _input = value; }

        }

        private object _input;

        private bool _isArgument = false;

        #endregion

        protected override void BeginProcessing()

        {

            WriteVerbose(String.Format("Begin Processing {0}", Name));

            if (_input != null && _input is ICollection)

            {

                _isArgument = true;

                StringBuilder output = new StringBuilder("There's input: ");

                foreach (object _in in (ICollection)_input)

                {

                    output.AppendFormat("{0}, ", _in);

                }

                WriteVerbose(output.ToString());

            }

            base.BeginProcessing();

        }

        protected override void ProcessRecord()

        {

            if (!_isArgument)

            {

                // This is the normal ProcessRecord code

                WriteVerbose(String.Format("Process: {0}", _input));

                WriteObject(_input);

            }

            else

            {

                // This is what we have to do unwrap -InputObject as Arg

                ICollection _collection = _input;

                _isArgument = false; // unset isCollection before recursing

                foreach (object _in in (ICollection)_collection)

                {

                    InputObject = _in;

                    ProcessRecord();

                }

            }

        }

        protected override void EndProcessing()

        {

            WriteVerbose(String.Format("End Processing {0}", Name));

            base.EndProcessing();

        }

    }

}