SVNUG Blog Aggregator

Introduction to .NET Talk

noreply@blogger.com (Allen Scharfenberg) — Sun, 25 Mar 2012 03:48:00 +0000

When Dusten Nance of the AITP Capitol Chapter approached me about their interest in an introduction to .NET presentation, I was very excited about the prospect of sharing my seven years of hard-earned .NET knowledge with others. Being a dutiful officer of the Sangamon Valley .NET User Group (SVNUG), however, I first contacted our past presenters to see if anyone would be available to give such an interesting talk to their group. Unfortunately, none of the SVNUG presenters were available to give the talk.

Well, unfortunately for them, that is. Fortunately for me, though, that meant I was able to give the talk, and I was so excited! I spent hours pouring over .NET books, my favorite .NET sites, my favorite .NET blogs. Reading. Researching. Thinking. It was tough. Of everything in the universe of .NET, what did *I* want to tell people about. What did *I* feel was so great and so special about .NET and why did I think they should feel the same. Hopefully, I did a decent job of it: the slides (for your viewing pleasure).

After the obligatory overview of .NET and what you can do with it, I spent some time on what I see as the advantages and disadvantages of using .NET (as opposed to another modern development platform). There are always the standard, obvious advantages of using .NET: mature technology, focused on developers, focused on business applications, plays nice with other Microsoft products, etc., etc. I was surprised, however, to see how strongly the audience reacted (in a positive way) to two not-so-obvious advantages of .NET: the strong open-source community and focus on patterns and practices.

In regard to open-source, Microsoft is definitely a different place than it was ten years ago. Although the patent wars may linger on, the world of the .NET developer is open and filled with many wonderful open-source and user-contributed options: CodePlex, Visual Studio Extensions, Web Platform Installer, NuGet, you name it. If you don’t want to buy it and you don’t want to build it, somebody out there probably has an open-source alternative for you in .NET. And, if they don’t, you could always create one.

Microsoft’s focus on patterns and practices was also very interesting to the audience. In my experience, Microsoft cares more than any other big box company about helping you build better software faster. Software that not only makes users more efficient and productive but also improves their experience and day-to-day life. Patterns and practices are a big part of this help: Enterprise Library, Unity, ASP.NET MVC, WPF with MVVM, and many more. Why re-invent the wheel and/or use an anti-pattern (gasp) instead of using a well-established patterns and practices project from Microsoft? Enterprise-proven, open-source software and whitepapers from Microsoft that make your life as a developer easier, make your software better, and make your users and business partners happier. That is the power of Microsoft patterns and practices.

I also spent some time at the end of my talk discussing what I see as the future of .NET. .NET is already well-established in IT shops around the globe as the go-to technology for building new, feature-rich business applications. The next step? Consumer applications. Windows Phone, Windows 8 Metro applications, and the push to the tablet I think signal Microsoft’s intention to develop a rich and integrated consumer user experience whereby the same application you use on your Windows Phone you can use on your Windows tablet, your Windows laptop, and your Windows desktop.

Skydrive, Microsoft’s free consumer cloud storage technology, ties in nicely with this new ecosystem of applications spanning form factors. Imagine starting a Word document on your Windows 8 desktop. Save it to the cloud, hop on the couch to rest your tired dogs, and finish the document on your Windows 8 laptop. The next morning, review the document on your Windows Phone on your way to the big meeting—where you present it to your colleagues on your Windows 8 tablet. The same application. The same file. Four different devices. Four different form factors. But all integrated and cohesive. That is the future of .NET.

Thank you Dusten Nance and all of AITP Capitol Chapter for the opportunity to speak at your March 2012 meeting on Tuesday night. I enjoyed it very much, and I hope you did too.

CSS Stylesheets Not Refreshing in Chrome

noreply@blogger.com (Allen Scharfenberg) — Sun, 27 Nov 2011 17:37:00 +0000

For the past month or two, I have been struggling with an issue on the SVNUG.com project where, when we would update the CSS stylesheet for the site, browsers (and Chrome specifically) would not automatically retrieve the updated CSS and would instead use the cached version. As you can imagine, this caused all sorts of usability and styling issues on the site, and, despite all my Googling, I could not find a good answer to why the CSS was not getting updated. I ended up bandaiding it by fiddling with the browser caching settings in the Web.config file, but I was not happy with that solution. Dictating the cacheability of every site resource because of a problem with only one just felt like overkill.

I let it go. Until today. This morning, we deployed a new release of SVNUG.com with brand spanking new Join and Contact forms, and, lo and behold, the form styling was not updated. Great!

So, after a little bit of panicking (since the release was already live), I Googled and luckily the found the following StackOverflow post:

http://stackoverflow.com/questions/2263096/css-file-is-not-refreshing-in-my-browser

The gist of the post is that, to control when browsers retrieve a new copy of a CSS stylesheet, add a query string to the end of the stylesheet path in your <link> tag that specifies the version:

The browser treats the entire href attribute uniquely for caching purposes. Thus, when the version number changes in the <link> tag on your site, the browser will treat the stylesheet reference as a new resource that it has not yet downloaded—causing the browser to download the updated CSS. The web server for its part will ignore the query string for a static resource—returning the desired stylesheet when requested.

Now, I will admit it has been a few years since I have built a web site from the ground up, but this is evidently a well-established trick for managing browser caching for your CSS stylesheets. Good to know.

All I can say is that it works and it works well. It also addresses cacheability issues in a granular fashion instead of across the board—which, if you will recall, is what I didn’t like about changing the browser caching settings in the Web.config file.

StackOverflow > All

Color Theme Generator

mark shiffer — Wed, 26 Oct 2011 15:25:38 +0000

I thought I had posted about this site before, but I could not find it and had to go back to a manual search and find mission to get back to it. ColorSchemeDesigner is a pretty flexible site that helps find complementary colors for those of us, like myself, that are artistically impaired.

Check it out!

Game / Code Kata – Krypto

mark shiffer — Mon, 05 Sep 2011 04:34:36 +0000

I used to read TheDailyWTF, not quite sure why I stopped, maybe I will start again. Anyway, I tucked this one away, Krypto and 24, for later because the game sounded quite interesting. One of those fun math games with playing cards that is really right up my alley. Here’s how Krypto works:

While most kids reached in their pockets for coins to ante up, we’d pulled the face and joker cards out of the deck, shuffle the rest, and deal out six cards, face-up, in the middle of the table with one of the cards a few inches from the rest.

8♥ 5♦ 2♣ 10♥ 5♣ 3♠

Our goal was to race to see who could make a mathematical equation using only the four basic arithmetic expressions and parenthesis.

5♣ - (8♥ * 5♦ / 10♥) + 2♣ = 3♠

The first to solve (which, almost never was me) kept the five cards as points, and play continued until we ran out of cards.

We’d also play another variant called 24, where the five cards would have to come to 24. For example...

8♥ 5♦ 2♣ 10♥ 5♣ = 24

... would become...

(5♦ + 5♣ - 8♥) * (2♣ + 10♥) = 24

These games (which I’ve since learned are called Krypto and 24) were – and still are – a lot of fun.

Bring Your Own Code

Your exercise for the day: play Krypto and 24. More specifically, write a program to play the games for you.

The input should be:
- Easy - six integers, the first five of which are between 1 and 10, and the sixth which is between 1 and 10 or is 24
- Hard - an integer array of unknown length and an integer that is a solution of the array
The output should be:
- Easy - a string representing a single solution to the input
- Medium - a string array representing all possible solutions to the input
- Hard - a string array representing non-duplicated solutions to the input; a solution is considered duplicate if the differences are only associative or commutative

For bonus points, create a function that mimics a game; i.e., starting with 40 cards, removing 5, shuffling again, etc.

Code Kata – Bonus

mark shiffer — Mon, 05 Sep 2011 03:33:13 +0000

This one came courtesy of Ted Neward, who got it from the University of Virginia’s programming contest way back when:

RoboStack

Problem: You work for a manufacturing company, and they have just received their newest piece of super-modern hardware, a highly efficient assembly-line mechanized pneumatic item manipulator, also known in some circles as a "robotic arm". It is driven by a series of commands, and your job is to write the software to drive the arm. The initial test will be to have the arm move a series of blocks around.

Context: The test begins with n number of blocks, laid out sequentially next to each other, each block with a number on it. (You may safely assume that n never exceeds 25.) So, if n is 4, then the blocks are laid out (starting from 0) as:

0: 0

1: 1

2: 2

3: 3

The display output here is the block-numbered "slot", then a colon, then the block(s) that are stacked in that slot, lowest to highest in left to right order. Thus, in the following display:

0:

1:

2: 0 1 2 3

3:

The 3 block is stacked on top of the 2 block is stacked on top of the 1 block is stacked on top of the 0 block, all in slot 2. This can be shortened to the representation [0:, 1:, 2: 0 1 2 3, 3:] for conciseness.

The arm understands a number of different commands, as well as an optic sensor. (Yeah, the guys who created the arm were good enough to write code that knows how to read the number off a block, but not to actually drive the arm. Go figure.) The commands are as follows, where a and b are valid block numbers (meaning they are between 0 and n-1):

