Keep Your Head Up

{

From an old Raganwald interview, I derived some inspiration this morning:

“Quite often we see something and we're very tempted to say "oh! this is a special case of a more general thing." and then we solve the general thing. However that is an infinite recursion: it's always a special case of a something more general and if you're always climbing up the tree on to the more general thing you'll eventually wind up with a PhD in computer science... and no code.

However, on the other hand, if we just scrabble along the earth and we never, sort of, poke our head up and look around to see the more general thing we are constantly re-solving the same problems, you're not even recognizing that two different things we solve are both aspects of same thing. So what I try to do is I always try to recognize what that general case is, and then discipline myself not to solve the general case until it's really an imperative but not to be ignorant of the general case.”

On the continuum of thinking in general, more theoretical terms and the more practical nuts and bolts, I’ll admit I err too often on being practical.

I’ve been in the trenches a lot of late so this is a good quote to meditate upon. Especially in a week like this: at the end of an iteration, being asked to “work overtime” to try to get things done and out to customers, it’s very easy to stay in scrabble mode rather than having the disciplines of study and analysis that keep the general case in mind.

}

Library of the Week: SharpZipLib with Silverlight

{

SharpZipLib has been around in various forms for some time but via this port to Silverlight we have the benefit of leveraging it for compression and decompression in our Silverlight based web applications. Doing a search on sample code gives back a lot of examples (the best of which, IMHO, is from The Codecruncher) of how to use the library but there’s an important difference when it’s used in the Silverlight space: many members of the FileStream are marked as SECURITY CRITICAL and are therefore out of reach in your application. A very simple technique to get around this is to convert the target stream object to a MemoryStream and proceed from there. A series of examples are below, written in simpe form for brevity (reading a file in a single step to a large byte array is a taste thing; of course I’m aware you can read chunks of the file) Here’s a little sample of getting that done:

public MemoryStream GetFileData(FileStream fs) 
{
    fs.Seek(0, SeekOrigin.Begin);
    byte[] data = new byte[fs.Length];
    fs.Read(data, 0, (int)fs.Length);
    MemoryStream ms = new MemoryStream(data);
    return ms;
}

Here are examples of listing, extracting, and compressing files, respectively:

//open a file dialog, pick a zip and list contents
List entries = new List();
OpenFileDialog ofd = new OpenFileDialog();
if (true == ofd.ShowDialog())
{

    using(FileStream fs = ofd.File.OpenRead())
    {
	    ZipFile zip = new ZipFile(GetFileData(fs));
	    foreach (ZipEntry entry in zip)
	    {
	        entries.Add(entry.Name);
    }
    zipFileListBox.ItemsSource = entries.ToArray();
}

//open a file dialog, pick a *.zip and extract to isolated storage
OpenFileDialog ofd = new OpenFileDialog();
if (true == ofd.ShowDialog())
{
    string fiName = ofd.File.Name;
    ZipEntry entry;
    using(ZipInputStream zis = new ZipInputStream(GetFileData(ofd.File.OpenRead())))
    using (IsolatedStorageFile isf = IsolatedStorageFile.GetUserStoreForApplication())
    {
        string folderForOutput = System.IO.Path.GetFileNameWithoutExtension(ofd.File.Name);
        if (!isf.DirectoryExists(folderForOutput)) {
            isf.CreateDirectory(folderForOutput);
        }

        while ((entry = zis.GetNextEntry()) != null)
        {
            if (isf.FileExists(entry.Name))
            {
                isf.DeleteFile(entry.Name);
            }
            long sizeToWrite = entry.Size;
            using (FileStream fs = isf.CreateFile(folderForOutput + "/" + entry.Name))
            using(StreamWriter sw = new StreamWriter(fs))
            {
                byte[] data = new byte[sizeToWrite];
                int bytesRead = zis.Read(data, 0, data.Length);
                if (bytesRead > 0)
                {
                    sw.Write(data);
                }
            }
        }
    }
}

//open a file dialog, pick some files and create a *.zip
OpenFileDialog ofd = new OpenFileDialog();
ofd.Multiselect = true;
if (true == ofd.ShowDialog())
{
    using (IsolatedStorageFile isf = IsolatedStorageFile.GetUserStoreForApplication())
    {
        using (FileStream fs = isf.CreateFile("TheZip.zip"))
        using (ZipOutputStream zipOut = new ZipOutputStream(fs))
        {                        
            foreach (FileInfo selectedFile in ofd.Files) {
                byte[] fileData = new byte[selectedFile.Length];
                using (FileStream selectedFileStream = selectedFile.OpenRead()) {
                    selectedFileStream.Read(fileData, 0, fileData.Length);
                    ZipEntry entry = new ZipEntry(selectedFile.Name);
                    entry.DateTime = DateTime.Now;
                    entry.Size = selectedFile.Length;
                    zipOut.PutNextEntry(entry);
                    zipOut.Write(fileData, 0, fileData.Length);
                }
            }
            zipOut.Finish();
        }
    }        
}

It must be noted that SharpZipLib is GPL but because of a special clause in the license, you can use it in a “closed source” application as Jon Galloway explains here.

}

Windows 7 In the House

{

Just  a quick test from Windows 7.

}

Library of the Week: Silverlight’s MD5 implementation

{

While there are a slew of cryptographic hashing algorithms a programmer finds at their disposal, and despite the documented vulnerabilities accompanying it, MD5 remains a popular approach to generating hashes. Hashes, as you know, are useful for a variety of things – verifying file integrity and password storage being just a few.

I discovered the Silverlight MD5 implementation because a project I work on leveraged MD5 for file integrity. I was a bit curious about this since it’s long been a recommendation to skip MD5 and use hashing algorithms like SHA-1 and SHA-2 which are proven to be more robust. It’s not just the predecessor of my project, many places still use MD5 despite the bad rap it takes. I posted on SuperUser and got some interesting answers, the most notable of which (I marked as the answer) detailed how MD5 is faster than SHA-1. Other comments can be summarized with this excerpt of an answer that wwas most highly upvoted:

“A MD5 hash is "good enough" for most menial tasks. Recall that it's still incredibly difficult to produce meaningful collisions in the same number of bytes.”

Silverlight’s core assemblies do not support MD5 but a person named Reid Borsuk at Microsoft created an implementation that is robust and easy to use. Because the code is hosted on MSDN Code Gallery you will need to put it into a project on your own but it’s not that hard. Here are some simple steps:

1. Create a Silverlight Library project

2. Download the MD5.cs and MD5Managed.cs (you can also download the MD5Test.cs if you’re interested in unit testing it)

3. Add both files to your Silverlight Library project.

4. Compile and you’re done!

If' that’s not straightforward enough, I’ve created a downloadable Visual Studio 2008 solution with the library, a Silverlight Application and a Web application to show it in action. Here is the code behind generating a hash from a file stream in a button’s click event:

 
private void cryptoButton_Click(object sender, RoutedEventArgs e)
{
    OpenFileDialog ofd = new OpenFileDialog();
    if (true == ofd.ShowDialog()) {
        using (FileStream fs = ofd.File.OpenRead())
        {
            MD5Managed md5 = new MD5Managed();
            byte[] hash = md5.ComputeHash(fs);
            fs.Close();
        }
    }
}

Thanks a lot Reid!

}

Library Of The Week: Simple Styles for Silverlight

{

I’ll admit I have a Man Crush on Robbie Ingebretsen that began when I discovered his work at MIX earlier this year. To expound a bit: Microsoft has worked hard to try to draw a line in the sand between “developer” and “designer” – a line I always had a visceral dislike for because it’s always been people like Robbie Ingebretsen who I’ve always tried to pattern myself after: people who can write code AND produce beautiful designs.

One of the more difficult things I’ve encountered in Silverlight is dealing with control templates. Even something as simple as a button, when opened in Blend, involves quite a few different moving parts so that changing behavior doesn’t always produce a desired effect. For example: changing the background of the button at some given visual state will not affect the button unless you take into account a predefined background gradient that is a part of it.

The Simple Styles samples are stripped down, intuitive versions of the control templates with a concise starting point for anyone working to customize their behavior. To go back to the previous example, changing the background of a button involves changing the BackgroundElement. Rather than changing individual gradient stops in a Visual State, simple modify the entire element related to that Visual State.

Default Button Template	Simple Button
102 lines of XAML	38 lines of XAML

The button is a starting point for simple conversations but there are controls like the listbox which can be deceptively unwieldy in how they are managed1.

The structure of the Simple Styles is also beautiful – not simply a resource dictionary with everything crammed together but a separate file for each control, a gesture one would think was straightforward until you see the many examples of Silverlight styles coming from Blend generated files.  

I mentioned previously that I think that the antidote to the “blank slate” of RIA is good precedent and patterns developers and designers turn to when they build things. I think Simple Styles are a step in that direction; what I wouldn’t give to look through Robbie’s resource dictionaries. How about it Robbie?

}

Library Of The Week: ImageTools

{

I’m not exactly sure of the reasoning, but Silverlight does not have support for either GIF or BMP file formats. This is to say that if you use the Image control, you will be unsuccessful setting the source property to a GIF/BMP file. It’s heresay from nearly a year ago but a member of the Silverlight team, Ashish Thapliyal, posted on (his|her) blog the following:

“We don’t want to take the hit for another codec. It may only be a little bit of download time—but our mandate is small and fast and every little bit counts. We are also hesitant to support .gif because it implies support for animated .gif, which we decided would have to be integrated into our animation scheme somehow—and that will be a lot of work.

Looking from Flash perspective, Flash does not support .gif either. However, as of present, this is something being evaluated, but no date has been announced.”

Initially it was this roadblock that led me down the path to ImageTools. ImageTools is a project that provides Silverlight with good support for GIF and BMP amongst other formats, complete with its own Image control that allows a user to preview either format. It’s been a lifesaver for me on my current project since we have a requirement for preview capability with both.

ImageTools is more than just support for those antiquated formats. Once you’ve downloaded the latest release you’ll see there are a series of demos to look at:

Animation
This project shows how easy it is to load an image using the AnimatedImage type. All the sample files are GIF format.

Colors
This project shows the ability to apply brightness and contrast to images on the fly using the ImageTools.Image type.

Dialog
Asynchronously loading an image file using ImageTools.Image with IsLoadingSynchronously flag.

Editor
Shows the ImageEditorContainer control and some editing features

Flip
Shows the ImageTools.Image.Transform method which supplies not just the ability to rotate, but also to “flip” the pixels within an image either on the X or Y axis (horizontally or vertically)

Loading
I’m not completely sure why this is called “loading” because there’s a lot more going on here: the AnimatedImage control is on display with the ability to apply filters to images that are loaded. The examples given are  Sepia, Inverter, and GrayscaleBT709.  The IImageFilter interface allows an extensible way to define filters, look into the ImageTools.Filtering library to see the interface and other filters available.

Resizing
Shows dynamic resizing of an existing image (returns an Image object with resized Image type)

SaveCanvas
Pretty sick; this handy extension method can return an Image object representing any canvas.

As you can see, my simple problem of needing support for more image formats resulted in finding a library that went the distance in giving a developer flexibility with image manipulation. One more thing, I love the dependency injected goodness of how the library works. Here’s a little snippet of code to give you an idea of how well designed (extensible!) the library is:

1. Add a reference to ImageTools, ImageTools.IO.Bmp, ImageTools.IO.Gif

2. Here is code to load the files – notice the Decoders.AddDecoder takes the generic type parameter to dynamically support the desired file format which means you need only reference the format specific libraries that you need:

    public partial class MainPage : UserControl
    {
        public MainPage()
        {
            InitializeComponent();
            // add decoders
            Decoders.AddDecoder<BmpDecoder>();
            Decoders.AddDecoder<GifDecoder>();
        }

        private void Button_Click(object sender, RoutedEventArgs e)
        {
            OpenFileDialog ofd = new OpenFileDialog();
            if (ofd.ShowDialog() == true)
            {
                // because decoders are taken care of, 
                // load images as needed!
                ImageTools.Image i = new ImageTools.Image();
                using(FileStream fs = ofd.File.OpenRead()){
			// note: myImage is ImageTools.Controls.AnimatedImage
			i.SetSource(fs);
	                myImage.Source = i;
		}
            }
            
        }
    }

It's a bummer when support for things, like well known file formats like GIF are not supported via a more arbitrary decision making process but the consolation is that it’s an opportunity for people make up for it in the community. ImageTools is a great library, every Silverlight developer should check it out.

}

Library Of The Week: Json.NET

{

In the Christian Bible there’s a story of 10 lepers miraculously healed by Jesus. Even if you don’t believe in Christianity, imagine a leper living in the dregs of society, totally dejected until one day a man shows up and heals him and nine other fellow outcasts. Imagine how happy they should be.

They’d say thank you, right?

In the Bible story, only one of the men returns to say thank you and the other nine are so busy getting back to the lives they wished they had that they forget about the reason they were healed in the first place.

There’s evidence of this kind of lack of gratitude in the ecosystem of free libraries and projects available for .NET developers on the web. I’m a part of that club and not proud of it. I use open source .NET libraries on a regular basis and don’t say thank you. But more than just me, I look at the community participation on CodePlex projects and find it amazing how few people say a simple “thank you.”

With that in mind, I’m going to start profiling libraries that I’ve used with success to build up awareness of their existence and hopefully inspire the people who write them to do more good work since what they do is so tremendously helpful.

The first library I want to profile is the Json.NET library available from CodePlex. It contains a great, intuitive Json serialization/deserialization library. You can point to most serializable objects and convert them to a JSON format with such simple sleight of hand as:

	List<Foo> data = new List<Foo>();
	// adds to data
	string json = JsonConvert.Serialize(data);

As if that wasn’t simple, retrieving values from their serialized format is also made trivial:

	string jsonItems = GetYourJSON();
	List<Foo> data = JsonConvert.DeserializeObject<List<Foo>>(jsonItems);	

One great differentiator of Silverlight versus existing web technologies is the ability to have a virtual file system on a client computer. While HTML 5 seems to include facilities for this it is not yet built into existing browsers and even when it is, previous track records on “standards” are a precedent for how balkanized the implementation of them can be. In many areas of web development, you can push the envelope of existing technologies to get what you do out of Silverlight, but the existence of Isolated Storage is a killer feature.

Give Json.NET a try whether you’re doing Silverlight or using a different .NET related paradigm. It’s a great library.

}

Exception HOF Pattern in C#

{

There’s probably a name for this specific approach but in a personal project of late I’ve found a useful pattern for generalizing my exception handling. I write a ExceptionHelper class that takes a variety of high order function style methods to handle my exceptions in a single spot. Here is a somewhat simple form of what I've been doing:

    public class ExceptionHelper
    {

        public static void ExecuteWithSuppress(Action code)
        {
            try
            {
                code();
            }
            catch (Exception ex)
            {
                // pass and ignore the exception
            }
        }

        public static void ExecuteWithHandler(Action code)
        {
            try
            {
                code();
            }
            catch (Exception ex)
            {
                Console.WriteLine("An exception occured! Details: \n" + ex.ToString());
            }
        }

        public static void ExecuteWithHandler(Action code, string errorMessage)
        {
            try
            {
                code();
            }
            catch (Exception ex)
            {
                Console.WriteLine((errorMessage.Length > 0) ? errorMessage : ex.ToString());
            }
        }

        public static void ExecuteWithHandler(Action code, Action onError)
        {
            try
            {
                code();
            }
            catch (Exception ex)
            {
                if (onError != null)
                {
                    onError();
                }
            }
        }

        public static void ExecuteWithHandler(Action code, Action onError, string errorMessage)
        {
            try
            {
                code();
            }
            catch (Exception ex)
            {
                Console.WriteLine((errorMessage.Length > 0) ? errorMessage : ex.ToString());
                if (onError != null)
                {
                    onError();
                }
            }
        }

        public static bool ExecuteWithNotificationButIgnore(Action code)
        {
            bool ret = true;
            try
            {
                code();
            }
            catch (Exception ex)
            {
                ret = false;
            }
            return ret;
        }

        public static void ExecuteWithLogging<T>(Action code) {
            try
            {
                code();
            }
            catch (Exception ex)
            {
                if (ex is T) {
                    Console.WriteLine("Logging exception " + ex.ToString());
                }
            }
        }

        public static void ExecuteWithLogging(Action code, Action<Exception> handles) {
            try
            {
                code();
            }
            catch (Exception ex)
            {
                handles(ex);
            }
        }

    }

At this point I use it in a lot of places, here are a few scenarios:

ExecuteWithSuppress(Action code) – code that has a low impact of failure or an expected failure under some conditions. For example, a client of mine once had a legacy database they wanted to me parse a “name” field from. We set up basic heuristics to separate out first and last and so on, but on failure we just returned a blank string.

ExecuteWithHandler(Action code) – you have some generalized exception handling to do something: prompt the user, do logging, etc. ExecuteWithHandler(Action code, Action handler) – you get to pass in the exception handling you want


ExecuteWithHandler(Action code, string errorMessage) – pass a custom error message


ExecuteWithNotificationButIngore(Action code) – try to execute some code but return a boolean to indicate success


ExecuteWithLogging<T>(Action code) – run some code, indicate the types of exceptions to differentiate


ExecuteWithLogging(Action code, Action<Exception> handles) – pass a method to catch be passed the exception that occurs.

The resulting code I write with this pattern, I find pleasant. Here are some examples:

    string userName = String.Empty;
    ErrorHelper.ExecuteWithSuppress(() => userName = doc.Descendants("Name").First().Value);
    return userName;

if (ErrorHelper.ExecuteWithNotificationButIgnore(() =>
{
	SendEmail();
}
else
{
	// message not delivered, etc, etc.
}

I want it to be absolutely clear that this is not a replacement for try/catch/finally logic where it is warranted. It is simply an alternative that can help to keep code clear and readable. As with many things in software, there is taste involved in when and where something like this is leveraged. But it works well enough for me that I thought I’d share.

}

FizzBuzz Functional

{

I’ve been reading Tomas Petricek and John Skeet’s Functional Programming for the Real World. I’m hoping I can, as Steve McConnel says, program into¹ my C# projects some elements of functional problem solving. As I was working to grok the beginning portions of the book I thought I’d rewrite FizzBuzz since I’ve aleady posted a few versions of a solution. Here is my solution:

Func<int, int[], bool> isMultiple = (n, n2) => n2.Any(m => n % m == 0);
Func<int, int, string, string> fb = (n, n2, s) => (n % n2 == 0) ? s : String.Empty;


foreach(var i in Enumerable
                    .Range(1, 100)
                    .Select(n =>(isMultiple(n, new int[]{3,5}))
                                    ?fb(n, 3, "Fizz") + fb(n, 5, "Buzz")
                                    :fb(n, n, n.ToString())
    )Console.WriteLine(i);

Another version, using ForEach on a List<T>:

Func<int, int[], bool> isMultiple = (n, n2) => n2.Any(m => n % m == 0);
Func<int, int, string, string> fb = (n, n2, s) => (n % n2 == 0) ? s : String.Empty;

Enumerable
        .Range(1, 100)
        .Select(n => (isMultiple(n, new int[] { 3, 5 }))
                        ? fb(n, 3, "Fizz") + fb(n, 5, "Buzz")
                        : fb(n, n, n.ToString()))
        .ToList()
        .ForEach(num => Console.WriteLine(num));

I'm just starting to wade into using F# but I'm hoping to start building my proficiency the further I get into the book

¹"Don't limit your programming thinking only to the concepts that are supported automatically by your language. The best programmers think of what they want to do, and then they assess how to accomplish their objectives with the programming tools at their disposal." – Steve McConnell, Code Complete 2nd Edition

}

UI Inspiration for Silverlight’s Blank Slate

{

I’ll admit that I spent an inordinate amount of time last week thinking about dialog boxes. Silvelright’s canned prompt comes courtesy of a call to MessageBox.Show which displays the browser’s native modal dialog. I think you get the same thing from HtmlPage.Window.Alert too. Needless to say, these should leave you wanting.

A good place to start, rather than wasting the better part of a day playing around like me, is to begin with a really good convention rather than making something “original.”

So without further ado, I’m linking to a nice PSD courtesy of teehan+lax that contains visual styles for many of the iPhone’s UI Elements. I’ll have to build a nice workflow to get things like this into XAML.

 

One more philosophical note (noted below so that if you just needed the link you won’t be daunted by my long windedness) – almost 100 episodes ago the Hanselminutes podcast featured Scott interviewing David Heinemeier Hansson and Martin Fowler at RailsConf 2007. When talking about UI design and originality here is what DHH had to say:

“I think the low level of
expressiveness that we have in HTML and CSS
and JavaScript is actually a huge boon to most
applications that constraints are a good thing,
that constraints leads to better applications when
we don’t need to reinvent everything. When you
just have blank canvas where you can paint
whatever you want on it, you pretty much end up
with something “original” every time; and I don’t
think originality in UI design is necessarily a good
thing; I just think actually most of the time it's a
bad thing.”

I agree with DHH on this point. It’s worth listening to the entire podcast to put some context to his comments. Where my opinion veers from his or at least my hope for Silverlight is that conventions more powerful than those of HTML/CSS/JavaScript begin to come together for developers and they spend less time thinking about a blank slate and more about how their application works with the benefit of a better experience. Themes are a good step in this direction but things like dialogs go beyond to interactions as opposed to just colors and gradients.

}

Why IE6 Continues To Ruin My Life

{

Via a good friend, this post confirms that many of us are in the same situation: corporate IT people force users to stay in IE6 which forces, in turn, all of us developers to suffer by having to support it. The post, written from an inside Digg perspective doesn't tell the whole story so I’d like to add one dimension. Many corporate environments are in this unfortunate cycle based on the inability to project abstract costs, that is to say that often (always?) software is rushed through and “finished” in an agile, YAGNI kind of way, and after the fact managers¹ have a hard time capturing the costs it takes to support legacy browsers because of “finished” software. The two development efforts are seen as separate, so the extra time in new development doesn’t factor into the decision to keep what is old.

Cheers for Virtual PC and the ability to test things out without having it installed locally but nevertheless I’d like to force everyone to upgrade and forget that browser ever existed.

Side note, if you are fortunate enough to force an upgrade, here is some help.

¹I’m sure special kinds of managers are able to guess this in and make good decisions but they are a rare breed and the elixir they drink is hard to find.

}

Proper 0.2: INotify, DependencyProperty Support

{

Several years ago, in a land of Visual Studio 2005 and no CodeRush, I made a tool called Proper to automate the monotony of creating properties. You just type something like “int Foo;string Bar;” and you’d get basic property generation. You can use shortcuts to types by typing an undercore “_” character. For example, “i_” will pop up int, “dt_” would pop up DateTime (You can also create your own). It’s funny how the stuff that you’re half serious about can last so long – at the time I wanted to write something useful entirely in JavaScript and to experiment a little with JQuery.

The tool suffered neglect for the next few years until recently when I began working with Silverlight and was amazed at how a similar monotony (and more code!) accompanies using INotifyPropertyChanged and implementing dependency properties. I remembered my old tool and added support for generating them there. Here are some screenshots that should illustrate how it works (you select “advanced options” and then select a few checkboxes, in a nutshell). I’ll update the feature to report bugs – I’m sure there are a few. I also neglected to update it for VB.NET – I’ll do that over the next few weeks.

If you do spot a bug, let me know. There are a few new goals I have with the tool, the first of which is refactoring some of the embarrassing JavaScript I crufted together to make this work. I remember Kevin Dangoor talking about Embarrassment Driven Development (when your code is so embarrassing that you’re motivated to update it); that’s the one thing about JavaScript – you can’t hide the way things are constructed. :)

}

Using IronPython For Converters in Silverlight

{

 

Tim Heuer has a great intro post on Silverlight data binding and value converters. The concept is a really nice one but I’m not wild about having to write a class that implements the IValueConverter interface every time I need some ad-hoc tweaking of the values I get from being data bound and how I’d like to use them within XAML. What set me off this track was a case where I simply needed to invert a boolean – what should just be “not myvalue” ended up requiring a class, an interface, and so on.

Dynamic languages excel at this sort of thing and since they support the ability to evaluate code on the fly I thought it would make sense to write a single implementation of IValueConverter and host Python inside of it to evaluate binding expressions that are passed in. Here is what that might look like:

public class PythonExpConverter : IValueConverter
    {
        private ScriptEngine _engine;

        public PythonExpConverter()
        {
	   
            ScriptRuntimeSetup setup = Python.CreateRuntimeSetup(null);
            setup.DebugMode = true;
            var runtime = new ScriptRuntime(setup);
            _engine = Python.GetEngine(runtime);
 	    
        }

        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            object result;
            string python = parameter.ToString()
                                .Replace("value", value.ToString());
            try
            {
                result = _engine.Execute(python);
            }
            catch (Exception ex)
            {
                // pass, just use original value
                result = value;
            }
            return result;
        }

        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        {
            // same concept as above
            return value;
        }
    }

No magic, just instantiate the Python runtime and then proceed to leverage it in the Convert phase by taking a string as the parameter for the conversion method. Use value as a keyword in your Python expression to get at the value of the underlying data.  Once this is added as a static resource, you can leverage it in many ways. For example, if I had a class “Person”:

public class Person
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public bool OnVacation { get; set; }
        public double Balance { get; set; }
    }

Let’s say I’m binding to an instance of Person (yeah, very contrived) with the following template conversions:

1. Uppercase last name.


2. If OnVacation is true, disable a link to their schedule.


3. Format balance using some currency specific format.


Here is the XAML that leverages my single converter for all of the above:

<StackPanel Orientation="Vertical">
            <StackPanel Orientation="Horizontal">
                <TextBlock Text="First Name" Width="100" />
                <TextBlock Text="Last Name" Width="100" />
                <TextBlock Text="Is Active" Width="100" />
                <TextBlock Text="Rating" Width="100" />
            </StackPanel>
            <StackPanel Orientation="Horizontal">
                <TextBlock Text="{Binding FirstName}" Width="100" />
                <TextBlock Text="{Binding LastName, Converter={StaticResource PythonExpConverter}, ConverterParameter=\'value\'.upper()}" Width="100" />
                <HyperlinkButton Width="100" NavigateUri="http://foo" Content="View" 
                        IsEnabled="{Binding OnVacation, Converter={StaticResource PythonExpConverter}, ConverterParameter=not value}" />
                <TextBlock Text="{Binding Balance, Converter={StaticResource PythonExpConverter}, ConverterParameter=\'%2.2f\' % value}" Width="100" />
            </StackPanel>
        </StackPanel>

This is a very powerful approach since the limitations you hit will probably be born by a limitation in skill with Python or your dynamic language of choice rather than the approach. 

}

Almost Famous

{

Yours truly, looking embarrassed in the middle.

 

Here is the link to Phil's write up.

}

Voidspace on Dot Net Rocks

{

Michael Foord, aka Voidspace, is on a Dot Net Rocks episode talking about IronPython.

}

Currying with C# and Algotron

{

Friend and coworker Algotron just posted an intro and sample of currying with C#. I decided to try out currying with the idea of successive regular expressions on a string array - I found it easy to approach first with anonymous delegate syntax and then use lambda expressions. Once this was in place it was easy to understand the use of an extension method to curry any binary function. 

Func<string, string[], Func<string, string[]>> fil = 
delegate(string pattern, string[] lines){
    return delegate(string pattern2)
    {
	return lines
		    .Where(p=> Regex.IsMatch(p, pattern))
		    .Where(p => Regex.IsMatch(p, pattern2))
		    .ToArray();
    };
};


Func<string, string[], Func<string, string[]>> regFil = 
				(pattern, input) => 
				    (pattern2) => 
					input
					    .Where(p => Regex.IsMatch(p, pattern))
					    .Where(p => Regex.IsMatch(p, pattern2))
					    .ToArray();
					    
// assume some address data
string[] data = new string[]{"1234 Somewhere", "this", "777 dakota"};

var filterNumeric = regFil(@"\d", data); // make sure it has a number
var filterUCase = filterNumeric("[A-Z]"); // make sure it has an uppercase character

Console.Write(String.Join(",", filterUCase));					    

That's cool stuff, worth looking at for a while to try to understand.

}

IronPython + SilverlightFX

{

SilverlightFX is an interesting library for declaratively attaching behaviors to objects in XAML. People new to the Silverlight world will like how they can use it to get simple animations out of simple code. Here's a step by step:

1. If you don't have it done already, set up an IronPython / Silverlight project.

2. Download SilverlightFX

3. Copy SilverlightFX binaries into your /app directory.

3. Edit the AppManifest.xaml to include the SilverlightFX binaries. Here is an example:

<Deployment xmlns="http://schemas.microsoft.com/client/2007/deployment" 
	xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
	RuntimeVersion="2.0.31005.00" 
	EntryPointAssembly="Microsoft.Scripting.Silverlight" 
	EntryPointType="Microsoft.Scripting.Silverlight.DynamicApplication">
  <Deployment.Parts>
    <!-- Add additional assemblies here -->
    <AssemblyPart Source="Microsoft.Scripting.ExtensionAttribute.dll" />
    <AssemblyPart Source="Microsoft.Scripting.Silverlight.dll" />
    <AssemblyPart Source="Microsoft.Scripting.Core.dll" />
    <AssemblyPart Source="Microsoft.Scripting.dll" />
    <AssemblyPart Source="IronPython.dll" />
    <AssemblyPart Source="IronPython.Modules.dll" />
    <AssemblyPart Source="System.Windows.Controls.dll" />
    <AssemblyPart Source="System.Windows.Controls.Data.dll" />
    <AssemblyPart Source="Silverlight.FX.dll" />
  </Deployment.Parts>
</Deployment>

4. Edit your app.xaml file to include references to the SilverlightFX namespaces. Here is an example:

<UserControl
	xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
	xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
	x:Class="System.Windows.Controls.UserControl"
	xmlns:fxui="clr-namespace:Silverlight.FX.UserInterface;assembly=Silverlight.FX"
   	xmlns:fxeffects="clr-namespace:Silverlight.FX.UserInterface.Effects;assembly=Silverlight.FX"	
	>

5. Party on with some declarative effects.

<Border Grid.Row="1" x:Name="redRect" Opacity="0.2">
	<TextBlock x:Name="outPut" TextWrapping="Wrap" 
		Text="Lorem ipsum dolor sit amet,..."  />
    <fxui:Interaction.Behaviors>
    <fxui:HoverEffect>
      <fxeffects:Fade FadeOpacity="1" />
    </fxui:HoverEffect>
    </fxui:Interaction.Behaviors>
</Border>

6. Read Nikhil's related blog entries.

}

DLR + IronPython + Silverlight in 5 Steps (with pictures)

{

A simple step by step¹.

1. Download the Silverlight DLR SDK

2. Map the binaries (the folder with Chiron² et. al.)  in your PATH Environment variable.

3. Download this starter template.

4. Run chiron /w from the command line in the directory of the starter.



a) Make sure you're in the correct folder
b) The command is chiron /w
c) You'll get a message that Chiron is serving at http://localhost:2060a

