MetaDeveloper

NDC 2011

2011-06-20T05:25:00.001-07:00

{

It may be easy to miss amidst all the hoopla around Windows 8 but the Norwegian Developers Conference just released all their session vidoes on the site.

It’s been a while since I’ve gotten to go to a conference but the last few I have attended were put on by Microsoft. Although this has advantages in the sense that it coalesces the “experts” of specific Microsoft technologies, many of the presenters work at Microsoft and therefore don’t have a similar problem set that you or I might slogging our way through building products, often with older (read: more “boring”) software. There are also some talks on development techniques like BDD and DDD that are not product specific.

The good thing about NDC is that it seems a lot of the presenters come from an outside perspective so it’s a good balance for a lot of the MIX / PDC type stuff I’ve been watching of late. Without further ado:

Direct Download from NDC website: Day 1 | Day 2 | Day 3

Roy Osherove’s “unofficial” torrent

}

Search, Match, Replace, Generate

2011-06-15T21:56:00.001-07:00

{

Many moons ago I got about 0.25 seconds of fame when nRegex, a tool I wrote for evaluating regular expressions of the .NET flavor, got a bit of acclaim. It was one of the better days of my life, an encouragement that sometimes struggling alone in a South Dakota basement can lead to a little bit of notice.

One of the tricks that keeps me going back to nRegex is being able to generate code by using a regular expressions. Regular Expressions, though often reviled, turn out to be quite handy in a lot of situations.

Let’s say you have a table that looks like this:

	CREATE TABLE PackingList(
		PackingListId	INT IDENTITY PRIMARY KEY, 
		PackingItem		VARCHAR(50), 
		Destination		VARCHAR(50)
	)
	GO

Let’s say you have a list of values:

Shoes
Camera
Laptop
Wallet

The list is short for brevity but let's say you want to insert them all into your table for a destination called //Build/. You know the syntax for an INSERT but it's a bit of a nuisance to type over and over again. One thing you can do is to use a regular expression to match and then reference the results of your match in a replace. Over on nRegex, we'd paste in our list of items into the main text area and then use the regular expression (.+) to match each item, line by line. Because the items are matched into a group with your parenthesis, you can now write something like the following for your replace:

INSERT INTO PackingList VALUES('$1', '//Build/')

And voila! You now just have to copy the results:

INSERT INTO PackingList VALUES('Shoes', '//Build/')
INSERT INTO PackingList VALUES('Camera', '//Build/')
INSERT INTO PackingList VALUES('Laptop', '//Build/')
INSERT INTO PackingList VALUES('Wallet', '//Build/')

But that's just a tip of the iceberg. There's a lot more nifty regular expressions tricks for working with code. Here's another one I run into quite often. Let's say I have some code that looks like this:

  rs["foo"] = myFoo;
  rs["bar"] = myBar;

I want to swap what's on either side of the equals sign to do the opposite type of assignment. Here's my regular expression:

(.+)\s=\s(.+);

And my replacement expression

$2 = $1;

Et voila aussi! You can now copy the swapped values to wherever they need to go.

One final thing: any place that offers you regular expressions you can use these techniques. There are some subtle differences but as long as you have a conceptual understanding of what your goal is it's quite easy to bend to the flavor of regular expressions presented. For example, if you are using Notepad++ and want to accomplish the same thing, you reference your groups with a leading backslash rather than the "$" character - in our first example you would use the following:

INSERT INTO PackingList VALUES('\1', '//Build/')

This is, of course, just scratching the surface. It’s not that hard though! Once you learn the meaning of things like ^ or $ then you can manipulate strings in all sorts of ways that may have once not seemed possible. The best way to learn regular expressions hasn’t changed for many years. The two canonical books I always refer to are Mastering Regular Expressions by Jeffrey Friedl and the Regular Expressions Cookbook by Goyvaerts and Levithan.

Although nRegex will allow you to hobble by I also recommend RegexBuddy. Rexv (which inspired nRegex) is a good tool though the Regular Expression engine is not .NET.

Last thing: do you have any nifty regex to code generation tricks you use on a regular basis? The audience of one you have in this space would love to learn them.

}

On Features

2011-06-14T22:05:00.001-07:00

{

“More features isn’t [sic] better. More features is unfocused. More features means you’ll do them worse. More features means you probably don’t have any differentiation. If you’re doing a startup, you should have less [sic] features than your competitors. If you have more features, you’re probably doing it wrong.”

Nugget from Peter Van Dijck. So the question is: when do you add a new feature? Joel Spolsky (who has written about most interesting things already, way back in the day (although it would be interesting to hear if things are still done the same in the present day FogCreek) ) wrote about how they decided on new features by prioritizing and voting as a group.

As a developer of one I’m interested in techniques on deciding what to put on a roadmap and how to prioritize features. Any insight?

}

Closures, Anonymous: JavaScript influenced C#

2011-06-13T06:12:00.001-07:00

{

I’ve taken knocks in the past because of my penchant for closures and lambdas. Syntactically they never looked that strange to me and most of the time when I used them it was because it made more sense to get a sense of the flow of how things were assigned. I thought: this feels so natural, what makes it so different from some of the people I’m around using C#? Here’s an example of how I’d approach something: in the constructor, assign a loading handler, in that handler, assign a click handler, and rather than putting it in some separate method where I’d have to scroll or look elsewhere, just place it here:

        public MainPage()
        {
            InitializeComponent();

            this.Loaded += (o, e) => 
            {
                myButton.Click += (_, e2) =>
                {
                    myText.Text = "Hello World";
                };
            };
        }

But then the other day I was tinkering with KnockoutJS, writing some Javascript with jquery and it dawned on my why I approach things the way I do.

        $(document).ready(function () {
            $('#myButton').click(function () {
                $('#myLabel').text('Hello World');
            });
        });

It's always interesting to make that connection more formally than trying to explain why my approach would be “better.” The advantage of being able to use a closure with the above approach has always been the main rational I’ve given when forced to come up with an answer.

}

Getting Random Rows, Random Numbers with Sql Server

2011-06-10T06:05:00.001-07:00

{

The 5 second version of this, should you arrive via search, is that to get random rows, simply use an TOP query with ORDER BY NewId() expression. It’s really that simple! Take a look:

-- SAMPLE TABLE
CREATE TABLE Keywords(
	KeywordId INT IDENTITY(1,1) PRIMARY KEY, 
	KeywordValue VARCHAR(50)
)
GO

-- SAMPLE DATA
DECLARE @N INT
SET @N = 1
WHILE @N < 101 BEGIN
	INSERT INTO Keywords(KeywordValue)
		VALUES('key word ' + CONVERT(VARCHAR(5), @N))
	SET @N = @N + 1
END

-- A TOP QUERY WITH ORDER BY NEWID()
SELECT TOP 5 * FROM Keywords ORDER BY NEWID()

The longer version of this is that I recently was asked to generate random keywords for a website I was working on with a lookup table. Getting random numbers in TSQL is easy, the RAND() function does all the magic but getting rows is a lot more tricky, especially if you want to make sure you exclude anything you’ve previously retrieved. The above technique worked quite well and made it easy to allow for them to add and remove keywords on demand.

One interesting application of this is that you can combine it with RAND() to get random numbers via multiplier and random rows (RAND gets a random between 0 and 1 leaving you the responsibility to multiply it to control the range you want).

Here is where I thought this could be taken as a flexible way to get random numbers within a bounded range:

-- get a series of random numbers
SELECT TOP 5 Rand() * KeywordId FROM Keywords ORDER BY NEWID()

There’s a lot of flexibility but SQL Server makes it trivial.

}

Silverlight Is Dead…

2011-06-08T21:59:00.001-07:00

{

… a title which I hope brings massive attention to this blog and to this rant against those that are rabid in their attacks on Microsoft and the Silverlight platform.

First and foremost: Silverlight 5 has yet to be released. How can the platform be “dead” if we’re on the verge of a new version?

Secondly: Spend some time listening to MVPs and Microsoft people. Even though there is this awkward gag order until //Build/ it seems quite obvious that the platform will continue to be a viable option for developers.

Third: HTML5 is no panacea. Spend a few days looking into the different specifications and the varied support by browsers and platforms. It will become obvious that the W3C is being true to their word when they say it won’t be “finished” for a while.

Fourth: Grow Up. Yes you’ve made this enormous investment in Silverlight or WPF. I have too; the last 3 years of my life have been in the trenches and my employer took a calculated risk to do a significant amount of work in Silverlight. Does that mean that every rumor should shake you to the very foundation and cause emotional outbursts at being abandoned? Stay the course. When you have real information from Microsoft directly then you can have your break down if it’s not what you expected. I don’t consider my time wasted no matter what the case. I can take my knowledge of MVVM elsewhere. I know a lot more than I used to about asynchronous programming.

Fifth: Let’s just say it’s true. Does it still warrant all that drama? You’ll be fine. People are dying in wars, unrest, and natural disasters all over the place but guess what? If you’re a Silverlight Dev and They all of a sudden remove the Silverlight Project Template from your Visual Studio and run a secret binary on your local machine to destroy the plugin removing all evidence of its existence globally you’ll still be alive. You’ll still dust off your trousers and either port your work or begin new and fanciful things in a platform that you find available.

Sixth: Try to make a distinction between people who are vocal versus people who are actually building software. I’m aware of a project right now where I work that makes heavy use of COM. Yeah that “not dead but done” COM. People who build things usually have their heads down creating value. I know there are a lot of talking heads online, especially talkers unsympathetic to the “evil” b0rg in Redmond, but there’s a lot of noise for very little signal. It’s cool that people get passionate (I’m being passionate myself now too) but sometimes it’s a good thing to take a step back and survey the landscape of what is real and what is bluster.

I’ve already admitted I could be wrong. But as significant a decision Microsoft has potential to make, my approach is to take it in stride, try to learn as much as I can and be flexible since in the tech world, no matter who you are, change is inevitable. For some of us change, with all the concomitant turbulence, is fun.

}

Happy pi day!

2011-03-14T21:29:00.001-07:00

{

class Program
{

       static double PI(int i, int limit)
       {
               return (i > limit)? 1 : (1 + i / (2.0 * i + 1) * PI(i + 1, limit));
       }

       static void Main(string[] args)
       {
               double pi = 2 * PI(1, 2011);
               Console.WriteLine(pi);
               Console.WriteLine("Happy pi day!");
               Console.ReadLine();
       }
}

}

Primes, Sums of Primes, 2011 in C#

2011-01-29T19:07:00.001-08:00

{

I had no idea:

2011 = 157 + 163 + 167 + 173 + 179 + 181 + 191 + 193 + 197 + 199 + 211

After learning that not only was 2011 was prime, but that it was the sum of consecutive primes, I sought to write some C# code that would demonstrate this. I wrote it in a functional style, meaning at some point to port it to F# – you'll recognize my in a forthcoming post on computing primes with F# which is actually an implementation of the algorithm I first worked through in the below C#.

Func<long[], IEnumerable<KeyValuePair<long, string>>> GenerateConsecutivePrimeSums = (primes) =>
{
	List<KeyValuePair<long, string>> primeSums = new List<KeyValuePair<long, string>>();
	for (int i = 0; i < primes.Count(); i++) 
	{
		List<string> operands = new List<string>();
		long primeSum = primes[i];
		operands.Add(primeSum.ToString());
		for (int j = i + 1; j < primes.Count(); j++) 
		{
			primeSum += primes[j];
			operands.Add(primes[j].ToString());
			if (!primeSums.Any(ps => ps.Key == primeSum) && primes.Contains(primeSum))
			{
				primeSums.Add(new KeyValuePair<long, string>(primeSum, String.Join(" + ", operands.ToArray())));
			}
		}                
	}

	return primeSums;
};

Action primesAndSums = () => { 
	// generate primes up to 2020
	var primes = GeneratePrimes(2020);
	// generate arrays of consecutive primes that add up to prime
	var primesSummed = GenerateConsecutivePrimeSums(primes.OrderBy(a => a).ToArray());
	// go through the summed primes (dictionary of prime as key, added numbers as value)
	// Console.WriteLine formatted results
	primesSummed
		.OrderBy(ps => ps.Key)
		.ToList()
		.ForEach(ps => Console.WriteLine(ps.Key + " = " + ps.Value));
};

primesAndSums();

The code actually calculates sums of the primes it generates, click here for all the other primes which are sums of consecutive primes up to 2020:

}

Interesting Data Points From How Facebook Ships Code

2011-01-24T21:57:00.001-08:00

{

I ran across this blog entry which is an unofficial attempt by somoene to glean the internal workings of Facebook’s product and software development processes. There are some very interesting things to be noted, most of which I’ll just quote from the article directly:

“resourcing for projects is purely voluntary”

It’s interesting from this unofficial post that project dynamics are organic and based on what engineers want to work on. It begs the question of how the more difficult and less pleasing problems are solved but I would hedge that by having people who are talented and motivated, difficult and more grimy problems might be what attract people that are always seeking challenges. Indeed, from later in the article: “engineers generally want to work on infrastructure, scalability and “hard problems” — that’s where all the prestige is.”.

“Engineers handle entire feature themselves — front end javascript, backend database code, and everything in between. If they want help from a Designer (there are a limited staff of dedicated designers available), they need to get a Designer interested enough in their project to take it on. Same for Architect help. But in general, expectation is that engineers will handle everything they need themselves.”

This is one of the more fascinating points because it reflects one side of an approach to programming that I’ve encountered: that delivering some functionality is a process of ownership where a person generalizes across disciplines and technologies. The opposing viewpoint sees programming more in terms of division of labor with staff assigned to “tiers” of the technological back end: database developers, “business layer” or component programmers, user interface and so on. I always think of sports with this dichotomy where the former thinks of software development like basketball – a game that involves some specialization but really rewards the generalist who can play any role on a team, and football – a game of specialists where it’s a liability to do too many things since even the physique is developed on a per position basis.

Many people acknowledge generalists for small organization but it appears that Facebook, a company as large as they come, prefers them.

“engineers responsible for testing, bug fixes, and post-launch maintenance of their own work. there are some unit-testing and integration-testing frameworks available, but only sporadically used.”

There are a few edits and comments to this point but the reason I find it interesting is that they are a corollary to the views that Joel Spolsky expressed on the StackOverflow podcast. Many developers, myself included, berate ourselves on a lack of unit testing with the assumption that “everyone is doing it, why can’t I?” As time passes, however, I realize that TDD and Unit Testing are very important but not essential. It’s a very unpopular opinion and while I admit that I strive to make my code testable and, especially on personal projects where I have enough control, architect my software so that it’s testable from the get-go.

}

Learning F# with FizzBuzz: Match

2011-01-22T21:40:00.001-08:00

