The whole house reverberated last night... not too impressive, but strangely odd... I figured  iit was probably an earth quake, but thats none too common in Auckland, so I also figured it might've just been a a really large truck, or perhaps a car exploding
;o)

... but turned out it was an earth quake...

Which got me to thinking, I haven't got any survival instincts when it comes to earth quakes ... I'd probably just stand around going "wow, never seen this before" as the roof collapsed on top of me, I probably wouldn't even think to save my laptop :P

Lets hope a bigger one isn't to follow!

Came across a short piece I wrote about IronPython while looking for something else - it was in response to some questions from Kathleen Richards in September of last year for Redmond Developer News (which I think was for this Article, though none of the content made it in - cest la vie).

At any rate, I figure I might as well post it here, it may be of use to someone... somewhere... who could say?  Looking over it briefly I'm not even sure I agree with some of the points I made any more :P

IronPython Article

How are you using IronPython?

Why did you choose this implementation over C python or Jython or
other dynamic languages?

What types of applications are you building?

When dealing with transforming this kind of content, python (and IronPython) is a great language to augment the message transformation process - strong string support, access to all the functionality of our underlying application and it's easy to develop and deploy - IronPython never seems to be working against us, I could never claim the same for any scripting language I've implemented into a product before.

Does the .NET environment offer any advantages?

First off the business case for building .Net applications is immediate within our home country of New Zealand, customers are generally expecting to host Microsoft tools and solutions, and our IT industry is geared towards this expectation, there is an implied trust which is worth taking advantage of.

Business cases aside however I think the .Net platform is very engaging for us, our company has a love for technology, and in the last few years the .Net platform has been satisfying that need very well - it offers stability, security and productivity increases that we can't find elsewhere (and certainly not in an unmanaged language), also the language-agnostic approach and ability to build dynamic languages (like IronPython) in the CLR make the choice all that simpler.

Disadvantages?

For instance we already have languages competing with C# on the .Net platform, such as Boo (http://en.wikipedia.org/wiki/Boo_programming_language), which offer some advantages over the current version of C# and are very suitable for building domain specific languages (DSL's) - but I believe in many bespoke development houses it would be very hard to get buy-in for using these languages in upcoming projects, even if they will save time and money or just be a better fit for their problems.

Do you think dynamic, object oriented (scripting) languages
(Ruby, Python) will start to play a larger role in enterprise
development?

If I am in a corporate environment should I be looking into these
languages?

That said, if you're not a Microsoft shop, and particularly if you are committed to open-source technologies I would look seriously, probably first at Ruby, it's very engaging story - though of course you can run IronPython on Mono with a little bit of tweaking ? ... and IronRuby is getting better every day.

What are some of the key issues from an application development
standpoint?

First off, you must change your point of view and adapt some of your practices, as they will confound you with the introduction of a scripting language that has access to your own .Net classes.  As you develop classes, try them on for size and make sure the selected scripting language doesn't have trouble accessing them - for instance heavily overloaded .Net methods in IronPython can be a recipe for frustration later on, same goes with using multiple out or ref parameters - that's not to say IronPython can't access them, just that it's awkward and unpleasant (something your scripting language should not be).

Second to this is security - dynamic languages effectively introduce a surface area to your application that didn't exist before - our server allows configuration (including iron python scripts) to be applied via a web service - you want to make absolutely sure there is sufficient trust between endpoints, and don't repeat mistakes of the past with other scripting languages (think injection attacks).

It seemed a long time coming, but finally
Rhino Mock's 3.0 is available, which of course also means

href="http://wiki.castleproject.org/index.php/DynamicProxy%20">Dynamic
Proxy 2 has made it to that sweet generic method support
nirvana as well :)



I don't know where I'd be without these tools, I haven't done a
.Net project without them in the last couple of years... in fact
it's fueled my reluctance over the last couple of years for
returning to bespoke development at any NZ dev shop which might
dictate other (crappier) alternatives ;o)



I also noticed that mono is getting it's C# 3.0 support slowly
sorted... Extension methods are in, as is some Lambda
support... I need to sit down and spend some time thinking about
how I should go about unit testing some of this stuff, it's on my
list of "testing" things to do right after getting to grips with
RhinoMocks 3 and perhaps writing another blog entry on mocking
Base4 with all the new "goodies" - I need to do a monorail/base4
website for another little venture, so it's probably as good a time
as any.



