Bring It On

Everybody wants to be different. The same is familiar, the same is boring. So we change clothes, put on makeup, cut the hair – whatever is necessary to be different.

In a way, the principle applies to software too – it’s safe but boring to be the same, yet another me-too product. Thus we try to be different, if only a bit, in order to be “special”.

But it’s nevertheless a risk – if your app is too special, it will take a lot of time adjusting too. Some might not even figure out what it is about. We have to be the similar, yet different.

It’s all about the balance. There is no recipe on how to maintain this balance, regardless of countless examples where the balance was bad, just OK or simply perfect. It’s up to you.

Here’s an example where a game developer got things just right while tweaking unbelievably small aspect of the gameplay. I’m talking about the Xbox game Black.

Black is a first person shooter (FPS) and one of the last few to come out for the Xbox (not the 360, the old one). It behaves pretty much like most of the other FPSs out there – conventional weapons, conventional locations, story that does not matter, simple goal (destroy everything and everyone)… The graphics are great, but so were the graphics of many other FPSs out there.

Still, Black is a great game, one of the greatest shooters I’ve played on a PC or a console. What is it that makes it special, besides the fact that it’s made by Criterion Games, the company that has proved to know how to design fun games (they are behind the Burnout arcade racing series)?

If I had to pick one term, it would be – particle effects. The only other exceptional thing is, for the lack of better term, destructability of the environment. So, while you’re fighting hundreds of enemies per level, usually you’ll be firing thousands of bullets that would break wooden planks into shards, shatter glass windows and other glass surfaces, smash wooden palettes, you’ll even be able to destroy weaker walls. The sparks will fly into air when you hit a metallic surface of any kind, the trucks, cars and other flammable objects will burst into flames, destroying everything in their radius.

This game is pure mayhem. There’s nothing else, though – just gunfight after gunfight. But boy is it fun. This is the only game that I’ve been playing for the second time on a harder difficulty level (it does “help” that the game is quite short).

There are other advantages like completely transparent level loading: you’ll never find yourself staring for seconds at “game loading” even though some of the levels are huge. Just as well there are disadvantages like automatic save – the game saves progress, but only at a few hand-picked checkpoints inside a particular level. If you have to abort the game for whatever reason while the level is in progress, next time you’ll start from the beginning of the level (argh!).

But in the end, it’s the particle effects plus destruction of the environment that makes this game special. It’s amazing how this changes the atmosphere and immersion effect so much that it defines the game.

There have been numerous rumors about a new, larger hard drives for the Xbox 360. Some people posted photos of a video feed of the dashboard showing 80 or so GB free, speculating about a 100GB drive model.

Supposedly, these were all fake. Understandably, Microsoft wouldn’t want to kill the sales of all the existing retail 20GB hard drive units by announcing larger drives a lot of time in advance.

But there was another accidental leak just today. Take a look at this Channel9 video. While showing off the capabilities of the XNA Studio on a “retail unit” (the presenter, Frank Savage, made sure to repeat this several times – this was not a developer’s kit) it’s obvious that this “retail unit” has 60GB free!

Here’s a frame some 35 minutes into the presentation. The camera is rather close to the screen – which is 1080p by the way – so there’s no mistake (click for original size screenshot). If you need more persuasion, just download the video and see for yourself.

I guess it doesn’t make sense to sell 4.3GB HD movies and store them on a measly 20GB after all, doesn’t it?

The nay-sayers will disagree that Windows Presentation Foundation (WPF) is simple but I don’t see that anyone will deny that you can produce very pretty and different applications using WPF. Just look at some of the examples Microsoft produced as a showcase – Max for example (unfortunately, discontinued) – and you’ll know what I mean.

There is a downside to this though and an unexpected one  First some examples of the existing applications in use today… Here’s a link to Anandtech’s recent mainboard review. Mainboards?!? Yes, bear with me. Go to any page with the features of any of the mainboards and take a look at how hideous are some of the utilities that mainboard makers deliver with the board.

Biostar’s utility is particularly ugly, but they are all kitsch. I don’t know if it’s a cultural thing so I just don’t get it, or is it the fact that programmers were designing user interfaces , but man are they all hard on the eyes.

Now, considering how easy it is to build crap UI like this using WPF, I shudder to think what we’re about to get in the future

For years Windows had inferior scripting capabilities compared to Linux and other OSes. I don’t mean to belittle the efforts of the teams that brought us VBScript and CScript, but the languages and the library support for them were simply not good enough for most of the people.

What every Windows administrator and power user needed was a more powerful language and even more importantly, better library support for common administration operation and, if possible, general library support for any task at hand. We finally have it – great language and even better library support – in the shape of Powershell.