{

I had previously done a solution for FizzBuzz in F# (from a long time ago) but now that I’m more familiar with the idioms of F# I tend more towards pattern matching instead of if/else logic for quite a few scenarios. Here is an example of my rewriting what could otherwise been a conditional if/else checking for factors of 3 and 5, but using a pattern match instead.

#light 
let fizz num = 
    match (num % 3 = 0) with 
    | true -> "fizz"
    | false -> ""

let buzz num = 
    match (num % 5 = 0) with 
    | true -> "buzz"
    | false -> ""

let outform num fizCalc = 
    match fizCalc.ToString().Length = 0 with
    | true -> num.ToString()
    | false -> fizCalc

let rec printer nums =
    match nums with
    | [] -> printfn "-"
    | h::t ->         
        printfn "%s" (outform h ((fizz h) + (buzz h)))
        printer t

let numbers = [1..100]
printer numbers

Although I read claims that if/else conditional operations are more readable, I think the pattern match used consistently across scenarios above makes for something I find quite readable.

}

On Leadership

2011-01-20T22:08:00.001-08:00

{

“If you want to build a ship, don’t drum up people to gather wood, divide the work, and give them orders. Instead, teach them to yearn for the vast and endless sea”

- Antoine De Saint-Exupery, author of "The Little Prince"

Originally posted on Chris Sells’s blog but worth some thought.

}

Download .NET Source Code

2011-01-19T20:53:00.001-08:00

{

I’ve been having a problem that warrants looking at the source which can be downloaded right here.

}

Learning F# with FizzBuzz

2011-01-19T05:53:00.001-08:00

{

Eons ago I'd posted on how I’d rewritten how I would solve FizzBuzz to have a more functional style (here is an imperative version), inspired by Tomas Petricek and John Skeet’s Functional Programming for the Real World. Shortly thereafter I had written a version in F#, I’m not sure what prevented me from posting it but here it is:

let numbers = [1..100]
let fizz num = 
    let res = if (num % 3 = 0) then "fizz" else ""
    res

let buzz num = 
    let res = if (num % 5 = 0) then "buzz" else ""
    res

let outform num fizCalc = 
    let res = if(fizCalc.ToString().Length > 0) then fizCalc.ToString() else num.ToString()
    res

let rec printer nums =
    match nums with
    | [] -> printfn "-"
    | h::t ->         
        printfn "%s" (outform h ((fizz h) + (buzz h)))
        printer t

printer numbers

I can already see now areas that are still influenced by the C# - most notably the use of if rather than using match for everything. I will clean it up, hopefully demonstrating an increased facility with F#. If you are looking at the above and know F#, what are some idioms or language constructs that I am neglecting in the above code? Type annotations for one... what else?

}

Information Diet Planning – Newsletters

2011-01-02T11:55:00.001-08:00

{

Given the amount of information that is out there it’s difficult to throttle back and actually digest it. A quick look at any web page will set that context; hit StackOverflow and you’ve got several dozens of links to follow, each a rabbit hole on its own. The same can be said for Hacker News, Channel 9, and just about every other popular developer site that is out there.

What tools exist to process this more efficiently? Perhaps, I hope, one of the oldest tools out there: email.

I came across this solution reading the Washington Post’s email newsletter I subscribe to one morning. I realized I’d get more out of the news by scheduling a more deliberate reading of the newsletter than by going to the site and being bombarded by stories and links that, while no doubt interesting, would result in an overflow of words that would invariably lose their depth.

I decided for the next week not to visit any news site directly but rather to subscribe to several newsletters and schedule the reading from directly from my email inbox. I also turned off the radio so that rather than hearing multiple versions of syndicated stories from the Associated Press, I would be able to dive more deeply and think more at length about what I read. The goal was to buck the trends of the modern day information seeker:

“characterised as being 'horizontal, bouncing, checking and viewing in nature. Users are promiscuous, diverse and volatile.' 'Horizontal' information-seeking means 'a form of skimming activity, where people view just one or two pages from an academic site then "bounce" out, perhaps never to return.' The average times users spend on e-book and e-journal sites are very short: typically four and eight minutes respectively.”

I wanted to get more vertical with my reading rather than surfing through multiple versions of the same piece of news.

I was so pleased with the results that I decided to use the same strategy with technical news and articles. I have long been a member of The Code Project and of the software development newsletters I receive (surprisingly few) theirs is probably the best. Each day, and then in a weekly digest, there is an email in my inbox with a decent roundup of technical articles. Although not all of them pertain to my skills set or interests, there are usually one or two good links to follow up with; in this newsletter received on the last day of the year I could easily spend an hour on The Best Technology Writing of 2010 or catch up with Rob Connery giving his sentiments on BizSpark.

The experiment will continue and although I do admit to “skimming” from time to time, even the tepid commitment that I’ve made seems to make my time online much more efficient. The next steps regarding newsletters is to find some more development related ones that come in a digest form, preferably weekly so that I can spend a full week on the contents.

}

Information Diet Planning - Part 1

2010-12-23T05:23:00.001-08:00

{

Goal Setting

I’ve let it slip that one personal goal for 2011 is a more regimented information diet. I’m becoming increasingly convinced that the concepts we apply to diets on the body can be applied with some parallel applications in the world of information.

Calorie Counting

The first thing that applies to physical diets is the concept of tracking intake. Our bodies can utilize up to a certain amount of food after which, no matter how good it is, the food is going to be stored up as fat. Is tracking intake something that can be applied to information? The number of sites visited in a day, the number of browser tabs open, the amount of time getting pumped with information via some form of media: podcast, radio, screencast, television or otherwise? Is there a point where that additional reading does no good and takes away from what might have been retained?

Exercise

The second basic thing in the world of physical diets is some concomitant form of exercise. Some of this might be for burning away calories (cardio) but sometimes it’s about gaining mass or turning “fat” into “muscle.” I wonder what exercise looks like in the world of information. Steve Yegge had an old article about practice for programmers and I suspect that exercise involves designating time specifically for the mental effort related to processing information efficiently.

“The great engineers I know are as good as they are because they practice all the time. People in great physical shape only get that way by working out regularly, and they need to keep it up, or they get out of shape. The same goes for programming and engineering.”

Media and Delivery

There are different “food groups” associated with a healthy diet. Some types of food, like “fatty carbs” are very difficult to incorporate into any meaningful diet but others, like fruit, are a staple of most sensible dieting efforts drawn up for a healthier lifestyle. I wrote down my main sources of intake and looking at the list I would consider some blog entries analogous to fatty carbs or sugar whereas other forms of intake such as technical books to be a more substantive form of media for input and processing.

Confession: I’m an architecture geek¹. It started in earnest when I moved to South Dakota – it was the first time I’d lived in a rural area. I missed the built environment I was used to in cities. Along the way I’ve managed to have 14 different architecture blogs in my RSS Reader. Especially since I’m not an architect, this is excessive. I usually enjoy a story here and there but I leave a lot unread. This is a case where it’s not my curiosity that needs to go away, it’s the delivery format. I’d be better served rereading Steen Eiler Rasmussen’s Experiencing Architecture or Bjarke Ingalls’s Yes Is More than getting distracted by blog entries from the web.

Processing

I’m not sure there is any equivalent in the world of dieting but the last thing I’ve been thinking about related to my information diet is designating time for processing. Earlier this year I finally made some headway in understanding Getting Things Done and though I can’t say I’ve implemented everything David Allen recommends two things have stuck: his recommendation of using a calendar and the idea that you process information rather than letting it idle in an indeterminate state.

It’s occurred to me that in recent years information access for personal and professional development is trivial. Wikipedia is a great resource for documenting general knowledge. For professional work there are websites, link aggregators, and vendors eagerly providing a glut of information to learn from.

In this environment, what does it mean to “process” an information resource? For example, at work this week we watched Bart De Smet give a talk on a language feature of C# called LINQ. I’ve used LINQ quite a bit but his talk covered some direction in the technology that is new (Rx). In a more general sense, he referenced the Wikipedia entry on Monads – another resource which I would like to process.

I’m not sure what processing should look like but it seems like what it means to process an information resource is less of an issue than the discipline it takes to designate time for it. Perhaps that ties this notion back to exercise.

Conclusion

I’ll be using the next couple of weeks to think more about what an Information Diet should look like and a practical structure to use. I’m posting in part because I would love any input on tactics and also because committing this to the permanence of my blog means the commitment is formalized. Four areas of focus will be:

Calorie Counting – tracking input
Exercise – deliberate practice
Media and Delivery – determining which formats and timing work best for information
Processing – what steps are involved in making meaning out of information

}

¹A running joke with my wife is that I will quit my job, enroll in an architecture program just so I can be a critic. She takes great joy in laughing about this.

Language, Programming, Quirks, Conviction; Derek Sivers at RailsConf

2010-12-20T05:42:00.001-08:00

{

“

Imagine that you are standing on a street, and you are in America, and a Japanese guy comes up to you and says “Excuse me… what is the name of this block?”

And you say “well, I don’t understand… there’s Oak street and there’s Elm street, this is 27^th street and that’s 26^th…”

And he says: “Yes but what is the name of this block?”

You say: “I don’t understand what you mean; blocks don’t have names, streets have names. Blocks are just the unnamed spaces in between the streets.”

He looks a little disappointed and leaves.

…

So now imagine that you are standing in Tokyo one day and you’re a little lost and you turn to somebody next to you and you say “Excuse me, what is the name of this street?”

And they say, “That is block 17 and that is block 16.”

And you say “Yeah, but what is the name of this street?”

And they say, “Streets don’t have names; that’s just the space between blocks 16 and 17.”

”

A great talk from Derek Sivers given at RailsConf earlier this year available on IT Conversations.

}

The Future Is Balkanized

2010-12-19T10:51:00.001-08:00

{

“I like HTML5, but I think you're duct taping a horn on a horse and hoping it will become a unicorn.”

Shawn Wildermuth hit the nail on the head with a recent analysis entitled “The Next Application Platform? All of them... ” It would be interesting to see how many more hits the article would have gotten with a title like “XYZ is dead” or “The Death of XYZ,” perhaps something along the lines of “The Death of the One Stop platform.”

A basic summary is that he points to a future in which developers tangle themselves with the following development targets:

An HTML5 solution for the web
Plugins to extend HTML5 as necessary
Desktop/Browser apps for in house/well known customers
Apps for mobile/tablets in Objective-C, Java, and Silverlight

The sentiments are corroborated by my own experience, most recently even with a potential customer who wanted to have an iPad friendly application (native) but also wanted to support web based users who had no such device. If I could translate the request, it could simply be that they want things in the best possible experience for each of the disparate platforms for which they had users. Of course the smart phone was no exception.

In a world like this, what could the future portend but that we will have multiple platforms, no singular delivery, and a constantly increasing need to build things quickly, portably?

I’ve cited the article quite a bit but over the years I’ve always gone back to Jonathan Edwards article on Beautiful Code:

“I wish someone had instead warned me that programming is a desperate losing battle against the unconquerable complexity of code, and the treachery of requirements.”

Although Edwards was talking more specifically about code, all of my experience points towards this truth in the realms of the disparate platforms, specifically that getting something to work in a “real world” where people use different operating systems, browsers, displays, and connectivity paradigms. Over the years there have been different tactics in trying to solve the problem: web standards, ActiveX controls, Java, plugins, and of course the latest new craze, HTML5. It’s not that these tactics (and the technologies related to them) are bad: I still advocate web standards to a point, I still have my day job programming Silverlight. It’s just that the pragmatist in me thinks this is the Arab-Israeli conflict in software: no perfect solution no matter how badly its desired by those in each of the platform camps.

The big insight for me as a developer is this line:

“This means as a developer you'll need to expand what you know and learn more platforms. Is that bad or good? Both. It means more work for all of us, but it does mean you'll need to less focus on silo's of platforms and use your knowledge across these platforms.”

}

Advent Calendars for Developers

2010-12-13T20:56:00.001-08:00

{

Since my days trying to hack up some Perl¹ I was charmed by the idea of a developer’s advent calendar: a day by day lead up to Christmas with articles pertaining to a specific topic. I’m otherwise a scrooge during the holiday time; not given to commercialism, Christmas music, and other seasonal rituals.

But I am up for the both the Perl Advent Calendar and the RJBS (Perl) Advent Calendar. On a similar vein, Sys Advent, a sys admin advent calendar should be interesting tracking too.

Others have riffed on the idea, most notably web developers. 24ways is a seasonal advent project that I’ve tuned into each year – I usually have at least one or two of the posts stick.

Finally, there is an entrepreneurial advent calendar, 24waystostart. A lot of good things in there, I feel the onset of holiday good cheer.

I’m disappointed not to find a .NET Advent calendar (or even a Python one!). If you know of a good advent calendar, developer or otherwise, feel free to share. A few good articles can make the season pleasurable, even for a grinch like me.

}

¹Could it have been that long ago? Funny to see those old posts, but that's part of why I blog

Serialization’s “Pit of Success” with C# and JSON

2010-12-02T05:36:00.001-08:00

{

Although it’s been mentioned before here, it bears repeating that before you find yourself making a reference to the DataContractJsonSerializer, you ought to consider and indeed are more likely better off with the NewtonSoft library Json.NET. Whereas the DataContractJsonSerializer relies on giving you the flexibility of creating types and using the DataContract and DataMember attributes on them for a lot of granular control, this is burdensome with types that should naturally find themselves serializable and JSON friendly. For example, let’s say I have a Dictionary<int, string>; the intent of the user shouldn’t be too complicated in the serialization process. Or, if I have a class Foo with a couple of properties, and I want to serialize an IEnumerable of said class, again, the intent doesn’t require the extra use of attributes and a complexity overhead.

This is not to say that the DataContractJsonSerializer does not have its place; if you are leveraging WCF and choosing JSON as your serialization format, it is probably the best route to go. That said, however, I have fallen more than once into a “pit of success” with Json.NET after getting burdened with trying to use the DataContractJsonSerializer.

Json.NET is still quite active, the last release during the latter half of this year. Check it out.

}

Design Related: Branding with Debbie Millman

2010-08-27T05:53:00.001-07:00