"move a onto b" This command orders the arm to find block a, and return any blocks stacked on top of it to their original position. Do the same for block b, then stack block a on top of b.
"move a over b" This command orders the arm to find block a, and return any blocks stacked on top of it to their original position. Then stack block a on top of the stack of blocks containing b.
"pile a onto b" This command orders the arm to find the stack of blocks containing block b, and return any blocks stacked on top of it to their original position. Then the arm must find the stack of blocks containing block a, and take the stack of blocks starting from a on upwards (in other words, don't do anything with any blocks on top of a) and put that stack on top of block b.
"pile a over b" This command orders the arm to find the stack of blocks containing block a and take the stack of blocks starting from a on upwards (in other words, don't do anything with any blocks on top of a) and put that stack on top of the stack of blocks containing block b (in other words, don't do anything with the stack of blocks containingb, either).
"quit" This command tells the arm to shut down (and thus terminates the simulation).

Note that if the input command sequence accidentally offers a command where a and b are the same value, that command is illegal and should be ignored.

As an example, then, if we have 4 blocks in the state [0: 0, 1: 1, 2: 2, 3: 3], and run a "move 2 onto 3", we get [0: 0, 1: 1, 2:, 3: 3 2]. If we then run a "pile 3 over 1", we should end up with [0: 0, 1: 1 3 2, 2:, 3:]. And so on.

Input: n = 10. Run these commands:

move 9 onto 1
move 8 over 1
move 7 over 1
move 6 over 1
pile 8 over 6
pile 8 over 5
move 2 over 1
move 4 over 9
quit

The result should be [0: 0, 1: 1 9 2 4, 2:, 3: 3, 4:, 5: 5 8 7 6, 6:, 7:, 8:, 9:]

Challenges:

Implement the Towers of Hanoi (or as close to it as you can get) using this system.
Add an optimizer to the arm, in essence reading in the entire program (up to "quit"), finding shorter paths and/or different commands to achieve the same result.
Add a visual component to the simulation, displaying the arm as it moves over each block and moves blocks around.
Add another robotic arm, and allow commands to be given simultaneously. This will require some thought—does each arm execute a complete command before allowing the other arm to execute (which reduces the performance having two arms might offer), or can each arm act entirely independently? The two (or more) arms will probably need separate command streams, but you might try running them with one command stream just for grins. Note that deciding how to synchronized the arms so they don't conflict with one another will probably require adding some kind of synchronization instructions into the stream as well.

Code Kata 16–21 of 21

mark shiffer — Mon, 05 Sep 2011 03:31:06 +0000

I came across this site quite a while back and have been meaning to blog about it. The site is CodeKata, and the premise is essentially to give reasonably interesting problems that can be solved using code in order to practice and hone your skills. Not everything is a coding problem, but where I can see these coming in handy are using the katas to learn new languages. I always learn better when I have something to implement as I learn. Anyway, my original intention was to just link to the site, however it looks like the site hasn’t been updated in 4 years! It concerns me that it might not be around if I merely link to it, so I am going to copy the katas here for future reference. I hope Dave doesn’t mind.

Kata 16 – Business Rules

How can you tame a wild (and changing) set of business rules?

Imagine you’re writing an order processing application for a large company. In the past, this company used a fairly random mixture of manual and ad-hoc automated business practices to handle orders; they now want to put all these various ways of hanadling orders together into one whole: your application. However, they (and their customers) have come to cherish the diversity of their business rules, and so they tell you that you’ll have to bring all these rules forward into the new system.

When you go in to meet the existing order entry folks, you discover that their business practices border on chaotic: no two product lines have the same set of processing rules. To make it worse, most of the rules aren’t written down: you’re often told something like "oh, Carol on the second floor handles that kind of order."

During first day of meetings, you’ve decided to focus on payments, and in particular on the processing required when a payment was received by the company. You come home, exhausted, with a legal pad full of rule snippets such as:

If the payment is for a physical product, generate a packing slip for shipping.
If the payment is for a book, create a duplicate packing slip for the royalty department.
If the payment is for a membership, activate that membership.
If the payment is an upgrade to a membership, apply the upgrade.
If the payment is for a membership or upgrade, e-mail the owner and inform them of the activation/upgrade.
If the payment is for the video "Learning to Ski," add a free "First Aid" video to the packing slip (the result of a court decision in 1997).
If the payment is for a physical product or a book, generate a commission payment to the agent.
and so on, and so on, for seven long, yellow pages.

And each day, to your horror, you gather more and more pages of these rules.

Now you’re faced with implementing this system. The rules are complicated, and fairly arbitrary. What’s more, you know that they’re going to change: once the system goes live, all sorts of special cases will come out of the woodwork.

Objectives

How can you tame these wild business rules? How can you build a system that will be flexible enough to handle both the complexity and the need for change? And how can you do it without condemming yourself to years and years of mindless support?

Kata 17 - More Business Processing

The rules that specify the overall processing of an order can be complex too, particularly as they often involve waiting around for things to happen.

In Kata Sixteen we had a look at the business rules that applied when we received payment for various kinds of product. Handling payments is just a small part of the overall workflow required to process an order. For the company whose application we’re looking at, order processing looks something like:

If we accept an order over the web, then we have to wait for payment to arrive, unless it’s a credit-card order. In the case of credit card orders, we can process the order immediately and ship the goods, but only if the goods are in stock. If they are not currently in stock, we have to delay processing credit card orders until the become available again.
We can receive a check in payment of an existing order, in which case we ship the goods (unless they are not in stock, in which case we hold the check until the goods become available).
We can receive a purchase order (PO) for a new order (we only accept these from companies with an established credit account). In this case we ship the goods (assuming they are in stock) and also generate an invoice against the PO. At some point in the future we’ll receive payment against this invoice and the order will be complete.
At any time before the goods are shipped the customer may cancel an order.

Each step in this process may occur many days after the previous step. For example, we may take an order over the web on Monday, receive a check for this order on Thursday, then ship the goods and deposit the check when the item is received from our own suppliers on the following Tuesday.

How can we design an application to support these kinds of rules? Of course, businesses change the rules all the time, so we better make sure that anything we come up makes it easy to update the workflow.

Kata 18 – Transitive Dependencies

Let’s write some code that calculates how dependencies propagate between things such as classes in a program.

Highly coupled code is code where the dependencies between things are dense, lots of things depend on other things. This kind of program is hard to understand, tough to maintain, and tends to be fragile, breaking easily when things change.

There are many different kinds of coupling in code. One of the easiest to work with programatically is \emph{static coupling}, where we’re concerned with the relationships between chunks of source code. Simplisticly, we can say that class A is statically coupled to class B if the compiler needs the definition of B in order to compile

In many languages, static dependencies can be determined by source

code analysis. Tools such as makedepend (for C programs) and JDepend (for Java) look for explicit dependencies in the source and list them out.

One of the insidious things about dependencies is that they are transitive—if A depends on B and B depends on C, then A also depends on C. So, let’s write some code that calculates the full set of dependencies for a group of items. The code takes as input a set of lines where the first token is the name of an item. The remaining tokens are the names of things that this first item depends on. Given the following input, we know that A directly depends on B and C, B depends on C and E, and so on.

  A   B   C
  B   C   E
  C   G
  D   A   F
  E   F
  F   H

The program should use this data to calculate the full set of dependencies. For example, looking at B, we see it directly depends on C and E. C in turn relies on G, E relies on F, and F relies on H. This means that B ultimately relies on C, E, F, G, and H. In fact, the full set of dependencies for the previous example is:

  A   B C E F G H
  B   C E F G H
  C   G
  D   A B C E F G H
  E   F H
  F   H

Let’s express this using unit tests. The following code assumes that our dependency calculator is a class with an add_direct() method to add the direct dependencies for an item, and a dependencies_for() method to return the full list of dependencies for an item. The code uses Ruby’s %w{…} construct, which builds an array of strings from its argument.

  def test_basic
    dep = Dependencies.new
    dep.add_direct('A', %w{ B C } )
    dep.add_direct('B', %w{ C E } )
    dep.add_direct('C', %w{ G   } )
    dep.add_direct('D', %w{ A F } )
    dep.add_direct('E', %w{ F   } )
    dep.add_direct('F', %w{ H   } )

    assert_equal( %w{ B C E F G H },   dep.dependencies_for('A'))
    assert_equal( %w{ C E F G H },     dep.dependencies_for('B'))
    assert_equal( %w{ G },             dep.dependencies_for('C'))
    assert_equal( %w{ A B C E F G H }, dep.dependencies_for('D'))
    assert_equal( %w{ F H },           dep.dependencies_for('E'))
    assert_equal( %w{ H },             dep.dependencies_for('F'))
  end

Stop reading now, and start coding. Once you’ve got your code working, try feeding it the following dependencies.

  A B
  B C
  C A

Does it work correctly? If not, ask yourself is this is a condition you should have considered during testing.

Once you’ve got your code working with all the various test cases you can imagine, let’s think for a minute about performance. Say we were using this code to find all the relationships between the inhabitants of the United Kingdom. How would your code perform with 55-60 million items?

Kata 19 – Word Chains

Write a program that solves word-chain puzzles.

There’s a type of puzzle where the challenge is to build a chain of words, starting with one particular word and ending with another. Successive entries in the chain must all be real words, and each can differ from the previous word by just one letter. For example, you can get from "cat" to "dog" using the following chain.

  cat
  cot
  cog
  dog

The objective of this kata is to write a program that accepts start and end words and, using words from thedictionary, builds a word chain between them. For added programming fun, return the shortest word chain that solves each puzzle. For example, my Powerbook running Ruby can turn "lead" into "gold" in four steps (lead, load, goad, gold), taking about 20 seconds. Turning "ruby" into "code" takes six steps (ruby, rubs, robs, rods, rode, code) and 90 seconds, while turning "code" into "ruby" (again in six steps) takes about an hour. Go figure…

Update: It turns out that my original algorithm was pretty dumb: a better approach greatly speeds up search and makes it symetrical. It now does all the above examples in between 0.5s and 1s.

Kata 20 – Klondike

Experiment with different heuristics for playing the solitaire game Klondike.

The solitaire game Klondike is probably the most widely played in the world (particularly if you’re a Window’s user, where it has been available since Windows 3.1). It’s a simple game.

Cards are dealt face down onto the seven piles in the tableau. The first pile receives one card, the next two, up to the seventh pile, which not surprisingly has seven cards initially. The top card on each pile is turned face-up, and the undealt cards are placed on the Stock pile, all face down. Here’s a picture of the game (52kb) if you haven’t seen it before.

The idea is to build up four piles of cards in their suits on the foundation area (one pile for the clubs, one for the diamonds, and so on). The piles must start with the ace and end with the king.

The available moves (in no particular order) are:

If the Stock becomes empty, turn the entire discard pile over and make it the new Stock.
Turn over the top card of the Stock and place it face-up on the Discard pile.
Move a card from the tableau or discard pile to one of the foundation piles. If the foundation pile is empty, only an Ace can be placed there, otherwise only the next highest card in the appropriate suit can be placed (so if a foundation pile is currently showing a four of hearts, only the five of hearts may be placed there).
Move the top card of the discard pile to one of the tableau piles. This card must be one less in rank and opposite in color to the card at the top of the destination tableau.
Move one or more cards from one tableau pile to another. If multiple cards are moved, they must be a sequence ascending in rank and alternating in color. The card moved (or the top of the sequence moved) must be one less in rank and opposite in color to the card at the top of the destination tableau. If the move leaves a face-down card to the top of the original pile, turn it over.
If a move leaves a tableau pile empty, an exposed King at the top of a tableau or discard pile, or a sequence starting with a King on a tableau pile, may be moved to it.

So, in the game pictured about, a possible first set of moves might be:

Move the Queen of Hearts onto the King of Clubs.
This leaves the first pile in the tableau empty, so the combined King/Queen can be moved to it. The card originally beneath the King is turned over.
The Jack of Clubs can be moved on to the Queen of Hearts, and the card beneath the Jack revealed.

The game is won when all cards are moved to the foundation, and lost when the only remaining moves form an endless loop.

The game is simple to play, but the strategy isn’t immediately obvious. For example, is it always a good idea to move a card from the tableau to the foundation, or is it sometimes better to leave it there to give yourself something to build down on? Is it a good idea to make a move which leaves a tableau pile empty if you don’t immediately have a King to move into the gap? If you have two possible moves which will result in exposing a new tableau card, should you expose the one on the longest or shortest tableau?

This kata is in two parts.

Come up with an infrastructure so you can have the computer deal and play games of Klondike.
Use that infrastructure to experiment with strategies to see if you can increase the number of times you win (perhaps you could tabulate the number of times the machine wins a random set of 1,000 games for each strategy you try).

Objectives

At one level, this is an exercise in design—how can the basic game be modeled in code? Where should the validation of moves be located (in the cards, in the various piles, in some kind of game overseer, or …)? How can we detect that we’ve lost?
Once the basic game is in place, it becomes an exercise in imagination: what strategies can be applied, and how do various sub-strategies interact?

Kata 21 – Simple Lists

Perhaps there’s more to the humble list of values than you might think. Let’s experiment with some basic list processing.

Lists are one of the first data structures we learn as programmers. But familiarity doesn’t mean that we can’t learn a little from them.

For this kata we’re going to code up three implementations of a list that has the following basic interface:

The list consists of nodes. Each node has a string value, along with whatever housekeeping the list itself needs.
New nodes are added to the end of the list.
You can ask the list if it contains a given string. If it does, it returns the node containing that string.
You can delete a node from the list.
You can ask the list to return an array of all its values.

Here’s a basic set of unit tests to illustrate the behavior.

    list = List.new
    assert_nil(list.find("fred"))
    list.add("fred")
    assert_equal("fred", list.find("fred").value())
    assert_nil(list.find("wilma"))
    list.add("wilma")
    assert_equal("fred",  list.find("fred").value())
    assert_equal("wilma", list.find("wilma").value())
    assert_equal(["fred", "wilma"], list.values())

    list = List.new
    list.add("fred")
    list.add("wilma")
    list.add("betty")
    list.add("barney")
    assert_equal(["fred", "wilma", "betty", "barney"], list.values())
    list.delete(list.find("wilma"))
    assert_equal(["fred", "betty", "barney"], list.values())
    list.delete(list.find("barney"))
    assert_equal(["fred", "betty"], list.values())
    list.delete(list.find("fred"))
    assert_equal(["betty"], list.values())
    list.delete(list.find("betty"))
    assert_equal([], list.values())

For the kata, where the idea is to practice, let’s write three implementations of the list:

A singly linked list (each node has a reference to the next node).
A doubly linked list (each node has a reference to both the next and previous nodes).
Some other implementation of your choosing, except that it should use no references (pointers) to collect nodes together in the list.

Obviously, we won’t be using predefined library classes as our list implementations…

Objectives

There’s nothing magical or surprising in list implementations, but there are a fair number of boundary conditions. For example, when deleting from the singly-linked list, did you have to deal with the case of deleting the first element in the list specially?

For this kata, concentrate on ways of removing as many of these boundary conditions as possible. Then ask yourself: Is the resulting code, which will contain fewer special cases, easier to read and maintain? How easy was it to eliminate these special cases? Were there trade-offs, where removing a special case in one area complicated the code in another. Is there a sweet-spot when it comes to simplifying code?

Code Kata 11-15 of 21

mark shiffer — Mon, 05 Sep 2011 03:27:35 +0000

Kata 11 – Sorting it Out

Just because we need to sort something doesn’t necessarily mean we need to use a conventional sorting algorithm.

We use sorting routines all the time; putting customer records in to name order, arranging orders by value (and even sorting the letters in a word back in KataSix). Most of the time we (wisely) use one of the sort routines built in to our language’s library (such as C’s qsort and Java’s java.Collections.sort). After all, very clever folks spent a lot of time getting these library routines tuned for speed and/or memory usage.

However, there are times when whipping up a sort of our own can outperform these generic routines. Our challenge this week is to implement a couple of different sorts. (However, at the risk of giving the game away, these sorts both have something in common).

Sorting Balls

In the Pragmatic Lottery (motto: There’s One Born Every Minute, and it Might Just Be You!), we select each week’s winning combination by drawing balls. There are sixty balls, numbered (not surprisingly, as we are programmers) 0 to 59. The balls are drawn by the personable, but somewhat distracted, Daisy Mae. As a result, some weeks five numbers are drawn, while other weeks seven, nine, or even fifteen balls make it to the winner’s rack. Regardless of the number of balls drawn, our viewers need to see the list of winning numbers in sorted order just as soon as possible. So, your challenge is to come up with some code that accepts each number as it is drawn and presents the sorted list of numbers so far. The tests might look something like:

    rack = Rack.new
    assert_equal([], rack.balls)
    rack.add(20)
    assert_equal([ 20 ], rack.balls)
    rack.add(10)
    assert_equal([ 10, 20 ], rack.balls)
    rack.add(30)
    assert_equal([ 10, 20, 30 ], rack.balls)

Sorting Characters

Our resident conspiracy expert, Dr. X, is looking for hidden messages in the collected publications of Hugh Hefner. Dr. X believes the message is hidden in the individual letters, so rather than get distracted by the words, he’s asked us to write a program to take a block of text and return the letters it contains, sorted. Given the text:

  When not studying nuclear physics, Bambi likes to play
  beach volleyball.

our program would return:

  aaaaabbbbcccdeeeeeghhhiiiiklllllllmnnnnooopprsssstttuuvwyyyy

The program ignores punctuation, and maps upper case to lower case.

Are there any ways to perform this sort cheaply, and without using built-in libraries?

Kata 12 – Best Sellers

Consider the implementation of a top-ten best sellers list for a high volume web store.

A GedankenKata this week: no code needed (although writing short prototypes might help you come to a conclusion).

Say you’re writing code for an online site that sells things (something like Amazon). Your site is wildly popular, and you sell millions of items each day.

The marketing department wants the home page to display a top-ten list of the best selling items over the last 24 hours, with the list being updated each hour.

How would you implement this?
Are there any changes you could ask for to make the implementation easier?
What would be the impact if they later came back and said:
- only update the list once per day; or
- we need the list updated in real time: each time the home page is displayed we need the list to reflect the 24 hours up until that point.

This kata might be deeper than it first appears. You might want to consider database vs. in-memory solutions, data structures that allow aging, time-space tradeoffs, and the like.

Kata 13 – Counting Code Lines

Counting lines of code in Java source is not quite as simple as it seems.

This week let’s write something vaguely useful: a utility that counts
the number of lines of actual code in a Java source file. For the purpose
of this exercise, a line is counted if it contains something other than
whitespace or text in a comment. Some simple examples:

  -   // This file contains 3 lines of code
  1   public interface Dave {
  -     /**
  -      * count the number of lines in a file
  -      */
  2     int countLines(File inFile); // not the real signature!
  3   }

and…

  -   /*****
  -   * This is a test program with 5 lines of code
  -   *  \/* no nesting allowed!
  -   //*****//***/// Slightly pathological comment ending...
  -
  1  public class Hello {
  2      public static final void main(String [] args) { // gotta love Java
  -          // Say hello
  3        System./*wait*/out./*for*/println/*it*/("Hello/*");
  4      }
  -
  5  }

Remember that Java comments are either "//" to the end of line, or "/*" to the next "*/". The block comments do not nest. There may be multiple /*…*/ comments on a line. Whitespace includes tabs, spaces, carriage returns, and vertical tabs. Oh, and remember that comment start sequences that appear inside Java strings should be ignored.

Goals of the Kata

The mixture of line-based things (single line comments, blank lines, and so on) with the stream-based block comments can make solutions slightly ugly. While coding your solution, consider the structure of your code, and see how well it fits the structure of the problem. As with most of these kata, consider coding multiple alternative implementations. Does what you learned on the first tries affect your approach to subsequent ones?

Kata 14 – Tome Swift Under Milk Wood

Trigrams can be used to mutate text into new, surreal, forms. But what heuristics do we apply to get a reasonable result?

As a boy, one of my treats was go to the shops on a Saturday and spend part of my allowance on books; for a nine-year old, I had quite a collection of Tom Swift and Hardy Boys. Wouldn’t it be great to be able to create more and more of these classic books, to be able to generate a new Tom Swift adventure on demand?

OK, perhaps not. But that won’t stop us trying. I coded up a quick program to generate some swash-buckling scientific adventure on demand. It came up with:

: …it was in the wind that was what he thought was his companion. I think would be a good one and accordingly the ship their situation improved. Slowly so slowly that it beat the band! You’d think no one was a low voice. "Don’t take any of the elements and the inventors of the little Frenchman in the enclosed car or cabin completely fitted up in front of the gas in the house and wringing her hands. "I’m sure they’ll fall!"
: She looked up at them. He dug a mass of black vapor which it had refused to accept any. As for Mr. Swift as if it goes too high I’ll warn you and you can and swallow frequently. That will make the airship was shooting upward again and just before the raid wouldn’t have been instrumental in capturing the scoundrels right out of jail."

Stylistically, it’s Victor Appleton meets Dylan Thomas. Technically, it’s all done with trigrams.

Trigram analysis is very simple. Look at each set of three adjacent words in a document. Use the first two words of the set as a key, and remember the fact that the third word followed that key. Once you’ve finished, you know the list of individual words that can follow each two word sequence in the document. For example, given the input:

  I wish I may I wish I might

You might generate:

    "I wish" => ["I", "I"]
    "wish I" => ["may", "might"]
    "may I"  => ["wish"]
    "I may"  => ["I"]

This says that the words "I wish" are twice followed by the word "I", the words "wish I" are followed once by "may" and once by "might" and so on.

To generate new text from this analysis, choose an arbitrary word pair as a starting point. Use these to look up a random next word (using the table above) and append this new word to the text so far. This now gives you a new word pair at the end of the text, so look up a potential next word based on these. Add this to the list, and so on. In the previous example, we could start with "I may". The only possible next word is "I", so now we have:

   I may I

The last two words are "may I", so the next word is "wish". We then look up "I wish", and find our choice is constrained to another "I".

   I may I wish I

Now we look up "wish I", and find we have a choice. Let’s choose "may".

   I may I wish I may

Now we’re back where we started from, with "I may." Following the same sequence, but choosing "might" this time, we get:

   I may I wish I may I wish I might

At this point we stop, as no sequence starts "I might."

Given a short input text, the algorithm isn’t too interesting. Feed it a book, however, and you give it more options, so the resulting output can be surprising.

For this kata, try implementing a trigram algorithm that generates a couple of hundred words of text using a book-sized file as input. Project Gutenberg is a good source of online books (Tom Swift and His Airship is here). Be warned that these files have DOS line endings (carriage return followed by newline).

Objectives

Kata’s are about trying something many times. In this one, what we’re experimenting with is not just the code, but the heuristics of processing the text. What do we do with punctuation? Paragraphs? Do we have to implement backtracking if we chose a next word that turns out to be a dead end?

Kata 15 – Playing With Bits

At my son's karate school, they spend most of their time doing various exercises, with the occasional round of sparring thrown in. But every now and then the teacher finds a way to break the routine by injecting some kind of game or surprise into the mix. This kata is one of those. It's nothing serious, and unlikely to have practical benefits (unless you're working in some fairly specialized areas).

Think of binary numbers: sequences of 0's and 1's. How many n-digit binary numbers are there that don't have two adjacent 1 bits? For example, for three-digit numbers, five of the possible eight combinations meet the criteria: 000, 001, 010, ~~011~~, 100, 101, ~~110~~, ~~111~~. What is the number for sequences of length 4, 5, 10, n?

Having worked out the pattern, there's a second part to the question: can you prove why that relationship exists?

Code Kata 6-10 of 21

mark shiffer — Mon, 05 Sep 2011 03:23:54 +0000

Kata 6 – Anagrams

Back to non-realistic coding this week (sorry, Martin). Let's solve some crossword puzzle clues.

In England, I used to waste hour upon hour doing newspaper crosswords. As crossword fans will know, English cryptic crosswords have a totally different feel to their American counterparts: most clues involve punning or word play, and there are lots of anagrams to work through. For example, a recent Guardiancrossword had:

  Down:
    ..
    21. Most unusual form of arrest (6)

The hint is the phrase ‘form of,’ indicating that we’re looking for an anagram. Sure enough ‘arrest’ has six letters, and can be arranged nicely into ‘rarest,’ meaning ‘most unusual.’ (Other anagrams include raster, raters, Sartre, and starer)

A while back we had a thread on the Ruby mailing list about finding anagrams, and I’d like to resurrect it here. The challenge is fairly simple: given a file containing one word per line, print out all the combinations of words that are anagrams; each line in the output contains all the words from the input that are anagrams of each other. For example, your program might include in its output:

  kinship pinkish
  enlist inlets listen silent
  boaster boaters borates
  fresher refresh
  sinks skins
  knits stink
  rots sort

If you run this on the word list here you should find 2,530 sets of anagrams (a total of 5,680 words). Running on a larger dictionary (about 234k words) on my OSX box produces 15,048 sets of anagrams (including all-time favorites such as actaeonidae/donatiaceae, crepitant/pittancer, and (for those readers in Florida) electoral/recollate).

For added programming pleasure, find the longest words that are anagrams, and find the set of anagrams containing the most words (so "parsley players replays sparely" would not win, having only four words in the set).

Kata Objectives

Apart from having some fun with words, this kata should make you think somewhat about algorithms. The simplest algorithms to find all the anagram combinations may take inordinate amounts of time to do the job. Working though alternatives should help bring the time down by orders of magnitude. To give you a possible point of comparison, I hacked a solution together in 25 lines of Ruby. It runs on the word list from my web site in 1.5s on a 1GHz PPC. It’s also an interesting exercise in testing: can you write unit tests to verify that your code is working correctly before setting it to work on the full dictionary.

Kata 7 – How’d I Do?

The last couple of kata have been programming challenges; let’s move back into mushier, people-oriented stuff this week.

This kata is about reading code critically—our own code. Here’s the challenge. Find a piece of code you wrote last year sometime. It should be a decent sized chunk, perhaps 500 to 1,000 lines long. Pick code which isn’t still fresh in your mind.

Now we need to do some acting. Read through this code three times. Each time through, pretend something different. Each time, jot down notes on the stuff you find.

The first time through, pretend that the person who wrote this code is the best programmer you know. Look for all the examples of great code in the program.
The second time through, pretend that the person who wrote this code is the worst programmer you know. Look for all the examples of horrible code and bad design.
The third (and last) time though, pretend that you’ve been told that this code contains serious bugs, and that the client is going to sue you to bankruptcy unless you fix them. Look for every potential bug in the code.

Now look at the notes you made. What is the nature of the good stuff you found? Would you find similar good stuff in the code you’re writing today. What about the bad stuff; are similar pieces of code sneaking in to your current code too. And finally, did you find any bugs in the old code? If so, are any of them things that that you’d want to fix now that you’ve found them. Are any of them systematic errors that you might still be making today?

Moving Forward By Looking Back

Perhaps you’re not like me, but whenever I try this exercise I find things that pleasantly surprise me and things that make me cringe in embarrassment. I find the occasional serious bug (along with more frequent less but serious issues). So I try to make a point of looking back at my code fairly frequently.

However, doing this six months after you write code is not the best way of developing good software today. So the underlying challenge of this kata is this: how can we get into the habit of critically reviewing the code that we write, as we write it? And can we use the techniques of reading code with different expectations (good coder, bad coder, and bug hunt) when we’re reviewing our colleagues code?

Kata 8 – Conflicting Objectives

Why do we write code? At one level, we’re trying to solve some particular problem, to add some kind of value to the world. But often there are also secondary objectives: the code has to solve the problem, and it also has to be fast, or easy to maintain, or extend, or whatever. So let’s look at that.

For this kata, we’re going to write a program to solve a simple problem, and we’re going to write it with three different sub-objectives. Our program is going do process the dictionary we used in previous kata, this time looking for all six letter words which are composed of two concatenated smaller words. For example:

  al + bums => albums
  bar + ely => barely
  be + foul => befoul
  con + vex => convex
  here + by => hereby
  jig + saw => jigsaw
  tail + or => tailor
  we + aver => weaver

Write the program three times.

The first time, make program as readable as you can make it.
The second time, optimize the program to run fast fast as you can make it.
The third time, write as extendible a program as you can.

Now look back at the three programs and think about how each of the three subobjectives interacts with the others. For example, does making the program as fast as possible make it more or less readable? Does it make easier to extend? Does making the program readable make it slower or faster, flexible or rigid? And does making it extendible make it more or less readable, slower or faster? Are any of these correlations stronger than others? What does this mean in terms of optimizations you may perform on the code you write?

Kata 9 – Back to the Checkout

Back to the supermarket. This week, we’ll implement the code for a checkout system that handles pricing schemes such as "apples cost 50 cents, three apples cost $1.30."

Way back in KataOne we thought about how to model the various options for supermarket pricing. We looked at things such as "three for a dollar," "$1.99 per pound," and "buy two, get one free."

This week, let’s implement the code for a supermarket checkout that calculates the total price of a number of items. In a normal supermarket, things are identified using Stock Keeping Units, or SKUs. In our store, we’ll use individual letters of the alphabet (A, B, C, and so on). Our goods are priced individually. In addition, some items are multipriced: buy n of them, and they’ll cost you y cents. For example, item ‘A’ might cost 50 cents individually, but this week we have a special offer: buy three ‘A’s and they’ll cost you $1.30. In fact this week’s prices are:

  Item   Unit      Special
         Price     Price
  --------------------------
    A     50       3 for 130
    B     30       2 for 45
    C     20
    D     15

Our checkout accepts items in any order, so that if we scan a B, an A, and another B, we’ll recognize the two B’s and price them at 45 (for a total price so far of 95). Because the pricing changes frequently, we need to be able to pass in a set of pricing rules each time we start handling a checkout transaction.

The interface to the checkout should look like:

   co = CheckOut.new(pricing_rules)
   co.scan(item)
   co.scan(item)
       :    :
   price = co.total

Here’s a set of unit tests for a Ruby implementation. The helper method price lets you specify a sequence of items using a string, calling the checkout’s scan method on each item in turn before finally returning the total price.

  class TestPrice < Test::Unit::TestCase

    def price(goods)
      co = CheckOut.new(RULES)
      goods.split(//).each { |item| co.scan(item) }
      co.total
    end

    def test_totals
      assert_equal(  0, price(""))
      assert_equal( 50, price("A"))
      assert_equal( 80, price("AB"))
      assert_equal(115, price("CDBA"))

      assert_equal(100, price("AA"))
      assert_equal(130, price("AAA"))
      assert_equal(180, price("AAAA"))
      assert_equal(230, price("AAAAA"))
      assert_equal(260, price("AAAAAA"))

      assert_equal(160, price("AAAB"))
      assert_equal(175, price("AAABB"))
      assert_equal(190, price("AAABBD"))
      assert_equal(190, price("DABABA"))
    end

    def test_incremental
      co = CheckOut.new(RULES)
      assert_equal(  0, co.total)
      co.scan("A");  assert_equal( 50, co.total)
      co.scan("B");  assert_equal( 80, co.total)
      co.scan("A");  assert_equal(130, co.total)
      co.scan("A");  assert_equal(160, co.total)
      co.scan("B");  assert_equal(175, co.total)
    end
  end

There are lots of ways of implementing this kind of algorithm; if you have time, experiment with several.

Objectives of the Kata

To some extent, this is just a fun little problem. But underneath the covers, it’s a stealth exercise in decoupling. The challenge description doesn’t mention the format of the pricing rules. How can these be specified in such a way that the checkout doesn’t know about particular items and their pricing strategies? How can we make the design flexible enough so that we can add new styles of pricing rule in the future?

Kata 10 – Hashes vs. Classes

If we’re programming business applications in a language such as Java or C#, we’re used to constructing and using classes to manipulate our business objects. Is this always the right way to go, or would a less formal approach serves us well sometimes?

This week’s topic doesn’t involve a coding challenge. Instead, we’re thinking about design and tradeoffs.

Imagine that you’ve been asked to write an export utility for a large and complex database. The export has to read data from 30 or so tables (perhaps 100 columns are potentially written to each export record). Some of the exported data is written exactly as read from the database, but other exported data must be calculated. In addition, if certain flag fields have specific values, then additional data must be read from the database to complete an export row.

The export data must obviously be correct, but the client is also asking for a flexible solution; their world changes a lot.

One solution is to use existing business objects and existing persistence mechanisms, and to use higher-level classes to aggregate their results into a form that can be used to generate export rows. This higher level object could perform the calculations necessary for the virtual fields, and read in additional business objects if the flag fields dictate.

An alternative solution might be to read the data row at a time into a Hash using ad-hoc queries, keying the hash on the field names. A separate pass could then be made to perform any necessary calculations, storing the results back in to the same hash. Additional data could be read from the database if the flag fields are set, again storing the results in the hash. The contents of the hash are then used to write the export record, and we loop back to do the next row.

This kata is a thought experiment. What are the top three advantages and top three disadvantages of the two approaches? If you’re been using classes to hold data in your business applications, what would the impact be if you were to switch to hashes, and vice versa? Is this issue related to the static/dynamic typing debate?

Code Kata 1–5 of 21

mark shiffer — Mon, 05 Sep 2011 03:20:19 +0000

Kata 1 – Supermarket Pricing

This kata arose from some discussions we’ve been having at the DFW Practioners meetings. The problem domain is something seemingly simple: pricing goods at supermarkets.

Some things in supermarkets have simple prices: this can of beans costs $0.65. Other things have more complex prices. For example:

three for a dollar (so what’s the price if I buy 4, or 5?)
$1.99/pound (so what does 4 ounces cost?)
buy two, get one free (so does the third item have a price?)

This kata involves no coding. The exercise is to experiment with various models for representing money and prices that are flexible enough to deal with these (and other) pricing schemes, and at the same time are generally usable (at the checkout, for stock management, order entry, and so on). Spend time considering issues such as:

does fractional money exist?
when (if ever) does rounding take place?
how do you keep an audit trail of pricing decisions (and do you need to)?
are costs and prices the same class of thing?
if a shelf of 100 cans is priced using "buy two, get one free", how do you value the stock?

This is an ideal shower-time kata, but be careful. Some of the problems are more subtle than they first appear. I suggest that it might take a couple of weeks worth of showers to exhaust the main alternatives.

Goal

The goal of this kata is to practice a looser style of experimental modelling. Look for as many different ways of handling the issues as possible. Consider the various tradeoffs of each. What techniques use best for exploring these models? For recording them? How can you validate a model is reasonable?

What’s a Code Kata?

As a group, software developers don’t practice enough. Most of our learning takes place on the job, which means that most of our mistakes get made there as well. Other creative professions practice: artists carry a sketchpad, musicians play technical pieces, poets constantly rewrite works. In karate, where the aim is to learn to spar or fight, most of a student’s time is spent learning and refining basic moves. The more formal of these exercises are called kata.

To help developers get the same benefits from practicing, we’re putting together a series of code kata: simple, artificial exercises which let us experiment and learn without the pressure of a production environment. Our suggestions for doing the kata are:

find a place and time where you won’t be interrupted
focus on the essential elements of the kata
remember to look for feedback for every major decision
if it helps, keep a journal of your progress
have discussion groups with other developers, but try to have completed the kata first

There are no right or wrong answers in these kata: the benefit comes from the process, not from the result.

Kata 2 – Karate Chop

A binary chop (sometimes called the more prosaic binary search) finds the position of value in a sorted array of values. It achieves some efficiency by halving the number of items under consideration each time it probes the values: in the first pass it determines whether the required value is in the top or the bottom half of the list of values. In the second pass in considers only this half, again dividing it in to two. It stops when it finds the value it is looking for, or when it runs out of array to search. Binary searches are a favorite of CS lecturers.

This Kata is straightforward. Implement a binary search routine (using the specification below) in the language and technique of your choice. Tomorrow, implement it again, using a totally different technique. Do the same the next day, until you have five totally unique implementations of a binary chop. (For example, one solution might be the traditional iterative approach, one might be recursive, one might use a functional style passing array slices around, and so on).

Goals

This Kata has three separate goals:

As you’re coding each algorithm, keep a note of the kinds of error you encounter. A binary search is a ripe breeding ground for "off by one" and fencepost errors. As you progress through the week, see if the frequency of these errors decreases (that is, do you learn from experience in one technique when it comes to coding with a different technique?).
What can you say about the relative merits of the various techniques you’ve chosen? Which is the most likely to make it in to production code? Which was the most fun to write? Which was the hardest to get working? And for all these questions, ask yourself "why?".
It’s fairly hard to come up with five unique approaches to a binary chop. How did you go about coming up with approaches four and five? What techniques did you use to fire those "off the wall" neurons?

Specification

Write a binary chop method that takes an integer search target and a sorted array of integers. It should return the integer index of the target in the array, or -1 if the target is not in the array. The signature will logically be:

   chop(int, array_of_int)  -> int

You can assume that the array has less than 100,000 elements. For the purposes of this Kata, time and memory performance are not issues (assuming the chop terminates before you get bored and kill it, and that you have enough RAM to run it).

Test Data

Here is the Test::Unit code I used when developing my methods. Feel free to add to it. The tests assume that array indices start at zero. You’ll probably have to do a couple of global search-and-replaces to make this compile in your language of choice (unless your enlightened choice happens to be Ruby).

  def test_chop
    assert_equal(-1, chop(3, []))
    assert_equal(-1, chop(3, [1]))
    assert_equal(0,  chop(1, [1]))
    #
    assert_equal(0,  chop(1, [1, 3, 5]))
    assert_equal(1,  chop(3, [1, 3, 5]))
    assert_equal(2,  chop(5, [1, 3, 5]))
    assert_equal(-1, chop(0, [1, 3, 5]))
    assert_equal(-1, chop(2, [1, 3, 5]))
    assert_equal(-1, chop(4, [1, 3, 5]))
    assert_equal(-1, chop(6, [1, 3, 5]))
    #
    assert_equal(0,  chop(1, [1, 3, 5, 7]))
    assert_equal(1,  chop(3, [1, 3, 5, 7]))
    assert_equal(2,  chop(5, [1, 3, 5, 7]))
    assert_equal(3,  chop(7, [1, 3, 5, 7]))
    assert_equal(-1, chop(0, [1, 3, 5, 7]))
    assert_equal(-1, chop(2, [1, 3, 5, 7]))
    assert_equal(-1, chop(4, [1, 3, 5, 7]))
    assert_equal(-1, chop(6, [1, 3, 5, 7]))
    assert_equal(-1, chop(8, [1, 3, 5, 7]))
  end

Kata 3 – How Big, How Fast?

Rough estimation is a useful talent to possess. As you’re coding away, you may suddenly need to work out approximately how big a data structure will be, or how fast some loop will run. The faster you can do this, the less the coding flow will be disturbed.

So this is a simple kata: a series of questions, each asking for a rough answer. Try to work each out in your head. I’ll post my answers (and how I got them) in a week or so.

How Big?

roughly how many binary digits (bit) are required for the unsigned representation of:
- 1,000
- 1,000,000
- 1,000,000,000
- 1,000,000,000,000
- 8,000,000,000,000
My town has approximately 20,000 residences. How much space is required to store the names, addresses, and a phone number for all of these (if we store them as characters)?
I’m storing 1,000,000 integers in a binary tree. Roughly how many nodes and levels can I expect the tree to have? Roughly how much space will it occupy on a 32-bit architecture?

How Fast?

My copy of Meyer’s Object Oriented Software Construction has about 1,200 body pages. Assuming no flow control or protocol overhead, about how long would it take to send it over an async 56k baud modem line?
My binary search algorithm takes about 4.5mS to search a 10,000 entry array, and about 6mS to search 100,000 elements. How long would I expect it to take to search 10,000,000 elements (assuming I have sufficient memory to prevent paging).
Unix passwords are stored using a one-way hash function: the original string is converted to the ‘encrypted’ password string, which cannot be converted back to the original string. One way to attack the password file is to generate all possible cleartext passwords, applying the password hash to each in turn and checking to see if the result matches the password you’re trying to crack. If the hashes match, then the string you used to generate the hash is the original password (or at least, it’s as good as the original password as far as logging in is concerned). In our particular system, passwords can be up to 16 characters long, and there are 96 possible characters at each position. If it takes 1mS to generate the password hash, is this a viable approach to attacking a password?

Kata 4 – Data Munging

Martin Fowler gave me a hard time for KataTwo, complaining that it was yet another single-function, academic exercise. Which, or course, it was. So this week let’s mix things up a bit.

Here’s an exercise in three parts to do with real world data. Try hard not to read ahead—do each part in turn.

Part One: Weather Data

In weather.dat you’ll find daily weather data for Morristown, NJ for June 2002. Download this text file, then write a program to output the day number (column one) with the smallest temperature spread (the maximum temperature is the second column, the minimum the third column).

Part Two: Soccer League Table

The file football.dat contains the results from the English Premier League for 2001/2. The columns labeled ‘F’ and ‘A’ contain the total number of goals scored for and against each team in that season (so Arsenal scored 79 goals against opponents, and had 36 goals scored against them). Write a program to print the name of the team with the smallest difference in ‘for’ and ‘against’ goals.

Part Three: DRY Fusion

Take the two programs written previously and factor out as much common code as possible, leaving you with two smaller programs and some kind of shared functionality.

Kata Questions

To what extent did the design decisions you made when writing the original programs make it easier or harder to factor out common code?
Was the way you wrote the second program influenced by writing the first?
Is factoring out as much common code as possible always a good thing? Did the readability of the programs suffer because of this requirement? How about the maintainability?

Kata 5 – Bloom Filters

There are many circumstances where we need to find out if something is a member of a set, and many algorithms for doing it. If the set is small, you can use bitmaps. When they get larger, hashes are a useful technique. But when the sets get big, we start bumping in to limitations. Holding 250,000 words in memory for a spell checker might be too big an overhead if your target environment is a PDA or cell phone. Keeping a list of web-pages visited might be extravagant when you get up to tens of millions of pages. Fortunately, there’s a technique that can help.

Bloom filters are a 30-year-old statistical way of testing for membership in a set. They greatly reduce the amount of storage you need to represent the set, but at a price: they’ll sometimes report that something is in the set when it isn’t (but it’ll never do the opposite; if the filter says that the set doesn’t contain your object, you know that it doesn’t). And the nice thing is you can control the accuracy; the more memory you’re prepared to give the algorithm, the fewer false positives you get. I once wrote a spell checker for a PDP-11 which stored a dictionary of 80,000 words in 16kbytes, and I very rarely saw it let though an incorrect word. (Update: I must have mis-remembered these figures, because they are not in line with the theory. Unfortunately, I can no longer read the 8" floppies holding the source, so I can’t get the correct numbers. Let’s just say that I got a decent sized dictionary, along with the spell checker, all in under 64k.)

Bloom filters are very simple. Take a big array of bits, initially all zero. Then take the things you want to look up (in our case we’ll use a dictionary of words). Produce ‘n’ independent hash values for each word. Each hash is a number which is used to set the corresponding bit in the array of bits. Sometimes there’ll be clashes, where the bit will already be set from some other word. This doesn’t matter.

To check to see of a new word is already in the dictionary, perform the same hashes on it that you used to load the bitmap. Then check to see if each of the bits corresponding to these hash values is set. If any bit is not set, then you never loaded that word in, and you can reject it.

The Bloom filter reports a false positive when a set of hashes for a word all end up corresponding to bits that were set previously by other words. In practice this doesn’t happen too often as long as the bitmap isn’t too heavily loaded with one-bits (clearly if every bit is one, then it’ll give a false positive on every lookup). There’s a discussion of the math in Bloom filters at www.cs.wisc.edu/~cao/papers/summary-cache/node8.html.

So, this kata is fairly straightforward. Implement a Bloom filter based spell checker. You’ll need some kind of bitmap, some hash functions, and a simple way of reading in the dictionary and then the words to check. For the hash function, remember that you can always use something that generates a fairly long hash (such as MD5) and then take your smaller hash values by extracting sequences of bits from the result. On a Unix box you can find a list of words in /usr/dict/words (or possibly in /usr/share/dict/words). For others, I’ve put a word list up at pragprog.com/katadata/wordlist.txt.

Play with using different numbers of hashes, and with different bitmap sizes.

Part two of the exercise is optional. Try generating random 5-character words and feeding them in to your spell checker. For each word that it says it OK, look it up in the original dictionary. See how many false positives you get.

XML Config Transformations in Visual Studio and SlowCheetah

mark shiffer — Wed, 24 Aug 2011 20:13:58 +0000

Xml config transformations are an easy way to provide consistent changes to web.config files when deploying applications to different environments. However, until SlowCheetah came out this useful transformation was limited to actual deploys. SlowCheetah provides the ability to complete transformations when Run/Debugging in Visual Studio on any file and could come in quite handy. Between SlowCheetah and T4 templates, maybe someone can come up with a way to have Visual Studio just code the whole app for you!

PsExec

mark shiffer — Mon, 22 Aug 2011 12:33:32 +0000

Scott Hanselman recently posted an article in which he used PsExec to open regedit running as the System user (think administrator on steroids). This allowed him to delete registry entries that aren’t normally accessible. The cool thing about this tool is the remoting capabilities. I’m about to give it a shot here at work to see if it is quicker than using remote desktop for administering remote servers.

Utilities like Telnet and remote control programs like Symantec's PC Anywhere let you execute programs on remote systems, but they can be a pain to set up and require that you install client software on the remote systems that you wish to access. PsExec is a light-weight telnet-replacement that lets you execute processes on other systems, complete with full interactivity for console applications, without having to manually install client software. PsExec's most powerful uses include launching interactive command-prompts on remote systems and remote-enabling tools like IpConfig that otherwise do not have the ability to show information about remote systems.

ASP.NET MVC 2 Presentation

noreply@blogger.com (Allen Scharfenberg) — Sat, 19 Mar 2011 03:29:00 +0000

I meant to post this a while back, but in January I gave a presentation on ASP.NET MVC 2 on behalf of the Sangamon Valley .NET User Group, and I thought I would share the following links to the slides and source code:

We tried our best to capture a decent video of the presentation, but alas the laptop I used for the presentation ate both the screen and audio feeds. The video for Mark Lovik’s February presentation on Silverlight 4, however, is in post-production, so stay tuned!

Windows Phone 7—Pivot Control

noreply@blogger.com (Allen Scharfenberg) — Sun, 07 Nov 2010 18:37:00 +0000

So, I spent last week picking through a few of the controls available for Windows Phone 7 applications. Although doing so did not allow for much visible progress on Project Badger, it did help me better understand what you can do with your Windows Phone 7 applications—which is important. After all, the only thing worse than failing to understand the tools at your disposal is failing to understand the need for your application at all.

My favorite Windows Phone 7 control so far is the Pivot control. It lets you create a Silverlight view with left/right flick navigation—like so:

Looks great, right? What about the code, though? Nasty, right? Nope!

Code Snippet
 <!--Pivot Control-->
<controls:Pivot Title="MY APPLICATION">
    <!--Pivot item one-->
    <controls:PivotItem Header="first">
        <!--Double line list with text wrapping-->
        <ListBox x:Name="FirstListBox" Margin="0,0,-12,0" ItemsSource="{Binding Items}">
            <ListBox.ItemTemplate>
                <DataTemplate>
                    <StackPanel Margin="0,0,0,17" Width="432">
                        <TextBlock Text="{Binding LineOne}" TextWrapping="Wrap" Style="{StaticResource PhoneTextExtraLargeStyle}"/>
                        <TextBlock Text="{Binding LineTwo}" TextWrapping="Wrap" Margin="12,-6,12,0" Style="{StaticResource PhoneTextSubtleStyle}"/>
                    </StackPanel>
                </DataTemplate>
            </ListBox.ItemTemplate>
        </ListBox>
    </controls:PivotItem>
 
    <!--Pivot item two-->
    <controls:PivotItem Header="second"> 
        <!--Triple line list no text wrapping-->
            <ListBox x:Name="SecondListBox" Margin="0,0,-12,0" ItemsSource="{Binding Items}">
                <ListBox.ItemTemplate>
                    <DataTemplate>
                        <StackPanel Margin="0,0,0,17">
                            <TextBlock Text="{Binding LineOne}" TextWrapping="NoWrap" Margin="12,0,0,0" Style="{StaticResource PhoneTextExtraLargeStyle}"/>
                            <TextBlock Text="{Binding LineThree}" TextWrapping="NoWrap" Margin="12,-6,0,0" Style="{StaticResource PhoneTextSubtleStyle}"/>
                        </StackPanel>
                    </DataTemplate>
                </ListBox.ItemTemplate>
            </ListBox>
    </controls:PivotItem>
</controls:Pivot>
 

As you can see from the above XAML, a Windows Phone 7 Pivot control is simply a container for as many PivotItem controls as you like. The Pivot control itself takes a Title property to be displayed at the upper left of the screen. Similarly, the PivotItem control takes a Header property to be displayed across the left/right navigation pane.

The rest is just XAML data templates! Pretty slick, eh?

You can test drive the Pivot control—if you have Visual Studio 2010—by creating a new project from the Windows Phone Pivot Application template. Navigate to File –> New Project –> Silverlight for Windows Phone –> Windows Phone Pivot Application.

Of course, you must have the Windows Phone 7 development tools installed. Scott Guthrie has a great blog post on how to do so. If you do not have Visual Studio 2010, you can instead install Visual Studio 2010 Express for Windows Phone.

As you have seen, the Pivot control is a great way to add sleek, maintainable navigation to your Windows Phone 7 applications. With just a small amount of XAML (or almost none if you use the Windows Phone Pivot Application template), you can turn a single screen app into a multi-paged powerhouse of rich functionality that is both stylish and easy to use.

Project Badger—Underway

noreply@blogger.com (Allen Scharfenberg) — Thu, 04 Nov 2010 03:10:00 +0000

Some significant progress on the best darn task manager app ever tonight! For now, I have codenamed the app Project Badger. Badgers are cool. And mean. And I don’t really know what either of those two qualities has to do with the app, but that’s okay—Project Badger has a good ring to it.

Now that I have played with the Windows Phone 7 development environment a bit, I am understanding some of the apps I already use better. I will post more on that later, but, for now, my pillow is more important.

More details soon!

Setting Up

noreply@blogger.com (Allen Scharfenberg) — Wed, 03 Nov 2010 02:46:00 +0000

Microsoft Visual Studio 2010 Professional? Check! Windows Phone 7 Developer Tools? Check! I am still working on getting my MSDN Essentials Subscription setup (the site is evidently having issues today), and I am still awaiting my free subscription to the Windows Phone Marketplace. Oh, and I want to get PEX going. Oh, and Team Foundation Server. Oh, and….

All this installing, and I just want to code! The anticipation is killing me! Gah!

Code what, do you say? Well, just the best damn little task manager app you ever did see, that’s what!

Stay tuned!

Windows Phone 7—People

noreply@blogger.com (Allen Scharfenberg) — Fri, 29 Oct 2010 05:58:00 +0000

When Steve Ballmer announced in the PDC 2010 keynotes address that each attendee would receive a Windows Phone 7, I’m pretty sure I almost passed out. First, Windows Phone 7 is a paradigm shifting evolution for the Windows Phone OS. Second, I have been hunting for months now for a replacement for my aging Nokia E71x. Third, it is damn cool!

Of all the great features in Windows Phone 7, what I am most impressed with is the People functionality. Once you have connected your Windows 7 Phone to your Facebook, personal email, corporate email, and other such accounts, the People widget aggregates all of the contact and demographic data for everyone and displays it as one coherent whole. For example, it will combine Facebook info on place of work, occupation, city of residence, and the like with home and mobile phone numbers from your corporate contact list. It’s amazing!

I Owe My Soul to the Company Store

noreply@blogger.com (Allen Scharfenberg) — Thu, 28 Oct 2010 06:33:00 +0000

Early registration took a heck of a lot longer than I thought it would. I’m glad I did the early registration, though, because I sure wouldn’t want to be stuck in a half-hour line tomorrow morning before the PDC keynote.

The big goodie in the goodie bag this year was a coupon allowing each attendee to purchase up to $120.00 (USD) worth of Microsoft software in the company store. For myself, I was all over a copy of Visual Studio 2010 Professional for home. So, for a hundred and twenty bucks I was able to score, oh, about eight hundred dollars worth of software. Such a great deal!

Now I am super excited to start experimenting more at home. The lack of proper tooling has been a significant factor in my lack of blogging this year, and I am very much looking forward to changing that.

More to come!

Inspiration

noreply@blogger.com (Allen Scharfenberg) — Wed, 27 Oct 2010 22:49:00 +0000

I’m not sure if it is the fresh air and beautiful scenery or if it is the anticipation of discussing my favorite technologies with some of the greatest minds in the computing field, but I must say this trip to the PDC has been quite inspirational thus far. The world is a big place with many interesting people, places, and ideas. So many that it is impossible for any one of us to experience them all. It is, however, important to sample what you can in life because variety gives perspective—which is key to overcoming our own biases, as best we can.

This hold true for software development just like any other field. As Guy Kawasaki discusses in his book Rules for Revolutionaries, you must eat like a bird and poop like an elephant. Contrary to popular belief, a bird actually eats a lot—for its body weight, a bird eats much more than, say, a person. Evidently, all that flying is not particularly efficient.

I will leave the elephant part to your imagination….

The crux of the saying, though, is that you should strive to take in as much information as possible—“eat like a bird'”—and transmit as much information as possible—“poop like an elephant”—so that the flow of ideas never stops. “Eating” and “pooping” different kinds of information is especially important because, as aforementioned, different kinds of information give you different perspectives on life—which is the nest in which great, well-rounded ideas are hatched.

That is why we should all strive to be inspired whenever possible. Without inspiration, we lack vision, and, without vision, we lack direction.

And, without direction, we lack purpose.

Preparing for the PDC

noreply@blogger.com (Allen Scharfenberg) — Wed, 27 Oct 2010 17:59:00 +0000

My colleague and I have had a great morning discussing our plans for the PDC. We also stopped off at Pike’s Place to tour the fish market and to get some yummy fried fish over at Pike’s Place Bar & Grill. Great times!

We have early registration tonight at Microsoft along with two pre-sessions to attend—one with the MSDN documentation team and one regarding Azure and cloud computing.

What a great day!

On My Way to the PDC

noreply@blogger.com (Allen Scharfenberg) — Tue, 26 Oct 2010 21:42:00 +0000

I am super excited to be on my way to Microsoft’s Professional Development Conference (PDC) in Redmond. The sessions are more down to earth this year—focused on Windows internals, Azure and the Cloud, Windows Phone 7, and the like—which I find refreshing and quite useful. I wouldn’t have minded a few sessions on Silverlight 4, though, but it is still going to be a great conference.

More to come. Stay tuned!

Prey for your lost laptop

brandon — Wed, 11 Aug 2010 04:12:00 +0000

Having recently purchased a laptop of my very own, I began to wonder what would happen if my Precious was lost or stolen. What would I do? There are commercial applications available, such as LoJack and others, that provide services to locate and recover your missing hardware. Some of these services even come with a money-back guarantee. Even with all these assurances, I still believe that any half-computer-savvy thief could easily get around a barrier like this. Regardless, looking into this type of application has been on my to-do list anyway, just to see what is out there.

A few days ago, I was catching up on episodes of Hak5 when they showcased the Prey Project. Prey is an open-source, free laptop recovery system. I'd tell you all about it, but just check out the Hak5 episode below.

I installed Prey on my MacBook Pro in just a few minutes. Installation was easy. I chose the control panel mode and created a new account from within the installer. After Prey was "running" (you get no visual indicators, icons, etc. which is what you want) I went to the control panel site and enabled the Alert feature under Action Modules. The message displayed as promised twenty minutes later.

Portable computer recovery software such as Prey, and others, is limited, however, and can only assist you if conditions are ideal. Those conditions include the computer being powered on and able to connect to the Internet. Prey will search for available wireless connections, but you'd better hope an open WiFi access point is nearby if your computer is locked via a password. If you don't have a password (and you really should) the thief will probably take care of establishing a network connection for you. If the thief is experienced with computers, however, chances of software such as Prey being successful is even more limited. An experienced person would probably keep your computer powered off and remove the hard drive after the deed is done. It's a good thing there are a lot of dumb criminals out there.

I plan to stick with Prey and hope that I never need to use it for its intended purpose. If you have a portable computer, give Prey a try. It's better than nothing at all, right?! If you choose the Control Panel tracking method you get to register up to three computers.

Let me know if you've used Prey or any similar services. Did you lose a laptop and activate the service? Did you get it back?

So Long, Nexus One

brandon — Tue, 20 Jul 2010 08:19:21 +0000

Oh, Nexus One, you had such promise! What happened? On Friday, Google put the final nail (ok, maybe next-to-final) in the coffin of their grand experiment in the direct-to-consumer mobile phone design and sales business, namely the Google Nexus One.

As those of you who follow the mobile device industry know, the Nexus One debuted earlier this year as Google's self-designed epitome of what an Android phone should be. The phone introduced then was sleek, fast, open and out to give Android's competitors a run for their money. The phone was well receivedby the tech industry pundits and is still loved by their die-hard fanboys.

Sales of the Nexus One to the masses, however, didn't quite take off. Not even six months after the launch of the Nexus One, Google announced it would be pulling the plug on the Web store. Now, the Nexus One will only be available to the masses until Google runs out. Luckily for Android developers, they will still be able to purchase handsets in order to have a solid development platform. Without mass production, though, who knows how long they will be available, what carriers they will work on or how expensive they will be.

Now, if you've read this far, you may be assuming this is going to be an anti-Android/Google post, because I have been accused of being an Apple fanboy many times in the past. [more]Not so! In fact, I think the market failure of the Nexus One is going to be a dark spot in the history of the mobile device industry.

The Nexus One had an important reason to be a strong competitor in a Smartphone market dominated by Apple and other handset manufacturers and carriers. Competition, after all, breeds innovation.

There are many Android-based phones on the market, so why do I believe the Nexus One should have been an important competitor? Are other Android phones non-innovative compared to it? No, this is not the reason. I wanted the Nexus One to succeed was because it was a Google-designed phone that didn't bow down to the demands of any particular service provider. It was a phone that Google made the way it wanted to, without crapware and lockdowns enforced by behemoths such as AT&T and Verizon. It was also sold direct to consumers, which was a new thing for Google. I'm afraid the combination of these factors, however, contributed greatly to the phone's demise.

Here are the reasons why I think the Nexus One failed as a mass-market Smartphone. These reasons come from my own perception on the phone and mobile device industry in general. Being an iPhone owner, I don't follow Android-based phone news as closely as some of my friends, so much of the information I hear about them comes from the same sources you or they read online. Even if you think my reasons are full of crap, remember this comes from my perception of what happened with the Nexus One. I didn't do a lot of research past a few Google searches while writing this article, so I may even be way off. Remember, though, facts are only as good as how widely they are perceived, so my opinions as an Android "outsider" may help you better understand the thoughts of those who didn't buy a Nexus One.

The Price, Compatibility

When the Nexus One launched in the U.S., it wasn't available on our largest mobile provider, AT&T. When it did become available, the price was a steep $500-plus for an unlocked, unsubsidized version of the phone. Price, I believe, still is the major deterrent to the acceptance of any neat, new gizmo, no matter how cool it is. The Nexus One was a phone built for Android lovers who were longing to escape the clutches of Microsoft, RIM and Apple-based Smartphones. The love came at a price, however.

Marketing

Google, easily one of the most popular websites to ever exist, simply didn't get the word out about their new phone. Granted, the homepage did feature the Nexus One, but it was only for a little while. Could the removal of the phone from the home page be related to pressure from other manufacturers or the carriers themselves? We may never know. There were plenty of opportunities for Google to push this phone, but it didn't happen compared to how in-your-face iPhone and Droid ads have been. It's not like Google doesn't have the money! The bottom line is: If you're not a computer geek that has an interest in mobile devices, then you probably didn't look into the Nexus One beyond the initial hype.

No Hands-On Experience

Tech reporters and Google alike think we need a hands-on, retail experience to fall in love with and buy a device like the Nexus One. I'm sure this is true, but couldn't this also be because of the failure of the marketing machine? Let's look at Apple and Verizon, for example. Prior to the release of the iPhone 4, no one had any hands-on experience with it until launch day, save for the normal industry reviewers, etc. Yes, there have been previous iPhone editions that set a precedent, but Apple sold millions within a few days after the product's launch. Similar conditions were present for the new Droid Xon Verizon, which also sold out on its first day. That's a lot of sales for not having a hands-on experience.

Competing With Itself

The last factor against the Nexus One is the fact Android competes with itself. If you want an Android phone, there are dozens to choose from on multiple carriers. This is great for the consumer, but bad for a niche product such as the Nexus One. With high price points for unlocked phones on certain carriers and others, such as Verizon, offering near-irresistible buy-one-get-one-free (which included the Droid) deals, the Nexus One was doomed to be overshadowed by cheaper phones that received a brighter spotlight.

Conclusion

Even after tough lessons learned from the Nexus One, I'd like to see Google supervise the creation of another phone. Large industry players, such as Apple and Google, are the only companies that have enough leverage over service providers to cut the crap and deliver a sleek, clean Smartphone to the consumer. Google will be an important player in keeping the Android platform truly open on mobile devices. After all, just because the OS is "open," manufacturers aren't obligated to let you play as you like on their devices, such as all the news speculating about the Droid X's eFuse chip. For the good of the industry, innovation and competition, let's hope that Google phones don't stop with the Nexus One.

This Backup is Gonna Take a While!

brandon — Tue, 30 Mar 2010 07:20:03 +0000

Just a quick, fun thing to share here. I've been taking a look at backup software over the past week, trying to decide what to use to back up a few additional PCs I have. I've written about backup software before, but this time I'm looking for something that handles the network backups a little bit better than the Acronis home series.

One software product I began looking into tonight is Novastor NovaBACKUP Professional. I have never used it before and found it via some searching. One unique feature it has is the ability to run a file copy/synchronize between two locations without writing data to a proprietary backup format file. No other backup software I've been testing recently does that. The functionality is very similar to Microsoft's SyncToy.

I thought I'd throw the largest thing that I have at this feature, which turns out to be a 100-plus gigabyte archive of photographs I've taken over the years. The source was the photo archive on my Drobo S. The destination is a network share on an old server that I have. After setting the options, I started the copy, got up and let it run for a bit.

I would have loved to finish the test, but I don't think I have quite this long to mess around!

Now, to be fair to Novastor, the destination server is old (HP Netserver LH3) and has some problems with file copies over the network. I still thought four years to finish was pretty funny. Maybe Novastor needs to take a look at how they're calculating their estimates under less-than-ideal conditions. Would it have really taken that long? I doubt it, but I'm not willing to find out!

Windows 7 Upgrade Time

brandon — Sun, 07 Mar 2010 02:53:00 +0000

If you're as lazy as I, you may have been using the Windows 7 Release Candidate (RC) until just recently. Why just recently? If you're not in the know, Windows 7 was released for sale in October of last year. Before then, the RC was made publicly available May 5, 2009, with a beta version available before then. During the RC phase, it was well known that the RC version of Windows 7 was set to begin shutting down your PC every two hours starting on March 1. How time flies! A friendly reminder from Microsoft (pictured here) sparked the motivation I needed to kick start my Windows 7 release version installation. Time to get started. [more]

So why did it take me so long to wipe out the RC and install the final version? Why did I hold out so long? Did I think Microsoft would change their mind? Of course not. Strolling down memory lane, I can recall the good 'ol (bad 'ol?) Win 3.x and 9x days, when re-installing my OS was a every-few-month ritual. Back then, half-baked application installers/uninstallers and OS tweaking, over time, either made your PC either completely unusable or bogged it down to the point it became unstable and impractical to tolerate. Backing up, formatting, and starting anew was not an unfamiliar process to computer geeks of that time. In hindsight, I can say I learned a lot from it and knew what I was getting myself into each time. Anyway, now it's not necessary to backup, format, and re-install your OS from scratch as often. Despite all our complaints about Windows, the OS has actually come a very long way in terms of stability and problem recovery. The machine of mine to be upgraded now was upgraded to the Windows 7 Beta from and initial installation of Windows Vista, which was installed in late 2008. It was then upgraded to the Windows 7 RC from the beta in May 2009. Even though upgrades to these editions weren't officially supported by Microsoft, there were ways. Also, I have to say, for a prerelease operating system, the Windows 7 RC was solid. I had better luck with it on this PC than I ever had with Vista. It was faster and more stable than Vista had ever been on this computer's hardware. To summarize, I was pretty happy with the Windows 7 RC. Why fix it if it's not broken?

Oh, right...Guess I'd better get on that!

It's been a long time since a format and re-install of my personal PC. I used to do this all the time, so why is it such a pain now? It made me realize that in the 1990s, we didn't have gigabytes of digital photos, music, videos, and everything else we hoard on our PCs now. In 1996, a gigabyte seemed like a lot more than what it is now. Heck, I carry 16 gigabytes in my pocket, on my phone. Reformatting and re-installing an OS is a bigger pain because we just have a lot more stuff than we used to.

Step 1: Back dat up!

I've previously written about my backup and restore experiences. If you're not backing up your PC or Mac, you're taking a huge risk. Of course, this depends on how important the data on your PC is to you. I've seen people who could not have cared less about a failed hard drive and those who are devastated at the loss. Be sure you know where you fall when it comes to data loss.

First, I performed a full backup of my PC, running the Windows 7 RC, to an external USB hard drive using Acronis True Image Home 2010. Simple enough. This would give me a good backup that I could pick data out of once I've restored.

The problem with a traditional backup like this is that once you've wiped out your machine and re-installed the OS, you have to pick and choose your data out of your backup's archive. What if you can't get to some data you're wanting, like how you had an application set up or some account information that was stored in an application and isn't accessible via the file system? Also, once you've taken the step to wipe out and start over, it can take some time to get your apps re-installed, patched, and reconfigured to the way you like it. This was my primary PC, so I wanted as little downtime as possible.

Step 2: A different way to back up

One of the cool new, but not often mentioned, features of Windows 7 is its ability to boot from .VHD files. VHD stands for virtual hard disk. It's the same technology used in Microsoft Virtual PC and Hyper-V to store the contents of virtual machines. When I say "boot from .vhd," I'm not talking about booting up a virtual machine either inside Virtual PC or Hyper-V. I'm talking about booting up your "real" hardware from a .vhd file, just like you'd normally boot your system from your C drive. You can read this Microsoft Technet article on how to use the bcdedit tool to edit your computer's boot loader in order to boot from a .vhd file. I believe this works on Windows 7 Professional and higher. I'm not sure about the other editions.

I heard about booting from .vhd during the Windows 7 RC phase and wanted to try it out since then. I'm lucky in the sense that I just happen to have another PC here with very similar hardware compared to the PC I am reloading. My plan was to convert my Windows 7 RC's drive to a .vhd, move it to the other computer (where the Windows 7 Ultimate release version is installed), configure it to boot from the .vhd of my old PC, and re-install my Windows 7 RC PC with the release version of Windows 7. This would allow me to reload my RC machine while still being able to use my apps on my ".vhd PC" and transfer my files and settings from the old to the new at my leisure.

The first step in this plan was to back up my Windows 7 RC installation to a .vhd file. There are some commercial tools available to do this, but there's an even better (and free!) tool from Microsoft (Sysinternals) called Disk2VHD which does an excellent job. I downloaded disk2vhd on my Windows 7 RC machine, ran the program and saved my system's C partition and boot partition to a .vhd file on my external hard drive. I then moved the .vhd file to my other Windows 7 PC via my home network. Then, on the Windows 7 PC to where I moved the .vhd, I followed the instructions to add the .vhd to that system's boot menu. One note about the Technet article. You'll need to put square brackets around the drive letter when using bcdedit. The article isn't 100% clear on this. For instance, if you copy your .vhd file to d:\oldpc\oldcdrive.vhd, you'll need to refer to this as "[d]:\oldpc\oldcdrive.vhd" (without quotes) when using bcdedit.

Next, I rebooted my PC containing the .vhd file into the Windows 7 RC operating system residing in the .vhd file. Upon boot, you're given a choice of which operating system to start, so just pick the one you created during the bcdedit steps. This worked perfectly! Once the operating system came up, Windows began re-detecting my hardware. When that happens, a reboot is required. I went through a few detection and reboot cycles, but, eventually, I was able to use my Windows 7 RC operating system just like it was on the original PC. Because all of that hardware redecting occurred, Windows 7 RC fell out of activation...so I had to re-activate Windows. I thought this was a little ironic, since I'd only be using this for a short time.

One very important note. When Disk2VHD creates your .vhd file, it only consumes as much drive space as the amount of data taken up on your source disk(s). For example, on your source PC (my Windows 7 RC computer), let's assume you want to back up your 640 GB C drive to a .vhd file. Let's also assume you're only using 230 GB out of the total 640 GB. Disk2VHD thusly creates a 230 GB .vhd file. You then move this to another PC and follow the bcdedit steps. The drive on this destination PC where you copied this .vhd must have enough free space to account for the entire source disk, which in our case is 640 GB. The reason this is so is because the size of the .vhd is dynamically expanded to the size of the source disk when you boot the .vhd-based operating system. If the physical hard drive does not have enough free space to account for the total size of the virtual hard disk file, you'll receive the famous blue screen of death when you attempt to boot the operating system in your .vhd file.

Step 3: Re-install at your own pace

Once I had my .vhd-based operating system up and running on my other computer, I was free to format and re-install the Windows 7 release version on my primary PC when I wanted to. Over the next few days, I re-installed all my applications and copied my data from the .vhd PC to the newly reloaded Windows 7 PC over my home network. It enabled me to ensure that my applications worked just like they did on the Windows 7 RC installation. If something came up while installing my applications on the newly reloaded PC, I could easily switch over to the PC running my Windows 7 RC .vhd.

Conclusion and afterthoughts:

Using the .vhd method, I was able to reload my computer's operating system while making sure I didn't lose anything important. Having both systems available at the same time made it really easy to verify everything was re-installed and working properly. One idea I'd like to mention is that it does not necessarily require another physical computer to pull off this technique. You could just as easily use Disk2VHD to create your VHD and then run it as a virtual machine in Virtual PC if you only have one physical PC available. I chose to use the second PC because I had it available and also because I wanted to try out bcdedit and .vhd booting. Overall, I'm very happy with how it turned out.

My Thoughts on the iPad

brandon — Sat, 06 Feb 2010 19:03:11 +0000

"Magical, revolutionary"... these are among the many words Steve Jobs and company used to describe the iPad during the device's announcement Jan. 27.

Is it, though? Right now, it kind of looks like a big iPhone or iPod Touch ...

The majority of people I have seen discussing the iPad online or talked to in person about it have a lot of hate for the device. Are these your typical Apple bashers feasting upon the latest fresh meat from Cupertino or are there some valid points among the name-calling and panty liner jokes?

While the iPad is a neat device, many of the naysayers have good points when it comes to what isn't included. I'm not a belittler. I'm looking forward to trying one out and, maybe, buying one if I like it. I thought I'd use this post to bring up some intelligent pros/cons about it. If that doesn't suit you, halt your reading now! [more]

Only one friend I've talked to about the iPad had positive comments about it and looked forward to trying it out. The rest, however, had some of the following to say:

"I want to show you something, and I'm really excited about this, it's the iPad mini (pulls out his iPhone)."
"No multitasking, no cameras (front or rear), hideously over-size bezel, no Flash in browser, no input ports of any kind ..."
"No multitasking, no camera, no HDMI out, no USB without adaptors, no Adobe Flash support, no widescreen, no thanks."
"It's a netbook without Flash, without a keyboard and a crappy OS laden with DRM. And for only 3x the price of a netbook!"

You get the idea.

I want to touch on a few of these points, of which Apple has missed the mark or deliberately planned, and offer up my opinion, drawing from experiences I've had with the iPhone and other mobile devices I've used, such as netbooks, laptops and tablet PCs.

Cameras:

A lot of people, including myself, expected the iPad to have a user-facing camera for video chat. Apple, after all, has been building cameras into iMacs and Macbooks for a few years now. Why not include a camera in this device? You could be sitting in your favorite easy chair, iChatting with your buddy or grandma. Maybe it has to do with how the iPad will be held? In a desktop or laptop (or netbook), the screen stays in a relatively fixed position when you're using it. The hardware vendor can count on where the position of your face is in relation to the camera, most of the time. If you need to adjust, simply tilt the screen. The iPad, according to Jobs at the Apple announcement event, has no true up or down because it "adapts to the way [you] want to use it." Taking that into account, maybe it is too cumbersome to use for video chat. After all, you'd have to hold it in a fixed position for the entire conversation. The iPad, at 1.5 pounds, isn't that heavy, but I know I'd get annoyed with holding it in a certain way in front of me for more than a few minutes. Excluding a camera is not a deal breaker for me. I don't video chat now, nor do I know anyone who currently does. For those who do, it would have been nice to include in the iPad, especially when it's seated in the optional dock.

Fantasy time. A really neat innovation would be to somehow have the camera behind/inside the middle of the screen instead of in the bezel. Being able to video chat while looking directly at the screen would make the act of video chatting practical, or at least more personal. Now, when you video chat, the image of the person you're chatting with shows them not looking directly at you, but looking at their screen (looking at you looking at your screen). With the way video chat works now, it's like you're standing face to face talking to someone, except you're looking at each other's chins instead of looking at the eyes. Before this gets too crazy, though, let's consider this could be a pretty creepy device. If you want to block the webcam in your monitor now, black electrical tape works great. An in-screen camera would raise a whole new line of privacy concerns.

As far as having a camera on the back, just get a real camera! Laptops and netbooks don't implement rear facing cameras, so I don't know why anyone would expect the iPad to.

Flash:

I'm not surprised about the exclusion of Adobe Flash support on the iPad. Apple, with many revisions of the iPhone OS, has had plenty of chances to include it. You've probably already read the back and forth between Apple and Adobe regarding Flash. Interactive Flash content on the iPhone would be hard to use and I don't find myself missing it. However, full Flash video support would be nice and I do miss that. Flash on the iPad should be a standard feature and it detracts from that "wonderful experience" we're being promised. I was surprised to see Jobs browsing pages in the iPad demo that would show the big, ugly "missing plug-in" graphic. Didn't they check that out before the show?

The deeper question to ask is why is Apple (namely, Steve) being so critical of Adobe? I believe Adobe was largely responsible for making Apple products a success for many years. How many graphic-artsy, video-centric folks do you know that use Apple products for their trade? Adobe, after all, could just decide to no longer produce Apple software. Do you think Adobe or Apple would suffer more for this? Adobe already offers most, if not all, of their products for Windows. Apple, on the other hand, has no Photoshop replacement waiting in the wings. I think Tim Gunnneeds to bring Apple and Adobe into the same room and give them a good "make it work" talking to. Heck, I guess they could go Silverlight. Oh, wait, maybe they are?

GPS:

The details on GPS are a letdown. The WiFi + 3G version will have AGPS (Assisted GPS). With all that room inside of the iPad, Apple couldn't fit a true GPS? If full GPS capability isn't included in all the models, it will cripple the usefulness of many of the available apps when taken from the iPhone to the iPad. WiFi-only customers seem to be out of luck if you're somewhere without a signal. Maybe Apple doesn't want you to file a lawsuit against them, because you, being so smart, decided to mount your iPad on your car's dash or windshield in order to have the baddest-ass navigation display on the planet.

Aspect Ratio:

I don't work for Apple, but if I had to guess, the decision to stick with 4:3 at 1024 x 768 came down to a decision having to do with compatibility and cost. Compatibility in the sense that going with a 16:9 ratio may have too greatly skewed non-iPad optimized apps running on the device. True, the pixel-doubled iPhone and iPod Touch apps in Apple's videos don't fill the iPad's screen entirely, but they do appear to fit nicely. Browsing the Web in portrait mode on a 9.7 inch 16:9 screen would probably not be pleasant, either. If you have a 19 inch wide-screen LCD monitor, for instance, try putting it into portrait mode and do some browsing. Chances are you'll be doing some side scrolling (a true Web browsing annoyance on any platform), because most Web content is too wide to fit in a narrower presentation mode. True, Apple could do some things, such as make it 16:10 or increase the resolution, but that brings in the cost factor. I think high-end screen features like HD and widescreen were first on the chopping block when Apple set their price goals for the iPad to be below $1,000.

HDMI:

I'm not surprised that HDMI was excluded. Apple's look and feel in all their devices is all about clean lines. I have no doubts about their new A4 processor having the capability to pump out 1080p HD video, but putting a port on the device would be design blasphemy as it's seen by Apple. You'd think there would at least be a 30 pin-to-HDMI cable. Apple's agenda could include other reasons for limiting the external display output, though. Consider the Apple TV. Having a fully HD-capable iPad has the possibility of cutting into the Apple TV's space. This is kind of a long shot, because you get a device like Apple TV so you can leave it attached to your entertainment system all the time. The iPad could breathe new life into Apple TV by working with it as you watch your content via Apple TV on your television. Not that I'm an Apple TV fan. In fact, I've never used one. Apple has to be cooking up something. Picture this: You could be watching your TV show/movie on your Apple TV while the iPad displays information, extras and all kinds of other information about what you're viewing at your fingertips. Using a movie's menu system on an iPad could eliminate the clunky, remote control-driven experience we're used to on DVD and Blu-Ray discs today. Let's not forget that if you have to stop watching on Apple TV, you can take your iPad with you and pick up where you left off.

USB:

Another missing feature that wasn't a surprise, but definitely a letdown. As an amateur photographer, I'd rather plug my camera or SD card directly into the iPad rather than use their camera kit. I think USB is excluded for two main reasons. One of them, again, is Apple's clean-line design. They could put one port on it, sure, but then people would just want more from there. No way is Apple going to make their new golden boy gaudy by sticking USB ports on all sides. The second – and principal – reason is expandability. Apple charges an extra $100 to double the storage capacity from one model to the next. Including USB ports would open the floodgates to a new generation of jail breakers and cut into sales of the higher-capacity, more expensive models. With USB flash drives getting so tiny, I have no doubt this was part of Apple's consideration when it came to leaving off USB. True, the camera kit will give you USB and SD and I have no doubt jail breakers will find a way to use these for storage expansion. The fact that they stick out of the iPad's 30-pin connector all of the time, though, will make using them as a permanent storage expansion solution kind of cumbersome. Speaking of the 30-pin connector, if it weren't for all of the accessories that require it out there, I think Apple would have eliminated that, too. Charging could be adapted to the MagSafe connector, like what is found on Macbooks. Syncing to iTunes could be done over WiFi or Bluetooth. I predict the 30-pin connector will be history within the next four years.

Micro SIM:

WTF is a micro SIM, anyway? Many people had similar reactions after the Jan. 27 announcement. It's a form factor that has been around awhile, just not widely used. It's obvious this is just a strong-arm tactic by AT&T to prevent anyone from using their existing service on the iPad. I'd love to know the insider secrets that keep Apple and AT&T married so tightly together in the U.S., especially after so much customer dissatisfaction when it comes to AT&T in general. If I were to buy an iPad and had a choice of carriers, I'd get a Verizon iPad over AT&T, just to stick it to them.

Multitasking:

Before I got my iPhone, I had an HTC TyTn (Cingular 8525) that ran Windows Mobile 6. It was absolutely horrible at multitasking. The experience was awful. True, it was probably just a terrible piece of hardware to begin with, but I did not miss multitasking when I switched to the iPhone. Background apps on my 8525 would constantly crash or require killing via a task manager and the battery would drain significantly if I didn't bother to kill them. I pulled the battery on that phone quite often. Task notifications, such as for a new instant message, also were bad about robbing the focus away from your current application no matter what you were doing. Yes, I'm sure it's gotten better on mobile phones since then, maybe even on Windows Mobile (or whatever Microsoft is calling it these days). I'd really like to see how Android handles it. Anyway, we're talking about the iPad here. Getting away without multitasking on the iPhone has been acceptable for me so far, but the iPad should include it. Task switching on a device with more screen real-estate is a more realistic option on the iPad. Because it runs the iPhone OS, though, I don't see the iPad featuring multitasking until they branch the OS into something more iPad specific. A drawback about having such a vastly popular catalog of iPhone and iPod Touch apps that run on the iPad is how to effectively and design a task-switching and notification interface that will be compatible with them while they still maintain compatibility with the iPhone/iPod Touch. It's not like the iPhone OS doesn't run background apps. It runs plenty of them, such as e-mail, SMS, iTunes ... only the things Apple directly controls, of course. As competition among iPad-like devices heats up, Apple will eventually have to cave on multitasking.

Software:

The iPad's applications are going to be what makes this device popular. Love or hate the iPhone, there's no denying that many of the applications that have been created for it changed people's expectations for smart phones. Re-watch the beginning of the iPad's announcement event if you still don't believe that. One question on my mind, and on the minds of many, is am I going to have to re-purchase the apps on my iPhone to be able to use them on the iPad? Chances are likely not for this one, which is a good thing. I've read that you can transfer iPhone apps to an iPod Touch. I'd assume you can transfer to an iPad as one of your five eligible devices that content can be transferred to. I am positive that developers will charge a premium for iPad apps and will have different prices for buying apps that are either iPhone or iPad optimized. Maintaining the code differences for the two form factors does take extra time. As a software developer, wouldn't you?

Conclusion:

So, after all this, will I anxiously await online for the iPad pre-ordering system to launch? That's a tough call. I've had a drink of the Apple Kool-Aid several times and it tastes good, my friend. As I try to keep myself focused, though, I would like to hold it in my hands a use it a bit before making an impulse buy online. Despite the obvious pitfalls, the iPad has potential to become very successful, just like the iPhone did, over the next few years. Will other manufacturers sit by in the face of Apple's latest innovation this time? I doubt it. Will this be the end of the netbook? Not yet. Will there continue to be plenty of iPad skepticism and nay-saying? Yes. Will they be as wrong as they were about the success of the iPhone? Maybe.

C# – Re-Throwing a Used Exception

noreply@blogger.com (Allen Scharfenberg) — Fri, 01 Jan 2010 00:12:00 +0000

A colleague of mine pointed this out to me the other day. When handling exceptions in C#, you can preserve the original stack trace of an exception you are working with in a catch block by simply using throw; like so:

Code Snippet
 try
{
    RaiseException();
}
catch (Exception ex)
{
    // do something with ex
 
    throw;
}
 

Previously, I had thought that you could only preserve the stack trace by wrapping the exception with another exception like the following:

Code Snippet
 try
{
    RaiseException();
}
catch (Exception ex)
{
    throw new Exception("<desc>", ex);
}
 

The above is rather cumbersome in that it introduces an inner exception in the stack trace and increases memory usage and garbage collection due to the creation and disposal of the wrapper exceptions. However, that is a better alternative than losing your original stack trace information by using throw ex; like so:

Code Snippet
 try
{
    RaiseException();
}
catch (Exception ex)
{
    // do something with ex
 
    throw ex;
}
 

I had mistakenly thought that the only case in which you could re-throw an exception is when you were not creating a reference to it because you were not going to use it for anything like so:

Code Snippet
 try
{
    RaiseException();
}
catch (Exception)
{
    // do something not with ex
 
    throw;
}
 

However, that is not the case! You can re-throw a used exception with throw; instead! No more wrapper exceptions! Pristine stack traces for killer debugging! Life is beautiful!

More practically, though, the following are what I believe to be the best practice guidelines for re-throwing exceptions:

throw;

If you want to preserve the original stack trace (which you usually do), use throw;—even if you are referencing the exception for other nefarious purposes.
Conclusion: Do this most of the time.

throw ex;

If you *do not* want to preserve the original stack trace (which you usually *do not* want to do because it can make debugging much more difficult), use throw ex;. The only reason I can think of to do this is when you want to make it look like an exception is coming from within your code rather than the code belonging to a third-party. If you can think of other reasons, I would be more than happy to hear them.
Conclusion: Don’t do this.

throw new Exception(“<desc>”, ex);

If you want to preserve the original stack trace but you want to communicate the exception using a different type, use a wrapper exception. Be warned, though, that this can make your stack traces harder to read and increase heap thrashing and time spent in GC.
Conclusion: Do this the rest of the time, but only if you absolutely need a more specific or more appropriate type of exception thrown.

(As an aside, the examples above contain uses of the generic Exception class, which is a no-no in C#. You should not catch Exception. You should not throw Exception. You should only catch and throw specific types of exceptions that you care about and let the rest bubble up to calling code. The only exception to this—pun intended—is to provide an exception catch-all around the starting point of each thread to centralize the handling of unanticipated exceptions and to prevent them from reaching the CLR thread pool and crashing the process.)

Wolfram Alpha in Bing

noreply@blogger.com (Allen Scharfenberg) — Thu, 24 Dec 2009 01:15:00 +0000

I don’t usually get involved in search provider wars (let alone browser wars), but, after reading David Barney’s snippet “Wolfram Alpha Breaks Search Engine Mold” in the December 2009 issue of Redmond magazine, I must say that I am pretty excited about the future of Bing and its inclusion of Wolfram Alpha.

Wolfram Alpha is the latest project from Wolfram Research—makers of Mathematica, the bane and the salvation of college math students around the world. Wolfram Alpha is the world’s first knowledge search engine—focused on facts and formulas rather than raw content. It solves complex calculations and graphs them for you, shows important tidbits of information about many subjects, slices, dices, and juliennes! Exciting stuff! As the Dragnet boys would say, Wolfram Alpha is “just the facts, ma’am.”

With Bing surfacing Wolfram Alpha in its search results in the near future, I am very curious to see how well Microsoft can meld its traditional content-based search engine with the up-and-coming fact-based knowledge search offered by Wolfram Alpha. Can Microsoft achieve the right balance between web and formulae? We shall see.

Microsoft Loses to Google

noreply@blogger.com (Allen Scharfenberg) — Sun, 20 Dec 2009 22:49:00 +0000

I am not really sure what the hubbub is all about lately. Microsoft lost a contract to Google in October for email services for the City of Los Angeles. Some speculate that losing the $7.2 million contract to Google shows that Microsoft is behind the times. Some speculate that it shows that Software-as-a-Service (SaaS) is the wave of the future.

To me, though, it’s a bunch of hullabaloo. It’s just a contract, like any other. The City of Los Angeles weighed all of their options on how to replace their aging Novell GroupWise installation and decided that Google’s cloud platform fit their needs the best. That’s just business, and smart business at that. I applaud the City of Los Angeles for exploring a new avenue instead of burying its head in the sand like many government entities.

Does that mean that Gmail in the cloud is an Exchange killer? No. Does that mean client-server solutions are dead? Of course not. It does mean, though, that the cloud does mean business, and that business is no longer relegated to startups and small companies. Behemoths like Microsoft, IBM, and SAP will need to adjust their business plans to account for smaller and more agile cloud-based competitors. Failure to do so risks falling behind the times.

Maybe this will mean cheaper upgrades to Windows 8! One can only hope.

(Many thanks to Lee Pender’s article “Clouds in L.A.: Microsoft Loses Los Angeles Contract to Google” in the December 2009 issue of Redmond magazine for the details.)

Azure and the AppFabric

noreply@blogger.com (Allen Scharfenberg) — Sat, 19 Dec 2009 15:44:00 +0000

I know I don’t always come off as the biggest fan of cloud computing, but in my heart of hearts I do find it a very interesting subject—both from a business and from a technical perspective. Maybe that is why I write critically about it so much: I know that it is a technology with a lot of promise but also with a lot of challenges. To make matters worse, I have a tendency to shun new buzzwords since, in my experience, they do not live up to their hype—at least not at first.

So, putting my skepticism aside for once, I am very excited about the possibilities for the AppFabric layer of Windows Azure. Charles Babcock’s article “AppFabric Key to Getting Developers on Azure” in the November 23, 2009, issue of InformationWeek highlights the high points—dynamic caching and dynamic scaling. The gist of it, though, is the ability for an application to decide on its own when to bite the bullet and create a cache or scale out by allocating additional instances during peak demand. Just imagine not having to worry if your data center can handle an order of magnitude spike in use. Amazing stuff.

I’m sure the devil is in the details as always, though, but I’m excited to see what Microsoft can do with AppFabric.

PrinterOnFireException

noreply@blogger.com (Allen Scharfenberg) — Sat, 19 Dec 2009 03:14:00 +0000

For some reason, I remembered something this morning that made me chuckle. One of the early pre-betas of the .NET framework shipped with a hilarious Easter egg: the PrinterOnFireException.

I can just imagine it—a print job gone horribly wrong. Flaming check stock shooting across the room. Workers fleeing in panic, hands waving in the air. Firemen axing the poor printer to death.

Good times.

Peer-to-Peer Government

noreply@blogger.com (Allen Scharfenberg) — Fri, 18 Dec 2009 02:50:00 +0000

I read something rather disturbing the other day in the November 23, 2009, issue of InformationWeek. J. Nicholas Hoover’s article “Feds Face P2P Clampdown” brings to light several recent leaks of sensitive government information via, of all things, peer-to-peer applications such as LimeWire and BitTorrent that were inappropriately installed on computers operated by federal employees.

Seriously? Government IT cannot detect that its users are installing P2P software that, as we all know, is an enormous security risk to any organization? Is application white-listing and firewalls really that hard to configure? I think not.

An ounce of prevention is worth a pound of cure. Now, instead of spending tax payer dollars on expanded IT security, better firewalls, and improved enterprise management software, the federal government has to waste money on relocating one of President Obama’s safe houses and escalating national security in light of China and Pakistan obtaining military personnel data and the Iranians downloading blueprints for Marine One, the president’s helicopter.

Vivek Kundra really has his work cut out for him….

Cloud Lock-In

noreply@blogger.com (Allen Scharfenberg) — Wed, 16 Dec 2009 23:37:00 +0000

In John Foley’s article “Cloud Computing’s Portability Gotcha” in the November 30, 2009, edition of InformationWeek, he discusses one very significant shortcoming of cloud-based systems: vendor lock-in. This is a topic I touched on in my blog post “Azure – Got It All Wrong?”, but Foley approaches the issue in a more general sense: the biggest problem with the cloud is getting locked in to a single vendor. Whether it be because of a proprietary development platform in the case of Windows Azure and Force.com or simply because of the enormous cost of transferring your data somewhere else, hitching your enterprise pony up to the cloud wagon is a risky endeavor.

Now, that is not to say that cloud-based solutions do not have their place in the current software ecosystem—they certainly do. They are great for startups or small business that cannot afford their own enterprise-class infrastructure. They are great for proof-of-concept work. They are great for cost-cutting.

Cloud systems, however, are not great for large enterprise applications—unless you are willing to pony up when and if you have to change providers. And, in the current economic climate, I don’t see a lot of businesses willing to take on that level of risk.

C# Field-Like Event Thread Safety

noreply@blogger.com (Allen Scharfenberg) — Wed, 16 Dec 2009 00:12:00 +0000

Chris Burrows is awesome for many reasons. First and foremost, his blog is subtitled “C#, developer tools, monkeys, etc.” As we all know, monkeys are awesome, and, due to the transitive property of monkeys, Chris must also be awesome. Secondly and more importantly, though, Chris has a lot of insight into interesting areas of C# that most of us don’t really think about.

One such insight I discovered the other day in his blog post from last year entitled “Field-like Events Considered Harmful”. In it, Chris lays out a potentially dangerous default behavior of field-like events in .NET—namely, the compiler translates field-like event declarations into add/remove blocks with mutex locks on the current object. That means code like this:

Code Snippet

public class CalculationEngine
{
    public event EventHandler CalculationComplete;
}

Essentially compiles to something like this:

Code Snippet

public class CalculationEngine
{
    private event EventHandler calculationComplete;
 
    public event EventHandler CalculationComplete
    {
        add
        {
            lock (this)
            {
                calculationComplete += value;
            }
        }
        remove
        {
            lock (this)
            {
                calculationComplete -= value;
            }
        }
    }
}

As we all know (or should know), lock(this) is very, very bad. So why does the compiler even allow you to declare field-like events? Well, most of the time, the threading of event subscriptions is not an issue. Usually, events that you write in your own code are for single-threaded scenarios such as those required by certain UI development patterns like Model-View-ViewModel (MVVM).

C# Method Signatures and Generic Constraints

noreply@blogger.com (Allen Scharfenberg) — Tue, 15 Dec 2009 00:12:00 +0000

Eric Lippert had an interest blog post the other day entitled “Constraints are not part of the signature”. This was a very good read on one aspect of the inner workings of the C# compiler. In the post, Lippert explains how and why the compiler does not include generic constraints as part of the signature of methods and how that can affect overload resolution. More specifically, the lack of constraints in method signatures can can result in the wrong overload method being chosen as the best match under certain conditions and lead to confusing compile errors that are actually correct according to the specification of C#.

A generic constraint in C# is a useful mechanism by which you can specify the base class or interface from which a generic type must derive. The following code sample contains a generic method that has such a constraint:

Code Snippet
 public void SomeMethod<T>(T arg)
    where T : SomeTypeOrInterface
{
    // do something with arg
}
 

What this basically says is that I have a method called SomeMethod that has a generic argument named arg. However, you cannot pass whatever you want in for arg. The where statement between the method signature and the body specifies that you must only pass the method an object that derives from type SomeTypeOrInterface. This ensures that the value of arg supports the functionality defined in SomeTypeOrInterface—which can be useful assumption in implementing the method.

Lippert explains how this breaks down in a situation such as the following:

Code Snippet
 namespace ModuleFactory
{
    interface IModule { }
    class ImportModule : IModule { }
    class ExportModule : IModule { }
 
    class ModuleHandler
    {
        public ModuleHandler()
        {
            // compiles
            var importModule = new ImportModule();
            this.InitModule(importModule);
 
            // does *not* compile
            var exportModule = new ExportModule();
            this.InitModule(exportModule);
        }
 
        private void InitModule(IModule module)
        {
            // initialize module
        }
 
        private void InitModule<T>(T module)
            where T : ImportModule
        {
            // initialize module
        }
    }
}
 

The snippet above produces the following compilation error in Visual Studio 2008 (click to enlarge):

I always find subjects such as this very interesting because it demonstrates how complex the everyday can be. To a developer, a compiler just *works*. To a compiler writer such as Lippert, the problem area contains many nuances and pitfalls that must either be solved or cleverly paved over—such as the subject of his blog post.

Code Samples and Untrusted Content

noreply@blogger.com (Allen Scharfenberg) — Sun, 13 Dec 2009 23:03:00 +0000

Brad Abrams had an interesting blog post the other day regarding issues his readers have been having with some of his recent code samples. More specifically, they receive a very fun and archaic error message that certain assemblies could not be loaded. Brad determined that the root cause of the problem was that Vista and Windows 7 treat content downloaded from the Internet—like his code samples—as *untrusted* content. Thus, in order for you to work with them correctly, you must first unblock the content via the file properties (see Brad’s post for details on how to do this).

This is an important little trick to remember if you frequently download code samples as part of your research. I know I have run into this a time or two myself—and the archaic error message certainly doesn’t help in tracking down the root cause.

Microsoft Hyper-V 2008 R2 IDE vs. SCSI Performance

brandon — Mon, 30 Nov 2009 19:46:00 +0000

Virtualization has been a hot topic in tech for several years now and shows no signs of going out of style any time soon. I think there are some really great uses for it, such as server and application consolidation, but, I also think there is a lot of hype and glamour surrounding the topic as well. Will virtualizing your servers really save you money and time? That all depends, in my opinion. Only you know what applications you have and how well those currently perform. The only way you'll know how virtual machines will help or hurt you is by testing.

The department I work for currently uses Microsoft Virtual Server 2005 R2 on top of Windows Server 2003 for the majority of our virtual machines. When Microsoft introduced Hyper-V with Windows Server 2008, we discussed upgrading, but ultimately held off on the new Microsoft virtualization solution. Hyper-V had many mixed reviews upon its debut, so we wanted to wait to see what later revisions could deliver. Also, at the time, Virtual Server 2005 met our needs just fine. Since VS2005 wasn't broken ... you get the idea.

Time has passed since then and Microsoft has recently released Windows Server 2008 R2 with an updated version of Hyper-V. There have been several improvements to Hyper-V since its initial release. Virtual Server 2005 has started to show its age, compared to all the other virtualization solutions now available, so now is a great time to do some testing of Hyper-V 2008 R2. [more]

As users of Virtual Server 2005, my co-workers and I have known using SCSI virtual disks (with Virtual Machine Additions installed) has advantages over using IDE disks in VS2005. Switching from the IDE to a SCSI interface made noticeable virtual machine performance improvements. When Hyper-V was originally released, however, booting off SCSI disks wasn't supported. "How version 1.0!" we all thought. Removing features from new products isn't new for Microsoft, after all. Well, it's not supported in Server 2008 R2, either. I was disappointed, but this time the question "Does it really matter?" came to mind.

I decided to test this using one of our newer servers that has been freshly reloaded with Windows Server 2008 R2 Standard with Hyper-V from scratch. For the test, I'd create a new Windows 7 virtual machine with two extra drives attached. One drive would be connected to the virtual IDE controller. The other would be connected to a new virtual SCSI controller. Both drives would be set to the same physical size (30GB) and both would be created as fixed-size virtual disks.

The test platform specs are as follows.

Test Server:

HP ProLiant DL380 G5
Dual Intel Xeon E5450 quad core 3.00GHz CPUs
14GB ECC memory
HP NC373i gigabit server adaptor (1x1GBPs connection)
Drive C is a HP Smart Array P400 controller (512 MB) with 2x HP 68GB 15k RPM SAS drives in RAID-1 (cache enabled)
Drive E is a HP Smart Array P800 controller (512 MB) connected to an external MSA50 drive array with 10x HP 68GB 15k RPM SAS drives in RAID-10 (cache enabled)
Windows Server 2008 R2 with Hyper-V installed on drive C
Virtual machine VHD files on drive E

Test Virtual Machine:

Windows 7 Enterprise RTM 32-bit
2GB memory
Drive C (boot) is a 40GB fixed-size NTFS volume connected to IDE controller 0, port 0 on the virtual machine.
Drive E (IDETest) is a 30GB fixed-size NTFS volume connected to IDE controller 1, port 0 on the virtual machine.
Drive F (SCSITest) is a 30GB fixed-size NTFS volume connected to SCSI controller 0, ID 0 on the virtual machine.
UAC is turned off, no updates applied (fresh installation for testing)
No antivirus installed
Logged in as an administrator

Below are some screenshots of the virtual machine's disk configuration, along with the Hyper-V settings for the virtual machine.

Disclaimer time. I've worked in the IT field for many years now and am knowledgeable in many areas of IT infrastructure and application development. I am relatively new to Windows Server 2008 R2 with Hyper-V, however. I'm also not a professional reviewer and benchmarker. I do my best to test, record, and interpret the results, but you may come to different conclusions. If you do, let me know (but play nice)! I also encourage you to repeat similar test steps if you have the time and resources. I'm doing this for fun and learning and didn't receive compensation from any product vendors (or their competitors!).

First round of tests: ATTO Disk Benchmark

To begin, I decided to go with good 'ol fashioned disk benchmarking. I searched for disk benchmarking software on Google and found ATTO Disk Benchmark v2.45. It's available as a free download from ATTO Technology, Inc. I've seen this software used on various hardware review sites, also.

For each test, I set ATTO to use the following parameters:

Transfer Size: 0.5 to 8192.0 KB
Total Length: 2GB
Direct I/O checked
Overlapped I/O selected
Queue Depth 4

The tests were run three times in a row for each virtual drive. The IDE disk was tested first. The virtual machine was then rebooted before the SCSI disk was tested. Below are screenshots of each test. Look in the application title bar for the test iteration.

Do these test results look strikingly similar to you, too? It seems the trend between SCSI and IDE disks are almost identical. To get a better visual representation of this that I could compare, I decided to plot the data in Excel. The graph below compares the average of the IDE read and write runs to the average of the SCSI read and write runs.

From the graph, it's easy to see how IDE and SCSI reads/writes are right on par with each other. Sure, there are some differences here and there, but I think the margin of error in this testing method makes this too close to call. There were variances in each run of ATTO, so, for now, it's looking like these virtual disks perform virtually (pun intended) equal.

One thing I wondered about is the behavior when the tests hit the 512KB mark. Until then, reads/writes scale nicely. For both SCSI and IDE, read and write performance basically "meet" at the 512KB mark and then diverge from there, with priority clearly given to reads for data transfer sizes greater than 512KB. Write performance after that tops out at about 200 MB/sec and holds steady, with read performance topping out at 500 MB/sec. I tried ATTO on the virtual host computer with the same settings and no virtual machines running and experienced similar results. I then ran ATTO on some other computers, such as my laptop and desktop, and did not experience that behavior. Reads and writes on those machines stayed near equal after a 4KB data set size.

I believe the cause of the performance differences, in this case, is the HP array controller's cache. Transfer rates in hundreds of megabytes per second is pretty high, after all. The test is still valid, in my opinion, because you'll want to have your controller's cache enabled when running virtual machines in a production environment. In fact, the only other instance where I was able to replicate this behavior with ATTO Disk Benchmark was on a Lenovo X61 tablet with an Intel 32GB solid-state disk (SSDSA2SH032G1GN). On this drive, there was a similar separation of read and write performance, this time at the 4KB mark.

Second round of tests: Microsoft's SQLIO utility

I wasn't completely satisfied with the ATTO benchmark after reviewing the results. For one, I wasn't sure if ATTO Disk Benchmark was necessarily the correct tool to test this scenario (SAS drives in RAID10, virtual environment, etcetera). Secondly, I wanted something that could differentiate between random and sequential testing, along with giving the virtual drives a longer workout. The ability to import test results directly into Excel would be a big help, too.

A co-worker recommended a utility from Microsoft called SQLIO. The name of this utility is deceptive, because it does not depend on Microsoft SQL Server nor does it seem to have anything else to really do with it. It should not be confused with another Microsoft utility with a similar name. After some Google searches about the app, I came across a really great tutorial with examples and video by Brent Ozar.

I used Brent's sample configuration batch file to run my tests. All I changed were the drive letters on the "-d" parameter. I followed the rest of his instructions and let the testing run over the weekend on the IDE and SCSI virtual disks. When I ran the USP_Import_SQLIO_TestPass stored procedure to populate the SQLIO_TestPass table from the imported data, I specified "Hyper-V IDE" or "Hyper-V SCSI" in the sixth parameter. I then imported the data into an Excel pivot table. The entire process was pretty easy to follow. Testing each disk took about six hours.

Below is a pivot chart of the test results. The "128" values on the horizontal axis represent 128 outstanding requests and the "2, 4, 8, 32, 64" values represent the number of threads. I only included the "128" outstanding requests values because having them all in the graph made it unreadable. The numbers in the graph area are the "Max MB/sec" column.

Overall, again, the performance for Hyper-V virtual SCSI and IDE disks are close to identical. The most important values are the Max MB/s and Max IOs/sec. For the random read and write tests, IOs/sec are nearly matching evenly for both IDE and SCSI across all tests. I would attribute this to the controller's cache. On sequential reads, however, the SCSI virtual disk has a slight edge over the IDE disk. Also, on sequential reads, the Max MB/sec of the SCSI disk is about 10MB/sec higher than the IDE disk for each run. Another interesting series of data to note is the Max Latency for sequential writes (shorter is better). As the thread counts increase, the IDE disk performed best by eight threads, but then climbed back up by 128 threads. The SCSI disk, however, started low and increased almost linearly.

Conclusion

Whew, that was a lot of testing ... at least for someone who doesn't do that type of work all the time. In the end, I don't think you'll see a huge difference between virtual IDE and virtual SCSI disk performance in Hyper-V 2008 R2. It's true that the SQLIO tests revealed some slight advantages to virtual SCSI disks, but I believe you'd only experience this under very controlled situations.

What other kind of tests could I have done? I'm sure there are plenty out there that I'm not aware of. I felt this was a good start, though, considering I couldn't find much out there regarding IDE vs. SCSI performance in Hyper-V. One additional test I thought of after I finished was placing a constant load on the virtual machine's CPU during the SQLIO tests. I've run out of time with this hardware, though, so maybe I'll get to save that for another day.

I hope you found this post helpful. If you have any questions, please leave a comment and I will answer as soon as I can. Thanks for reading!

Backups to the rescue!

brandon — Sun, 22 Nov 2009 00:30:00 +0000

This post is a friendly reminder regarding the importance of regularly backing up your computer. Data disasters happen. Are you prepared?

I recently had a chance to put my backups to the test. I have a secondary computer here that I use for games, fun, and general messing around. I use it a few times during the week, but mostly on weekends. This week, I happened to fire it up on Tuesday evening. My attention drew elsewhere after initially pressing the power button. When I returned to find it hung on the disk detection screen, I knew there was a problem.

On this PC, I used a RAID 0 array for the C drive. For my non-technical readers, RAID is a technology that lets you combine multiple hard drives for either speed, data redundancy, or a combination of both. In my case, I used RAID 0 to combine two physical drives into one logical one. Basically, this means the operating system and applications consider the two hard drives to be one. The advantages to RAID 0 are that it lets you combine the capacity of two hard drives and increases disk performance, generally, by a noticeable amount.

The main disadvantage to RAID 0 is the fact that if one of your hard drives fails, then the data on the remaining drive(s) is useless. This is so because RAID 0 splits the data, like your videos, pictures, songs, and operating system files, between the hard drives (two or more) in the array. If part of the data is gone, like when a hard drive fails, you're toast.

Aware of the data loss risk, I used RAID 0 on this computer for the disk performance improvement. Having made the decision to go with RAID 0, I knew regularly backing up the C drive would be important. Keep in mind, regular backups are important regardless whether or not you are using RAID. I believe it's especially important when using RAID 0, however, because this level of RAID does not provide any data redundancy. Other levels of RAID do and I'd recommend them for storing important data. I won't go into the differences here, but you can check out the Wikipedia articles above or do some general Internet search to find out the benefits of RAID.

The drive that failed was a Western Digital Raptor Raptor 150GB. When a hard drive fails, it can be time consuming to track down exactly which drive is the culprit in multi-drive systems. I had a good idea which one was at fault because the hard drives in this system are in individual trays, each with their own indicator lights. The light on the faulty drive was lit solid when the computer was trying to detect the installed hard drives at startup. To verify this drive was bad, I removed all other hard drives from the system and downloaded the Western Digital diagnostic tools from their site. Each hard drive manufacturer generally has a similar tool they offer for helping your identify hard drive problems. I ran the tool and it verified the drive was bad. Check out the screen shot below. I ran the full scan, like the software suggested, and eventually received another status code (0222 & 0225) indicating the drive failed.

I replaced the drive a few days later with an updated Western Digital model. I've had good luck with Western Digital in the past. One friend of mine has sworn them off completely. Why go back to a manufacturer that failed on me? The simple fact is standard hard drives are mechanical, and thus will eventually wear out and fail, no matter who made them. I, for instance, tended to avoid Maxtor drives before the company was bought by Seagate. Ask ten tech guys what their favorite brand of hard drive is and why and you'll get ten different answers. It's a lot like asking someone about their favorite kind of car.

For my backup solution, I chose to use Acronis True Image Home to back up to an external hard drive. I started using Acronis True Image a few years ago when it was at version 11. They recently released version 2010, which is what my latest backup was created with. I've used Acronis software many times at work to backup and restore data to various machines, but this was the first time I had to use it to recover personal data that would otherwise be gone for good without a reliable backup. After booting the PC from the Acronis recovery CD, I selected the backup archive on my external hard drive and chose to restore it to the new internal hard drive. About an hour and a half later, I saw the message below.

Even before I started the restore, I was confident I'd get my data back. It's always a relief to see this screen, though! After this, all it took to getting back to normal was removing the Acronis CD and restarting the computer. Everything was back to normal.

Lessons learned:

I got lucky because I took the time to set up a backup schedule and made the necessary adjustments to it throughout the years to make sure backups were getting created successfully. My backup solution, which was a USB external hard drive plugged into the computer I was backing up, worked out fine in this case. When creating backups, however, you need to consider all possibilities. Instead of an internal hard drive failure, where would I be now if the house caught on fire or if someone stole all my computer equipment?

With the wide availability of high-speed Internet service, many online backup service providers have emerged. Their goal is to back up your data, encrypted over the Internet, to a secured data center that's protected against fire/flood/theft (hopefully!), rather than an external hard drive sitting no more than 6 feet away from your PC.

Advantages to a service such as this include:

Safe, offsite storage of your data.
Having your data available on any Internet connected PC, secured by your account credentials.
The ability to retrieve older versions of your files (this varies by service provider)

There are some disadvantages, too:

It can take a long time to back up all your data over the Internet.
Limitations of the service provider, such as storage limits or platforms supported (Mac and Linux not supported by all).
Cost, which is usually a monthly or yearly fee.
Doesn't back up your entire computer (just photos, documents, etc.)
Generally limited to one computer backed up per account.

Despite the drawbacks, I think I'm going to look into a service like this. It's one thing to lose the hard drive of my secondary PC. I'd be pretty unhappy, though, if I lost all the digital photos I have from the last ten years or so. If I subscribe to one of these services I'll post a follow-up.

I kept the geek level to a minimum in this post so all readers, regardless of computer skills, can understand the importance of backups. If you have a technical question, feel free to ask it in the comments.

Azure – Got It All Wrong?

noreply@blogger.com (Allen Scharfenberg) — Fri, 25 Sep 2009 03:29:00 +0000

The more I read about public clouds the more I think Microsoft has it all wrong with Azure. Competitors such as Rackspace, Amazon, and Google are rolling out solutions that support one or more hypervisors and that offer a plethora of pricing, architecture, and other operating environment options—unlike Azure. And they don’t require a proprietary development environment to boot.

Sure, forcing people into using Microsoft’s development framework in order to host under Azure is good for their complimentary offerings such as Visual Studio, Team Foundation, and such, but, especially in the world of application hosting, nobody likes to be locked in to a particular vendor. An application coded in C# for Windows Server 2008 can be ported easily between competitors’ clouds, but the minute you write that first line of code that taps into SQL Data Services in Azure you are in for a lot of problems if you ever decide that Microsoft’s hosting is not for you.

Sure, you will be able to host an application written for Azure in your own datacenter if you decide you do not care for Microsoft’s hosting, but that just defeats the whole purpose of cloud computing. Why would you spend all the time and money to train your staff to code to Azure and then host the application in your own datacenter? You might as well just code it in ASP .NET or WPF or Silverlight or whatever your staff is already familiar with and be done with it that much quicker.

I just don’t see how Microsoft thinks that the pro of increased use of their development tools will come even close to offsetting the inherent con of vendor lock-in that hosting with Azure will entail.

Programming Sucks

noreply@blogger.com (Allen Scharfenberg) — Wed, 16 Sep 2009 23:05:00 +0000

I stumbled across an interesting post on The Daily WTF yesterday entitled Programming Sucks! Or At Least, It Ought To that rings true in the industry: most programmers are not rock stars. That is not to say that most programmers do not have rock star skills—although, in my experience, many do not even have kazoo-level skills, but that is a separate issue. It is to say, though, that most programming *jobs* are not rock star jobs. Very few of us will ever have the opportunity to start the next Google, write the next Windows, or develop the next World of Warcraft. Again, not because of talent but because of the statistical rarity of such opportunities.

Instead, most computer science graduates are destined to be information systems developers. It’s not a glamorous job. It’s not a glorious job. Most of the time, it’s not even an interesting job. It is a job, though, and it is a job that *can* be challenging and rewarding at times, even if the end result isn’t co-credit for the next Facebook.

It’s hard work. It’s tedious. And sometimes it even sucks. But those of us that do it and continue to do it do so because we love it. We love code. We love logic. And most of all we love solving hard technical problems—even if the end result is simply an account balance routine that performs bankers rounding correctly.

Oracle’s Growing Pains

noreply@blogger.com (Allen Scharfenberg) — Thu, 27 Aug 2009 21:55:00 +0000

According to Bob Evan’s article “As Regulators Jam Oracle, Rivals Snatch Sun Users” in the August 17, 2009, edition of InformationWeek, Oracle is losing a great deal of share in the integrated systems and software market to rivals like IBM, HP, and Dell since its merger with Sun Microsystems. The European Union’s threat to roadblock the merger for up to four months for “review” further clouds the future for the industry giant in the data center.

Since I was a little put off by Oracle’s acquisition of Sun and the rights to the Java programming language, part of me is relishing in Oracle’s recent troubles—even more so when you consider that I am a .NET developer. That being said, no company is perfect, and I appreciate the competition that Oracle presents to the rest of the software industry, so I do hope that they pull through okay. (I’m sure they will—deep pockets.)

Still, I can’t help but see Oracle’s current situation as a deserved drink in the face for making a power play for Java. I maintain that Java, like C and C++ before it, should remain a language controlled by a community, not by a corporation. We have enough proprietary languages—C# included—and what alternative does the development community have other than Java for open-source enterprise development?

Cisco UCS – I’m Not the Only One That Doesn’t Get It

noreply@blogger.com (Allen Scharfenberg) — Mon, 17 Aug 2009 03:29:00 +0000

It was good to read Mark Ferelli’s article “Cisco Plays Both Sides of the Virtual Coin” in the August 2009 edition of Redmond magazine. In it, Ferelli discusses the advantages of going single vendor throughout the data center using Cisco UCS—primarily the streamlined virtualization that Cisco UCS offers. Ferelli also discusses the difficulties that Cisco is going to have trying to muscle its way into the already tight server hardware market during a down economy with an unproven platform.

Needless to say, that was refreshing for me to read after my post “Cisco UCS Server – Missed the Memo?” regarding the same subject since I was afraid I had missed something in my analysis. Ferelli’s article got me to thinking about UCS a bit more, and I must say that streamlined virtualization is a great feature, so that is definitely a big selling point. In addition, a lot of industries are wary of making the leap from the data center to the cloud—even with the cost savings of doing so—and Cisco UCS’ “cloud in a box” may end up being the right solution to bridge that gap. And, since UCS supports both the Hyper-V and the VMWare, Cisco’s approach avoids vendor lock-in at the sensitive hypervisor level.

We shall see, though, if Cisco has the technology, the tools, and the people to make their server hardware vision a reality.

SVNUG Blog Aggregator

Introduction to .NET Talk

CSS Stylesheets Not Refreshing in Chrome

Color Theme Generator

Game / Code Kata – Krypto

Bring Your Own Code

More Interview Questions

Code Kata – Bonus

RoboStack

Code Kata 16–21 of 21

Kata 16 – Business Rules

Objectives

Kata 17 - More Business Processing

Kata 18 – Transitive Dependencies

Kata 19 – Word Chains

Kata 20 – Klondike

Objectives

Kata 21 – Simple Lists

Objectives

Code Kata 11-15 of 21

Kata 11 – Sorting it Out

Sorting Balls

Sorting Characters

Kata 12 – Best Sellers

Kata 13 – Counting Code Lines

Goals of the Kata

Kata 14 – Tome Swift Under Milk Wood

Objectives

Kata 15 – Playing With Bits

Code Kata 6-10 of 21

Kata 6 – Anagrams

Kata Objectives

Kata 7 – How’d I Do?

Moving Forward By Looking Back

Kata 8 – Conflicting Objectives

Kata 9 – Back to the Checkout

Objectives of the Kata

Kata 10 – Hashes vs. Classes

Code Kata 1–5 of 21

Kata 1 – Supermarket Pricing

Goal

What’s a Code Kata?

Kata 2 – Karate Chop

Goals

Specification

Test Data

Kata 3 – How Big, How Fast?

How Big?

How Fast?

Kata 4 – Data Munging

Part One: Weather Data

Part Two: Soccer League Table

Part Three: DRY Fusion

Kata Questions

Kata 5 – Bloom Filters

XML Config Transformations in Visual Studio and SlowCheetah

PsExec

ASP.NET MVC 2 Presentation

Windows Phone 7—Pivot Control

Project Badger—Underway

Setting Up

Windows Phone 7—People

I Owe My Soul to the Company Store

Inspiration

Preparing for the PDC

On My Way to the PDC

Prey for your lost laptop

So Long, Nexus One

The Price, Compatibility

Marketing

No Hands-On Experience

Competing With Itself

Conclusion

This Backup is Gonna Take a While!

Windows 7 Upgrade Time

Step 1: Back dat up!

Step 2: A different way to back up

Step 3: Re-install at your own pace

Conclusion and afterthoughts:

My Thoughts on the iPad