Powershell is a “console on steroids”. Where before you had weak and strange constructs and only a text input/output model, today you have .NET-like scripting language, object input/output model (the pipe symbol still works but you can send .NET objects across) and the full .NET Framework at your disposal!

This is great, great news. To celebrate the occasion, I bring you a third version of the signature verifier tool. I first made a C# version (compiled to EXE), then a Ruby one (interpreted) and finally here is a Powershell version. Just a reminder – this tool takes a SHA1 hash you got from the MSDN subscriber site (for a given download), compares it with the downloaded bits and verifies if the hashes match. If they do, your download is OK, if not, some of the bits got corrupted during download so you should download it again. Here’s the script:

param ([string]$path = $(read-host "Please specify path to the file to verify"),
       [string]$hash = $(read-host "Please specify the expected hash")
      )

$f = New-Object -typeName System.IO.FileStream $path, Open, Read
$s = New-Object -typeName System.Security.Cryptography.SHA1Managed
$bh = $s.ComputeHash($f)
$f.Close()

$sh = ""
foreach ($b in $bh) { $sh += ("{0:x02}" -f $b) }

if($sh -eq $hash.ToLower())
  { Write-Host -foregroundcolor Green "The file is valid" }
else
  { Write-Host -foregroundcolor Red "The file is NOT valid" }