{

I always struggled with a singular identity. Maybe that had something to do with going back and forth from East Africa and the United States, maybe it is because my father had a lot of books and it gave me a curious nature. Whatever it is, I am the kind of person who, when I find myself in a bookstore, picks up a magazine on a topic I know nothing about and enjoys trying to discover the nuances of a not yet explored world of information. I’ve done it with things like pens, model trains, and antiques.

When it comes to design, as much as it may seem by some to be orthogonal to software development, I’ve had the growing understanding that the two go hand in hand. Design, to me, is not picking nice colors for gradients or making icons. Design is planning, it’s understanding a problem and solving it. Although as a software developer my visual design has often been an afterthought (something I’ve fought with increasing intensity over time) and yet when I write a piece of software, put together a user interface, or model data structures, I am planning and problem solving. I am designing, even if I’m making a poor effort of things.

The more aware I’ve become of this, the more I’ve sought to have a baseline understanding of design which is why I found myself at the South Dakota AIGA hearing Debbie Millman give a talk on the history of branding, which was originally prompted by her thinking about the phenomenon of MySpace. I’d long been aware of Debbie; I listened to her Design Matters show when it originally became available online and look forward to a new podcast via Design Observer.

In speeding us to the present, the question of why there may be 300 national brands of cereal or 100 different types of bottled water in a store, Millman began 50,000 years ago with the “big brain bang” where scientists believe we developed our Triune brain. The 3 parts of the brain Millman talked about, Reptilllian, Limbic, and Neocortex are a basis for how she believes that branding works today – if I could shortcut to the conclusion, the reason why we put ourselves in groups and find affiliation important is because this need is hardwired. In one humorous aside, Millman said of the part of the brain that fears the unknown:

“You can’t meditate it away. It’s just there.”

The talk bolstered this point along many fronts, some anthropology, some historical/statistics and other scientific studies and anecdotes. She then divided the history of branding, starting from the US Trademark Registration (landmark legislation that is the legal foundation for branding) in 1876, into 5 different “waves:”

Wave 1: 1875 – 1920

Brands as a guarantor of consistency (Think Campbells soup, Quaker Oats).

Wave 2: 1920 – 1965

Brands as a guarantor of quality. (Think Mortin’s Salt, Pepsi).

Wave 3: 1965 – 1985

Brands as self expressive statements, telegraphing what others should think of us. (Think Nike, Levis, Volskwagen).

Wave 4: 1985 – 2000

Brands as an experience. (Think Starbucks.)

Wave 5: 2000 – present

Limbic brands. (Think Social Networking). In reference to the earlier portion of the talk on brain development, this is the part of our brains which serves us emotion and sense of group. In our present, fractured world, where traditional models of group like family are being uprooted by modernity, we turn to brands to fill that portion of our lives, which is hardwired.

I found the talk riveting, in large part because it aimed at a higher level thinking of how branding works. Afterward I had a chance to talk to Debbie and it sounds like there are new Design Matters shows in the making. I’ll look forward to hearing them and learning more.

}

Failure in two parts, IronRuby

2010-08-11T21:45:00.001-07:00