Went for a swim at Omaha today... just can't get enough of the
beach this year - John
Campbell turned up at the same time we did, there's only so
many "Not in front of John" jokes I can handle in one day... or a
life time ;o)

Found myself writing a simple class for implanting "trial" logic for a client (as in you have 30 days left of your trial etc.) ... it relies on the current date and time, and so you can never really be assured your tests are robust unless you can control the current date & time within the test fixture (in fact any time you find yourself writing DateTime.Now alarm bells should be going off... even worse is logic based on DateTime.Now where it's evaluated more the once for a single function).

In the past I've generally Implemented something like an "IClock" interface, which would have a method like "DateTime GetCurrentTime()" or whatever seemed appropriate to the situation... but I decided to go with the lightweight solution of delegates instead in the morning, if only because I was being lazy I didn't see the need for creating an entire interface for such a trivial requirement... so we have:

private DateTime _trialExpirey;

private int _maxExecutions;

private TimeSpan _trialDuration;

private Func _nowFunction;
public TrialUpdater(DateTime trialExpirey, int maxExecutions, TimeSpan trialDuration)

    : this(delegate { return DateTime.Now; }, trialExpirey, maxExecutions, trialDuration)

{

}
public TrialUpdater(Func nowFunction, DateTime trialExpirey, int maxExecutions, TimeSpan trialDuration)

{

    if (nowFunction == null) throw new ArgumentNullException("nowFunction");
    _nowFunction = nowFunction;

    _trialExpirey = trialExpirey;

    _maxExecutions = maxExecutions;

    _trialDuration = trialDuration;

}

But I'm starting to wonder if this code doesn't smell a bit if I start using it other places... for instance:

• Could I supply an alternative delegate via the castle container...?
• Could I mock out the nowFunction parameter easily using something like RhinoMocks and still have it participate in constraints...?

Just a quick post, for part two let's look at grouping our results for display purposes... first off, I grab only the episodes which we think are "valid" (in this case ones which are assigned a series, episode and part number)...

EpisodeParser episodeParser = new EpisodeParser();
YouTubeSearcher searcher = new YouTubeSearcher(DeveloperId);
// get a list of all the parts we are interested in
IEnumerable parts = (from result in searcher.QueryByTags("QI", "Quite", "Interesting")

                                select episodeParser.Parse(result))

                                .Where(p => p.SeriesNumber > 0 && p.EpisodeNumber > 0 && p.PartNumber > 0)

                                .Distinct();

Obviously what I've done here is probably rather poor style, surely the where clause could have been inside the select statement??... but I'm just trying to illustrate how you can mix the two notations... next we're going to group the results up using some nested "group by" and object projections... this is disgustingly easy, what more can you say about it.

// group those parts
var allSeries = from part in parts

                group part by part.SeriesNumber into series

                orderby series.Key

                select new { SeriesNumber = series.Key,

                    Episodes = from episodePart in series

                               group episodePart by episodePart.EpisodeNumber into episodes

                               orderby episodes.Key

                               select new {EpisodeNumber = episodes.Key,

                                       Parts = from chunk in episodes

                                               orderby chunk.PartNumber

                                               select chunk

                                       }

                    };

Great, I think that saved us a lot of time, compared to doing it ourselves in C# 2.0...  let's now generate a little page to view the results - for now I'm just writing code in NUnit fixtures - so we'll use Console.WriteLine... though in a website I would probably just use some quite similar brail template code.

foreach (var series in allSeries)

{

    Console.WriteLine("

Series {0}
rn", series.SeriesNumber);

    foreach (var episode in series.Episodes)

    {

        Console.WriteLine("

Episode {0}
rn", episode.EpisodeNumber);
        foreach (var author in episode.Parts.GroupBy(p => p.Result.Author))

        {

            Console.WriteLine("
Author: {0}rn", author.Key);

            foreach(var part in author)

            {

                YouTubeResult result = part.Result;

                Console.WriteLine("part {1}  ", result.Url, part.PartNumber, result.ThumbUrl);

            }

        }

    }

}

I've also dumped the output from this to an html page, if you'd like to have a look at it.

Next time I might have a look at storing the results of the youtube query with base4 and writing some code for a little daemon which can identify newly posted episode parts on a periodic basis... which should all lead towards implementing the RSS feed capability I discussed in  part one.

But for now I'm off to enjoy the sun!