Note how it’s really easy to create any .NET object with a New-Object – I am creating FileStream and SHA1 this way. Also note how easy it is to change a console foreground color to emphasize output (red for no match, green for match). The only line that might be confusing is the part where string formatting takes place. Expression ("{0:x02}" -f $b) is more or less equivalent to string.Format($b, ("{0:x02}"), the only difference is that Powershell has -f operator for string formatting.

In order to test the script, copy the source above into a plain text file, save it as Verify-Signature.ps1 and put it somewhere on the path. Don’t forget to set the execution policy to RemoteSigned (or alternatively, sign the script). On the screenshot to the right you can see the script in action, validating Office 2007 ISO image. Note how if you don’t name the parameters, everything works, just as if you don’t provide them at all – the Powershell will prompt you for each of them.

While waiting for the price (to fall) of the newly released Splinter Cell: Double Agent I thought I’d download the PC demo. I still have the Xbox – I will hold off buying Xbox 360 until I get a decent HD LCD TV – otherwise I would have downloaded demo to the Xbox 360 and tried it.

I was unpleasantly surprised to find out that the game won’t run on my system at all! It requires shader model 3.0 while my Mobility Radeon 9600 Pro only supports shader model 2.0. This is on a Dell Inspiron 2 years old laptop that almost had top of the line graphics card when I got it.

For comparison, Microsoft requires shader model 2.0 for Aero Glass effects in Windows Vista.

I guess this is one more reason to stick with the consoles – their hardware is fixed and stays fixed throughout the lifetime of the console.

The title of this post is what you’ll get while installing .NET 3.0. Since version 3.0 is additive to the version 2.0, the installer is only about 2.5MB and when launched, it checks your machine, decides on what has to be downloaded, downloads only that and then installs the bits.

I find the message about disconnecting from the Internet funny because:

• most of the people I know have broadband, have had it for years, and naturally they never disconnect from the Internet
• even though the message makes sense if you are on a dial-up connection, who in their right mind would download 20–30MB worth of code over a dial-up connection?

At least the downloader does its best to estimate the time it’ll take to download everything so if you find it too long, you can abort the process early.

Every now and then the topic of software engineering compared to other kinds of engineering pops up. It’s almost always either in the context of bad estimates on the time it takes to finish a software project or in the context of unusually high failure ratio of software projects compared to other kinds of engineering projects.

A good recent take on this topic can be found at Jeff Atwood’s popular Coding Horror blog in a post It’s Never Been Built Before. In short, Jeff claims that the reason software projects fail and are difficult to estimate is because they are totally unlike the other kinds of engineering projects. His analogy is actually quite good, so I’ll just quote him:

One kitchen remodelling project is much like another, and the next airplane you build will be nearly identical to the last five airplanes you built. Sure, there are some variables, some tweaks to the process over time, but it's a glorified factory assembly line. In software development, if you're repeating the same project over and over, you won't have a job for very long. At least not on this continent. If all you need is a stock airplane, you buy one. We're paid to build high-risk, experimental airplanes.

I think this is precisely what's going on. But does it have to be like that?

Funny that the term factory assembly line has been mentioned because that’s precisely what some new software development techniques have been named (and I think it’s an unfortunate name) – software factories.

There are many definitions of software factories. My interpretation is that this is a way to formalize software development on a somewhat higher level of abstraction so that we can build software more easily and reliably and end up with a “less-experimental airplane”.

Differently put, some people (me included) think that software development does not have to be highly experimental. While it’s not as repetitive as building a train wagon over and over again, it’s not as experimental as a new stealth fighter plane, but something in between¹. The reasons we, developers, build a highly risky products are many, some completely out of our hands, but we can do something to improve the process.

The progress in the field of DSLs (Domain Specific Language) gives me the most hope. Expressing your customer’s intentions in a language specifically designed to address the needs of the problem domain tends to be much more readable than a bunch of Java, C# or Python code.

¹An example of a technology that moves us in the right direction is Windows Workflow Foundation.

As you know, both Windows Vista and Office 2007 have been released to manufacturing (RTM’d) about a week ago. Both are available for download now.

However, for a couple of days, if you were in France, you were greeted with a strange note after logging in to the MSDN subscription site:

Note to Customers in France
Office 2007 has not been authorized for supply, import or export to or from France. If you are located in France, Microsoft does not authorize the download of this product, until further notice.

No further explanation was provided. Fortunately, as of last night, the following can be found on the same place:

Note to Customers in France
Office 2007 is now available for download.

Note the use of color – red for bad, green for good  Again, no explanation, just that it's available.

Digging through some French blogs I ran into a few rumors of which the most plausible one was that because pieces of Office 2007 contain DRM (I don’t think that’s true, but it might be interpreted as such) and France has recently passed a (controversial) law regarding DRM that this was an issue.

Whatever it is, it’s resolved now. Start your download engines

Considering how big the .NET FCL (.NET Framework Class Library, sometimes – confusingly – also known as BCL, or Base Class Library) is, you would not expect glaring omissions to happen.

Naturally, everyone has it’s own pet feature and needs a very special class, but I’m talking about missing classes/types that should be there for the significant enough number of developers.

While implementing the BitTorrent’s message stream encryption protocol, I ran into a case of missing functionality – there is no class for arbitrary long integers in the .NET. Considering how portions of .NET FCL look almost exactly like their counterpart in Java and that Java does have BigInteger type, this is surprising. Before someone asks – I know that Visual J# has BigInteger, but J# is not a part of the .NET Framework (it’s an extra download) and nobody uses it anyway.

In fact, .NET FCL does have a BigInt class. Except that:

• it’s internal and sealed in the mscorlib and System.Security (can be found in both of them)
• it’s relatively inefficient
• its “public” interface sucks – there is no shift-right “>>” operator nor is there a multiplication of two BigInts

So, even though you could instantiate the BigInt class using reflection (which is ugly, but works), you can’t use it for cryptography because it lacks functionality to properly implement ModPow¹.

What are the alternatives? Well, IronPython has BigInteger, there is one implementation on CodeProject and there’s Mono implementation which is actually a descendant of the one on the CodeProject.

IronPython’s implementation looks the best, but it won’t work out of the box because it will treat all input coming as byte[] (which is what you’ll have, we’re talking about numbers with hundreds of decimal digits here) as signed, which is exactly the opposite of what you’d want (you want all numbers to be treated as unsigned).

CodeProject article is great, the implementation is good and even has a lot of code to generate prime and coprime numbers. But it’s 4 years old and apparently there are some bugs.

Mono implementation should have all the bugs found in the original CodeProject code fixed, but (I assume for performance reasons) they switched to using unsafe code, and I don’t want unsafe code in my app (rarely there is a justification for that).

So I’m left with a tough choice. Alternatively, I could wait till “Orcas” Visual Studio release, as it looks like Microsoft will finally add the BigInteger into the BCL.

Ugh.

¹ModPow is a very common name for a function that calculates a^x mod b. If a, x and b are large numbers, and I really mean large, this calculation cannot be performed naively (it’s practically impossible to calculate a^x). There is an algorithm for it of course, it boils down to using shift-right (division by 2), multiplication and modulus (and by extension, division); you can find the definition of the algorithm here.

I wrote about this problem before – Microsoft’s service packs for any product take forever to come out and in the meantime the users have to struggle with the bugs. Note that all along, for many of the issues, Microsoft already has a patch – they just don’t want to distribute patches one by one. I understand the motivation: Microsoft is trying to avoid “patch hell” with this policy. Makes sense, if you’re an end user.

But take developer tools as an example. Developers are in general more careful and more computer literate than end users, thus with a suitable disclaimer it should be no problem to issue patches for the development tools like Visual Studio, compilers and such. Yet it hasn’t happened. Till now.

There is a pilot program where you can download patches for Visual Studio, .NET and related compilers. You decide if the patch is appropriate and you are taking the risk because the patch has not been tested on all 2 million languages and whatnot, but it’s up to you, not Microsoft to decide when to try the patch.

Great move. I wish they’d started doing that sooner, I remember how just a few years ago there were known and patched problems with the C++ compiler that my company needed. We got the fixes, but had to go through quite a few hoops.