{

I recently ran across a two part series from Dave Winer related to failure. Essentially Winer asserts the following:

“The only way to succeed in my opinion is if you cannot visualize failure.”

In the first post he describes a personal experience where failure was imminent and he pushed on despite it because he realized his back was to the wall. In the second he keeps the theme by emphasizing the special level of determination necessary for success. Many of the blog posts I find my way to via Hacker News and other outlets have similar exhortations but Winer holds more gravitas for me because of his success as a founder and longevity as one of the alpha dog programmer/internet personalities.

Both pieces were inspired by the recent news that Google was no longer pursuing Wave – the kind of capitulation that may have inspired Winer’s title: “Embracing failure is a good way to fail.” As an aside, Dare Obasanjo has some thoughtful points on why Wave couldn’t grow.

Not long after I discovered that IronRuby’s future as a Microsoft project was in flux. It seemed to me similar to Wave in the sense that I remember the fanfare when all the Iron* (IronRuby, IronPython, etc… ) projects were beginning and the excitement of people in the programming community only to perk my head up now and find that the project seems no longer to have the good graces of its company. What a contrast.

I speak as an outsider but I suspected that as time passed the level of interest in these projects began to erode: everything from key people leaving teams to diminishing excitement from people on the outside. Most of my interest was directed toward IronPython since it was the most mature dynamic language implementation in the beginning (the whole concept of the Dynamic Language Runtime (DLR) came from Jim Hugunin’s early port of Python). This was both fortunate and unfortunate; I was eager to learn Ruby but since I can’t learn languages very fast I decided to maintain my focus on Python in exclusion of other DLR language implementations. All I can do is suspect but perhaps there were others like me who decided rather than trying to learn different languages simultaneously it would be better to focus on one.

Now as I think upon my encounters with the DLR, I realize that I’m a part of the “failure,” if one can call it that, of Microsoft in valuing this and other dynamic language implementations. Although I was excited early on, even spending some time creating projects and coming up with ideas that leveraged the dynamic languages on the DLR, I got bogged down by how hard it was without a lot of documentation and the difficulty of trying to convince people around me that what I was doing was worth it. (Insert the glazed eyes and “why not just use C#? It has intellisense…” conversation). In the interests of a more full disclosure, a personal tragedy from last year took a lot of wind out of my sails and I didn’t do any programming my spare time for a long stretch of time.

But of course I neither think that IronRuby is a “failure” nor do I think my lack of initiative over the last few years is the way things need to remain. Now seems an even better time to become more active in what community IronRuby has since the absence of Microsoft will create space for people like me, on the outside. I will probably return to the drawing board with a few projects and ideas in IronPython but Bruce Tate’s latest book has inspired me to think that perhaps trying to tackle multiple languages at the same time isn’t so outlandish a goal after all. The important thing I’m going to try to bring with me is the frame of mind I quoted above from Winer: being unable to imagine that IronRuby can go away or lose value as an idea or a platform.

}

Management Perspectives from a Groundling and Dan Pink

2010-07-29T05:40:00.001-07:00

{

Over the weekend I took the time to watch Stan Lee’s Mutants, Monsters and Marvels, a film that consists entirely of an interview between film maker Kevin Smith and Stan Lee. As a kid who grew up loving comics, I loved the unveiling of the world behind the worlds I spent as much time as I could with my imagination: Spiderman, Fantastic Four, Hulk, Iron Man, and the list goes on though I’ll stop before daunting anyone without appreciation for such comic book geekdome.

One of the interesting segments dealt with Stan Lee’s approach as the top editor at Marvel. Although the characters we are familiar with are his creations and he would collaborate with artists on the first few releases of books, subsequently other teams of artists and writers would work on their own releases of the characters he created. When Kevin asked how he managed this he waved his hand and said that he found the best way to manage creatives was to leave them alone: that’s how you would get their best work.

Stan Lee seems to be a man of intuition (in the interview he’s matter of fact and terse, less a man of “Big Ideas” and more of “Common Sense” when it comes to managing) but I think he was getting at the management theory that is being articulating these days by Dan Pink. Pink’s ideas have to do with the connection of motivation and better outcomes that are concomitant with employee autonomy. A summary of his ideas as well as their rational basis is in this entertaining animated video from RSA:

Although I do not have any formal disagreements with Pink’s ideas (they are spot on in my book) I think what is telling is his background and where he worked. Some top notch schools and the upper echelons of government imbue a sense of personal worth and require the freedom and tactics he recommends. The same is true with Stan Lee: his management style worked precisely because of the environment he was in and the nature of his work; in comics being creative and motivated as well as finding ways to help your employees in that regard are the name of the game.

What I would add, from the groundling floor, is that in many places it’s not that these theories don’t make sense or aren’t highly empirical (Pink glosses over some behavioral economics although if you really want to dive into the field Dan Ariely is a better start); it’s that different organizations have different goals. As much of a thought bludgeon as it is, the haunting truth is that some places are perfectly happy trading out creativity, autonomy, and the requisite unpredictability associated with them.

}

XAML Iconography

2010-07-27T16:51:00.001-07:00

{

I have been having a lot of fun lately using Adobe Illustrator and symbol icons to build icons in XAML. Although the typical icon libraries provide very compact image files, the advantage of XAML comes not just in space, but in the ability to manipulate the graphic that you are leveraging.

Here is a brief example of what I mean:

1. There is no shortage of good symbol fonts (or fonts in general, for that matter). I have bought fonts at both MyFonts.com and Fonts.com and had great experiences. The symbol font I will use in this case is Energetics.

2. In Illustrator, I create a document and insert the character of choice making it large enough that it will be easily visible when I import it to Blend.

3. Using the File –> Import option from Blend, I have two Adobe related options; in this case we obviously leverage the Import Adobe Illustrator option

4. Voila! We now have our same symbol in Blend but digging in it’s a XAML Path rather than an image. Although it has been imported, however, you will notice a few extra pieces of XAML that you don’t need holding the Path as its container. I usually copy the Path, delete the extras and then paste it back in.

Now that the symbol is in XAML, not only is it not taking up the kind of space that the original image would have, it is also easier to work with if you need to manipulate it programmatically. Here’s my weight lifter in XAML:

<Path Data="F1M562.59375,264.9375C562.59375,283.96875,560.390625,301.390625,556.015625,317.234375C551.625,
333.078125,546.125,345.03125,539.53125,353.125L510.140625,353.125C503.296875,344.578125,497.703125,332.296875,
493.375,316.296875C489.046875,300.296875,486.890625,281.96875,486.890625,261.34375L480.5625,261.34375C475.65625,
264.09375,468.9375,269.5,460.40625,277.578125C460.515625,285.671875,459.921875,299.328125,458.609375,
318.515625C457.296875,337.71875,456.359375,350.90625,455.796875,358.078125C455.671875,359.796875,454.359375,
360.640625,451.859375,360.640625C449.34375,360.640625,448.09375,359.796875,448.09375,358.078125C443.765625,
358.984375,439.578125,359.703125,435.53125,360.21875C431.484375,360.734375,425.78125,360.9375,418.4375,360.8125C411.09375,
360.703125,404.0625,359.9375,397.34375,358.5C390.625,357.078125,383.71875,354.59375,376.65625,351.0625C374.609375,357.5625,
372.46875,362.953125,370.25,367.21875C368.03125,371.5,364.578125,377.734375,359.921875,385.9375C367.328125,390.953125,
372.671875,395.703125,375.984375,400.203125C379.28125,404.703125,380.9375,410.03125,380.9375,416.1875C380.9375,424.15625,
378.453125,431.109375,373.5,437.03125C368.53125,442.96875,362.46875,447.296875,355.296875,450.015625C357.109375,456.84375,
358.96875,465.703125,360.84375,476.59375C362.71875,487.46875,364.171875,497.328125,365.203125,506.15625C366.234375,514.984375,
366.796875,521.109375,366.921875,524.53125L335.140625,524.53125C330.234375,524.53125,329.140625,522.078125,331.890625,
517.1875C332.796875,515.6875,332.21875,513.015625,330.171875,509.15625C323.453125,496.390625,312.109375,481.46875,296.171875,
464.375C295.25,463.34375,293.90625,461.84375,292.140625,459.84375C290.375,457.84375,289.09375,456.375,288.296875,455.40625C287.5,
454.4375,286.875,453.734375,286.421875,453.265625L274.8125,455.3125L289.84375,511.375C290.640625,514.09375,289.15625,517.578125,
285.40625,521.796875L250.375,521.796875L250.71875,517.53125L264.390625,504.015625L211.578125,456.34375C210.09375,454.984375,
207.390625,452.5625,203.453125,449.078125C199.515625,445.609375,196.671875,442.8125,194.90625,440.703125C193.140625,438.609375,
191.859375,436.5,191.0625,434.390625C190.265625,432.28125,189.875,429.796875,189.875,426.953125C189.875,421.375,192.28125,
415.828125,197.125,410.296875C201.96875,404.765625,209.828125,400.015625,220.71875,396.015625C231.59375,392.03125,245.578125,
389.984375,262.671875,389.859375L239.78125,350.390625C231.90625,355.984375,222.671875,359.875,212.078125,362.09375C201.484375,
364.3125,191,364.234375,180.640625,361.828125C178.015625,351.578125,176.109375,342.59375,174.921875,334.84375C173.71875,327.09375,
172.859375,319.609375,172.34375,312.359375C171.828125,305.125,171.34375,295.578125,170.90625,283.734375L151.25,272.28125L140.140625,
272.625C140.140625,313.75,132.78125,343.71875,118.09375,362.515625L90.0625,362.515625C85.84375,357.28125,82.09375,350.5625,78.78125,
342.359375C75.46875,334.15625,72.859375,324.578125,70.921875,313.640625C68.984375,302.703125,68.015625,291.03125,68.015625,
278.609375C68.015625,259.921875,70.125,242.890625,74.34375,227.515625C78.5625,212.140625,83.796875,201.140625,90.0625,
194.53125L118.09375,194.53125C121.84375,198.75,125.234375,204.359375,128.265625,211.359375C131.28125,218.375,133.78125,226.5,
135.78125,235.71875C137.765625,244.9375,139.109375,255.25,139.796875,266.640625L148.171875,266.640625C148.625,264.703125,149.5,
263.234375,150.8125,262.203125C152.125,261.171875,153.6875,260.859375,155.515625,261.265625C157.328125,261.671875,158.984375,
262.890625,160.484375,264.9375C163.890625,259.59375,167.828125,259.359375,172.265625,264.25C172.953125,262.3125,174.375,261.0625,
176.53125,260.5C178.6875,259.9375,180.578125,260.4375,182.1875,262.03125C183.65625,260.4375,185.34375,259.84375,187.21875,
260.234375C189.09375,260.640625,189.984375,262.3125,189.875,265.28125L271.390625,262.375C271.046875,252.921875,271.6875,244.75,
273.34375,237.859375C275,230.96875,277.9375,224.734375,282.15625,219.140625L314.796875,217.9375L322.484375,260.65625L448.4375,
256.5625C449.6875,253.9375,451.625,252.34375,454.25,251.78125C456.875,251.21875,458.921875,252.40625,460.40625,255.359375C462,
253.3125,463.875,251.96875,466.046875,251.34375C468.203125,250.71875,470.375,251.5,472.53125,253.65625C475.265625,249.5625,
478.578125,248.875,482.453125,251.609375C484.5,250.359375,486.09375,249.890625,487.234375,250.234375C488.03125,235.09375,
490.5625,220.578125,494.84375,206.671875C499.109375,192.765625,504.203125,182.796875,510.140625,176.75L539.53125,
176.75C542.828125,180.28125,545.90625,185.046875,548.75,191.03125C551.59375,197.015625,554.078125,203.90625,556.1875,
211.703125C558.296875,219.515625,559.890625,227.90625,560.96875,236.90625C562.046875,245.90625,562.59375,255.25,562.59375,
264.9375L562.59375,264.9375 M535.9375,182.734375L512.875,182.734375C508.765625,187.75,505.140625,194.59375,502.015625,
203.25C498.875,211.90625,496.515625,221.9375,494.921875,233.3125L518.171875,233.3125C519.640625,222.15625,521.953125,
212.203125,525.078125,203.421875C528.203125,194.640625,531.828125,187.75,535.9375,182.734375L535.9375,182.734375 M447.75,
262.375L364.015625,265.28125C371.875,268.25,378.484375,271.78125,383.84375,275.875C389.1875,279.984375,393.8125,286.25,
397.6875,294.671875C404.859375,292.859375,411.515625,292.375,417.671875,293.21875C423.828125,294.078125,429.40625,297.234375,
434.421875,302.703125L447.75,262.375 M312.234375,237.59375L309.84375,223.921875L285.40625,224.9375C280.84375,231.671875,
278.28125,239.765625,277.71875,249.21875C279.65625,253.09375,284.03125,255.015625,290.875,255.015625C295.421875,255.015625,
300,253.578125,304.625,250.671875C309.234375,247.765625,311.765625,243.40625,312.234375,237.59375L312.234375,237.59375 M375.296875,
299.625C375.296875,292.109375,371.421875,286.296875,363.671875,282.203125C355.921875,278.109375,344.75,276.046875,330.171875,
276.046875C317.1875,276.046875,307.5,277.359375,301.125,279.96875C292.8125,277.8125,286.03125,276.734375,280.796875,
276.734375C271.453125,276.734375,262.59375,278.390625,254.21875,281.6875C245.84375,285,239.203125,289.1875,234.296875,
294.25C229.390625,299.3125,226.953125,304.125,226.953125,308.6875C226.953125,313.46875,229.453125,317.296875,234.46875,
320.140625C239.484375,322.984375,244.671875,324.40625,250.03125,324.40625C257.203125,324.40625,264.953125,322.984375,
273.265625,320.140625C281.578125,317.296875,288.1875,313.921875,293.09375,310.046875C298.671875,313.359375,305.671875,
316.125,314.109375,318.34375C322.546875,320.5625,330.921875,321.671875,339.234375,321.671875C348.921875,321.671875,357.34375,
319.578125,364.53125,315.359375C371.703125,311.140625,375.296875,305.90625,375.296875,299.625L375.296875,299.625 M328.125,
340.125C328.125,337.40625,325.125,334.921875,319.15625,332.703125C313.171875,330.484375,305.625,329.359375,296.515625,
329.359375C287.859375,329.359375,280.328125,330.625,273.953125,333.125C267.578125,335.640625,264.390625,338.203125,264.390625,
340.8125C264.390625,344.921875,271.390625,347.140625,285.40625,347.484375C273.21875,351.921875,267.125,356.59375,267.125,
361.5C267.125,363.09375,268.25,364.328125,270.53125,365.171875C272.8125,366.03125,276.03125,366.65625,280.1875,367.046875C284.34375,
367.453125,287.78125,367.703125,290.53125,367.8125C284.03125,371.234375,280.796875,374.375,280.796875,377.21875C280.796875,379.15625,
282.8125,380.875,286.859375,382.34375C290.890625,383.828125,294.96875,384.5625,299.078125,384.5625C303.390625,384.5625,
307.71875,383.765625,312.0625,382.171875C316.390625,380.578125,318.5625,378.59375,318.5625,376.1875C318.5625,373.90625,317.671875,
372.265625,315.90625,371.234375C314.140625,370.21875,311.09375,369.1875,306.765625,368.15625C320.203125,364.96875,326.9375,361.5,
326.9375,357.734375C326.9375,355.578125,325.671875,353.71875,323.171875,352.1875C320.65625,350.65625,317.40625,349.3125,313.4375,
348.15625C323.21875,346.453125,328.125,343.78125,328.125,340.125L328.125,340.125 M259.078125,268.6875L189.015625,271.265625L187.65625,
275.359375L192.609375,312.109375C198.296875,306.640625,205.3125,303.625,213.625,303.046875C216.921875,297.8125,220.703125,
293.140625,224.984375,289.03125C229.265625,284.9375,234.359375,281.09375,240.28125,277.5C246.203125,273.90625,252.46875,270.96875,
259.078125,268.6875L259.078125,268.6875 M112.453125,200.5L92.796875,200.5C84.703125,210.53125,79.125,226.03125,76.046875,
246.984375L95.703125,246.984375C98.78125,226.03125,104.359375,210.53125,112.453125,200.5L112.453125,200.5 M360.59375,518.71875C360.25,
512.109375,358.546875,499.4375,355.46875,480.6875C352.390625,461.9375,348.296875,444.921875,343.171875,429.59375C338.046875,
414.28125,332.28125,406.609375,325.90625,406.609375C315.765625,406.609375,306.53125,410.09375,298.21875,417.03125C289.90625,
423.984375,285.75,430.9375,285.75,437.890625C285.75,440.734375,286.765625,443.5,288.8125,446.171875C290.859375,448.859375,295.53125,
454.203125,302.828125,462.234375C310.109375,470.265625,316.328125,477.546875,321.453125,484.109375C326.578125,490.65625,331.265625,
498.09375,335.484375,506.421875C337.1875,509.484375,338.1875,511.796875,338.46875,513.328125C338.75,514.859375,338.4375,516.65625,
337.53125,518.71875L360.59375,518.71875" Stretch="Fill" Margin="57,81,0,0" UseLayoutRounding="False" HorizontalAlignment="Left" 
Height="131.781" VerticalAlignment="Top" Width="187.405">
	<Path.Fill>
		<LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0">
			<GradientStop Color="#FF2D2D2D" Offset="0"/>
			<GradientStop Color="#FF3D3C3C" Offset="1"/>
		</LinearGradientBrush>
	</Path.Fill>
</Path>

}

Excel Interop in C# .NET without COM

2010-07-24T21:16:00.001-07:00

{

Tonight I ran across the excellent albeit unimaginatively called excellibrary project on Google Code and leveraged it in one of my personal projects. It’s nice to be able to get the Excel file format without having to do it in either CSV or with COM Interop.

Reference: Stackoverflow Question / Answer

}

TortoiseSVN Extensions Missing on Windows 7

2010-07-22T21:32:00.001-07:00

{

Ran into this issue recently after upgrading my TortoiseSVN shell extensions. To fix, simply run the installer again using the Repair option.

Reference: StackOverflow Question / Answer.

}

Keep Your Head Up

2009-12-15T05:16:00.001-08:00

{

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

2009-12-05T20:48:00.001-08:00

{

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

2009-11-18T20:08:00.001-08:00

{

Just a quick test from Windows 7.

}

Library of the Week: Silverlight’s MD5 implementation

2009-10-27T21:07:00.001-07:00

{

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

2009-10-20T19:32:00.001-07:00

{

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

2009-10-08T20:01:00.001-07:00

{

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

2009-09-27T21:35:00.001-07:00

{

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#

2009-09-20T22:18:00.001-07:00

{

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

2009-09-19T17:57:00.001-07:00

{

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

2009-09-19T08:07:00.001-07:00

{

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

2009-07-16T21:08:00.001-07:00

{

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

2009-05-06T05:59:00.001-07:00

{

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

2009-04-24T04:22:00.001-07:00

{

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

2009-03-23T20:38:00.001-07:00

{

Yours truly, looking embarrassed in the middle.

Here is the link to Phil's write up.

}

Voidspace on Dot Net Rocks

2009-03-20T08:44:00.001-07:00

{

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

}

Currying with C# and Algotron

2009-03-04T08:10:00.001-08:00

{

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

2009-03-03T05:36:00.001-08:00

{

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)

2009-02-26T23:35:00.001-08:00

{

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

2009-02-25T22:34:00.001-08:00

{

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

2009-02-19T21:44:00.001-08:00

{

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#?

2009-02-09T20:42:00.001-08:00

{

Both.

}

Lazy Coder On Point

2009-01-11T11:23:00.001-08:00

{

SOA is Dead?

}

Another "Dead Java" Proclamation

2009-01-02T06:05:00.001-08:00

{

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.

}

Using SGMLParser With IronPython

2008-12-31T05:27:00.001-08:00

{

Mark Pilgrim's excellent Dive Into Python has a section on using SGMLParser and having seen nothing similar (and imagining its many uses!) I thought I'd give it a whirl in IronPython. I thought a good proof of concept would be creating a database out of link heavy sites. Since I visit Arts & Letters Daily every so often and the closet intellectual in me likes to hang onto what I find there, I thought I'd target it:

import urllib2
import sgmllib
from sgmllib import SGMLParser

import clr
clr.AddReference("System.Data")
clr.AddReference("System.Net")
from System import *
from System.Data import *
from System.Net import *

class AlReader(SGMLParser):
    def reset(self):
        SGMLParser.reset(self)
        self.urls = []
        self.pieces = []
        self.track = 0
        self.prePend = "No Category"
        self.counter = 0
        
    def start_a(self, attrs):
        href = [v for k,v in attrs if k == "href"]
        key = [v for k,v in attrs if k == "name"]
        if href:
            self.urls.extend(href)
            self.track = 1
        elif key:
            self.prePend = attrs[0][1]
    
    def handle_data(self, text):
        if self.track:
            self.pieces.append("|".join([self.prePend, text]))
            self.counter = self.counter + 1
    
    def end_a(self):
        self.track = 0
    
    def get_links(self):
        links = []
        for i in range(0, len(self.urls)):
            links.append("|".join([self.pieces[i], self.urls[i]]))
        return links
        #print "%s %s" % (self.counter, "Total links") 
    
    def get_link_datatable(self):
        d = DataTable()
        d.Columns.Add(DataColumn("Category", Type.GetType("System.String")))
        d.Columns.Add(DataColumn("Site", Type.GetType("System.String")))
        d.Columns.Add(DataColumn("Url", Type.GetType("System.String")))
        
        for text in self.get_links():
            newRow = d.NewRow()
            newRow["Category"], newRow["Site"], newRow["Url"] = text.split("|")
            d.Rows.Add(newRow)

        return d
        
response = urllib2.urlopen("http://www.aldaily.com")
a = AlReader()
a.feed(response.read())
linkdata = a.get_link_datatable()
# write it out to prove we got it.
ds = DataSet()
ds.Tables.Add(linkdata)
ds.WriteXml("c:\\temp\\arts and letters links.xml")

If you find tihs interesting do make sure you look at Pilgrim's chapter on HTML Processing.

}

Parameterized IN Queries

2008-12-20T05:50:00.001-08:00

{

I haven't listened to the podcast yet but saw a cool trick from Joel Spolsky on approaching parameterized IN queries. Purists will bemoan its lack of premature optimization but I think it's novel enough to study because of the approach: using the SQL LIKE operator on your parameter rather than a field, which is what people like me are used to. There's code on the StackOverflow post but I thought I'd paste some of the poking around I did in Sql Management Studio:

-- setup
CREATE TABLE Person
(
      PersonID INT IDENTITY(1,1) PRIMARY KEY, 
      FirstName VARCHAR(50) NULL
)
GO

-- some data 
INSERT INTO Person VALUES('David')
INSERT INTO Person VALUES('Jonathan')
INSERT INTO Person VALUES('Zlatan')
INSERT INTO Person VALUES('Trilby')

-- here's the magic
DECLARE @FirstName VARCHAR(50)
SET @FirstName = '|David|Trilby|'
SELECT * FROM Person WHERE @FirstName like '%|' + FirstName + '|%'

-- ported to a proc
CREATE PROC uspPersonSelector
      @FirstNames VARCHAR(500)
AS
      SELECT * FROM Person WHERE @FirstNames like '%|' + FirstName + '|%'
GO

-- showing it works
uspPersonSelector '|David|Trilby|'

-- somewhere in the netherworld of C#: 
/* 
string[] names = {"David", "Trilby"};
SqlCommand cmd = GetACommandFromSomewhere();
cmd.Parameters.AddWithValue("@FirstNames", "|".Join(names));
*/

--teardown
Drop Table Person

}

Programmers as Goalkeepers

2008-12-19T05:20:00.001-08:00

{

The 8th annual New York Times magazine Year in Ideas featured a section on Goalkeeper Science profiling this paper by some Israeli scientists called Action bias among elite soccer goalkeepers: The case of penalty kicks. In looking at the approach of keepers in some 286 penalty kicks they found that though 94 percent of the time they dived to the right or left, the chances of stopping the kick were highest when the goalie stayed in the center. The researchers theorized that the reason keepers behaved in this way was that they were afraid of appearing that they were doing nothing.

Immediately I remembered a blurb from an Paul Graham's What Business Can Learn from Open Source essay where he expressed a similar dynamic for programmers:

"The other problem with pretend work is that it often looks better than real work. When I'm writing or hacking I spend as much time just thinking as I do actually typing. Half the time I'm sitting drinking a cup of tea, or walking around the neighborhood. This is a critical phase-- this is where ideas come from-- and yet I'd feel guilty doing this in most offices, with everyone else looking busy."

I wonder what Paul would say about the IBM commercial on ideating in which concludes that people should "start doing" after showing an image of people laying inert on an office floor, a stark portrayal of how a manager at IBM might see someone like Paul Graham.

As programmers much of what we should do may not appear to be work for the nonprogrammer and as a result many of us end up doing it at home. I spend a lot of time at home exploring different technologies in a kind of tangential approach that wouldn't look like "working" at work but often my best ideas and solutions come from here. I also spend a lot of time reading technical books and blogs.

I'm wondering what it would look like if we could step back and look in a quantitative way at the performance deficits resulting from the desire to look busy at work. What would the workday look like? I'm wondering what an hour for reading, a few hours for exploratory/research programming, and the rest as project time would do for my own productivity.

If programming was goalkeeping was programming, Edwin Van der Sar would be quite the Python hacker.

}

Windows Forms + Web, WIB part II

2008-12-18T04:38:00.001-08:00

{

A while back I made the case for applications that put together the strengths of Windows Forms and Web technologies (I thought of the catchy "WIB" as a name for this approach). The example I’d given then was a Windows Forms hosted Web Browser for local images that one could use for annotation that leveraged Windows for local file storage and a Web technology like jQuery for doing transitions in the user interface.

Today I thought of another use for this approach that wrapped itself nicely into a tool I've been using for some time to download mp3s from a given website^1,2. I call the tool "Fortinbras" and if you find it useful I'd be delighted.

So how was Fortinbras changed?

Parsing the HTML for mp3 files was a little tricky. My initial approach was to use a regular expression against the text of the document which, truth be told, is a brittle approach. Part of why I never trumpted the tool was because I never completely perfected this tactic (while it worked well enough for me personally). My code looked as follows:

	WebClient wc = new WebClient();
	string pageText = wc.DownloadString(browser.Url.ToString());
	Regex re = new Regex("href=\"(?<url>.+?mp3)\"", RegexOptions.IgnoreCase);
	Match mp3Matches = re.Match(text);
	while (mp3Matches.Success)
	{
		string matchUrl = mp3Matches.Groups["url"].Value.ToString();
		AddMp3(browser.Url.ToString(), data, matchUrl);
		mp3Matches = mp3Matches.NextMatch();
	}

Today my epiphany was that I didn't need to use a regular expression when I could use the DOM from Windows Forms to pull out the anchors that have mp3 destinations. Here's what that looks like:

	while (browser.Document.Body == null)Application.DoEvents();
	HtmlElementCollection anchors = browser.Document.Body.GetElementsByTagName("a");
	foreach (HtmlElement anch in anchors)
	{
		string linkUrl = anch.GetAttribute("href");
		if (linkUrl.ToLower().EndsWith("mp3"))
		{
		    AddMp3(browser.Url.ToString(), data, linkUrl);
		}
	}

As usual feedback is welcome - you can download a copy of the Fortinbras project here.

¹I am aware of the Firefox extensions that do this but someday (imagine a pie in the sky look on my face) I was hoping to incorporate a "favorites" list with URLs / locations so that this would be a one stop shop for my downloading and organizing of podcasts. My goal here is embarrasment driven development so I'll probably be bummed enough about the code I've just posted to put in some enhancements as time permits.

²My friend's music blog is a great stop, try a couple of tracks at The Look Back.

}

Growing Open Source Community

2008-12-17T05:40:00.001-08:00

{

Kevin Dangoor recorded an interesting screencast on some of the essentials of getting an open source project more widely circulated. Essentially Dangoor explains that having a successful open source project is not just about code, it's about good product management. I wanted to title this post with Dangoor's most quotable quote: "Rails is not where it is because of great code." But there are a lot of people who would take that as an opener for a religious war without seeing his real intent of highlighting marketing and management of a project.

I won't rehash it, it's worth watching it for yourself.

}

Bruce Eckel's Python Book

2008-11-25T22:07:00.001-08:00

{

It escaped my notice but Eckel's been writing a new Python book. Should be worth digging into sometime in the future.

}

How to steal time: On Programming and being a Father

2008-11-23T20:16:00.001-08:00

{

It's been alluded to but here it is neither shaken nor stirred: I became a father exactly on month ago. While it hasn't been without challenges the joy of being a father is something I understand now firsthand after being told or observing it in others. Even though I first was quite seduced by a "mystique" in programming - a nocturnal person drinking jolt with binary being reflected from mirror shades - I now realize not only that nearly every programmer and professional person I admire is a parent, but that they find their core of happiness in that well beyond the realm of work.

Nevertheless, I have been trying to keep up my personal work and interests so with that goal in mind I've adjusted my schedule to wake up as early as I can (usually 5am) and get a few hours of solid time while leaving the evenings as a time when I can help out and be a "family man." It still doesn't feel natural but the payoff is that I can still advance my work with IronPython and other interests. It's already been pointed out to me that my productivity here and other places has dropped since my daughter was born.

So question for other programmer/dad people: how do you work the family schedule? Any tips and tricks for a one month father who is still daydreaming about what it was like to sleep all night?

}

Loop Reordering, Optimizing Face Recognition

2008-11-10T21:28:00.001-08:00

{

Got this a few weeks ago from a friend but didn't have a chance to sit down and digest the entry until tonight. Pretty cool and although premature optimization gets a bad rap, it's a reminder that sometimes what seems intuitive and quick could actually be costing a lot -

}

Lake Wobegon Distribution

2008-11-05T21:23:00.001-08:00

{

Not sure where I saw this one first but it's a great article. I wonder if the Lake Wobegon distribution applies as well to programmers...

}

LINQ to SQL death rumors

2008-10-31T22:39:00.001-07:00

{

I think it all started with this post from Tim Mallalieu reporting some directions for LINQ to SQL and the ADO.NET Entity Framework. Ayende and others have had some strong reactions (LINQ to SQL is dead) and there's now a StackOverflow thread you can use to follow the discussion.

It will be interesting to track over the next few days what other responses pop up. A few things that come to my mind:

1. This is an opening for people using Linq to SQL to migrate to SubSonic or NHibernate. I've been using SubSonic lately and enjoying myself quite a bit.

2. A big disappointment for people like Benjamin Day who I saw speak at VSLive and who have incoprorated LINQ to SQL into their development projects. Next time wait for Microsoft to 2.0 something before spending too much time working it into your dev cycle.

3. I wonder if Microsoft hasn't thought of spinning off some of the tool makers as different companies. Perhaps there is an MBA out there who could draw some charts and convince management to have ADO.NET Entity Framework and the LINQ to SQL folks compete/copy in the same space. If the team isn't fully formed, why not make one? And then how cool would that be: profit centers that encourage developers to use Microsoft tools and competition to get the best ideas out the door. The trade off of Balkanization versus One True Product is that the former will mean that cool new ideas belong to you - the company won't have to get the ideas from outside sources.

4. I wonder if we aren't moving towards a tipping point of Microsoft developers "getting" open source and shifting their tool/framework usage outside of Microsoft. I know lots of people who won't use __anything__ unless it has a Microsoft logo because it feels safer and more commoditized. Moves like this seem to go against that since open source projects tend to live a longer time and technologies / frameworks from companies become "obsolete" (how many versions of ADO can you count?) because of a product cycle that requires new purchases every 2 years or so. I would argue with my boss on a new project that it's safer to use NHibernate than ADO.NET Entity Framework if this indicates a chance that the Entity Framework could be the next LINQ to SQL project.

}

.NET Survey

2008-10-23T22:35:00.001-07:00

{

Scott Hanselman did a survey of .NET usage and posted results on his blog. A few interesting notes:

1. Heavy use of older stuff: ASMX, DataSet, WebForms, Windows Forms
You'd be hard pressed to find new blog entries on it but it shows that older (tried) technologies don't sync up with what's popular. The last few projects I've worked on have had development cycles that far exceed the excitement of their underpinning technology. One needs to remember that excitement and hype aren't what make something useful, it's use. So the people who talk down DataSets do so in the face of what obviously works for a silent majority who are busy getting stuff done.

2. Some new stuff won't take, some new stuff takes off
The respondents using CardSpace and WorkFlow are dismal. I can match the "unscientific" survey with a lot of my own experience in the last few years and conclude it's within a broader trend. On the other hand, LINQ To SQL has very heavy use for something relatively new, almost on par with ADO DataSets which one could argue are in the same competitive space. That says to me that in some cases adoption is just slow when there's a "legacy" counterpart for a technology but in others, when the new technology is compelling, people take to it very quickly.

3. WinForms > WPF
More than twice the respondents but here's my conclusion: it's all about the toolset, not the technology. WPFs tools are not on par with their WinForms equivalents. The dual Blend + VS strategy doesn't make sense for a large majority of us who don't have full time designers we work with and the lack of built in controls (such as a DataGridView) mean as cool as rounded edges are, function trumps form when programming.

4. MVC?
Last I checked this was *just* released as a beta. More people claim to use that than WPF which seems to indicate a Hanselman type majority in respondents. Even if I wanted to jump into MVC, until it's at a "1.0" release I couldn't (and I'm wondering how others seem to be doing so) justify starting or migrating a major product to a product/framework that isn't yet complete.

}

Recursive Copy ala LINQ

2008-10-22T22:30:00.001-07:00

{

Tonight I needed to copy a bunch of images, no matter their level in the hierarchy to a single folder. Cake walk with C# and LINQ, I'll post the Python equivalent tomorrow.

string sourceDir = @"C:\thesource";
string targDir = @"c:\thetarget";
var files = new DirectoryInfo(sourceDir).GetFiles("*", SearchOption.AllDirectories)
                .Where(p=> !p.Extension.Contains("db")) // exclude the pesky windows db file
                .Select(p => p.FullName);
foreach (string path in files) {
    File.Copy(path, Path.Combine(targDir, Path.GetFileName(path)));
}

}

Better Know a Framework: Zip / Package Multiple Files in C#

2008-10-20T21:59:00.001-07:00

{

Making a single archive out of multiple files in .NET is easy once you know where to look but I spent far too long realizing there is a System.IO.Packaging namespace (not in the mscorlib, but you need to reference WindowsBase assembly).

// target file
string fileName = @"C:\temp\myZip.zip";

// point to some files, say JPEG - did I say I love LINQ?
var filesToZip = new DirectoryInfo(@"c:\temp\").GetFiles("*.jpg").Select(p => p.FullName);

using (Package exportPackage = Package.Open(fileName))
{
    foreach (var file in filesToZip)
    {
        using (FileStream fileStream = File.OpenRead(file))
        {
            Uri partUriDocument = PackUriHelper.CreatePartUri(new Uri(Path.GetFileName(file), UriKind.Relative));
            PackagePart packagePart = exportPackage.CreatePart(partUriDocument, System.Net.Mime.MediaTypeNames.Image.Jpeg);
            CopyStream(fileStream, packagePart.GetStream());
        }
    }
}

// somewhere else, the CopyStream
private static void CopyStream(Stream source, Stream target)
{
    const int bufSize = 0x1000;
    byte[] buf = new byte[bufSize];
    int bytesRead = 0;
    while ((bytesRead = source.Read(buf, 0, bufSize)) > 0)
        target.Write(buf, 0, bytesRead);
}

The trap in looking for this was that searches for this all point towards the GZipStream which is nice for a single file but not applicable for packaging multiple files. In my case I wasn't even interested in compression, just a single archive. You'll find additional documentation for the library here.

I'm half tempted to write a nifty tool in IronPython for command line packaging but in a world with 7-zip, that's simply foolish.

}

Mashing Up: JQuery and Windows Forms, a first WIB

2008-10-18T22:52:00.001-07:00

{

A lot of people are down on Windows Forms as something passe. I have a feeling there are a lot of people like me who not only must use it for practical reasons but also think there are advantages to fat clients that sit on the Windows platform. I'm getting to a point where I will start doing more than poking around with WPF but at present two factors hold me at bay: the control library is not robust enough (another tutorial of how to make a custom button in blend isn't incentive enough) and XAML is still a bit daunting for what usually end up being rather involved UIs. Here, for example, is a UI from an application I've been working on for a while (small intentionally to impart an idea of complexity without revealing any details):

I think a lot of "do it in XAML" problems can be solved with a more web development style paradigm in Windows. A simple example is template driven databinding with styles. That's easy to do in web applications but a little less flexible in a control based world (think a GridView with CSS versus the Windows Forms DataGridView).

As a proof of concept I decided to use the System.Windows.Forms.WebBrowser in a Windows Forms application to get cool features from JQuery while maintaining the strengths of a windows app. Here's the scenario: a photo manager application. It builds and manages a database of photos from a digital camera. Rather than uploading the 300+ pictures taken in a single session to Flickr (or in conjunction with that act) one can open it up, start annotating their files and saving the comments to a portable "database" that they can back up along with the files on their home machine. On any machine with the application they point to the directory and can view their original comments along with the pictures. Here is a screen shot:

The strength in this scenario of Windows Forms is the ease with which one can build the editing interface: textboxes, buttons and other "drag / drop" pieces of the control library. The strength of JQuery is in the display - I've chosen to use an animation and the accordion to spruce up the interface where the user looks at their photos.

You can download the whole thing here. (Very 0.1 but posted as an example/idea - just use the next / previous buttons to view some photos, get a feel of things).

I wonder if this paradigm can be a kind of Ajax "aha" moment; Ajax was centered on the use of a single, relatively simple MSXML component. Though System.Web.Forms.WebBrowser is not simple, it's a single component that has a lot of room for leverage. Ajax set up some pretty standard protocols / approaches to using asynchronous HTTP requests from a client - I think an interesting parallel could exist in wrapping jQuery and Html controls into a kind of framework that is easy for any developer to use with the WebBrowser control. Imagine a grid you drop with some properties and a CSS. The last thing that made Ajax pop was the catchy name. I love naming things myself so I've been calling this kind of application a WIB (Windows + Web) but perhaps there's something more catchy one could use.

Just some ideas, I'd be curious in the following:

1. Any existing applications written with this approach.
2. Any potential applications that could benefit with the pros of both Windows and Web
3. Any glaring shortfalls

}

ps. Thanks to Corey for encouragement on the blogging tip.

YUI File Disjoin Complexity HELP

2008-10-01T17:27:00.001-07:00

{

I got a little help yesterday from Dav Glass and Eric Miraglia for my issue on selection of YUI javascript files. What I'd had distributed over a bunch of files is now:

Hm... a bit better. Both Dav and Eric confirm that the canonical solution to this problem is to spend some quality time at the YUI Configuration Site which will allow you to pick the widgets and utilities you've leveraged in order to combine it into a more simplified call.

A someday project: the following style of implementation to make the reference a bit more crisp (I didn't add everything from above, but the pattern should be easy to observe):

<script type="text/javascript" src="http://yui.yahooapis.com/combo/2.5.2/dom-event&animation-min&element-beta-min&container_core-min"></script>

Anyhow, thanks for the help.

}

YUI File Disjoint Complexity FAIL

2008-09-30T15:39:00.001-07:00

{

So here's what has been getting my goat for a while with YUI and a very smple application I've been using it to build.

So for said application, I have to reference 12 separate Javascript files along with 5 separate CSS files. All for this simple interface (datatable, tabs, button, ajax (connection), events and maybe a few more things I am not remembering):

This type of complexity is what makes YUI daunting for many developers and difficult to maintain; over at nRegex I'm referencing a bunch of older versions of YUI and if/when I do decide to update there will be quite a few places in which compatibility and errors have the potential in manifesting themselves.

YUI controls are nice once working but I'm at the point of wondering if this kind of disjointedness should lead me towards jQuery or Dojo. Especially with Microsoft's recent adoption of jQuery, I'm leaning in that direction. But I don't want to be rash so I'll ask:
1. What is the canonical solution e.g. blessed by Yahoo! (I see a YUI loader of some kind)?
2. What does that look like with the 5 CSS and 12 *.JS files I've got above?

}

Reading Source, Minima III

2008-07-28T22:05:00.001-07:00

{

As my reading of Minima source code continues I wanted next to comment upon the database interaction which is novel (to me at least) in that it is exclusively a LINQ implementation with no stored procedure or ADO.NET implementation. I've seen LINQ quite a bit, but many using it seem to stick to using the query syntax rather than using raw lambda expressions. All the LINQ in Minima that I've seen uses lambda expressions and I've come to appreciate it as a clean, sparse syntax. To illustrate a more trivial example, assuming I have a table Users with Username / Password columns I wanted to verify for access. The first step with all things LINQ is to make your data model, which amounts to a DBML file that you map database objects to with drag and drop. Next you can write query expressions to pull data out of the database - notice that the db variable here points to the data model as embodied in a "data context" object:

            var authUserQuery = from u in db.Users 
                    where u.Email == Login1.UserName && u.Passphrase == Login1.Password
                        select u;

Unfortunately the query expressions return an IEnumerable<T> that doesn't support a Count or Length property. It's a somewhat inflexible thing that in my *very* limited experience is useful mainly for iterating with a ForEach - and I suspect it's reasons like this that led Betz to using a lambda syntax that is much cleaner and gets more bang with less code:

            Func<Data.User, Boolean> checkUser = x => x.Email == Login1.UserName && x.Passphrase = Login1.Password;
            Data.User u = db.Users.SingleOrDefault(checkUser);

You can use nullability to test for the presence of a record based on the LINQ query. Some source from Minima that demonstrates this is verification of the existence of a blog author:

            Func<AuthorLINQ, Boolean> authorExists = x => x.AuthorEmail == authorEmail;
            authorLinq = db.Authors.SingleOrDefault(authorExists);
            if (authorLinq == null)
            {
                throw new ArgumentException(message);
            }

It's truly novel and I don't mean to make that sound like a trivial or ornamental type "novel" I write; after spending so much time building a data access layer with stored procedures and ADO.NET (Connection, Command, Reader, DataSet, ad nauseum) it seems like our collective destiny is to walk away from that and let something like a DBML data context do black magic for us.

Even though the ADO.NET Entity Framework is getting a FAIL vote from some people, I'm interested to see how this overlaps with LINQ. Even after listening to Hanselman's interview of Mike Pizzo I'm still a little unclear. My plan of action is to get serious about NHibernate to try to understand, as Scott would say, "the gestalt" of an ORM and then make the call on ADO.NET Entity Framework when it's released.

}

Twining, TwyDL

2008-07-24T21:35:00.001-07:00

{

A quick note that Twining isn't dead and that I actually have been working on it. Some work I've done in the past few months has involved a lot of databases I don't have more than an ISPs user/password level of access to so it's been quite handy to copy data in and out with brief pieces of code. Here's one feature I've used, exporting a table definition and all of its contents to a scripted insert statement in a file:

database(cn).table("MY_TABLE").copyto.script("c:\\temp\\MY_SCRIPT.sql")

Another piece that I've been working on is the ability to generate schema objects in a more fluid, compact way. I like SQL just fine but after seeing how easy it is to make data structures with the Google App Engine I sought to shoot for something similar. Also within the flow of writing a Twining script it's easy to keep this type of syntax Pythonic for certain scenarios (you want to create a temp table and dump data into it from somewhere; you want to create a table and generate sample data, etc, etc). I call it TwyDL as a play on DDL:

database(cn).create.table("Employees", 
                               [
                                   col.ident("EmployeeID"), 
                                   col.string("FirstName"), 
                                   col.string("LastName"), 
                                   col.numeric("Salary")
                               ]
                          )

The methods you see for defining column types take optional parameters so you can pass additional specifications when you feel the need. For example, the string columns default to varchar(50) but if you wanted to have a specific length all you'd need to do is:

col.string("FirstName", 25)

The same is true for numeric types:

col.numeric("Salary", 18, 4)

I've got one more thing I'm interested in implementing (time! time!) which is generating sample data given some table definition. I'm hoping to get up a rough cut of it all in the next day or two, after I've updated unit tests and organized things.

}

Reading Source, Minima II

2008-07-21T22:19:00.001-07:00

{

Yesterday I wrote that my next stop was the use of Generics with WCF. Sometimes, it seems, a lot of experience is a handicap to learning new things - such was definitely the case when it comes to the full use of Generics with C#. Most of my usage, I admit, has been limited to Generic Collections such as List<T> or Dictionary<T, K>. But there is a beautiful leveraging of Generics I see with WCF that can be applied all over the place. As a trivial example, consider the code that is used to safely read values from a database field. I will admit to writing a lot of code like:

class ReaderHelper{
	public static void GetSafeString(object field);
	public static void GetSafeDecimal(object fiel);
	// and so on.
	
}
// somewhere else in code:
string firstname = ReaderHelper.GetSafeString(rs["FirstName"]);
decimal salary = ReaderHelper.GetSafeDecimal(rs["Salary"]);

A lot of redundancy and little extensibility. Here's how a WCF infected mind might write that:

class ReaderHelper{
        static T SafeField<T>(object field, T defaultValue){
            return (field == DBNull.Value) ? defaultValue : (T)field;
        }
}
// somewhere else in code:
string firstname = ReaderHelper.SafeField<string>(rs["FirstName"]);
decimal salary = ReaderHelper.SafeField<decimal>(rs["Salary"]);

If you coupled the above with some inversion of control you'd have a pretty powerful and extensible code for dealing with any potentially null field type coming from your database. It's not that such use is an innovation exclusive to WCF, I see it used a lot more there. Back to Minima, one can see a good example of this in the project responsible for exposing configuration values:

namespace Themelia.Configuration
{
    public static class ConfigAccessor
    {
        public static T ApplicationSettings<T>(string key);
        public static string ApplicationSettings(string key);
        public static T ApplicationSettings<T>(string key, bool isRequired);
        public static string ApplicationSettings(string key, bool isRequired);
        public static string ConnectionString(string key);
    }
}

More on Minima later (hopefully tomorrow), taking a look at database access.

}

Reading Source, Minima I

2008-07-20T21:05:00.001-07:00

{

I'm interested in the notion of deliberate practice as it relates to software developers. How do we "practice" effectively? One of the things I've been wanting to be more serious and deliberate about was reading source code. Hanselman has inspired me with his "weekly source code" posts and since good ideas are worth copying I'll start to document some of the projects I download and look into for examples of good code.

The project I'm currently working on involves a lot of WCF. I've got mixed feelings (as well as a lot to learn) about it so I thought I'd start off by running Minima, Dave Betz's WCF/.NET 3.5 blog engine as a sample of an end-to-end application I can model my own WCF architectures after.

Minima was not easy to get going. While I'm perhaps not the brightest kid on the block, the biggest item I struggled with would probably be a challenge to anyone: the certificates used in the WCF security model. While Betz has a blog entry documenting the basic usage of certificates with WCF, it is predicated on the WCF host not being IIS. For the blog I assumed everything should be deployed to IIS and ran into the a lesser known fact that one must use the Windows HTTP Services Certification Configuration Tool to enable the ASPNET account access to the certificates for their usage. There were also a couple of post build events in the project that I removed after getting my references set up.

But before I get into particulars, I wanted to go over the broader structure of the project. The Minima solution has the following projects:
* Minima.Service
This has the service and data contracts with no implementation
* Minima.ServiceImpl
This has the implementation of the service
* Minima.Configuration
A configuration helper which makes use of a library called Themelia (Betz is, apparently, a Biblical Greek scholar on the side)
* Minima.Web
Library for the blog website's features
* Website
A website project
* Website Service project (exposes services for posting content to the database via WCF)

I'll write about more particulars in my next post but for this overview my biggest takeaway in the project structure is decoupling. Separating the service from the service implementation, separating the website from it's functionality by a project with the only purpose of implementing that backend logic, and separating general purpose frameworks like Themelia (for reading the config file etc).

When I start my own projects I usually think too much about doing a proof of concept and less about decoupling the overall structure. As a result most projects start off as a "sketch" in a single Visual Studio project and by the first release end up staying that way on a permanent basis. But perhaps what we should focus on as programmers is less the cleverest algorithms and more the most elegant structure for building solid applications.

Next stop: WCF and Generics.

}

Tragically Well Known

2008-07-16T21:01:00.001-07:00

{

Of late there seem to be a lot of the well knowns of blogging bowing out (at least in volume) because of how much work it takes to qualify and disclaim the topics they take upon themselves. I find it sad because even the essays I find myself disagreeing with usually provide the same thought provoking effect as the ones I enjoy in agreement. It's strange to think that people like Paul Graham and Joel Spolsky would be exasperated by the barbs people toss their way and yet, it seems, they are. Paul's essay on disagreement seems evidence of this and the most recent Stackoverflow podcast dwells considerably on the topic from Joel's perspective.

I would like to make the following proposal both in encouragement of people like this writing and for people like myself enjoying it: rather than quick barbs and/or "jumped the shark" posts, return to the previous material of the author and enjoy an old post. It's not that disagreement is bad or unwelcome; I think a lot of the well knowns enjoy a spirited discourse. It has more to do with people either misunderstanding or disagreeing in the wrong way - DH0 to DH4 as Paul would have it.

}

Predictably Irrational: Startups and Open Source

2008-07-13T18:05:00.001-07:00

{

The Herding Code podcast took up the topic: "Why don't startups run on Microsoft?" which I thought was interesting - it crossed paths with comments in a spat I've followed between Atwood (who chose .NET as a platform for Stackoverflow) and Marco Arment (of tumblr fame (side note: I actually have a tumblr)). Had you asked me before Friday for an opinion I would have probably attributed it to the Byzantine licensing schemes for Microsoft products as well as marketing oriented decisions like making IIS 7 unavailable on XP.

On Friday, however, I heard a commentary on Marketplace from Dan Ariely that is a basis for a hypothesis that hadn't occurred to me but seems to make perfect sense for software. Ariely, a behavioral economist at MIT, starts with suggesting that the next time you eat out with friends, it might be better to have one person pick up the "pain of paying" for dinner rather than distributing it across all the people who were out. According to the commentary (emphasis mine):

Findings from behavioral economics tell us that one person should pay the entire bill and that the person paying should alternate over time. When we pay any amount of money, we feel some psychological pain. We call this the pain of paying. This is the unpleasantness that is associated with forking over our hard earned cash. But it also turns out that this pain does not increase linearly with the cost of the meal. This means that when we double the payment, the pain doesn't double; it increases just by a bit. In fact, the biggest increase in the pain of paying comes when we switch from paying nothing to paying something. Now, it's easy to see why one person should pay the entire bill. How so? Well, if every person paid their share, they would all experience some pain of paying.

If you're curious about how Ariely is able to make that assertion, he elaborates on this and other ideas in his book Predictably Irrational.

It makes perfect sense that this could be a credible idea behind why startups don't work with Microsoft technology - that the cost is less of a factor than "costing" some dollar amount. If you attach to that complex licensing and many flavors of the same product and you get pain that goes beyond the "pain of paying."

It makes some sense on the Microsoft side of things too; rather than trying to determine which products developers should get matched to, most companies just buy a high end MSDN subscription for developers even though chances are high that not all the products are actually used. They can count on "enterprise" companies conservatively overpaying and hence getting the most out of them.

A couple of thoughts that come to mind:
1. How could one go about trying to measure the "pain of paying" with software?
2. Does "free" open source translate to more time in managability/expertise?

}

Change Dispensed

2008-06-27T10:51:00.001-07:00

{

Steve posted a coding challenge a few days ago - a change dispenser. I thought it would be a nice exercise for my fledgling Python skills and implemented it with just a small variation on pluralizing coin denominations.

def make_change(amt):
    output = "Change is "
    coins = (['quarte|r|rs', 25], ['dim|e|es', 10], ['nicke|l|ls', 5], ['penn|y|ies',1])
    for i in coins:   
        r = amt // i[1]
        if(r > 0):
            coinout = re.split('\|', i[0])
            output += "%d %s%s " % (r, coinout[0], coinout[1:][r > 1])
            amt = amt - (r * i[1])
    print output
    
make_change(48)

A few things I learned along the way:

* I was reminded that dictionary objects do not guarantee order.

* I was using Python regular expressions to do a match on the string "this |and|or that" and discovered if you use match with simply \|(\w+) it returns nothing since the match must start from the beginning of the string!

* I was going to use a lambda expression for the pluralization but that's such a large hammer for what in the end would become a split

Python's behavior with booleans is another point of interest - when I test the following: coinout[1:][r > 1] I'm taking advantage of anything true being a 1. I wonder if this is "bad" but it's a seductive thing to take advantage of...

}

Deep Fried Bytes, Yegge, Interviewing

2008-06-23T21:50:00.001-07:00

{

Found a good podcast today, "Deep Fried Bytes." Skip the first episode but the second on interviewing is a gem. Although it was posted on May 29, it ties in quite well with thoughts delivered (not simply written, but delivered) by Steve Yegge in his recent post on finding good people, Done and Gets Things Smart. Not only is it entertaining to hear Ayende Rahein take nonusers of using blocks to task, but later Scott Belware seems to be on the same page as Yegge on how you can know if people are "good." Here is his approach (listen to the podcast if you want total accuracy):

- I don't ask questions I do pair programming for interviews...
- Interview questions are irrelevent... most of the people asking interview questions are showing the people who are interviewing what they know
- Ask for a code sample with unit tests that run inside Visual Studio
- If that's okay ask them to come in for 4 hours of pair programming
- Most interview related items would come up during the pair programming session

}

C# Multiple Replace Extension Methods, Levithan Style

2008-06-12T22:04:00.001-07:00

{

A couple of nights ago I blogged about an implementation of a technique to replace multiple patterns in a string on a single pass. Steve Levithan had an entry on the approach (not mine in specific, just the approach and commenting on a few weaknesses). It inspired a few things out of me: first, making the multiple replace an extension method of the string class, and second to duplicate Steve's approach which enables a more robust model because you can use metasequences etc...

Here is the code (included the using statement since the use of ToArray() from the Dictionary key collection isn't available without System.Linq):

using System;
using System.Linq;
using System.Collections.Generic;
using System.Text.RegularExpressions;

static class RegexExtender {
    public static string MultiReplace(this string target, Dictionary replacementDictionary) {
        return Regex.Replace(target,
                                "(" + String.Join("|", replacementDictionary.Keys.ToArray()) + ")",
                                delegate(Match m) { return replacementDictionary[m.Value]; }
                                );
    }

    public static string LevithansMultiReplace(this string target, Dictionary replacementDictionary)
    {
        foreach (string key in replacementDictionary.Keys) {
            Regex r = new Regex(key, RegexOptions.None);
            target = r.Replace(target, replacementDictionary[key]);
        }
        return target;
    }

}

Here is some usage:



// the original approach, as an extension method
string x = "Holly was a hunter";
Dictionary rdict = new Dictionary();
rdict.Add("Holly", "Hannah");
rdict.Add("hunter", "hatter");
Console.WriteLine(x.MultiReplace(rdict));

// Steve's technique
rdict = new Dictionary();
rdict.Add(@"[A-z]", "x");
rdict.Add(@"\d", "y");
string test = "David is 33";
Console.WriteLine(test.LevithansMultiReplace(rdict));

}

Regex: replace multiple strings in a single pass with C#

2008-06-10T22:13:00.001-07:00

{

I wish I could say I was the clever one to think of this but I ran into it in my copy of the Python Cookbook (the original author is Xavier Defrang, the Python implementation here). It's cool enough that I ported it today - I'll know I'll use the C# implementation of it quite often:

        static string MultipleReplace(string text, Dictionary replacements) {
            return Regex.Replace(text, 
                                    "(" + String.Join("|", adict.Keys.ToArray()) + ")",
                                    delegate(Match m) { return replacements[m.Value]; }
                                    );
        }
	// somewhere else in code
            string temp = "Jonathan Smith is a developer";
            adict.Add("Jonathan", "David");
            adict.Add("Smith", "Seruyange");
            string rep = MultipleReplace(temp, adict);

}

Languages And Thinking

2008-06-08T21:08:00.001-07:00

{

I'm approaching the end to a rough week and should be coding but the virus scanner on my office machine is slowing development to a point where it's not bearable for me. I'll pass the time with a quick thought about how programming languages affect thinking and why it makes me both picky about languages I use and also curious to see how the different languages solve problems.

I will confess that the project I've been working on is written in VB.NET. The reason for that was very practical since our client was adept at VBA and needed to, on occasion, get to the code level of things. I'd spent a lot of time in Visual Basic (the "classical" VB) so I thought nothing of it - perhaps somewhat of a refreshment after so many years away. As we wrote more and more code, I started noticing a lot of nested "If" statements in the style of:

If Some Condition Then
	If SomeOtherCondition Then
		If YetAnotherCondition Then

You get the picture.

I remember working with a different VB programmer and she was also given to writing a lot of nested conditions in the same manner even though we were using C#:

if(cond){
	if(cond2){
		if(cond3){

At the time it really bothered me in a "code smell" sort of way; nesting conditions, I would have argued, invites clutter and entropy. Since I've been attending Hanselman University for a while now I can say with more technical gravitas that they increase cyclomatic complexity and this was why they smelled bad. The alternative I would have wished for would have been:

if(cond && cond2 && cond3){
...
}

Pretty natural, right? Actually no, especially if you're coming from Visual Basic because the Visual Basic And and Or operators don't do short circuit evaluation. If you combine boolean expressions you have to make a mental note to verify that they both will work at runtime - that there is no dependency between them. That's something a C# progammer completely takes for granted often writing code like this which is a ticking bomb in VB.NET (it won't go off until you're demonstrating the app to your client, trust me):

If Not MyCollection Is Nothing And MyCollection(0) = "Something" Then
	...

One expects the second expression will be passed if the first fails in a "short circuit" approach. Unfortunately, Visual Basic .NET will attempt to evaluate the second even if the first is not true!

To clean this all up the VB.NET folks provided the AndAlso and OrElse operators which do traditional short circuit evaluation. I read somewhere that the reason And and Or were left as is was for backward compatibility and people who were "upgrading" their code from Visual Basic to Visual Basic.NET. Using these operators you're back to thinking "normally" as a C#, C, Javascript, etc... developer.

So back to my original thought - nested If blocks are a simple way around an operator that doesn't short circuit and it's a way of thinking if you've spent a lot of time writing Visual Basic code. The language is what drives that even though there may be alternatives. Even though it may produce cyclomatic complexity. Some people tell me picking a language is just a simple process of picking a tool, but I think it's more than that; it's picking a way of thinking. That's why it's not only important to me, it's interesting to see how different languages lead us in different directions. Even if an idiom is available elsewhere, it's getting to think that way that is most often the trick to being better in both languages.

One more side note, I can chart a few different ways in which new languages have affected me. Take a look at the type of thing I did before a lot:

foreach(string s in stuff){	
	master += s + ",";
}
master = master.Substring(0, master.Length -1);

Nowadays:

// like a map, I first started thinking this way from perl
stuff.ForEach(delegate(string s) { master += s + ","; });
// like a join, very Pythonic
String.Join(",", stuff.ToArray())

}

Galloway et. al. Roundtable Podcast

2008-06-01T17:45:00.001-07:00

{

If you haven't and you do Microsoft development, give an ear to John Galloway, K. Scott Allen, Scott Koon, and Keven Dente in their "Technology Roundtable" podcast. There are a lot of podcasts I find entertaining, (like Joel and Jeff's discussions) but these guys seem to do what I do - and to contextualize that since it may sound presumptuous, they deal with Microsoft development tools building "real world" software.

I try to have "take aways" from podcasts so from the first more impetus to investigate Ninject and dependency injection as well as more investigation of LINQ to SQL and the ADO.NET Entity framework (opinions flew on these, I'd like to develop some of my own). Finally, even though I'll probably skip the beta, I will look forward to .NET 3.5 SP1 since ASP.NET Dynamic Data will be packaged therein.

The second podcast had a great discussion on javascript libraries. I've used jQuery and YUI and Prototype on different projects and while my fondness for Prototype/Scriptaculous is probably greatest of all I am always eager to hear other people's experiences. The framework I have yet to do anything serious with is Dojo - I did some quick prototyping of their flyout menu with ASP.NET server code and I hate to say it but the ASP.NET Menu control was a lot more effective and fast. While it wasn't explicitly stated, this podcast has dampened my interest for the ASP.NET Ajax stuff - I looked at it again a few weeks ago and it seemed so... heavy. I'm not sure who mentioned it in the podcast but they said it seemed more oriented for writing controls versus Ajaxy type applications. I would have to concur with my limited knowledge.

I'll stay tuned, it will be interesting to see what they talk about next time.

}

Knowing C

2008-05-31T16:10:00.001-07:00

{

I've been having a good time listening to the StackOverflow podcasts. Joel's a great curmudgeon and Atwood is as opinionated as ever. An ongoing disagreement between the two has been the usefulness of knowing C. Joel's adamant about its importance and Atwood thinks there is much else a developer can spend their time in understanding.

Eric Sink has since chimed in with a post called C and Morse Code wherein he reveals his cards: like Joel, he thinks it's of vital importance if you want to reach past mediocrity:

I'm not going to take a black-and-white stance on this. I won't go so far as to say that every developer must learn C. I've met lots of developers without C experience who are successful and making positive contributions to important software projects.

Furthermore, I'll admit that knowing C is not a magic solution to poor skills. A lousy developer who happens to know C is simply better equipped to hurt himself or somebody nearby.

However, I can say these two things:

All of the truly extraordinary developers I know are people who really understand the kind of low-level details that C forces you to know.

Every programmer without C experience has a clear path of personal development: Learn C. Get some real experience using C to write a serious piece of software. Even if you never use it again, you'll be a better programmer when you're done.

My relationship with C is tenuous at best. I spent a few months some years ago delving into it (and C++) seriously - I'm curious to go back and find some of that code but it was a few machines ago*. I remember during that time I'd work on little toy programs (mostly an implementation of some algorithm) in C and then have the need for a utility and write it in something else. It would be interesting to take Eric up on his second point of writing a "serious piece of software" using the language. One interesting angle on this is how one would keep said "serious piece of software" strictly in the realm of C, without venturing too much into the world of C++ and object orientation done poorly.

So brainstorm question: what's something nice and useful that could be implemented strictly within C? (That one might not yawn and think *gosh* that would take 1 minute to do in Python).

}

*Great memories of Me, Markus, and bcc32 in a coffee house somewhere in southern California. Too far gone are those days...

Splitting Files with Python

2008-05-29T21:09:00.001-07:00

{

I've been recently needing to generate sql scripts from large Excel spreadsheets. But once the script is finished I've had issues getting SQL Management Studio to execute as large a script in a single run. The solution? Split up the file with a little Python that takes it's arguments like this:

ipy Splitter.py LargeFile.sql 3

#import clr
#pass arguments like so:
# THISSCRIPT.PY FILE NUM_PARTS
# ipy Ringil.py LargeFile.sql 4

import sys

if(len(sys.argv) == 3):
    splits = int(sys.argv[2])
    f = open(sys.argv[1])
    data = f.readlines()
    lc = len(data)/splits
    print "number of lines", len(data)
    for c in range(0,splits):
        outstream = open("data" + str(c + 1) + ".sql", 'w')
        for line in data[:lc]: 
            outstream.write(line)
        outstream.close()
        del data[:lc]
    f.close()
else:
    print "Expected arguments: file and number of splits\n example: ipy Splitter.py LargeFile.sql 4"

}

It's speed that counts

2008-05-20T19:31:00.001-07:00

{

I usually don't talk about hardware because I don't pay too much attention to it unless something is bothering me. However I've discovered something interesting about myself in the last week. I've done a lot of my development over the last few years on an enormous HP zd8000. I jokingly called it "the 747" because of its size and girth - 10 lbs and a 17" screen. For a guy like me who's usually also carrying a few books in his bag it's quite a load as evidenced by my going through at least one laptop bag (my current one is also in poor shape).

So because of some changes at work I got to try out a machine I'd liked the thought of - another HP but this one with a small 13" screen and weighing perhaps 4 lbs. It's a great little machine and has a cool look but after about a week I'm back to the 747.

Why go back to the back pains and encumbrance of this massive machine? One simple reason: speed. It's got twice the RAM (2GB) and a much faster processor. I didn't think about this much but for a person like me who is usually running an instance of SQL Server, an IDE of some sort, a text editor, web browsing with 10 tabs open, listening to music, chatting up friends (Messenger is no joke when it comes to resources), etc, etc - you get the picture - it's frustrating to be on a beautiful, compact machine that you have to wait around for. I'd rather exchange power with encumbrance for convenience with time penalties.

Or, as I like to joke with my South Dakota friends, I'm like a guy who exchanged his Chevy Silverado for a crossover vehicle... until he realized that he made his living hauling lumber.

Footnote: I ordered a Thinkpad T61 which should be a foot in both worlds. I guess my bit of the economic stimulus went to China.

}

Nregex mention

2008-05-19T21:54:00.001-07:00

{

Steven mentions Nregex in a list of regular expression testers online. Nregex is still up and still useful especially if you need to work with .NET's implementation of regular expressions. A coworker of mine just used it to build a parser for Sql Reporting Services RDL files. Steven's own RegexPal is a fairly intense implementation of regular expressions in javascript, complete with syntax highlighting.

}

Workaholism

2008-05-12T21:54:00.001-07:00

{

Matt from 37Signals blogs about workaholics with the following assertions: they don't get as much done (most of the time) and they focus on inconsequential details.

Many leapt to the defense of workaholics - people who, it seems, are workaholics themselves. Because I'm often labeled a workaholic I'm trying to see past my emotions and yet it still doesn't smell like the truth to me.

And even more so because this weekend I watched Triumph of the Nerds, Cringley's chronicling of the personal computer industry from it's humble roots in what would become Silicon Valley. As he interviewed people, I couldn't help but think that software development is experiencing a culture change. The people who got the boat off the ground were almost entirely obsessed with their work, even down to the details. I have a hard time imagining an Andy Hertzfeld, Woz, or young Bill Gates as a 501 developer.

Even if you go forward a few years, guys like John Carmack don't fit the mould of "balanced life/time to go pick up my kids and watch TV!"

These days though, I think what used to be hobbyism is now simply work and fair game for any person who wants a way to earn their keep and "clock out" for life afterwards. This is not to say that it wasn't that way before, it just seems like much more commitment was involved. Or maybe the moral is that no one with a 501 development attitude did anything noteworthy.

But even as I write that and play my hand as a kid who grew up on the folklore of the early computer industry I have to do a gut check because me staying at work late building yet another website for someone is not the same as writing the first GUI. Not even close...

I take away the notion that there isn't necessarily a direct relationship between time spent at work and productivity but I also know that if I had the 9-5 attitude with no tendency to "get into" my profession, I might as well be an accountant. And as grandiose as it may seem, I'd love to have one idea that really matters versus a lifetime of mediocrity so I could rush home to have a "life."

}

Old Computer Books

2008-05-10T20:26:00.001-07:00

{

I was recently feeling ashamed of myself after reading Atwood's Programmers Don't Read Books... post for what he called Programming book pornography: "The idea that having a pile of thick, important-looking programming books sitting on your shelf, largely unread, will somehow make you a better programmer." To clarify, I actually do read the books I have bought but I'm guilty of keeping a full shelf for the sake of showing off my long and continuing struggle to be a good programmer.

One way I can soften this sort of conceit is by thinking of how I'm really proud and boastful of my friends in real life who do things that amaze me. I'm not shy to boast on their behalf. In the same way a lot of these old books are like old friends that have seen me through some pretty turbulent times. I carried Francesco Balena's Programming Visual Basic 6.0 around for years when I was training people on VB6, COM, and ASP. Another set of heavy books I spent many a quality night in a hotel room with were Gary Cornell's Core Java and Core Java Advanced Features. I don't have a formal computer science education but I consider a large part of my education the 7 or so years I spent on the road, in various hotel rooms, reading and practicing what I needed to know.

If truth be told there are a few there that I didn't get much out of. I never did run Slashcode and I never did more than tinker with Bryce. But I'm not ashamed to say that I had hopes of doing so that time supplanted with other things.

I packed them away and made room for some of the books I have piled on top of the shelves. Since I don't travel much and remain in project mode I'm not as efficient about reading what I have but a smaller shelf is more tidy and palatable. I won't wait so long before my next big cleanup.

So the big question: what to do with these books?

}

Processing.js

2008-05-08T21:04:00.001-07:00

{

John Resig of jQuery fame has released a library called Processing.js for javascript graphics. Yes, you read that right: Javascript graphics.

Earlier this week I was in some training and the instructor asked what future we saw for Silverlight. My response was that I can't drink the koolaid just yet; while there are certainly applications in streaming media in which Silverlight will compete to the death with Flash, for web applications I see people taking Javascript to the level where its maturity with the browser makes most applications feasible. I also like the competitive environment around the Javascript libraries - the Dojo, jQuery, YUI, Scriptaculous, and other people trying to outdo one another just means better ideas, faster turn arounds, and a better experience.

}

C# Extension Method for Generic Collections

2008-05-05T19:59:00.001-07:00

{

Tinkering a bit with extension methods tonight, inspired in part by Scott Hanselman to write something I've frequently needed with generic collections: to spit them out in some delimited format. Here are the extension class and method:

    static class EnumerableExtensions
    {
        public static string AsDelimited<T>(this List<T> obj, string delimiter)
        {
            List<string> items = new List<string>();
            foreach (T data in obj) {
                items.Add(data.ToString());
            }
            return String.Join(delimiter, items.ToArray());
        }
    }

You can spit out your delimited instances of any List<T> now:

            List<string> test = new List<string>(new string[] { "David", "Morgan", "Philip" });
            Console.WriteLine(test.AsDelimited(" => "));

            List<int> primes = new List<int>(new int[] { 2, 3, 5, 7, 11, 13, 17 });
            Console.WriteLine(primes.AsDelimited(" , "));

}

Twy

2008-04-24T22:06:00.001-07:00

{

I'm still trying different things with Twining. I'd thought about writing some "front end" type experience for usage but it really crystallized as a need when I showed it to a person I know and there seemed to be a disconnect in how it could be used. For me it's natural to set my path environment variable, launch favorite text editor X and then run things from the command line or a script, but it's a nuisance if you're used to a one stop shop for being able to use some tool. And as much as I want language as the focal point in the word "tool" there is something practical in the notion of something you download and click a button to execute with.

Enter Twy, which I pieced together after looking at a few samples of a hosted DLR engine in a Windows Forms app. Now one need not figure out how to install or configure anything, or worry about creating and disposing of script files.

If you want to write something that hosts the DLR engine, take a look first at these samples on Voidspace. There are other samples online if you hunt and peck but be aware that things have changed between the various releases of IronPython. A few gotchas for me:

1. Redirecting standard output:

// where engine references the ScriptEngine type
// and ms references a Stream of some sort
engine.Runtime.IO.SetErrorOutput(ms, Encoding.UTF8);
engine.Runtime.IO.SetOutput(ms, Encoding.UTF8);

Many examples of this are deprecated for the IronPython 2.x beta

2. Referencing classes in mscorlib:

Be aware that doing the following:

import clr
clr.AddReference("System")

is not going to be enough to get types out of mscorlib. Although types will load from System, you'll need to get a reference to the assembly directly if you plan to use it in your hosted engine. I had a little trouble with the StringBuilder but easily resolved it with the following after a tip on the IronPython mailing list.

Assembly assem = Assembly.GetAssembly(Type.GetType("System.Text.StringBuilder"));
scope = engine.CreateScope();
engine.Runtime.LoadAssembly(assem);

3. The only novel thing I did that I didn't see a lot of was loading a module so that you could utilize it with your hosted engine. I added Twining.py to the project and set Visual Studio to copy it to the compile destination. I then have the following code which keeps the module available for later use:

string p = Path.Combine(Environment.CurrentDirectory, "Twining.py");
scope = engine.Runtime.ExecuteFile(p); 

// later on:

ScriptSource source =
    engine.CreateScriptSourceFromString(input,
        SourceCodeKind.Statements);
object res = source.Execute(scope);

All in all not rocket science, it's amazing how much power one has at their fingertips in such a small application. I would love to see other modules, especially ones that define some interesting type of DSL, have utilities like this that let you play around without much effort.

Oh yeah, the project and source. Download it here, I'll clean up a bit more later.

}

Getting better with meta-thinking

2008-04-20T21:06:00.001-07:00

{

Some excerpts from a great post from Ola Bini, one of the JRuby core developers:

In short, I believe that being able to abstract and understand what goes on in a programming language is one way to become more proficient in that language, but not only that - by changing your thinking to see this part of your environment you generally end up programming differently in all languages...

A little further on, emphasis is mine:

... I call this meta-level thinking. I think it's mostly a learned ability, but also that there is an aptitude component.

Cheers for this as a "learned ability" which would give one pretentious enough to call his blog "Metadeveloper" some hope.

}

Generic Enum Parsing in C#

2008-04-19T08:37:00.001-07:00

{

Generics, as it were, are passe to talk about these days. However, I found myself dealing with enumerations on Friday and was a little surprised there wasn't an approach to parsing these out in a more generic fashion. I scribbled the following, perhaps it will be of value to someone:

enum Test { 
    v1, 
    v2,
    v3   
}

public static T EnumParser<T>(string givenValue)
{
    return (T)Enum.Parse(typeof(T), givenValue, true);
}

//usage:
Test val = EnumParser<Test>("v1");

}

Sense of urgency

2008-04-15T22:15:00.001-07:00

{

One thing I’ve come to realize is that urgency is overrated. In fact, I’ve come to believe urgency is poisonous. Urgency may get things done a few days sooner, but what does it cost in morale? Few things burn morale like urgency. Urgency is acidic.
- read the whole post

Jason Fried of 37Signals neglects to mention one aspect that seems to come back over and over to haunt those of us who live with "urgency"; that it costs dearly to rework things that were done in a hurry.

}

From TFS to SVN

2008-04-15T22:10:00.001-07:00

{

My project at work added some remote developers and it was decided that rather than try to figure out TFS, which we use for everything internally, we'd use SVN. I'm not used to SVN since we used Team Foundation Server for source control and Visual SourceSafe before that - I've used TortoiseSVN quite a bit to get source code from projects online, but never as a primary source control environment for a big project.

So far it's a breeze. I installed VisualSVN Server and configured repositories and users - this took about 10 minutes. After that I was up and running with TortoiseSVN in about 3 or 4 minutes.

Hm...

Because in a parallel universe a completely different project I'm working on required me to install the TFS client for Visual Studio 2008. On my super duper 4GB Ram, 3 Ghz, desktop machine at work it took about 45 minutes.

Just the client.

So yeah, I've been thinking about that contrast quite a bit all day. One thing I think is interesting is the contrast between small teams as I heard discussed at CodeMash earlier this year and the features of TFS: all the note taking, task assignment, iteration, etc, etc... On a "one to two pizza" team (e.g. a Google, Amazon), how many people go in depth with those features versus some massive team of developers (e.g. a government agency)?

}

Twining

2008-04-14T21:00:00.001-07:00

{

Now has a its own location. I'll still post of goings on, but will keep the external site as a source of updates and documentation. There's a form there for feedback as well.

}

From Komodo to Wings

2008-04-08T22:35:00.001-07:00

{

I started my IronPython musings with Notepad++ since it's my usual text editor (after being enamored with Textpad for many years, I moved on - lots of reasons, perhaps I'll blog them later). As time passed and my scripts grew in size I started using an old version of Komodo I've got which has decent support for Python. I used Komodo (3.5) when I was writing a lot of Perl and it worked pretty well for that, especially since it had a good enough debugger and CGI emulator for me to dig myself out of holes. Komodo does okay with Python but I've been using Wings IDE on recommendation from fuzzyman and it's much more responsive and fluid as a development environment. Additionally, I got Komodo when there was still a cheapo version but now it's quite expensive - exceeding the Wife Acceptance Factor for experiments (WAFe). Wings is quite reasonable, I'll start with the Personal edition and if I can get my company onboard I'll ask that they upgrade my license.

Unfortunately I still need to run my scripts outside the IDE environs since Wings isn't built with IronPython support (correct me if I'm wrong), but I'm quite used to this now.

}

Programming Languages, Trends

2008-04-07T21:54:00.001-07:00

{

DDJ (the print edition at least) has an interesting interview with Paul Jansen, managing director of TIOBE on languages. Some interesting points:

Direct quote: "I expect in five years time there will be two main languages: Java and C#, followed closely by good old Visual Basic."
While not much has changed over the last 10 years, COBOL is now out of the top 10 list and Python is moving in.
Direct quote: "Another langauge that has had its day is Perl. It was once the standard language for every system administrator and build manager, but now everyone has been waiting on a new major release for more than seven years. That is considered too long."

Interestingly enough, TIOBE has picked the language of the year to be Python.

}

Reddit for Javascript

2008-04-06T19:35:00.001-07:00

{

Via Raganwald, there's now a Reddit for JavaScript.

}

Generate Catalog Images in IronPython

2008-04-02T22:15:00.001-07:00

{

What if you had a client who has a big product catalog you're integrating with the web. You work out a convention for how data is displayed and want to generate some test images for yourself...

First, just some basics on generating a single image:

import clr
clr.AddReference("System.Drawing")
from System import *
from System.Drawing import *

def GenerateImage(text):
    starter = Bitmap(1,1)
    g = Graphics.FromImage(starter)
    f = Font("Arial", 14) 
    theImage = Bitmap(starter, Size(200,200))
    g = Graphics.FromImage(theImage)
    g.Clear(Color.Orange)
    g.DrawString(text, f, SolidBrush(Color.DarkBlue), 0, 0)
    g.Flush()
    theImage.Save("c:\\temp\\pyImage.gif")    

if __name__ == "__main__":
    GenerateImage("Holly was a hunter")

Here's some TSQL for the sample data I'll use:

create table testdata(
    testid int identity(1,1), 
    testvalue varchar(50)
)

declare @i int
set @i = 0
while @i < 25 begin
    insert into testdata(testvalue)
        values('PRODUCT ' + convert(varchar(2), @i))
    set @i = @i + 1
end

Now for a finalized version that hits the database and generates images:

import clr
clr.AddReference("System.Drawing")
clr.AddReference("System.Data")

from System import *
from System.Drawing import *
from System.Data import *
from System.Data.SqlClient import *

def GenerateImage(text, path):
    starter = Bitmap(1,1)
    g = Graphics.FromImage(starter)
    f = Font("Arial", 14) 
    theImage = Bitmap(starter, Size(200,200))
    g = Graphics.FromImage(theImage)
    g.Clear(Color.Orange)
    g.DrawString(text, f, SolidBrush(Color.DarkBlue), 0, 0)
    g.Flush()
    theImage.Save(path)
    
def GenerateImagesFromDatabase(connectString, query, sourceColumn, outPath):
    cn = SqlConnection(connectString)
    cn.Open()
    cmd = SqlCommand(query, cn)
    r = cmd.ExecuteReader(CommandBehavior.CloseConnection)
    while r.Read():
        baseText = r[sourceColumn].ToString()
        GenerateImage(baseText, outPath + "\\" + baseText + ".gif")
    r.Close()

if __name__ == "__main__":
    connect = "Data Source=.\\sqlexpress;Initial Catalog=MVCBaby;Integrated Security=SSPI;"
    sql = "select * from testdata"
    col = "testvalue"
    GenerateImagesFromDatabase(connect, sql, col, "c:\\temp\\fobot")

Pretty cool stuff, I hope it's useful to more people than just myself. Download the first script here, the second more elaborate one here.

}

Twining

2008-04-01T22:02:00.001-07:00

{

I've been quiet but still working on Twining. Unfortunately lots of distractions at work have slowed me down. Most of what I've done of late is adding unit tests for the functionality that already exists. I twittered that adding unit tests a posteriori is not fun and tends to have the effect of one simply verifying what they've done with pasted code. Now that most of that is done I'd like to add a few things:

1. Operating on queries like tables for export and copy. Everywhere that you see "table" below, I'd like to have "query":

database(cn).table("MyTable").transform(mytrans).copyto.database(cn2)
database(cn).table("MyTable").transform(mytrans).copyto.xmlFieldsAsAttributes("c:\\here.xml")
database(cn).table("MyTable").transform(mytrans).copyto.xmlFieldsAsElements("c:\\there.xml")
database(cn).table("MyTable").transform(mytrans).copyto.delimited("\t", "c:\\foaf.tsv")
database(cn).table("MyTable").copyto.delimited("\t", "c:\\foaf_no_trans.tsv")
database(cn).table("MyTable").transform(mytrans).copyto.csv("c:\\foo.csv")
database(cn).table("MyTable").copyto.xmlFieldsAsAttributes("c:\\here.xml")
database(cn).table("MyTable").copyto.xmlFieldsAsElements("c:\\there.xml")

how about:

database(cn).query("select this, that, [the other] from foo").copyto.csv("c:\\querydata.csv")

2. Support for SqlBulkCopy - as far as I know this is only available between Sql Servers (or, more specifically SqlConnection instances).

3. Cloning of tables - if you use sql server, this is quite simple with the following TSQL:

SELECT * INTO MYCOPYTABLE FROM MYORIGINALTABLE WHERE 1 = 2

4. Database "ping" - just a simple way to test connection strings.

cn = "my connection string"
database(cn).ping()

5. Inspired by ConfigObj I'm wondering what a JSON like table definition would look like. In ConfigObj, you can define things like:

section2 = {
    'keyword5': 'value5',
    'keyword6': 'value6',
    'sub-section': {
        'keyword7': 'value7'
        }
}

I wonder if one could have the following for a table:

tableDef = {
    'personid': {
        'datatype':'int',
        'identity':'true',
        'seed':1        
    },
    'firstname':['varchar',50, 'null']
}

Just something to gnaw on...

I'll hopefully get a chance to work on this stuff soon.

}

Data Access Strategy

2008-03-29T22:13:00.001-07:00

{

What data access strategy do you use in your .NET work? The question has been on the mind of Scott Hanselman it seems because the last few podcasts have covered two different strategies - LINQ and CLSA. Tonight I noticed that the ADO guy has a poll of his own with some interesting results:

Web Poll Powered By MicroPoll

I will admit that I'm pretty consistently using ADO.NET + Datasets but more so because the project I'm working on was well under way before the release of VS 2008. I wonder of those responding how many are working on new versus older, longer projects?

}

In Defense Of Lurkers

2008-03-26T22:32:00.001-07:00

{

Hanselman's 7 Blogging Statistics Rules... post was good medicine for a haphazard blogger like me. There was one portion to which I had comment:

I feel like we've (that means me and you, Dear Reader) have a little community here. When you comment, I am happy because I feel more connected to the conversation as this blog is my 3rd place. I blog to be social, not to have a soapbox. I'm even happier when the comments are better and more substantive than the post itself. I would take half the traffic and twice the comments any day. If you're a "lurker," why not join the conversation?

I've spent most of my time on the web lurking. It started with a mailing list for people who like electronic music ("IDM") I joined while in college - in the 10 years it's been I've probably posted less than 20 messages. But I have spent a lot of time as a curator for posts I've enjoyed as well as making notes of what music I would investigate the next time I was in a record store.

In a similar fashion I tend to hang onto posts I enjoy and go back to them. To out myself further as a geek I even print out the ones I'd like to focus on so that I can read them offline at a coffee house or bookstore. I file them away and when I do my occasional cleaning it's hard not to smile and pause to re-read something that was good on the first effort. It's hard to measure us lurkers because we don't vocalize our responses right away and when we do finally get them the post may have tens or hundreds of comments at which point all seems moot. But I think as a lurker I can be a better blog consumer in the sense that I hang onto what's said a little more - it's not just a random post I skimmed in the aggregator.

Forgive the lurker as they make sputtering or failed attempts at immediate conversation, but maybe that conversation will be like the one you have with a great dead tree publication being read and reread.

}

simplejson

2008-03-26T22:05:00.001-07:00

{

simplejson is a JSON library for Python 2.3+, courtesy of here. A while back I goofed off with IronPython and Prototype writing a web based "shell" inerface. I may have to return to that project although my problem wasn't really with encoding, it was with keeping context while using multiple commands (like cd .. and then dir with the new directory as your location) in a session with cmd.exe. I've been meaning to write the PoshConsole guy to ask specifically about this...

}

Chris Wilson interviewed on Pixel8

2008-03-26T21:58:00.001-07:00

{

The interview is here, it's good stuff. Imagine a half billion users. That's a humbling thought...

}

Jeff Zeldman, Pixel8 Interview

2008-03-25T22:39:00.001-07:00

{

Joel's got a big enough voice that I'm sure most people didn't miss his Martian Headphones essay which explained the futility of standards. Jeff Zeldman, who I've always been aware of in my time lurking on the web chimes in on web standards on Craig Shoemaker's new gig, "Pixel 8." The podcast sound is very rough but it's a good context builder for the notion of standards and what they mean. If you've ever had to wrangle with a different look in different browsers, you appreciate standards even if they are complicated and never achieve perfection.

Just noticed that Pixel8 has a podcast with Chris Wilson. That will have to wait until tomorrow -

}