5. Navigate to http://localhost:2060 and hit index.html to see what's up.

 
The starter³ should make it easy to get up and running. Open the app.py and app.xaml files and you will be able to modify the xaml and write code to customize it into your own creation.

1. Michael Foord aka Voidspace is the guy when it comes to IronPython. He wrote a book on it. He has a "getting started" tutorial that is much more extensive if you want more details. His tutorial isn't as terse so I thought I'd write this one for people who just want a step by step before poking around. There are other people like JimmyThinking who offer a lot of help to beginners but lean towards IronRuby.

2. The name Chiron for a tool makes me think about a few things: first, being born out of time since most BigCo shops today name computers and tools in a hollow, mechanistic fashion. In the salad days of computing on Unix, tools had cool names like ed or yacc. The second thing I think is that Dmitri (and I'm sure there's an "et. al.") must be a cool, interdisciplinary fellow to come up with a name like that.

3. The exchange in the sample is from Swahili classes at Rusinga Primary School in Nairobi.

}

nRegex 9

{

I've been getting up to speed with Silverlight and decided to rewrite nRegex to leverage it as a client side processor for what the original nRegex shipped to the server with AJAX calls.  In the original nRegex this worked fine until you had to deal with large documents but once you were in the large document space things began to go awry. My solution was to allow for a "manual" evalution of the regular expression (rather than a time interval based evaluation) but I'm hoping that Silverlight will prove an elegant solution since not only can it harness the power of the client but it also has features to run code asynchronously.

In my first iteration I leveraged a lot of the JavaScript interop for the Silverlight control and avoided XAML for display. I think in the next iteration I'm going to spend more time on displaying results via XAML.

Feel free to present any comment or suggestion on nRegex and its direction.

}

DDD

{

Not to be confused with D&D... Domain Driven Design for those of us who don't keep up with all the acronyms.

I'm seeing this more and more in places I lurk. DDD is the next buzz like Agile?

Next steps: relisten to Hanselminutes, ALT.NET Podcast, lurk on DDD site, and pay more attention on the ALT.NET mailing list.

}

Which is better, IronPython or F#?

{

Both.

}

Lazy Coder On Point

{

SOA is Dead?

}

Another "Dead Java" Proclamation

{

I was browsing to Elliote Rusty Harold's blog to see if he had any predictions for XML in 2009 and to my surprise I found his post: "Java is Dead. Long Live Python!"

My familiarity with Harold comes from a time in my life where I worked heavily with XML and later Java and it was his books on both subjects that proved invaluable when I hit my rather frequent roadblocks.  As invested as he is in Java, what would make him say as much? In a nutshell, it's the way the language has been implemented over the last few years - claims which, even if you don't agree with the premise that Java is "dead like COBOL", are worth some attention.

What is interesting to me about Java right now is not the language itself but dynamic languages and their platforms built on top of the JVM. JRuby is what comes to mind first and I'm recently interested in what a JRuby/Glassfish world looks and feels like.

}