Doing the Dishes

Mercurial Versus Git (Kind Of)

2013-06-22T00:00:00+00:00

There are many posts comparing Mercurial and Git, but here are the top things I noticed recently when I used Mercurial for an extended amount of time. Before that, I had come from a Git background.

Git has a staging area and Mercurial doesn’t. In Mercurial, when you modify files already in a repo, they’re automatically added to the list of things that will be commited. In Git, you need to explicitly add these every time to the staging area.
Branches in Mercurial and Git are different in a few important ways:
- Mercurial tracks global commits (which can be on different branches), but Git tracks branches and the isolated commits inside these branches.
- So, when you pull or push a Mercurial repository, you implicitly pull/push all branches.
- In Mercurial, you “close” branches instead of deleting them (and they can be re-opened later at any time by just committing to them again). In Git, you actually delete branches. For Mercurial, this is good in that it preserves history, but, arguably, it’s not as clean.
Git’s checkout is an overloaded, Swiss Army knife, whereas Mercurial splits things into hg branch, hg update, and hg revert.
The often-used git pull command combines two things (fetching and merging). In Mercurial, this shortcut command doesn’t really exist. You need to do hg pull and then an hg update. Though, you can do hg pull -u to achieve the same.
Mercurial does garbage collection on a repository automatically when certain commands are called. Git makes you do it explicitly. I heard some people from GitHub at a recent presentation say that they get support tickets sometimes for people asking GitHub to do a git gc for them to try and magically fix certain problems.
In Git, you can remove a stash/shelf with git stash drop, but it seems you can’t do this in Mercurial. Though, shelves are just stored as patches under .hg/shelves, so you can remove a file there to delete a shelf.
Mercurial is more lenient on the format used for the user name and the email settings, so things can, arguably, get messier in the commit log than with Git.

In the end, I actually enjoyed using Mercurial, and I can see where it’s perhaps better designed in several ways. However, the features of GitHub versus BitBucket outweigh a lot of these factors.

Python Package Management with Virtualenv on OS X Mountain Lion 10.8

2013-06-18T00:00:00+00:00

Preface

I had worked with both Ruby’s RVM and rbenv a little, and setting up something similar for Python version and package management seemed a little undocumented, ambiguous, and generally quirky to me. Maybe doing this should not require a blog post, though the following was the simplest way for me to accomplish this.

Also, this post on the same topic was very helpful.

Python

I choose to leave OS X’s stock Python install alone, which was a slightly out-of-date version 2.7.2 for the system executable at /usr/bin/python. Also, the Python package manager easy_install comes with 10.8, but it’s deprecated.

So, I wanted to start with a base Python version that was more recent than the OS X stock Python. I did this using Homebrew:

brew install python

This installed version 2.7.5. Note that the Homebrew install of Python also includes Pip (the preferred Python package manager these days) as well as Distribute (a lower-level package management piece that Pip builds upon).

Global Packages

At this point, if I use Pip to install a package, it will be installed globally. In general, I want to only install packages into specific environments and leave the global package store alone. However, I still need a global package for virtualenv itself:

pip install virtualenv

I may have to install other global packages in the future, but the only package I’ve installed explicitly for now is virtualenv.

Setting Up Virtualenv

I created a ~/.virtualenvs folder where I will create all or most of my environments:

mkdir ~/.virtualenvs

For example, I can create a global environment for Python 2.7 packages, and a global environment for Python 3 packages. Note that I can also create project-specific environments if I want.

Then, I added the following default settings to my .bashrc file:

# virtualenv settings
export PIP_REQUIRE_VIRTUALENV=true # pip should only run if there is a virtualenv currently activated
export PIP_RESPECT_VIRTUALENV=true # tell pip to install packages into the active virtualenv environment
export VIRTUALENV_DISTRIBUTE=true  # tell virtualenv to use Distribute instead of legacy setuptools

The first setting is the most important. It tells pip to only run if inside a virtual environment. This keeps global packages untouched and stable, and it prevents a package from accidentally being installed globally when you mean to install it in a particular virtual environment. However, if global packages need to be installed/uninstalled/upgraded later, I’ll need to temporarily comment out and disable this setting.

Also note the VIRTUALENV_DISTRIBUTE option. This tells virtualenv to use the newer Distribute supporting library. From the official Python package page here: Distribute is a fork of the Setuptools project. Distribute is intended to replace Setuptools as the standard method for working with Python module distributions.

Now, we can create an environment and activate it:

cd ~/.virtualenvs
virtualenv default
. ~/.virtualenvs/default/bin/activate

With this environment active, any calls to the Python, Pip, etc. executables will pass through it, and packages will be installed to this environment.

Listing and Uninstalling Environments

Since I plan to create most environments in ~/.virtualenvs, I can just check that directory to see all installed environments. Likewise, to remove an environment, I can just remove the corresponding directory there.

Creating a Default Environment

To activate a default environment on login, I also added this to my .bashrc file:

# set a default virtualenv
. ~/.virtualenvs/default/bin/activate

Final Thoughts

Virtualenvwrapper

Virtualenvwrapper claims to ease several of the pain points and manual steps I described above, but I wanted to see if I could use virtualenv directly without adding another layer of tooling to learn.

Modifying the Shell

When you activate an environment, virtualenv modifies your prompt to indicate which environment you’re using. If this is undesirable, you can add the following line to your .bashrc file:

export VIRTUAL_ENV_DISABLE_PROMPT=true # tell virtualenv not to modify my prompt

If you disable this indicator in your prompt, you can check which environment you’re currently using by echoing the $VIRTUAL_ENV variable.

An Environment’s Bindings to a Python Executable

When a new environment is created, it is bound to the current system Python executable by default (whatever which python points to). In my case, this will be the Python 2 executable installed by Homebrew. You can, however, bind a new virtual environment to a particular Python executable by using the -p flag. For example, you could do virtualenv -p python3 foo-py3 to create a Python 3 environment or even virtualenv -p /usr/bin/python2.6 foo-py2.6 to call out a specific path to a Python executable.

Using Try...Catch Blocks with Async Methods in .NET 4.5

2013-05-31T00:00:00+00:00

In my last post, I mentioned that you can still use try...catch blocks with .NET 4.5 async methods. There is some interesting magic that .NET injects for you under the covers in this case. For example, imagine you have the following (simplified and contrived) code which uses the newer .NET 4.5 SendAsync() method on UdpClient instead of the older, synchronous Send() version:

// Do something...

try
{
	var client = new UdpClient();
	client.SendAsync(datagram, datagram.Length, hostname, port);
}
catch (Exception e)
{
	// Handle exception here...
}

// Do something else...

Let’s assume that the host specified by hostname is down/invalid. The part about this flow that blew my mind was that the call to SendAsync() will return immediately (and not delay the code in // Do something else...), but the exception will still bubble up and be handled by the catch block. This post has an in depth explanation of how the compiler handles this. In the post, he mentions how you can even debug and step through code like this in Visual Studio, pass over an async method and see it return immediately, step through more code, and be jarringly brought back to the thrown exception from a method that has already returned!

Sending Statistics to StatsD with UdpClient in .NET

2013-05-28T00:00:00+00:00

This post is just a note about a quick fix we did at work to remedy a brittle (and embarassing) dependency on StatsD. StatsD is a simple daemon that listens for and aggregates statistics sent over UDP and can be plugged into various reporting tools and dashboards. We make a lot of calls to StatsD in our app (measure anything, measure everything), so any problems doing so is central to performance.

One day, the our main web stack actually went down because our StatsD machine crashed and our app was inadvertently dependent on it. We rebooted the StatsD server and everything was up again, but we then immediately made it a priority to decouple our app from StatsD.

The problem was in how we were using the System.Net.Sockets.UdpClient class. We had a small utility wrapper class that, at its core, just used UdpClient.Send() to throw packets at StatsD. At first, I just tried wrapping the call to Send() in a try...catch block. When I tested this, though, I found that our app significantly slowed down. Why was this happening for something that sends UDP packets? Shouldn’t it be fire and forget?

I mistakenly took this method to work asynchronously. Send() actually seems to stall a bit when sending data (as it presumably establishes a connection), and even longer when it can’t reach the destination and throws an exception.

To fix this, I simply switched to using the SendAsync() method instead (which is new in .NET 4.5). I could have also used the older BeginSend() method if the project wasn’t up to 4.5.

Note that I still needed to wrap the call to SendAync() in a try...catch block in the (rare) case that our StatsD machine is down. More on that in my next post… Update 2013-05-31: See here for more detail on this.

In addition to not having a hard dependency on StatsD, we immediately noticed an increase in responsiveness in several central endpoints of our app as we’re now making all calls to StatsD aynchronously. Not our best moment, but we’ll take the easy wins wherever we can. :)

Upgrading to an SSD

2011-09-19T00:00:00+00:00

I recently upgraded the hard drive in my laptop (a Western Digital Blue, 640GB) to an SSD (OCZ Vertex 3, 240GB). I’d heard how much an SSD improves performance, and I can now definitely vouch for this; the upgrade has been a substantial boost for my aging mid-2009 MacBook Pro (Intel Core 2 Duo 3.06GHz, 8 GB RAM).

During the course of the upgrade, I did a couple before and after benchmarks.

Boot Times

First, I took some very informal measurements of boot time. I routinely boot into Windows using Boot Camp for work, so I have boot times for both Windows 7 and OS X Lion.

Windows 7

From boot menu to desktop:
- Before: 1:15
- After: 0:29
To launch Firefox
- Before: 2:13
- After: 0:40

OS X Lion

From boot menu to desktop
- Before: 1:12
- After: 0:17 (17 seconds!!!)
To launching iTunes
- Before: 1:44
- After: 0:29

CrystalDiskMark

I also took before and after measurements using CrystalDiskMark (a disk benchmarking utility for Windows).

Before

After

Windows Experience Index

Lastly, here are the results from the Windows Experience Index utility on Windows 7.

Before

After

Software Engineering as Tinkering

2011-09-14T00:00:00+00:00

I saw this fascinating graphic in an online presentation called “Programming and Scaling” by Alan Kay:

Kay used this to illustrate the role tinkering plays in mathematics, science, engineering, and also in making computer software. He uses the Empire State Building as a marvelous example of good engineering (and indeed it is; the building was completed ahead of schedule in 1 year and 45 days at a rate of over 7 floors per month), and contrasts that with how (even today) nothing this dependable can be “engineered” by the disciple of software engineering.

Notice how disproportionate the tinkering circle elapses the computer software bubble. The premise is that we largely build software today by tinkering along with the related “make and fix paradigm” (which he also describes).

Custom Error Pages with ASP.NET MVC 3 and ELMAH

2011-09-10T00:00:00+00:00

I was having a problem in an MVC 3 app with the HandleErrorAttribute hiding exceptions from ELMAH and also clashing with the <customErrors> section in the Web.config (similar to this Stack Overflow question). TL;DR version: I ended up just removing the default registration of HandleErrorAttribute and leaning on what’s specified in <customErrors>.

Some details…

By default, a new MVC 3 project has a global filter registered in Global.asax that applies the HandleErrorAttribute to each controller action. This attribute will essentially appy a try/catch around each controller action and render the Error.cshtml file (or .vbhtml if you’re using Razor with VB.NET, or .aspx if you’re using the WebForms view engine) in the Views/ControllerName or Views/Shared directory. A new MVC 3 project has a Error.cshtml file in the Views/Shared directory by default.

If custom errors are enabled (either via the mode attribute being set to “On” or “RemoteOnly” on the <customErrors> element), then HandleErrorAttribute will render the Error.cshtml view.

My first problem was that I was using ELMAH to log errors, and exceptions would be swallowed by HandleErrorAttribute and not logged in ELMAH. I saw a few posts such as this one from Scott Hanselman about making a custom attribute to handle errors and log to ELMAH, but stay with me for a few minutes more…

To handle different kinds of custom errors, I removed the stock Error.cshtml from Views/Shared, made a new controller and set the following in the Web.config file:

<customErrors mode="On" defaultRedirect="~/Error/ServerError">
  <error statusCode="404" redirect="~/Error/NotFound" />
  <!-- Other status codes here -->
</customErrors>

However, if an exception was thrown with HandleErrorAttribute and the <customErrors> settings applied, I would first get another exception (logged in ELMAH):

The view ‘Error’ or its master was not found or no view engine supports the searched locations. The following locations were searched: ~/Views/ControllerName/Error.aspx ~/Views/ControllerName/Error.ascx ~/Views/Shared/Error.aspx ~/Views/Shared/Error.ascx ~/Views/ControllerName/Error.cshtml ~/Views/ControllerName/Error.vbhtml ~/Views/Shared/Error.cshtml ~/Views/Shared/Error.vbhtml

Then, the app would fall back to rendering Error/ServerError as I had directed it to in <customErrors>. The real error was masked in ELMAH. This is because the HandleErrorAttribute was looking for Shared/Error.cshtml, couldn’t find it, then threw up and fell back to what was specified in <customErrors>.

(Note that 404 errors still passed through; it turns out HandleErrorAttribute ignores all but 500 errors).

Why did I even need to use the HandleErrorAttribute? Can’t I just lean on the <customErrors> section in vanilla ASP.NET? I ended up taking the attribute’s registration out of Global.asax and doing just that. Errors were then properly picked up by Elmah, and I would see friendly error messages when enabled in production.

Summoning a Professional

2011-08-28T00:00:00+00:00

Dr. Dobb’s on the easy dismissal of professional programming these days (emphasis mine):

This depreciation of our trade has roots in our trade, alas. COBOL was designed specifically to enable managers to run their own reports. The quixotic belief that non-programmers could do this is what still nourishes the BI field’s abuse of the term. This self-deception persists despite the now considerable body of evidence to the contrary. Everything is simple for the neophyte “programmer” until something unexpected happens. Then everything stops suddenly. Frequently, a professional programmer is summoned. If none is available, the project or report simply dies in its tracks. So ends the matter.

I have a different, even bleaker, instinct and prediction for this scenario: the team pushes blindly without the aid of a “professional” and, more importantly, without the broader perspective and arsenal of techniques an experienced programmer may bring to the situation. They push on no matter what, until some crazy, hair-brained solution or workaround is found; basically, until anything that works is found.

Using String.Format with Nulls

2011-08-27T00:00:00+00:00

Just a quick tip from my last post…

Notice how I didn’t check for nulls in the code sample:

@model DateTime?
@string.Format("{0:yyyy-MM-dd}", Model)

You’d think it would be necessary to do something like so instead:

@model DateTime?
@(Model.HasValue ? Model.Value.ToString("yyyy-MM-dd") : "")

However, String.Format in the .NET framework will just return an empty string when formatting null values. I thought this was handy, and it seems to pop up in a surprising number of cases.

Display and Editor Templates for Nullable Types in ASP.NET MVC

2011-07-20T00:00:00+00:00

I was recently confused about how to specify a display and editor template for a nullable value type (such as int?, double?, and DateTime?) in ASP.NET MVC, and couldn’t find much on this topic anywhere, so here’s a quick tip on how to do it.

ASP.NET MVC has a feature called display and editor templates that let you specify in a central location how a given data type should be displayed. For example, if you want DateTime values to be displayed in a certain format throughout your app, you can add a file called DateTime.cshtml to the Views\Shared\DisplayTemplates folder (I’m using C# with the Razor view engine). When you use one of the built-in HTML helpers such as @Html.Display() or @Html.DisplayFor() in a view to display a DateTime, it will use the template you specified (note that the same applies for the Views\Shared\EditorTemplates folder and the @Html.Editor() and @Html.EditorFor() methods).

So how would you specify a template for nullable DateTime? Since Windows doesn’t allow the characters “?” and “<>” to be in a file name, that kills the convention of naming the file DateTime?.cshtml or Nullable<DateTime>.cshtml.

It turns out that if you just specify a model type of DateTime?, then a template named DataTime.cshtml can cover both cases of displaying a nullable and non-nullable value type. Here’s the full contents of my display template for DateTime?:

@model DateTime?
@string.Format("{0:yyyy-MM-dd}", Model)

Jason Fried on Designers and Writing

2011-05-21T00:00:00+00:00

Sorry to keep posting quotes by this guy, but…

We’re trying to encourage all of our designers to be great writers. To me, there is no difference between writing and design. You’re either designing a sentence or designing a screen - it’s all the same thing. I think a product that’s poorly written is not a well-designed product.

The Big Web Show: Episode #10

Please, Please Back Up Your System Databases

2011-05-20T00:00:00+00:00

I’m just recovering from a two-day bender of re-building our production SQL Server install at work. In hindsight (of course), it seems obvious what I should have done to prevent this, and at least I learned a couple things from this freak accident.

The cause doesn’t even sound that glamorous: I installed service pack 2 for SQL Server 2008. The service pack said it installed correctly, and I rebooted the machine as instructed. When I tried to connect to the server afterwards, though, I got the following error:

Server is in script upgrade mode. Only administrator can connect at this time.

Looking in the event viewer for more details, I saw this bone-chilling message:

Script level upgrade for database ‘master’ failed because upgrade step ‘sqlagent100_msdb_upgrade.sql’ encountered error 3602, state 126, severity 25. This is a serious error condition which might interfere with regular operation and the database will be taken offline.

…followed by:

Cannot recover the master database. SQL Server is unable to run. Restore master from a full backup, repair it, or rebuild it.

Ouch. After seeing this and further googling and tinkering, my heart sank, and I realized we were in for an all-nighter. We couldn’t manage to restore or access the master database.

The system databases in SQL Server store a bunch of metadata including login and security information, db mail settings, jobs, and (in our case) replication settings. So, while we had regular backups of our user databases being done, we had neglected to backup the system databaess and hadn’t thought through the process of rebuilding our server.

The part that really stings is that we later just added a few lines (a few measly lines!!!) to the backup script to include the system databases. But, lesson learned, and plus we got to go through an instructive (though painful) process of going through and revising our disaster recovery process.

Bottom line, please, please backup your system databases, and the next time I do a service pack install or other serious upgrade, I’m going to be sure to take a full backup of all user as well as system databases so that I can not only restore our data, but also our configuration.

A Generic Repository

2011-05-14T00:00:00+00:00

I’ve seen a few examples of repositories that are written for specific types, but I’ve been using a repository interface very similar to what is described here. It’s worked out very well for me, and provides a lot of flexibility via a simple interface:

public interface IRepository
{
    IQueryable<T> All<T>() where T : class;
    void Add<T>(T item) where T : class;
    void Delete<T>(int id) where T : class;
    void Save();
}

I tweaked Pablo’s example to completely use generics (it seems he uses a concrete type on the Entities property).

Here’s an implementation using Entity Framework 4 Code First:

public class MyRepository : IRepository, IDisposable
{
    private MyDbContext db = new MyDbContext();

    public IQueryable<T> All<T>() where T : class
    {
        return db.Set<T>();
    }

    public void Add<T>(T item) where T : class
    {
        db.Set<T>().Add(item);
    }

    /// <summary>
    /// Retrieves the entity from the database, then marks
    /// it for deletion in the db context. Note that this
    /// executes a query to retrieve the entity (if it's not
    /// already loaded in the context). Would be better to 
    /// find a way to delete without retrieving the object first.
    /// </summary>
    public void Delete<T>(int id) where T : class
    {
        var entity = db.Set<T>().Find(id);
        db.Set<T>().Remove(entity);
    }

    public void Save()
    {
        db.SaveChanges();
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (disposing)
        {
            // Free managed resources
            if (db != null)
            {
                db.Dispose();
                db = null;
            }
        }

        // Free unmanaged resources here
    }
}

(The Delete method is a little inefficient, as it seems to be a little difficult to delete without querying in Entity Framework)

Here’s how it can be used inside an ASP.NET MVC 3 controller:

public ActionResult Index()
{
    return View(repository.All<SomeModel>());
}

[HttpPost]
[Authorize(Roles = "Editor")]
public ActionResult Delete(int id)
{
    repository.Delete<SomeModel>(id);

    repository.Save();

    return Content("");
}

For unit testing, here’s an implementation of a mock repository (which is backed by an ArrayList):

public class MockRepository : IRepository
{
    ArrayList list = new ArrayList();

    public bool SaveWasCalled { get; private set; }

    public IQueryable<T> All<T>() where T : class
    {
        return (from Object item in list
               where item.GetType() == typeof(T)
               select item as T).AsQueryable<T>();
    }

    public void Add<T>(T item) where T : class
    {
        list.Add(item);
    }

    public void Delete<T>(int id) where T : class
    {
        throw new NotImplementedException();
    }

    public void Save()
    {
        SaveWasCalled = true;
    }
}

(I still need to figure out that Delete method using reflection… or something…)

Removing ASP.NET Membership Objects from SQL Server

2011-05-08T00:00:00+00:00

On a recent project using ASP.NET MVC 3, I started out using the stock ASP.NET membership provider with SQL Server. I later decided that it was going to be too heavy, and went about making my own simpler membership, roles, and form services.

As part of the change, I created the following script that I used in a database migration when I switched over to my new users and roles mechanism. I hope this helps someone if they need to quickly rip out the default membership provider:

Jason Fried on Running a Flat Company

2011-04-23T00:00:00+00:00

Interesting take on employees inevitably progressing into management from Jason Fried of 37 Signals:

We always try to hire people who yearn to be master crafts people, that is, designers who want to be great designers, not managers of designers; developers who want to master the art of programming, not management.

This kind of view would probably be hard for most companies to swallow, but it’s a compelling idea for someone like myself who’s interested in becoming the best they can be at their craft (at least for now).

Mobile UI Influence

2011-04-17T00:00:00+00:00

I noticed a couple tweets floating around today about leaked images of UI in an upcoming version of Microsoft Outlook that mimics the Windows Phone 7 “Metro” UI style:

Also, keep in mind the demos of the upcoming OS X Lion that Apple’s been showing off (the Launchbar feature is shown here, which looks the same as folders on iOS):

It’s interesting to see desktop OSes taking major cues from mobile UIs.

Moving to Jekyll

2011-04-14T00:00:00+00:00

I moved this blog from BlogEngine.NET to a static site generator called Jekyll. It was made by some of the smarty pants at GitHub, gives you easy and direct control over your blog’s markup, and it even allows you to host your site on GitHub (more on this later).

BlogEngine.NET is backed by a database such as SQL Server and built upon the idea of dynamically generating content on each request. Static site generators work by having you write posts in plain text (in Jekyll’s case, in Markdown) and generating html files for the entire site on each update. The generator is smart enough to do things like wrap your posts in templates, insert post dates, and generate next/previous pages and links. While this might sound like a brute force method (generate the entire site every time you write a new post???), with today’s computers it’s really not a big deal.

There are some interesting side effects to using a static generator for your blog. For one, you get the benefits of high scalability inherent in the capability of web servers to serve simple html files very quickly without the added overhead and complexity of hitting a database, caching, etc. Dan and Marco had a good discussion about this on episode 18 of the Build and Analyze podcast.

I found myself not needing many of the features that modern blog engines such as WordPress, Movable Type, or (in the .NET space) SubText, dasBlog, and BlogEngine.NET offer. Not maintaining a separate database for the blog as well as an easily customizable and simple template system were also very appealing. I’ve been writing more and more in Markdown too, so this seemed like a natural way to write posts, and Jekyll supports this.

Importing Posts from BlogEngine.NET

Jekyll has some support for importing from an RSS feed, but I didn’t get good results from this. BlogEngine.NET is capable of exporting to BlogML (which is a nice format - I wish I would have caught on), so I modified the RSS import script in Jekyll to such in my BlogML data and transform it to Jekyll’s post format.

Caveats

Jekyll’s not for everyone, and it’s squarely aimed at developers or at least advanced geeks. If you don’t want to set up your own blog installation, there are several good hosted blog platforms such as Tumblr, WordPress.com, and Blogger. I host my personal blog at Tumblr, and it’s great.

For example, to write and publish a new blog entry, I write a post in Markdown, preview it locally using the Jekyll command line program (which does things like regenerating the site and starting a development web server), the commit my post and push to GitHub.

Not for the faint of heart, but to me it’s comfortable and fits in with my desired workflow.

Hosting at GitHub

You can host your site at GitHub by storing your Jekyll repository there and using the GitHub Pages feature. You can find out more about how this is done by poking around the Jekyll repo on GitHub and by looking at some of the sites using Jekyll that are listed in the project’s wiki.

Basically, each time you push a commit to your blog repository on GitHub, your site is regenerated and republished. It’s easy enough just to upload the files that Jekyll generates to your own server, but I find the workflow of having my blog automatically refreshed every time I make a commit very appealing.

Update (May 8, 2011): Here’s a link to this blog’s source on GitHub.

Yes, Yes. Another, Another Backup Lecture.

2010-09-28T00:00:00+00:00

I realize there have been some very popular web celebrities in recent memory post about backups, but here goes.

Spurred on by posts like those from Gruber and Merlin Mann, I've been working on getting backups right this year. A hard drive failure a few months ago along with a fire in my apartment building recently also provided motivation, and it looks like I've settled on at least some kind of strategy. Maybe it's a little overkill and clumsy, and maybe I have a weird setup, but it feels redundant enough that I won't lose my (precious) home movies and personal pictures.

I don't think of my setup so much as a strategy (although I have a backup plan that I follow regularly now), but rather as a hodgepodge that works for me and contains pieces that may be applicable to a lot of other people. So take away from it what you can, and I hope it helps.

Online Services

It turns out a lot of content I produce is uploaded and shared somewhere. Practically all of my pictures are hosted at Flickr (some marked as private or just for friends), my videos at Vimeo, my email to Gmail, many documents to Google Docs, etc, and I consider this a form of offsite backup.

I also use Dropbox heavily. While not only serving to synchronize files on both my Windows 7 and OS X partitions, it also is a form of cloud backup. I've come to use in in place of the user documents folder on both OSes.

For code, I use version control systems (Team Foundation Server at work, and GitHub for personal projects). That, again, is redundant, as I have local copies on my laptop and another stored on a server somewhere.

It could be said that you're entrusting too much to a third party, but I just might trust Flickr with its thousands (millions?) of users and the responsibility that goes along with maintaining a datacenter to host all of this content reliably than I do my own backup practices.

However, I certainly do local backups, but it's interesting to note the impact of modern "cloud computing" services (whatever that means to you) on data redundancy.

My Setup

Even though I'm an ASP.NET developer, I develop on a MacBook Pro running Windows 7 on Boot Camp during the day (Macs are... pretty). In the off hours at home, I boot into OS X Snow Leopard where all my media lives in iTunes, Aperture, iMovie, etc. So, I have two environments to back up: Windows 7 and Snow Leopard.

I also have a Windows Home Server device (an HP EX485 Mediasmart), which I use for backups and network storage. The device has redundant storage spread across several discs, but I want to back it up too (in case the machine fails and for offsite backups). Make that three environments.

Backup Tools

Here are the tools I use:

Windows Home Server (WHS)
WHS's included backup software for Windows 7
OS X's Time Machine (which can use WHS as a backup drive via software included with the HP WHS device)
SuperDuper!
WinClone
Two external laptop hard drives
Two external desktop drives with lots of space
An extra 1 or 2 external drives for juggling files or images around in case of an emergency

Process

My setup is a little tricky because I spend time booted into two different OSes. This can make it difficult to reliably schedule backup jobs (e.g. if I work in the evening and stay booted into Windows 7, then Time Machine or SuperDuper's nightly backup won't run on the OS X side). While not foolproof, I've found I get enough coverage so that I shouldn't lose more than, at worst, a week's worth of data on my hard drive.

If I'm in Windows 7 at home for an extended period of time, Windows Home Server will automatically back up the Windows partition every night at midnight, or I can explicitly trigger a backup.

When in OS X (where I am most of the time at home), Time Machine backs up to WHS frequently (I think it's every hour or so). Since Time Machine takes snapshots of files and allows you to view file history, I'm able to recover deleted or accientally overwritten files within a certain window (Recovery Point Objective vs Recovery Time Objective).

I also make an image of the OS X partition regularly using SuperDuper! and one of the external laptop drives. If my laptop's hard drive completely fails, I can get my computer back up in the time it takes me to take the old hard drive out of my laptop and replace it with the new one containing the image. The SuperDuper! image isn't taken as regularly as Time Machine backups, but I can more quickly get my machine up from a failed drive than with Time Machine restoration process.

To image the Windows 7 partition from OS X, I use WinClone. I take weekly snapshots, and store them on a separate partition of the laptop drive.

I use Windows Home Server's included backup utility to archive files to one of the large desktop drives every week.

For offsite backups, I rotate both the laptop and desktop drives every few weeks and store a set of drives in my office at work.

Remember Your Discs

If you need to troubleshoot your system or do a restoration, it's important to have your installation media. Both the Windows 7 and OS X discs include diagnostic utilities that you can use on boot. You should also have the discs for restoring with Time Machine (on the OS X disc) or with Windows Home Server (on the included WHS media).

Top Versus Left-Aligned Labels

2010-09-01T00:00:00+00:00

While working on a new web app at work, I've been flip flopping between two designs for forms: using top-aligned or left-aligned labels. While this was on my mind, a Hacker News entry appeared for an article claiming top-aligned labels are easier for users to scan and require less eye movement.

The article cautions that designs with top-aligned labels take up more vertical space. Users are fairly comfortable with scrolling vertically in web pages, though, and forms can be split up into separate pages if they become too unruly.

This makes sense anecdotally, but it would be nice if the article gave citations for studies backing the claim up.

UX Movement - Why Users Fill Out Forms Faster With Top Aligned Labels

PowerShell Script to Clean Up Downloads Folder

2010-09-01T00:00:00+00:00

Here's a simple PowerShell script to delete files and folders older than 1 month from my Downloads folder:

ls ~\Downloads | where {($_.LastWriteTime).AddMonths(1) -lt (get-date)} | remove-item -force -recurse

The script deletes items older than 1 month as-is, but this can be adjusted by changing the call to AddMonths appropriately (there are other methods on the date object such as AddDays, AddHours, AddMinutes, etc).

The script calls ls (alias for Get-ChildItem) on my Downloads folder. The output is piped to a where clause that filters on the LastWriteTime property of the current object or $_ (pipline variable). One month is added to LastWriteTime, and if it's less than (-lt) the current date then it's piped to remove-item (which has aliases of rm and rmdir) where the file/directory is forcefully removed without prompt and contents in directories is recursively deleted.

This can be called manually every now and then or can be scheduled with Windows task scheduler.

Although this can be done using the forfiles command in the normal Windows command prompt, I had trouble deleting folders using it and PowerShell is more flexible overall.

Surprisingly, this was hard to find after a little Googling around. It seems to be that way with PowerShell samples, and I hope that's just because it's still relatively new.

A Quote from Luke Wroblewski

2010-08-19T00:00:00+00:00

There's nothing wrong with writing down specifications, but I would say write them down once you've actually worked through some of the issues - that's the fundamental problem. If you can work through some of the issues with Keynote, great. If you can work through some of the issues with a lightweight HTML and JavaScript prototype, great. If you can do that on paper, more power to you.

Until you can actually do that, you're pulling things out of thin air and it's going to lead to a lot of re-doing and iteration anyway, so you might as well get that iteration done up front.

The Conversation - Episode 28: Designing with Keynote?

SSIS Package Storage

2010-08-02T00:00:00+00:00

At work recently, we had a little confusion about where SQL Server Integration Services (SSIS) packages should be stored on our database server, and we ended up having multiple copies of packages littered around the server. To me, the dialogs for dealing with SSIS packages seem a little confusing (as does SSIS in general, but that's another topic).

We use SQL Server 2008, so I'm not sure if there are slight differences between this and 2005 / 2008 R2.

Basics

After SSIS packages are developed (using Visual Studio Business Intelligence Development Studio - BIDS), they are deployed to a production environment in SQL Server. Within SQL Server, packages can be stored in two places: "File System" and "MSDB". Shown below is a screen shot showing this in SQL Server Management Studio (SSMS) connected to Integration Services.

When you connect to Integration Services with SSMS then right-click and select Import Package on the MSDB tree node under Stored Packages, it stores the package in the MSDB system database (of course).

When you right-click and select Import Package on the File System node under Stored Packages, you're able to select a .dtsx file in a dialog. It seems when you do this (or at least it did to us), that SQL Server will reference the file in the location that you specified. Actually, it copies it to a special directory that SQL Server manages ("C:\Program Files\Microsoft SQL Server\100\DTS\Packages" in our case).

We had our own directory on the database server that we agreed to store SSIS packages in. When we stored the package files there, then went through the import process for the File System option, we ended up having two copies (one in our directory, one in SQL Server's).

Another confusing point was the dialog itself when right-clicking and selecting Import Package on either the MSDB or File System nodes. It gives a choice of three locations to import from: SQL Server, File System, and SSIS Package Store. When you select SQL Server, you're given a choice to import items just under the MSDB node. When you select File System, you're can choose a .dtsx file that's on your hard drive (not in the File System node of the same name under Stored Packages). When you select SSIS Package Store, you're given a choice of anything under the Stored Packages node (including items under the MSDB node which you see when you select the SQL Server source - giving you two ways to access the same package).

Although confusing, it seems this dialog is designed to be flexible enough for you to import packages stored not only locally on disk, but also stored on a different SQL Server either in that server's MSDB or File System store.

Where Should Packages be Stored?

Bear in mind that packages can just be stored on disk outside of SSMS and the file referenced directly from a SQL Agent job (where the package will commonly be triggered). This probably doesn't give you the flexibility or management that is intended with SSIS, though, as you can't see the list of all SSIS packages from within SSMS, you can fire a package directly from within SSMS if it's stored there, etc.

Packages can be imported using the File System target and SQL Server can manage the files in its special directory, but this puts the package physically outside of database and it won't be backed up along with the database.

What we ended up settling on is storing our packages in MSDB. Several Google results recommended this for ease of management and backups (if you backup MSDB, then all the packages are backed up too).

A Quote from 37signals

2010-07-03T00:00:00+00:00

...then, if you cut down one or two more words, the sentence has gone from being clear to being really, really brief. Sometimes, people - I think programmers do this quite a bit - mix up the idea of being concise and compressed with being clear. ... Brevity and clarity are two different things.

37signals Podcast Episode #16: Design roundtable

SharePoint List Adapters for SSIS

2010-05-25T00:00:00+00:00

Update - August 2, 2010

Support for specifying credentials in addition to using integrated security was rolled into the main package. Currently, it's in beta, and it can be downloaded from here (named "BetaSharePointListAdaptersSetup.msi" under "Other Available Downloads").

My project is unneeded now, and will probably be deleted from Codeplex soon.

On a project at work recently, we needed to create a report using SharePoint list data. We decided to use SQL Server Integration Services (SSIS), and looked at using these SharePoint list source and destination adapters on CodePlex. However, these sample adapters only supported Windows integrated authentication, so I modified them to accept basic authentication.

I've created a project on CodePlex for these modified source and destination adapters, and also put together a simple release with the pre-built assemblies and simple instructions.

I hope this helps someone who has a similar problem.

Reflections on StackOverflow DevDays Amstersdam

2009-11-12T00:00:00+00:00

I went to Amsterdam for the one-day DevDays conference put on by the guys behind Stack Overflow. While the creators of Stack Overflow are proponents of ASP.NET and the site itself is built on a Microsoft stack (ASP.NET, SQL Server, etc), the Stack Overflow is billed as language-agnostic. As such, the conference was meant to be "a sample platter for web developers". That being said, the conference wasn't afraid to toot its own horn, and detailed several of (rapidly expanding it seems) Stack Overflow properties such as Stack Overflow, Stack Exchange, Stack Overflow Careers, and even Fog Creek's (Joel Spolsky's company) main product, Fogbugz.

And so, the sessions:

Keynote

Joel Spolsky, Fog Creek Software

This was my favorite session of the day. It kicked off with a cheeky and geeky, but a bit lenghty intro video filmed at the Fog Creek office where Joel shows how he, despite all of his promotion over the years of good developer working conditions and proper respect for developers, really manages his ~~peons~~ employees.

Choices. Users are faced with, every day, a staggering amount of choices from software. Over abundant and illogical dialog boxes and prompts bombard us. More choices can be demotivating. In a study conducted at a supermarket, two tables were set up with samplers, one with 10 kinds of jam, and one with 2. The results indicated that, while more samplers attracted more people, the table with only 2 kinds of jam actually outsold the other table significantly. Every time you have an option is a dialog box, you're asking someone to make a decision (this is generally a bad thing).

Simplicity. There's a trend in software (especially from Web 2.0 companies) towards simplicity, but software shouldn't just be simple, it should also be powerful. This is where elegant design and programming comes in. Why did this idea of simplicity so popular in modern, trendy software? One reason is the number of startups with limited staff and resources. Is this taken too far? Maybe. Just google bug trackers and see how many of them advertise "simplicity". In Joel's experience, features added elegantly (with gracy, economy, strength, and modesty) generate more sales. Think about what motivates people and don't think your code is so important. Elegance actually takes more work (not only in UI development, but also in coding).

jQuery

Jorn Zaeffer, jQuery

jQuery. You might've heard of it. It's big. So says Zaeffer (jQuery team memebrr and UI main developer). Thirty-five percent of sites using JavaScript use jQuery.
Who uses jQuery? 35% of sites using JavaScript use jQuery. This talk was a fairly simple introduction to jQuery for those who might be interested.

Qt

Eroe Bragge, Nokia

Ah, the worst session in my opinion and the one that got the worst backlash on the conference's live Twitter hashtag (I started feeling sorry after awhile reading these tweets).

Sounds great: write an application once and run it on Windows, Mac, Linux, and even phones running Nokia's Symbian OS. Except that this is too reminiscent of Java's failed promise and the demo is unexciting and tedious. Cough... cough... iPhone UI is better... cough... cough...

Fogbugz 7

Spolsky

The product looks fantastic, and I wish my company would pay to use this issue tracker. Estimates based on actual team member estimating and actual delivery dates (something they call Evidence-Based Scheduling), burndown charts, integration with a Mercurial-based version control system ("Kiln"), code review capabilities, oh my!

But, is it too much self-promotion?

Python

Simon Willlison, Co-Creator of Django

Holy smokes what a great live-coding demo! What skill, what flare, what Python! Willison demonstrated an application from a real-world use case at The Guardian in which he sucked in data from a feed of H1N1 flu statistics and infused this with a SVG vector graphics file to create a heat map of infections for various countries. As well as being an interesting demonstration of a compelling and flashy application, it was fascinating to see first-hand how a proficient Python and web developer works.

Google App Engine

Nick Johnson, Google

It must have been tough following Willison's impressive demo, but Johnson carried on nicely. He created a humorous knock-off application of Stack Overflow using Google App Engine, and, although the app itself was fairly simplistic, it still served as a sucessfull accessory to discuss some of Google App Engine's features.

What features, you say? Built-in memcache, mail, scheduled tasks, an extensive admin console with statistics, logging, XMPP support, and integration with Google Accounts.

Yahoo Developer Tools

Christian Heilman, Yahoo

Yahoo really wants you to create mash-ups using their JavaScript library (YUI), web services, and something called Yahoo Query Language (YQL). Using an SQL-like syntax, YQL allows you query over various data feeds (provided stock by Yahoo or with a customizable source). Heilman has even crafted his homepage to be entirely composed of data brought in by YQL.

ASP.NET MVC

Alex Thiessen

Oh ASP, why can't you attract hip, passionate figures such as Willison and Heilman. As an ASP.NET developer (who has a great interest in and respect for ASP.NET MVC), I wanted this to be a compelling talk. In spite of it being well-presented, however, I came away feeling that the Microsoft ASP.NET team had ~~copied~~ been inspired by more progressive frameworks (especially after hearing talks using Python, Django, and YQL mashups).

Some truth to this? Sure. But I also believe in ASP.NET MVC and think it's a great direction for ASP. Things must be taken in perspective, and in the world of Microsoft web development, ASP.NET MVC is one of the most exciting frameworks to arise in years.

Various Overheard Quotes

The problem with quick and dirty ... is that the dirty remains long after the quick has been forgotten. -Steve McConnell

Every day that we spent not improving our products was a day wasted. -Joel Spolsky

Python is definitely what all the cool kids are using. -Joel Spolsky

Running IE8 and IE7 Seamlessly on Windows 7 with Virtual PC and XP Mode

2009-08-31T00:00:00+00:00

I often need to test against Internet Explorer 7 while developing, and while there are several hacks to run IE7 alongside IE8, I've settled on using a virtual machine instance of Windows XP (such as the temporary ones provided by Microsoft).

Today, I tried running the release candidates of Virtual PC and XP Mode for Windows 7 to more seamlessly accomplish the same thing. Here's a screencast of it in action.

After running the Virtual PC then XP Mode installers, you can either run a windowed XP virtual machine (just as e.g. Virtual PC 2007 allows), or you can add application shortcuts to the all users programs folder of the start menu inside the virtual machine and they'll appear in the host's start menu. Then, these applications run similar to a regular application (ala VMware Fusion for the Mac).

In the screencast, I show launching IE7, but this can be used for other applications as well.

Converting An ASP.NET Web Forms Project To ASP.NET MVC

2009-06-15T00:00:00+00:00

Continuing with my last post about the differences between Web Site projects and Web Application projects in ASP.NET, this post details how I converted a legacy ASP.NET Web Site project to an ASP.NET MVC project (a variant of a Web Application project).

Getting Started… ASP.NET MVC?

I originally intended to only convert the project to a web application. I ran into a couple scenarios during development in which I wanted the capabilities that a Web Application project offers over a Web Site. See my previous post for some of these differences.

However, when I started looking into the conversion process, I decided to jump ahead and convert to the ASP.NET MVC framework.

Why jump to ASP.NET MVC? I had been keeping an eye on the development of the ASP.NET team’s MVC framework (an alternative to the existing ASP.NET Web Forms model) and liked the direction it was headed. I had experimented with Ruby on Rails (probably the most well-known web MVC framework), and liked the clean separation of concerns, more natural model of web development (as opposed to the leaky abstractions of ASP.NET Web Forms), etc.

I knew it wasn’t realistic to convert all pages in the existing project to new MVC ones. However, since it’s possible to run regular Web Forms inside of MVC projects, this seemed like a good compromise to preserve legacy code while using the MVC paradigm for future work. The MVC project type is a specialized version of a Web Application Project, and current Web Forms page, even in an MVC project, can still be processed as usual since the underlying ASP.NET engine is the same for Web Forms and MVC applications.

Steps and Caveats

I began by installing the ASP.NET MVC installer, which installs the MVC library DLLs into the GAC as well as the ASP.NET MVC Visual Studio project types and templates, and creating a new ASP.NET MVC project. I then started copying files from the old to the new project.

There's a decent walkthrough here (the guide is for Web Application projects, but it was close to what I needed). Still, I was greeted with over 5,000 build errors after following the official directions and trying to build the project for the first time. I found I needed to take things slower and at a more granular level, transferring a few files at a time to the new project and evaluating the differences one by one.

I transferred several settings from the web site’s web.config appSettings section to settings in the Visual Studio project settings file (right click on project –> Properties –> Settings). This more closely follows the standard way of managing settings using Visual Studio project files, and also performs code generation to create strongly-typed properties automatically. These settings are still stored in the web.config file (so they can be changed while the web application is running), but they’re stored under a slightly different schema for project file properties.

The mechanisms for references to web services is different in Web Application projects versus Web Sites, but this is fairly straightforward as I just re-added all my references (although this might take time if you have many references).

I love ReSharper, but I had to shush it during the conversion process to avoid being nagged to death by premature warnings and code analysis.

Something to keep in mind is that the automatically generated designer files for Web Application project aspx pages are automatically re-generated when aspx files are saved. This means that when you adjust the namespace in the aspx file (e.g. with an Inherits="C4IFACT.App.WebForms.ExecutionPlans" attribute on the Page directive) then it is reflected in the designer file. I was getting many perturbing error messages about incorrect namespaces that were resolved by this (since the aspx page and designer files can temporarily get out of sync at times).

While there is some level of security from static typing and having your project "compiled" into a DLL, you should remember that an ASP.NET project has a DLL for all of the plain C# code supporting the application, but the aspx pages are not compiled when a project is built, but instead reference types in the project’s assembly and are executed by the ASP.NET runtime when a page is visited. This means that you might still have compile errors in aspx files that won’t be reflected in the build. To help this, you can flip a switch on your MVC project to trigger the ASP.NET compiler to compile ASP.NET markup and code inside aspx pages on project compile (see here for directions on doing this – it even works against Web Forms pages if you have some mixed in with your MVC project). However, this affects the performance of building the MVC project significantly.

Organization and Folder Structure

While trying to respect the default conventions of ASP.NET MVC, I also looked at Rob Conery's enhanced version and also the Rails folder structure.

While creating my folder structure, I thought about re-structuring parts of the old app and creating clean namespaces. I settled on this:

The App folder contains most executable content (following the Rails convention). MVC controllers and views are here.
The App\Helpers folder contains former App_Code files and miscellaneous utility classes.
I have a separate project in the solution containing data access code and models, so I don’t have a strict folder for models. However, I have a ViewModels folder, where model classes tailored specifically for presenting view logic or data binding are.
Master Pages and User Controls (Partials) are under Views\Shared.
I wanted to put my Web Forms into the Views folder (even though they aren't true Views), but there seems to be a hard setting in ASP routing that doesn't serve anything from the Views folder, so I placed them into a separate WebForms folder. I could have also routed Web Forms pages to friendler URLs (using the routing portion of the MVC framework), but for now I kept things simple and used the physical location (e.g. “MyPage.aspx” is accessed at “www.mysite.com/app/webforms/mypage.aspx”).
The Assemblies folder contains third-party, referenced assemblies (those not contained in the GAC). Note that things under here should be referenced in the project, but should also be set to Content and not be copied to the project's build output location so that they won't be included with the project output as content (although they will be included as necessary along with the project's built DLL in the published folder).
The Public contains static content divided into Images, Stylesheets, and JavaScripts folders.

CodeFile Versus CodeBehind

One last point - Web Site project "CodeFile" directives should be "CodeBehind" in Web Application / MVC projects. I found a great tip in the comments from this post about possible confusion that can result when converting from Web Site to Web Application projects. Here's an excerpt from the comment:

The issue with CodeFile is that the code is compiled into its own (or directory level assembly) and so the type may not be available to another page unless the control is @Registered. If you dynamically load you pretty much can't reference the ASCX codebehind class. With WAP everything goes into a single assembly so you can reference the codebehind class from just about anywhere... The thing is that if you forget to set the proper format for WAP code the page/control will still work because ASP.NET internally doesn't care whether a project is stock or WAP so the page/control runs just fine with CodeFile.

This hit upon a frustrating problem I ran into: my user controls were being compiled into their own separate assembly because I left them using the CodeFile attribute, so when I tried to import the user control (with its custom server tag) globally via the web.config (as this tip suggests) and I just referred to what I thought was the correct namespace I had problems because the user control was being compiled automagically into a separate assembly where CodeFiles are compiled.

The "Convert to Web Application" context menu for aspx pages is supposed to handle this for you and change CodeFile directives to CodeBehind, but I had issues with several pages where this didn't work and I didn't realize it for awhile. Even still, this action doesn't handle namespaces for you and still accepts the Web Site-style "Folder1_Folder2_ClassName" unique name approach instead of conventional .Net class library "Folder1.Folder2.ClassName" namespaces (how I preferred things). Basically, adjusting namespaces properly ending up involving a lot of manual work, as simply copying files and clicking "Convert to Web Application" doesn't adjust namespaces properly even if you put the files in the conventional folders.

ASP.NET Web Sites Vs Web Applications

2009-06-12T00:00:00+00:00

There are, confusingly, two basic types of Visual Studio projects for developing web apps with ASP.NET: Web Sites (File –> New –> Web Site), and Web Applications (File –> New –> Project –> Web Application). I recently converted a legacy Web Site to a Web Application (and actually, to an ASP.NET MVC Web Application – there’ll be more on the conversion to the MVC framework in the next post), and ran up against several differences between the two during the process. First, a little history…

Lineage

Visual Studio .NET 2002 and 2003 both shipped with versions of ASP.NET projects that were of the Web Application variety: ASP.NET web apps were housed in Visual Studio projects similar to other project types (such as Windows Forms apps or class libraries). Upon each change, the project had to be rebuilt for the resulting web application to reflect changes. This was an unnatural model for web developers used to simple HTML or dynamic languages such as PHP and Perl (where you have a running site, make a change to some code, then simply refresh a page and have changes appear).

In Visual Studio 2005, a new default type of ASP.NET project called Web Sites was introduced. This, through behind the scenes magic, allowed ASP.NET web apps to be created that were simply loose directories with code and aspx files (there was no Visual Studio project file that everything had to be associated with) that could be loosely edited and would be compiled at first page hit and dynamically refreshed as changes were made to the running web site. This followed a seemingly more natural model for web development, but got further away from normal model of application development with Visual Studio. There was some backlash from the community, and an add-on was later released for VS 2005 that allowed developers to use the older Web Application project type.

When Visual Studio 2008 was released, it supported both the Web Site and Web Application models out of the box, developers being able to choose the style they preferred (although I doubt if this choice was a clear one for most developers).

Until recently, both of these project types used the ASP.NET WebForms model. However, with the recent 1.0 release of the ASP.NET MVC Framework, there is yet another way to do ASP.NET (although, basically, MVC projects are Web Application projects).

Differences

Why did I do the conversion? Because, for my specific case, the features of the Web Application model better suited my project than those of the Web Site model.

Here is a list of the major differences I came up against:

Web Applications can properly use conditional compilation constants (having them change based on build configurations).
References are more tightly controlled with Web Applications (like normal VS projects). With web sites, it's a little indirect. Assemblies can be added to the Bin folder where they're automatically referenced by the site, or they can be referenced in the web.config file (for assemblies stored globally on a computer in the GAC).
Since Web Application project files are proper MSBuild files, build actions can be done (pre- and post-build, etc).
With Web Applications, namespaces can be more properly managed. With Web Sites, all compiled class code (not code behind files directly paired with a page), must be stored in a special "App_Code" folder. So, following the convention of storing classes in folders corresponding to their namespaces, these would have to be under an "App_Code.Blah..." namespace).
Pages in web applications must have a "designer" file associated with them (e.g. “MyPage.aspx.designer.cs” for a C# web app). This is a partial class where the server controls in ASP.NET markup are declared in auto-generated code (all ASP server controls correspond to .NET objects). Here are Scott Guthrie's comments from his good walk-through (Rick Strahl also has a good description here and a re-visit to it here):
- “One difference between a VS 2005 Web Site Project and a VS 2005 Web Application Project is that the VS 2005 Web Site Project Model dynamically generates the tool-generated partial class half of a page, and does not persist it on disk. The VS 2005 Web Application Project model on the other-hand does save this partial class on disk within files that have a .designer.cs extension and compiles it using the in-memory VS compilers when a build occurs (one benefit of this is faster build times).“
A strongly-typed profile object is automatically generated with the Web Site project type, but requires a special add-in to Visual Studio when using web applications (available here) for some reason. Alternatively, you can not use the strongly typed object and get values dynamically at runtime with magic strings.
Web Site project "CodeFile" directives are "CodeBehind" in Web Application projects. These directives control how aspx pages are compiled. The CodeFile directive can still be used in Web Application projects, but are not compiled correctly. There’s a great tip in the comments on this post about possible confusion that can result when converting from a Web Site to Web Application project. Here's an excerpt from the comment:
- “The issue with CodeFile is that the code is compiled into its own (or directory level assembly) and so the type may not be available to another page unless the control is @Registered. If you dynamically load you pretty much can't reference the ASCX codebehind class. With WAP everything goes into a single assembly so you can reference the codebehind class from just about anywhere... The thing is that if you forget to set the proper format for WAP code the page/control will still work because ASP.NET internally doesn't care whether a project is stock or WAP so the page/control runs just fine with CodeFile.”
Web Applications have a strongly-typed app settings section in the web.config corresponding (and automatically updating with code-gen) to the Visual Studio Project settings.
When you compile a Web Application, it compiles the code behind files so that if a change is made to a running web app's code behind file it must be re-compiled (however, if you make a change to the aspx file of even a Web Application, then it still auto updates with an explicit re-compile – honestly, I'm confused about this part). With a Web Site, however, it will detect the change and re-compile no matter what.
You must recompile a Web Application almost each time you make changes to it. This sounds worse than it is. The build is generally fast for me, as Visual Studio does a good job of keeping track of what has already been built and what really needs to be rebuilt. Also, you can "build" a Web Site project type from within Visual Studio, but really this is only doing a dry run of the build to catch possible compilation errors in the manner that the ASP.NET runtime does when a Web Site is visited.

JavaScript Coding Guidelines for ASP.NET

2009-05-30T00:00:00+00:00

Recently for work as part of our sporadic push to create coding standards, I contributed by writing a draft of our JavaScript coding guidelines document. I've probably been the most active developer at work JavaScript and Ajax, and this combined with me having recently finished Douglas Crockford's excellent Javascript: The Good Parts book made me the most likely candidate to do so. Here is what I came up with.

The document is written from an ASP.NET developer's perspective, and since the direction for JavaScript that Microsoft is pushing now is a mix of its own ASP.NET Ajax library and jQuery, those are the libraries I focused on. Also, I didn't write much into strict coding standards per se (i.e. variables should be named and cased this and this way...), but instead focused on general guidance for the JavaScript language and some key best practices.

Here are several resources I used to come up with the standards (these are also in the references section at the end of the document):

JavaScript: The Good Parts, by Douglas Crockford.
A lecture related to the book (and which contains a large portion of the book's content for free) can be found here.
Code Conventions for the JavaScript Programming Language.
Block Statement.
With Statement Considered Harmful.
WestWind Ajax Toolkit.

Four Rules

2009-05-18T00:00:00+00:00

...for software project management. I heard these on a recent episode of .NET Rocks titled "Pat Hynds On Why Projects Fail" (skip to around the 13:00 minute mark - are the intros long enough on this show or what??).

Status - if you're not paranoid earlier, you're going to be unhappy later.
Never Assume - always make sure requirements are clear between you and the customer.
Don't Be Wishful - a project is not done until after the coding is done and lots of other things happen. When asked if a project is done, you should be able to definitively say "Yes" or "No" (without any "Yes... but...." responses). You must confirm with the customer that the project is done.
No Spec, No Estimate - many people want a fixed-bid price when they give a time and materials spec. Make sure that a detailed spec is given by the client. Include what will not be done.

Using Ruby and Rake with ASP.NET

2009-03-31T00:00:00+00:00

For awhile now at work, I've been using a loose collection of PowerShell scripts and manual steps to handle deployment of ASP.NET sites and associated SQL Server databases. I recently switched to using a Rake build script to not only automate deployment, but also to help in a few other tasks such as re-building the development database, and synchronizing the staging database with the production db.

Briefly, Rake is a Ruby version of Make, and is a framework for build scripts written in Ruby. Since a Rakefile (the main build file you work with) uses a plain Ruby syntax (albeit one that uses a few Rake conventions), it's very easy to get up to speed with if you know a little Ruby, and even if you don't, Ruby's syntax has a reputation for being fairly straightforward anyway. Rake also has many built-in library functions for handling builds and uses a dependency-based computational model. For example, I can specify that task A depends on task B and be sure that task B is always called before task A:

task :a => :b do
     puts "World" 
end 
task :b do
    puts "Hello " 
end

Rake is normally used in the Ruby world (such as for working with Ruby on Rails sites), but is generic enough to be usable with other setups such as .NET. Why did I switch to Rake? I tried, I really tried to like and use PowerShell. PowerShell is Microsoft's newer command line environment and scripting language. It's a definite improvement over the normal Windows command prompt, as it offers a greatly enhanced command set and direct interoperability with the .NET framework. PowerShell, as well as a light development environment for PowerShell scripts, are tentatively set to be included in Windows 7.

However, I was put off by PowerShell's syntax, which uses a blend of curly braces, mixed case keywords, dollar signs, and unconventional operators e.g. the less than or equal to operator in:

for ( $i = 7; $i -le 84; $i+=7 ) { $i }

Also, since PowerShell is relatively new, there seems to be poor support for it. Editing support is not included with Visual Studio and it's not natively supported (with syntax highlighting, etc) in common free text editors such as Notepad++. Also, while you can write individual PowerShell scripts and tie them together yourself, there's not a robust framework such as Rake made specifically for builds (although there is the psake upstart). Ruby and Rake, on the other hand, are much more mature and established.

To deploy, the central steps that my Rakefile does are:

Take in an argument specifying whether to target the staging or production server.
Deploy the database
1. If deploying to the staging server, synchronize the schema from the production server (using RedGate's excellent schema comparison and synchronization tool).
2. If deploying to the staging server, synchronize the data from the production server (using another RedGate tool). This and the step before insures that the staging server has a db that's a mirror of production.
3. Run migrations to get the db up to the latest version.
Deploy the site
1. Compile the Visual Studio web site solution.
2. Copy the site files to the staging or production server (using the free Robycopy tool).

I should run the unit tests as a part of the deployment task, but since the project is fairly small, I've been running them independently before deploying. I have a task set up for the unit tests, so I could fairly easily plug this in later.

There's a task that recreates the test database on a developer's local system, and it actually still calls out to an older PowerShell script that I haven't bothered converting yet (but having Rake and PowerShell interact is fairly seamless at the moment).

Here's my Rakefile. The steps outlined above should be recognizable in the script, but please leave a comment if you have a question about anything in particular in it or any suggestions as well.

Upgrading My Home Theater PC

2009-02-12T00:00:00+00:00

I recently turned on the TV to see my home theater PC frozen and a nasty buzzing sound coming from the speakers. Long story short, eventually I figured that my motherboard had gone bad (and not surprisingly too, as the system was my old main computer that I built almost 6 years ago and had an AMD Athlon XP single-core processor, etc). I can’t say I wasn’t expecting this sometime.

The skeleton of the system is still fairly modern, and the case looks good in the living room alongside the receiver, so I figured I could try to replace the guts. Since this computer is mainly used for playing video from a shared media folder or streamed from the web, I didn't need the most up-to-date hardware, and I wanted to find a motherboard with a lot of capabilities onboard that was fairly inexpensive. Additionally, I wanted the system to be quiet and low-power, as the old system, while not terribly annoying, was a little louder than most electronics you find in a living room.

Luckily for me, Coding Horror had a great piece on building something very similar to what I wanted that was posted last April. The hardware I went with was slightly updated from what Jeff used, but essentially the same:

CPU	AMD Athlon X2 4850e 2.5GHz Dual Core (45w)	$60
Motherboard	GIGABYTE GA-MA78GPM-DS2H	$100
RAM	2 x 1 GB Mushkin DDR2 800 Mhz EM2-6400	$10
Blu-ray Drive	LG 6X Blu-ray DVD±R DVD Burner	$115

* I used my existing parts for the remainder.

The specs and reviews of the motherboard surprised me; I read it was capable of decoding Blu-ray video very smoothly with its miniscule (by today’s standards) 128 MB of on-board video memory. This being said, and even though bare Blu-ray drives are numerous, they’ve come down in price, and Netflix has a growing catalog of Blu-ray discs, I still think getting a Blu-ray drive may have been unnecessary, but I caved in to the appeal of the bright and shiny.

Ports!

Also, the processor is a fairly powerful dual-core one yet only uses 45W of power. Given this, the stock heat-sink and fan that’s included with the processor is supposed to suffice while being fairly quiet. The CPU’s fan speeds up as the processor temperature rises, and in my testing I never heard it kick into a higher gear.

Putting it all together in the Antec HTPC case

Resolution

The biggest problem I ran into was getting the proper resolution driven to the TV. The TV (a 46” Sony LCD), is capable of displaying up to 1920x1080 (1080p), and my old system would show this resolution in Windows for me to select. For some reason, the new system and video card would only let me select up to 1600x1200 using a VGA cable, and, after experimenting with different drivers, an HDMI cable (which would display the desired resolution but looked fuzzy), and ATI’s Catalyst display software, I eventually settled on using PowerStrip to force 1920x1080 through the VGA cable. The results are good, and the picture is comparable in sharpness to a computer monitor.

Testing

I tested playing several HD 1080p sample videos with good results. In informal testing, overall CPU utilization stayed around 40-50% when playing full screen 1920x1080 video.

I added Blu-ray access to my Netflix account (for an additional $1), and got my first Blu-ray disc in today (Burn After Reading). I needed to use PowerDVD to play the film (included with the drive), but the video was beautifully smooth.

The finished setup (receiver on the left, PC on the right)

Windows 7 and Windows Media Center

I also did all of this testing using Windows 7 Beta 64-bit edition, and I didn’t experience any major stumbling blocks. Where applicable, I chose the Vista 64 version of software, and only encountered a few glitches (such as preferences not taking effect immediately or general UI bugs).

Windows 7 Beta Ultimate edition includes Windows Media Center, and I tested using it to access shared video on my home network and some internet TV “channels” that are set up by default in the app, but since I don’t have cable TV and and don’t use Windows Media Center as a Tivo, I could manage (as I’ve been doing), by picking shared network video files from Windows explorer or by watching content on ABC.com, Hulu, etc.

Boxee

I also tried the alpha version of Boxee for Windows, but the display was distorted badly when the program started and it was unusable (driver? Windows 7 incompatibility?). I’ll have to see if there’s a workaround for this and look out for a beta version of it.

Back To School

2009-01-20T00:00:00+00:00

I was a little put off by the last graduate class on formal methods that I took a little over a year ago. I got frustrated, and decided to quit with the idea that I would pursue a focused, independent course of study relevant to my career (meaning I would experiment with and study new technologies in my spare time). I know what’s better for me than the out of touch instructors at a university, right?

Last week, I started a class at Auburn again (towards a Master of Software Engineering degree). A couple reasons come to mind:

I don’t have the discipline to direct myself on any outside of work study that’s remotely close to the level of work that is required of you from a university course. It’s far too easy for me to just spend an hour going through my RSS reader on development blogs and call that learning than it is for me to struggle with working on something in depth in my spare time. I hope I can get better at this someday.
I’m over half-way through my master’s degree course requirements, and it would be nice to complete it.
Although I don’t get a feeling that master’s degrees are a necessity for even advanced software engineering positions, I still think the degree will help me in my career.
Work can be monotonous, and it would be good to get my neurons firing in different ways.

You can make up seemingly reasonable excuses about why you shouldn't do something challenging, but even if that something is not 100% on target or good for you, if it's in some part beneficial, then when you look back at it you're probably not going to regret it.

My current class is on web development using Java Server Pages. While JSP is by far not the hippest buzzword in the web development world, I’m still excited about learning something different.

iPhone Duel - Evernote Vs Notes

2008-11-19T00:00:00+00:00

About a week after switching from the stock iPhone Notes app to Evernote, I'm moving back to Notes.

The feature list for Evernote is seemingly impressive. You can enter notes on their site, from a Windows or Mac desktop application, from email, or from a Windows Mobile or iPhone application. Content is stored on Evernote's servers and synchronized with all your devices. As the intro video on their site shows, you can highlight content on web pages and use the desktop client to easily send something to your Evernote account. Using the iPhone client, I was given the option of creating notes by entering text, taking a picture with the phone's camera, or even by capturing a voice message.

For me, however, the way I mainly want to use it is to simply jot down something fairly short when an idea hits me so that I can later go through my notes and process it. I can do the same with the phone's built-in camera and photo management app, and I already use Jott for capturing and transcribing voice notes.

Still, I decided to try something more advanced than the stock notes app and give Evernote a whirl.

I can really understand this Daring Fireball post on iPhone-Likeness now (scroll down to where the Notes app is discussed). It's as if the Evernote iPhone app is trying to be too clever, and in doing so, fails at following iPhone UI conventions and loses the simplicity that made using the Notes app useful. There were just too many fields and too many tabs to fidget with, and I felt the app was getting in the way of writing my thoughts down. The Notes app, by comparison, is beautifully designed and fun to work with (important for an app that you're going to be using on a regular basis).

Also, Evernote's syncing service was ok, but there was misleading lag at times (I lost a couple of notes when I accidentally shut down the app before it had a chance to save and sync notes, and unsynchronized content would appear momentarily before changing), and I like the simple mental model of having things be in one place that I can depend on. And, after going through years of duplicated or missing contacts and calendar events using Outlook, Exchange, and even a trial of MobileMe, I'm still nervous about syncing.

For sure there are some perceived cons to Notes: there's no cut and paste (the same for all iPhone apps), notes can only be sorted one way, the "loading" screen is misleading and annoying, and there's no dedicated way of syncing notes to your desktop. But actually, these haven't bothered me and, for the way I use it, there are adequate workarounds. It's hard to believe, but I honestly don't miss having cut and paste, the sorting I just deal with, and if I have a long enough note that I want to get out of the phone, I can just email it to myself (but maybe these are symptoms of Apple Stockholm syndrome).

But that's probably enough time devoted to a little note-taking app for now...

A Problem Unit Testing with .NET Private Accessors

2008-10-11T00:00:00+00:00

Recently I ran into a problem using .NET accessor methods to unit test private methods. I was able to resolve the problem, but in doing so ended up abandoning accessor methods in favor of a simpler approach (using reflection).

But should you even test private methods?

It's a nuanced question. On one hand, it seems reasonable to break a class into small, purposeful private methods (exposing the main points of the class publicly) but still test the smallest possible chunks of functionality by testing those private methods in addition to the public ones. On the other, testing only public methods should exercise those private methods enough, and testing private methods can make your test code more brittle to change. There's a good table here with more arguing points.

For my purposes, I decided that I should.

What's a private accessor method?

But how do you get at privates? The default .NET unit test suite (MSTest) provides a seemingly handy facility within Visual Studio to easily do this by generating so called "private accessors".

Just right click on a private method in your code like so

then click "Create Private Accessor" and point it to a project containing your test code. and the tool magically provides proxy types (with the suffix "_Accessor") that expose these private methods publicly and that you can use from within your unit tests to access these private members like this:

 var myObject = new MyClass_Accessor();
 var result = myObject.PrivateMethod();

How useful, right?

A problem

I ran into trouble when I had a private method that returned a generic list of private classes. When I generated an accessor for the method, an accessor for the private class was also generated so that the accessor method actually returned a list of "MyPrivateClass_Accessor" types instead of "MyPrivateClass" types.

This generated code actually gives an error, and seems to be a bug in Visual Studio 2008. MyPrivateClass_Accessor derives from MyPrivateClass, and while you can cast a derived class to its base class, in .NET you can't cast a list of derived classes to a list of its base classes (as I assume it's doing internally in the generated code).

I suppose they're working to fix this.

A simpler alternative

Using a bit of code (good samples are available here and here) that uses reflection and extension methods, you can still fairly easily test these methods like so:

 var myObject = new MyClass();
 var result = (List<MyPrivateClass>) myObject.CallMethod("PrivateMethod");

Sure, there's extra casting work and you have to use nasty string literals for the method names, but this is test code after all, and if it breaks you should know quickly from a regular test run.

A lesson

One of the hazards, it seems, working with Microsoft tools is the strong focus on tooling itself. This can sometimes get in the way of more elegant solutions based on simpler principles.

Not that all or most of the tools are bad (a lot of them I feel make me more productive), but it's a glamorous trap that you should be aware of.

DevLink Conference - Day 2 Notes

2008-10-07T00:00:00+00:00

The session that made the biggest impression on me from Day 2 was an informal, impromptu talk that was arranged during lunch to demonstrate Test Driven Development (TDD). The premise was that several presenters or prominent developers from the conference were to start a simple, greenfield sample project and use TDD to write code from requirements.

The results were striking (and not in a good way).

The leaders took suggestions from the audience about what kind of app should be developed and simple requirements were gathered. As several volunteer developers took turns typing, there were arguments over difficulties with the environment, over naming guidelines, over Visual Studio add-ins, over testing frameworks, and over code templates. Some of the typists experienced with TDD jumped ahead of the general audience, writing code that they were accustomed to writing without properly explaining themselves. There were arguments from the audience that some of the code was being written without first writing tests and therefore was in violation of TDD.

All in all, it was eye opening for me (having little experience with Test Driven Development) to see several proponents of TDD fall apart in this simple demonstration.

Of course it was not a properly prepared talk. It did not have a focused vision, and there was a lot of informal distracting chatter between the audience and the group of people directing the talk. However, it was still discouraging to be denied the chance of seeing a cohesive demonstration of a practice I've heard quite a lot about.

Day 2

Web Testing

McWherther

TestDriven.Net
MbUnit row tests (like data driven tests in MSTest).
The very precise .NET Stopwatch class used to performance test (dataset loading, etc).
Test for 0, 1... N. If things work with 0 and 1, and some N, then they should work for other values (but watch out for large values).
May need to run integration, web, slower tests at night because you want tests to run very quickly.
Even if your unit tests are hitting the db, that's still ok and at least you're doing testing.
Don't show me pictures of and talk about your dog - I don't care.
Very expensive. Visual Studio Team System (AKA "Left Kidney") Edition is $5000 for single developer.
Web tests, recorder tool
Load testing. Mercury tool, other load testing tools?
Test 56k connections for time outs, don't assume everyone has broadband.
Fiddler. Using to inspect payloads.
FireBug has some performance measuring tools, but it's not as comprehensive as Fiddler.
Watin (Ruby' Watir for .Net).
Watin test recorder. Updates fixed Ajax issues.
Setting up Cassini for testing.
Wcat (in resource kit for iis 6).
Go command line. It'll be cheaper and more powerful.
Profiling. Ants profiler.
Web testing, load testing, profiling. Understanding these things seems to be concentrated on more maybe, but there could even be more sessions done with it.
DotTrace.
It's good hearing about the various tools, but doesn't seem to be enough real-world experience behind it.
TDD by example, Kent Beck
Pragmatic Unit Test with C# and NUnit
Behavior Driven Development talk: Tinyurl.com/Mx4p2
They keep saying to sneak practices into organizations, as if managers will suddenly notice that code is better and ask "Wow, things are great! What did you change?".
I'm getting fatigue from youthful enthusiasm.
SiteWalker.

Open Spaces - SOA

Kickoff, how to get enterprise to adopt SOA from existing communications code in place
Flex doesn't work well with SOAP, so Rest is a better fit?
Using SOA to tie disparite systems together.
What is SOA is a bad quesstion. More appropriately, what do you want from it. What does your company want from it.
It can be soap, rest, remoting. Whatever can work.
It's message passing. To create a big interface that will bridge large #s of gaps is not good to focus on.
Soa is very ambiguous I'm feeling. It's people dealing with interconnected systems.
It's a buzzword that non-technical people in companies can latch onto.
Woa - web oriented arch
Cloud computing sounds great, but we're still probably far away from having companies trust it.
Excel being able to pull data is impressive to business people. They could get this ,it's hard to grasp sharePoint, bam, sitefinity.
It's better to show than to tell about.
Bof
"I ducking hate sharepoint"
You can't put Esb in a box
Something that maintains a directory of services is valuable
Uddi
Couple of consultants expressing experience integrating services within companies.
Oslo? Does uddi fall away with it?
Msft has a roadmap, kinda private, and if they stop talking about something then maybe it's going away.
Thomas Erl books. Great resource, big books, but a quick read.
New patterns. Maybe driven by ego. But the value of a pattern is that it capitalizes on existing knowledge and experiences.
Scott Bellware is becoming House MD

Soa in a word
- Reusability? been promised before
- Reusability within the enterprise
- Interop maybe?
- Integration?
- Loosely coupled integration?
We're not doing anything new, you could still just pass a flat file around, but this is a more open way where you maybe don't have to understand an opaque util that processes that flat file.
Noticed that laptops, slides didn't look near as refined and beautiful.
Soa has a steeper learning curve because you need to know about several pieces.
This is going to be a factor for me layer (integration), so should increase priority of Astoria, restful stuff ... Also, design patterns.
It's important to separate components where they can be service oriented.
With speaking and writing, even general conversation, explaining ideas elegantly is the key skill. I need to be able to think clearly, and restrain myself. Can practice this is writing. Keep myself honest by proving my points. I don't think quickly though, so slow down to go fast.
Open spaces help to flesh out ideas from various people. The speaker has to be very, very good to attend a strictly face-forward presentation.

Lunch - TDD demo

Start using TDD syntax for tests. Stop always calling things BlahTest.
Take out template code and comments (it's noise).
Lunch session on TDD was full. Seems to be interest in testing and tdd. Even though we're using statixally types languages, we still need tests (and it's a tool to develop business requirements)
Try doing TDD on a refactoring or new feature. Let the design drive me.
Was great to see speakers being engaged. Lots of stumbling, arguments over tooling. Good to see them in practice.
Are getters and setters evil?
The zealots have an aversion to MSTest.
Class WhenAllPeopleAreFed
Method Are_there_people_to_feed, for example.
It take discipline to take small steps and not skipping things.
Michael Feathers book was highly recommended.

Service Design

Rayburn

Best is the enemy of good. Good enough is by def good enough.
Soa is nothing but evolution.
Quotes a study that documents the most popular real world benefit of implementing SOA is agility.
YAGNI
You can't get it right.
WF and WCF go together well and Msft will continue to support them. It's a good idea to invest learning in these.
WSDL plus address
Are open spaces for people who like to talk. Is it more ego driven?
It's not RESTful
How do WCF and REST work together
Use XML namespaces. Many people neglect this.
Service methods are not code. Take one parameter that has all parameters bundle, then can add optional parameters.
What doesn't matter? New operations and new properties on existing types.
Orgs that are just starting to use or create services shouldn't need an ESB. Don't get treatment until you feel pain.
How will Astoria change this stuff? I haven't looked at it a lot, but I don't see this as the major problem.
Some asks, what if I need to return a million rows? If it's possible and you have enough bandwidth and power, do it. Or consider using an async technique, such as a return address (if doing programmatically) or provide an FTP address, username, and pass that a file will be present at.
Oslo.

Closing Keynote

Joe Stagner

Today's problems can't be solved with the same thinking that got us into those problems. Einstein.
The web is completely broken? No!!
Consumer IP traffic should surpass enterprise for the first time in 2008.
Last year, my parents did most of their Christmas shopping online.
Data centers are the fastest growing energy segment in the US.
This is bullshit. He's just talking with his friends in the audience and making stupid jokes. Guy next to me just said, this is awesome, which makes me depressed about the audience.
Develop habit of using time better. Pretending like I have less time and try to effectively work 4 days. Focus hardcore. Also, prepare this year for when I have to work in a real environment. Stricter.
Msft is the biggest SW company. 78k employees.
Question: What is Msft development division doing to reduce complexity and make adopting new techs that are rapidly being produced more palatable?
Answer: You don't have to do it, and Mvc
Although I don't think his talk was particularly innovative or inspirational, his attitude seems to generally be in the right place with regards to embracing future developments.
Makes a joke to not use UpdatePanel. They've apparently had bad experiences with it scaling.
When OSS for Msft? "Honestly, I think a lot of people don't get OSS in Msft."
A lot of people don't realize that Msft cannot accept legally contributions from OSS contributors. They can't take the risk. Is the risk perceived? Will Msft ever get over this? Not likely.

DevLink Conference - Day 1 Notes

2008-10-03T00:00:00+00:00

Partly because I'm lazy and partly because I came away from the conference disillusioned and disheartened, I haven't posted my notes about DevLink (a .Net conference I went to several weeks back near Nashville, TN) like I did awhile back for the local Ruby conference (the Ruby Hoedown). I know you've been holding your breath for my insightful impressions, so I'm sorry for the delay.

Recently I've toyed with the idea of stepping away from developing in .NET and with Microsoft tools. Sure, there's a lot of good stuff they provide for developers, but the monopoly thing and their clunky reputation starts to grind on you after awhile. However, I'm not sure if that's realistic, and maybe I'm too entrenched. Or maybe not. Ehhh.

Nevertheless, it's nice to be in a development community that you can look up to and that gives you a good feeling inside.

Did I get a good feeling going to DevLink? Certainly not. It was more of a icky, awkward feeling - like walking in on your grandparents making love.

Why? Well it wasn't all bad. There were some good presenters that gave me interesting perspectives. It's just that there were a lot of uninspiring talks too that made me question if I'm in the right place with my career.

But, I'm just an inexperienced douche bag and it was just one conference in one particular place.

Day 1

The highlights of Day 1 were the disappointing keynote that caused a flurry of negative comments on Twitter and several people to abandon it. On a more positive note, there was a well-delivered and knowledgeable talk by .Net Rocks host Richard Campbell about scaling ASP.NET and and a look at a functional language that's being pimped a lot lately by Redmond.

Keynote: Stranger in a Strange Land

Rex Black

[The big deal about this presentation was the twitter feedback that was present. People voiced their displeasure. Saw which people were participating on Twitter]
What is outsourcing? Outsource developing and/or test. To even multiple companies.
Immediately I’m struck by how dense the presentation slides are. Shouldn’t have this much information on slides? Can’t pay attention to what he’s saying (there’s even an animated gif in his slide header!).
How did outsourcing arise? The bubble, people sought to reduce costs. Also to take advantage of resources present in a different geographical region. Labor and cost savings. Inability to handle in-house.
Unspoken reasons: peer-pressure (everyone’s doing it), and dissatisfaction with in-house business.
How to deal with it?
Chaos does not scale!
Outsourcing greatly increases complexity.
Like any complex endeavor, careful planning, organization, and closely managed execution are key.
Lifecycle / process choices? I’m agnostic. Just have one, and stick to it (but still think about it).
Take quality beyond CMM
CMM can be used as a marketing device
It does not say much about testing (even a CMM Level 5 org can score low in test maturity!).
Plan for and manage project risks. Working with dev teams in certain regions can be influenced by politics (wars).
Being there
Do you trust people you’ve never met?
Do you really hear the whole message when you don’t talk face to face?
Conference calls and email work for routine communication
But, sometimes only a visit will do
Need to adapt to the cultures
Conclusions: outsourcing is here to stay. It might be cheaper, but it’s harder and more complex (and thus riskier).

Gathering Business Requirements

Tim Peek

Many projects don’t take the time to define requirements enough.
Requirements: fill in the details of scope.
Very important to define what details are not part of scope.
When a new requirement emerges, check to see if it’s in the scope.
There are non-functional requirements such as how it looks, aesthetics.
There are also false requirements such as vague requirements, opinions, technology decisions (“Let’s use an Oracle database on this project”, “This application needs to run on the intranet.” – why??)
Techniques
- Use cases. “A user does an action and something happens”.
- Prototypes
- Requirements development. I ask questions, you talk, I listen. I analyze, ask follow-up questions. I document, ask follow-up questions, we all agree. Can take months, years. Is very hard work.
[He emphasized being very stringent and thorough]
[Someone asks how you can estimate requirements gathering though, if it can take so much time. His answer was "come see my other talk on so and so".]
Techniques for elicitation.
- One on one interviews
- Group interviews
- Questionnaires
- Prototypes
- Follow people
Validation (make sure requirements from Elicitation are accurate)
Consolidate the requirements.
- Put similar requirements together.
- Determine if you have a complete picture or if gaps are present.
- Eliminate requirements that are out of scope.
Specification
- Prioritize
- Traceability
- Testability
[For me, sounds good in theory, but it just seems nebulous. I would need to be in an environment that values good requirements gathering and physically implements it and has a process to get a feel for what he’s describing. I just can’t relate well enough. It seems too hard to get it right.]
[Still too much text in slides.]
Make signoff a formal process.
Someone asked how to test WinForms or WPF apps at the moment. These are more opaque than HTML testing. Do WinForms and WPF represent inferior ways to dev apps?

Scaling ASP.NET Web Apps

Richard Campbell

Scaling means that the page behaves the same as concurrent users increase. The page is consistent as the number of users scale. We can even sacrifice the performance of a single page to improve consistency for users.
IE 7 does 2 requests at same time. FF does 2. http spec specifies 2. IE 8 will do about 6.
Web browser makes a request, then gives back data (TTFB), but the page still has to request CSS, JS, and images (2 simultaneously).
Websiteoptimization.com analyzer
Latency matters
Decomposing the problem. Server compute time, client compute tiem, bandwidth, concurrent connections, latency (http ping time).
Performance spreadsheet and formula.
Make sure you’re working on the right problem!
Consolidating JS and CSS cuts down on round trips.
In a perfect world, we should have 4 files: 1 for html, 1 JS, 1 for CSS, and 1 image (using CSS sprites).
Server compute time is, in the end, the thing that doesn’t scale and is genuinely a problem (but make sure you’re working on the right problem and not choking on something else).
Set cache refresh? Don’t do too often (or else you loose the benefit), but maybe once a day.
Everyone has too much content on slides!! No presentation zen that I saw.
ASP.NET’s signature problem is memory consumption.
ASP.NET comes under load, memory runs out, GC kicks in, asp.net tells IIS to hold all requests, IIS stacks up requests.
Everyone wants 100% of everything (uptime, accuracy, scalablity). But you really need to do what’s important to the business (e.g. For a bank, it’s much better to do nothing, than to do a transaction incorrectly).
Dell 1950 = 250 req/sec (untuned asp app)
It’s important to have communication between development and IT so each one is aware of the other’s world and is respectful.
Lots of people are saying they can do a better garabage collection algorithm, but they have yet to prove it. There are very smart people working on this at Msft. It’s easy to criticize decisions made in 2000, 8 years later.
Tech politics. When a business is successful, you tend to get cowboys who say they they wan to improve things (aka circumvent the procedure).
It’s hard to do good, accurate load testing.
Summary
- Focus on actual user perf problems. What is reality.
- Start with low hanging fruit.
- Use methodical perf improvement.
- At large scale the network is the computer.

Open Space - Distributed Source Control Management

Is Svn good enough?
What's the compelling reason to move to Git? I just got people off SourceSafe to Svn, and now I have to explain DSCM and branching?
A big reason is private commits.
Git is great for feature work.
Why suddenly have so many people moved to Git? GitHub. The fact that people have moved to RoR means that they're alternative thinkers, so they're already receptive to Git.
Bazaar. Friendlier to Windows? Bazaar, Mercurial and Git
You can start using Git by using it just like Svn, then slowly introducing branches.
Workflows detailed on the Bazaar and Mercurial site.
Will eventually Msft get there? You can already do TFS shelves (even though they reside on the server).
If you are in an environment that's not receptive to these changes, then you have 2 choices (change your environment or live with it).
There seems to be a real danger of people being afraid to commit because they're committing publicly.
Is Git a cargo cult?

F#

Ted Neward and Amanda Laucher

Don Syme did it. Also did generics. Was made syntax compatible with OCaml.
Official post by Somar saying F# was going to be productized.
Very sparse designer support for it.
Might be useful to learn F# because it's like Erlang?
Strongly typed, statically-types, but type inferenced.
"Full benefits of C# or Java without all the high ceremony."
Room is packed - lots of people interested in functional programming maybe.
SETI at home was one of the first large scale exercises in functional computing.
Functional unit testing is isolated, simpler.
Has both a compiler and interpreter.
The "let" F# construct
This is a silly talk, unfocused, too much quasi-entertainment and fluff.
People seem very dependent on intellisense, or maybe this is just background compilation they're relying on.
Very funky syntax.
let myfunction x y = (x * x) + y
Where x and y are parameters to the function.
The idea of tuples. They combine values into packets. Think of them as a row from a table. Where a row can have columns with different types.
Because it has to compile to IL, is it a leaky abstraction?
One of the dangers of an inferred language is that it can be inferred incorrectly.
There's the equal operator, then there's the <- destructive update operator.
' operator
This talk is masturbatory.
The plan is F# will set on top of Parallel LINQ stuff which will interface with VM and OS to scale across processors.
Was mind blowing to see this bizarre syntax.
Relation to "yield" keyword in C# (amount other things like delegates and lambdas).

Ruby Hoedown Day 2 Notes

2008-08-14T00:00:00+00:00

Here are the notes I took from day 2 of the Ruby Hoedown conference:

Calling Your Code: Gluing Phone Calls to Ruby

Troy Davis

[Troy spoke on how you can use Ruby to write voice applications with phone calls.]
Asterisk - open source PBX & telephony platform
Adhearsion - Ruby framework that sits on top of Asterisk.
Typical flow: PSTN -> SIP -> Asterisk -> AGI request (Asterisk Gateway Interface) -> Accept call with Adhearsion -> Run call flow
Instead of administering the PBX manually, can use Asterisk to administer it in Ruby.
There are various TTS (text to speech) engines (some much better than others).
[Troy walked through a few live demos using mobile phone. There were problems, but overall it's impressive.]
Example apps:
- Yelpvox - call a #, then get surrounding restaurant information
- SendSign - real estate flyer information service. If flyer box is empty, call the provided # to get information. Can then go to SendSign.com, enter in the phone # that you called from, and see the homes that you looked for.
- Frucall - do online comparison shopping by calling a number and entering in a barcode of a product while you're in the store.
What you need to get started:
- Asterisk or FreeSwitch (available in virtual machine format)
- Text to speech engine
- SIP provider
- DIDs (phone numbers)

Ruleby: The Rule Engine for Ruby

Joe Kutner

We're used to imperative programming.
It's nice, but the programmer should, ideally, understand all of the entire program (which is often impossible with imperative programming).
Alternative: rules engines, rules-based paradigm
Write rules declaritively, but don't specify how code runs.
Ruleby uses a Ruby domain specific language (DSL) to specify rules
Uses the Rete algorithm. Good, but exchanges memory for speed (be aware of this).

flog << Test.new

Rick Bradley

Flog - continuous integration for code complexity.
Evolution of a programmer:
1. Lamer
2. Haxor
3. Cowboy
4. Embryo (start to notice testing)
5. Webelo
6. Poseur (half-heartedly do testing)
7. Human
8. Apprentice
9. Journeyman
Test driving code in a greenfield scenario is much more different than testing existing code.
Technique: don't change existing code without test covereage.
Legacy code = code without tests (Michael Feather's book Working with Legacy Code)
[Comments from the audience: This may just unnecessarily confuse the terms "untested code" and "legacy code". What if old code is well tested? Rails 1.0 is well tested, but is still legacy code.]
So, for an existing app without tests, where do you start? Very basically, on the outside, pealing away layers.

Archaeopteryx: A Ruby Midi Generator

Giles Bowkett

[Presentation starts with live demo of electronic music driven by a Ruby script and edited live in a text editor to change the music's style.]
I'm a former DJ.
A lot of DJs are using laptops now, which should in theory, make computer geeks popular at parties.
Venture capitalism is like the patronage system for artists and is stifling.
Programmers are often distracted by shiny toys.
Be profitable from the start by being small and cheap.
I'm trying to create my own niche market using Archaeopteryx and MIDI controllers for DJ work.
This is your brain on music book.
I'm going to test my program by running it for 7 days at Burning Man.
Good business is the best art. -Warhol
[For sure it's an entertaining presentation, but there are too many rat holes and it comes off to me as scatter-brained.]

Lightning Talk: What Can We Learn?

Yahuda Katz

Ruby can be used in the "enterprise".
While I don't want to use Rhino or Hibernate, we can learn a lot from Java's experiences.
Whereas Ralis embraces convention whole-heartedly, Merb has good defaults set on a highly configurable backend.

Keynote: Ghosts of Ruby

David Black

The Ruby language did, in fact, exist before Rails.
Presently, version 1.8.6 has the highest adoption.
1.8.7 is a strange, present/future 1.8.6 with backported 1.9 features.
1.9.0 is not in widespread use.
1.9 features
- New Enumerable methods. There are lots.
- BasicObject - knows nothing, above Kernel in the class heirarchy.
- New lambda literal constructor
  - -> () { }
  - A way to have blocks with method argument paramter semantics.
  - Ex: -> (a, b=1) { b } is like lambda { |a, b=1| } except that this is kinda invalid because how can you distinguish b=1 from the bitwise or operator.
[Points out several things he finds personally peculiary in 1.9]

Ruby Hoedown Day 1 Notes

2008-08-13T00:00:00+00:00

Here are the notes that I took from day 1 of the Ruby Hoedown conference. I hope I didn't misquote anyone too badly, but these are the points that stuck out to me the most.

Ruby: A Year of Innovation

Jason Seifer and Gregg Pollack

Above: Jason as "DJ Ango" (in reference to the Django framework)

This talk is not 100% Rails (it's a Ruby conference, after all)
We'll be talking about several cool Ruby libraries:
Rack
- Framework A --> Rack --> Web application server
- Serves as an adapter between numerous Ruby frameworks and web servers.
Phusion Passenger
- I needed a blog for my user group.
- I chose TextDrive for hoster, and it was painful.
- Switched to DreamHost, but it turned out to be HellHost.
- Was too slow, needed something more powerful, but wait - it's just a freakin' blog!
- Phusion Passenger came out (and it's compatible with Rack!) so you can use it with any framework (not just Rails).
Github
- What do you get when you mix SourceForge with Facebook? [Some people from the audience yell] GitHub! [I think one of said people was Chris Wanstrath, a co-creator of GitHub]
- Features include Hardcore Forking Action!
- GitHub is more than a year old, but it's adoption has taken off in the past year.
- Many well-known projects, such as Rails itself, are now hosted there.
- [I've been hearing so much about Git, it reminds me that I really, really need to get out of my SourceSafe and Subversion habits and try a distributed version control system like Git or Mercurial]
Ruby EventMachine
- Event processing library.
- Like Twisted for Python, Apache Mina for Java, and Poe for Perl
- You can do this stuff with threads, but its slow (and potentially deadlock dangerous).
- Evented Mongrel took EventMachine and applied it to Mongrel, but there's a catch - EventMachine is best for fast requests that aren't long-running.
- Recently built into Merb.
- Use like so: deferred_requests["/uploads", "/long_process"]
- Other alternatives: Thin, Ebb, and Starling.
Redmine
- For awhile, Trac was the only good project management application.
- Redmine is a project management app written in Rails.
Pool Party
- Cloud EC2 computing made easy.
make_resourceful
- Scaffolds make it easy to generate data access code, but much of the code is duplicated.
- Helps to eliminate duplicate code from scaffolding.
Various screencast series have launched
- Railscasts
- Peepcode
- Pragmatic Programmers screencasts
- And soon.... EnvyCasts!
Hpricot
- doc = Hpricot.open("www.website.com") and then work on the doc object.
Juggernaut
- Server push with Rails (uses Flash)
Praun
- Ruby PDF generation
Capistrano
- Deployments made easy
Ruby Virtual Machines
- JRuby for the Java VM
- IronRuby for .Net
Skynet
- Clones Google's map reduce functionality
DataFabric
- Allows DB sharding for scalability
merb
- Everything that Rails isn't
- Lightweight, JavaScript library agnostic, DB access agnostic, but still with a strong set of defaults
Sinatra
- Very lightweight web app development.
- Hello world web app in Sinatra:
  require "sinatra"
  get "/" do
  "Hello world
  end

The Future is Now: Leveraging the Cloud with Ruby

Robery Dempsey

I'm angry because people say Rails can't scale.
What is scalability? The ability to expand gracefully under load.
What do you need?
- Servers
- Storage
- Access to other utilities
- Not have to buy everything up front.
- Can you do that with Ruby? Of course! ... that's the cloud
Other ways other than using cloud computing.
- High availability cluster. A set of servers that constantly ping each other. If one goes down, then another takes over.
- Load balancing cluster. A routing mechanism directs traffic to various servers based on load.
- Grid. A loosely coupled group of servers
A Gartner study says that by 2011, startup companies will start buying a significant portion of their infrastructure on demand.
Amazon EC2. Neat, but you need to build reliability in yourself. I've had EC2 instances vaporized upon restart. If this is the only copy of your server, you're screwed.
There are alternatives to manual Amazon EC2:
- Morph
  - Uses EC2, but has a custom, rigid deployment mechanism.
  - Doesn't even allow file-level access.
- RightScale
  - Lots of configuration options.
  - $2,500 setup, $500/month plus Amazon fees.
- Heroku
  - Free (for now!)
  - Later, will be charged based on... units of work kinda... (it's sketchy)
  - Everything is done in the browser
  - Automatic scaling
  - Work locally, then deploy
- PoolParty
  - Uses an Ubuntu EC2 AMI (Amazon machine image)
  - Not production ready
- Scalr
- ElasticRails
So, if you go straight with EC2 yourself, a standard EC2 deployment will cost $432 for a good-sized app.
And you have to do a lot of configuration yourself.
His suggestion of 3rd party tools (from cheapest to most expensive and scalable):
1. Morph
2. Scalr
3. RightScale
There are Ruby libraries to interact with various Amazon services such EC2, S3, SimpleDB, and SQS.
[There was a comment from the audience about a problem having mail sent from Amazon serves flagged as spam]
[There was another comment wishing that IT department would embrace cloud computing more]

Mock Dialogue: Conversations on Testing and Mocking

Joe O'Brien & Jim Weirich

[Acted a scripted simulation of two developers working through difficult testing and mocking scenarios]

Concept of a fluent interface. Like in jQuery:

$('form#login')
    // hide all the labels inside the form with the 'optional' class
    .find('label.optional').hide().end()
    // add a red border to any password fields in the form
    .find('input:password').css('border', '1px solid red').end()
    // add a submit handler to the form
    .submit(function(){
        return confirm('Are you sure you want to submit?');
    });

Mentioned Psychology of Builds article. The frequency of build or test runs drop dramatically when builds last longer than 30 seconds.
Michael Feathers guidelines for unit tests.
[This format of presentation seems to take you along lines of a conversation that I wouldn't necessarily go, but still, the style is differentl]
Difference between stubs and mocks: stubs fake objects that can give you data back, mocks are a little more involved.
Flexmock and Mocha mock frameworks for Ruby
Mocks still need to be supplemented with system tests that test the whole stack.

Ruby Best Practice Patterns

Rein Henrichs

Best practices are a current understanding, and they do change.
Now, for a little introduction / diversion...
The Developers Dilemma - job security decreases as code maintainability increases.
So, to guard against this... Unfactoring!
Taking well-designed code and purposefully making it obscure to insure job security.
"Decomposing" methods. Naming methods incorrectly, even using Pig Latin, or other obfuscation techniques.
But seriously, on to the real talk...
Composed methods - try keeping methods small.
Kent Beck - Smalltalk Best Practices
Execution around method pattern
- How can I ensure 2 things happen? (ex: I want to open a file and ensure that it closes)
- around_filter in Rails
- Wrap an object in a block to make sure it has been completely initialized and uninitialized.
- [The "using" keyword in C#]
Sharing objects with multiple lines in a method. Pass variable into an initializer, initialize other temp variables and have them as shared variables within the class.
I urge people to look into Ruby libraries or various open source projects for examples of pattern usage. Ask yourself why the writers did something in a certain way.
Be aware when code doesn't feel right to you.
Code should be fun to write and read.
[Comment from David Black about the idea of taste and readability. Some things he's seen that people describe as readable don't seem readable to him. Rein responds that it's a valid point; people have different tastes in music, but still humans can generally agree on what harmony is and what scales we use.]
[Another commenter stated that it's important to separate generic patterns from Ruby idioms.]

Lightning Talks

PJ Davis
- Web interface for God system monitoring tool
Brian Lyles
- Test all the fucking time!
- Become obsessed with testing.
- I write code to make my specs turn green.
- Various tools:
  - TestSpec
  - Shoulda
  - Mspec
  - Cucumber
- Do not imitate the old masters, seek what they sought.
- Is there every a time when you shouldn't test? Yes, when you're not coding. If it works without tests, it works by accident.
Yousseff Mendelsohn
- "Truthy" gem package for Ruby. Helps to ease confusing true and false evaluations in Ruby.
- Usage: variable.truthy?
- Only nil and false are false in Ruby. Really. That's it. Stop looking.
Another guy
- Making charts with Google Charts
- gchartruby library

Keynote

Chris Wanstrath

No slides, I will just read an essay.
In the future, Ruby will be more popular.
People will wax philosophic about the old days of Smalltalk (when they've never actually done Smalltalk).
The suits will come down upon us, but hopefully Ruby will stay good.
[His talk is well-written, but quoted Wikipedia too much for my taste, and without visual slides and little content, the majority of it fell flat on me.]
PHP has a ton of helpful methods (aka a shotgun blast of functions in the global namespace).
I haven't made a ton of money directly from open source software, but I have gotten a lot of work indirectly from it and through my reputation gained from working on open source.
You need to work on a side project.
But, you say you don't have the time?
- Stop reading RSS feeds, and instead rely on aggregation sites or speakers to give you the really important news.
- Rely on people to filter for you.
But what if people don't like it, it's already been done, or it's stupid??
Forget it, just do a side project that you love.

Ruby Hoedown Impressions

2008-08-12T00:00:00+00:00

Last weekend, I attended The Ruby Hoedown conference here in Huntsville. As a mostly .Net developer, it was refreshing going to a conference where material and ideas were presented outside of my normal habits. I've been tinkering with Ruby and Ruby on Rails for awhile now, and when I saw the conference advertised and the line-up of speakers having a couple writers and podcasters that I've been paying attention to on the fringe lately, I signed up (even though work didn't buy my excuse that a Ruby conference would contribute to my .Net skills, I still decided to sign up on my own and take a vacation day).

Overall, the presentations were very exciting from what I'm used to at software conferences or meetings, and were formed from a mix of humorous images (including Chuck Norris and various internet memes), illustrative diagrams, and even screencasts of coding embedded in the presentations.

The highlight for me was seeing the guys from the Rails Envy podcast deliver the opening keynote. Their presentation seemed to have just the right balance of content, delivery, and even entertainment. As well as the podcast, they have also produced a humorous series of parody videos comparing RoR to other web frameworks. As I'm writing this, I see that they've even posted a 10 minute summary video of the Hoedown.

Going sure didn't help my feelings of OS X envy (I've never seen so many geeks brandishing mac laptops), and I definitely feel mainstream now having an iPhone. In short, an unusually stylish and hip-geeky group compared to other conferences I've been too.

On the down side, the conference did seem a little unorganized at times, and there were slight problems with communicating the agenda and delays in presentations. Also, towards the end I felt a little fatigue with how witty the presenters were trying to be, and wished that I could see a little less funny Google image search results try to pass for presentation content.

Also, much of the content wasn't directly relevant to me, but this wasn't a negative, as the purpose of going was to see something different. Even if I only understood 50% of some talks, I'm still learning new keywords, practices, and ideas, and just seeing how everyone is using tools makes me reevaluate how I use various dev tools and even web apps.

These are just some of my general impressions, but I've taken notes from many of the presentations, and I'll be posting those over the next couple of days.

My Current Firefox Extensions

2008-07-25T00:00:00+00:00

I got a new machine at the office towards the beginning of this week, and I've spent the last few days installing and tweaking software. A lot of settings can be exported and imported with many programs and operating systems these days, so in a certain way having to reconfigure things seems like a waste of time. But recently I've been relying on defaults more and more, and I can also use times like this to re-evaluate what settings and tools I really need.

Maybe I'm becoming old and curmudgeonly, but I'm finding that I don't have the stomach anymore to spend tons of time tweaking and optimizing software settings. I was pleased to find that I've settled on the following Firefox extensions after a few days of heavy use on the new machine:

(And, actually, I could probably do without FaviconizeTab).

I might end up adding or taking away a few here and there, but I think this is a good sign that I can get up and running with Firefox 3 quickly and that it provides a lot of functionality by default.

As a side note, this reminds me of a Coding Horror post on The Dark Side of Extensions.

X Envy

2008-06-16T00:00:00+00:00

In this post from VentureBeat, a survey is cited saying that only 8 percent of developers are writing applications for Vista this year. While these claims don't seem very substantial (I'm thinking that a more interesting question is how many developers are writing for .Net and not targeting Vista specifically over Windows XP), the following section nevertheless struck me:

Granted, the 8 percent data is taken from only 380 North American developers surveyed, but over half of them said they were still developing for previous iterations of Windows. Meanwhile, Apple’s OS X has seen a 380 percent surge in growth as a targeted development platform.

It seems for the past couple of years I've been steadily hearing about Mac OS X apps that make me envious. The other day, Andy Ihnatko mentioned one called Fluid on MacBreak Weekly that allows you to create site specific browser applications. As someone who keeps Google Calendar and Gmail tabs open all day, an app that allows me to cleanly separate key web applications into their own space that is integrated well into the OS seems very appealing.

But that's just one example. Here are several other compelling Mac OS X apps that come to mind at this moment:

Textmate
Keynote
Development tools for the iPhone
Quicksilver
Apps from Panic
SnapzPro
iLife
Parallels
Skitch
Apps from The Omni Group
Twitterific
Growl
Firefox*
iTunes*
VLC*
Twhirl*
Lightroom*

* Ok, so I cheated a little and these are available for Windows too, but that's part of the point.

Of course it's easier to spout off a bunch of trendy apps than to actually derive value from them on an everyday basis, but I still can't help but feel intrigued by the amount of exciting products coming out for OS X. Looking at the development tools available for the Mac, it doesn't make me very envious (I'm thinking of you, Cocoa and Xcode), but yet there seems to be a vibrant community of Mac OS X focused developers who seem to be skilled in developing sophisticated and well-designed UIs.

I'm not sure where this stems from, and maybe it's just my perspective at the moment, but it still seems like a factor that's coming to the forefront.

And, of course, there are several key applications for Windows that I just couldn't do without such as Visual Studio.... and... maybe Microsoft Office... and... oh yeah, this issue tracking software we use at work, but wait... it has a web-based version...

Maybe Developers Don't Even Know What They Want

2008-05-12T00:00:00+00:00

While listening to a new podcast the other day, I stumbled up on an old presentation from a Java conference (Javapolis 2005) titled "Perspectives on Agility" by Kevlin Henny. While the talk, in general, contained several interesting points concerning agile development, one point peaked my interest in particular. I get the feeling that it's often said by developers (and I definitely know I'm guilty of this) that the customer doesn't know what they want. More specifically, they don't know what they want until they see it, and by that time, a significant amount of effort might have already been devoted to a project and more work will be needed to correct things. This might be true, and even seems reasonable to accept this as a part of human nature (as agile methods commonly do), but what about developers? Do they exhibit the same behavior to some extent?

In the presentation, Henney suggests that the most capable software engineers that could work on a software project are the ones that have seen it to its completion (or, just as likely, failure). Typical developers are constantly learning about the problem domain and may even significantly adjust their development tools and practices during a project. While the traditional waterfall process is often chided for its naive attitude towards changing requirements (which is ironic considering that in the original paper describing the process it was never called a "waterfall" and the author even warned against using it), I wonder how many times when software is planned changing developer knowledge or habits are taken into account.

When confronted once with a client who rejected "agile" software processes (the client having been burned before by a process describing itself as "agile"), Henney describes successfully re-branding his approach as a "sustainable" process. While he might have gotten some inherent acceptance owing to recent popular environmentalist attitudes, I think "sustainable" is a good term to describe a software development approach that accepts both changing customer requirements and perceptions as well as changing developer knowledge and habits.

Podcast Habits

2008-04-26T00:00:00+00:00

While listening to the first episode of a new podcast by a pair of my favorite bloggers Jeff Atwood (of Coding Horror fame) and Joel Spolsky (from JoelOnSoftware.com), I heard a discussion about their new developer community site Stack Overflow and its associated podcast. They described the site, but also gave reasons for doing a podcast. This got me to thinking more about why I like listening to podcasts so much and which ones and what types of shows I have gravitated towards listening to since I started listening to them a few years ago.

First, a disclaimer: If you don't like the idea of podcasts/audio books, that's perfectly fine. Some people tend to have an aversion to them and prefer the printed word. That's fine, and you're probably better off for it. Reading's better for you brain anyway, and you can consume information faster by reading than listening to it anyway, or something like that... So, you can just stop reading now and come back in another 2 months when I write my next post.

Still with me? Here's another disclaimer: I am now sure that I have a weird, geeky, anti-social, possibly unhealthy podcast habit. I can't stop listening to them, all the time. I practically always have my iPhone's earbuds in: at work basically all day (I work on a project by myself and communicate mainly with my client through email), while I'm at the gym, driving by myself (or, if my passengers are particularly uninteresting), while I'm at home doing chores, basically most of the time. I'm writing this listening to a podcast (Armin Van Buuren's State of Trance music podcast). As such, what I'm writing is coming from this perspective of podcastaholism. As soon as it's possible to get decent earphone implants, I'm in. You need the right equipment to make this practical and seamless (read - an all in one pda/phone/media player). I'm still loving the iPhone, and it look like there are plenty of these devices popping up and it's the way things are going. It's truly a geek orgasmic experience to be jogging while listening to a podcast, get a phone call from the Red Cross about setting up a donation, have the audio gently transition from iPod mode to phone mode (as the iPhone so slickly does), make the appointment, then be gently transitioned back to the audio program without skipping a beat.

Enough disclaimers. Here's a few reasons why I love audio programs:

Above all, you can listen to a podcast and still use your eyes. This means you can listen while commuting, while exercising, while working even. For my adult ADHD self, this always multi-tasking behavior is well suited.

I don't get angry in traffic (really, never). In fact, if there's an accident and I'm forced to stand in line an extra 20 or 30 minutes, I'm actually a bit glad for these, what Dale Carnegie called, "gifts of time" and I'm able to listen to more material.

Podcasts make exercising fun. I love exercising now, both because of the runner's high thing, and because I get to listen to a (usually) stimulating audio program while I'm at it.

When I can pair doing chores with listening, it makes them enjoyable. There's nothing like ironing clothes while learning about Sydney's Gay and Lesbian Mardis Gras.

People speak or converse differently than they write. While with good writing you can express a complex thought maybe more elegantly and definitely more concisely than with speech, listening to someone explain something or a group talk about something of interest gives you a better feeling for their personalities and tends to bring out more dynamic, improvised, and somewhat cruder thoughts (like everyday conversation). This can go either way. While there are many delightful, entertaining, and intelligent speakers, I've been unpleasantly surprised several times by how people (John Dvorak, Joel Spolsky, Paul Thurrott come to mind) can be fairly competent writers but stumbled through hours of bad jokes and off topic side conversation that forces me to skip to the next show in my queue.

I'm able to get a very candid and personal impression of various personalities or micro-celebrities. I'm a motorcycle racing fan, and it's very entertaining to hear a mechanic and blogger on one of Ducati's teams speak about his experiences traveling around the globe on the excellent MotoGPod podcast.

I can also hear from professionals closer to my field, such as on the This Week in Django podcast. To hear insightful talk from core Python developers data access and internationalization problems is fascinating. As a developer dealing with bugs everyday, it's particularly fun and a little comforting to hear from prominent developers on a major project deal with nuanced issues and committing fixes to a public source control repository (they discuss specific changesets even!).

I think it can be a good educational tool (if used correctly). Most notably for me, I think it's helped me as I try to learn Russian. It seems important to be exposed to a lot of spoken language if you're trying to learn another tongue to get a halfway-decent pronunciation, and I it has helped me listening and repeating the Pimsleur Russian courses and various podcasts aimed at those learning Russian (although Jamila and my Russian-speaking friends might disagree :).

There are disadvantages I've found. It's anti-social to walk around other people (especially co-workers or your girlfriend) with earbuds in for a very long time while tuning them out. I've had to learn how to politely take the earbuds out and pretend like I'm listening. I still can't decide if it's dangerous to drive with earphones, but this is probably fine judging by how many crazy drivers I see without earphones in or listening to loud crappy music blaring as they barrel down the interstate. Also, I have to be careful of what material I listen to when. It's possible to listen to a dance podcast or two while programming, but if there's a show that is particularly technical or detail oriented, I'd better save that for a jog sometime.

I'm posted a list of the podcasts I listen to here. It's really a .opml (podcast subscription file) but named "podcasts.txt" (because I couldn't get my web server to serve it correctly), so you can rename it as .opml to use with iTunes, etc or just browse through it in plain text if that's not your interest.

Queryable Endpoints

2008-04-04T00:00:00+00:00

It's been several weeks since I went to the Alabama Code Camp that was held here in Huntsville, but there's been one concept that was mentioned in a session that I think has noticeably changed my development habits. It's something I heard mentioned in a talk by Shawn Wildermuth about Microsoft's Astoria project: queryable endpoints.

I think the core idea is that, when structuring a database's schema or when writing data access code, it helps to keep a data model simple and avoid baking inappropriate aspects into it such as aggregate columns or a default sort order. One's goal should instead be to create an understandable, clean model that allows its consumers to transform data themselves (via filtering, sorting, summing columns together, etc).

In the talk, Shawn discussed how the Microsoft data access team is trying to build one solution for this with Astoria. The stated goal of Astoria is "to facilitate the creation of flexible data services that are naturally integrated with the web". In its simplest form, it basically allows you to expose data in a RESTful manner via URLs like this:

http://server/data.svc/Customers

which returns a list of Customer entities, or in a more specific way like:

http://server/data.svc/Customers(’ALFKI’)/Orders?$filter=Active eq true&$orderby=OrderDate

The caller can request that entities be returned in JSON or ATOM format, and the format can be chosen with a flag in the HTTP request header. It seems Astoria provides the mechanism for such communication, but the back end (how you talk with data sources) can be constructed in a variety of ways using .NET (talking to XML files, various databases using ODBC, even remote web services).

While Astoria sounds very exciting, and I hope I get to play with it sometime, just keeping the concept of queryable endpoints conscious has proven beneficial to me on my current project in the past couple weeks. After the code camp talk, I looked back and saw where me and my team had violated this idea in a few particular ways: we had created many inflexible, overly-specific stored procedures in the database such as "GetUsersByLastLoginTimeDesc" and also ones that retrieved records given a filter which ended up being raw SQL (which is certainly not a very maintable practice).

While these may be very glaring examples, sometimes the decisions can be a little more subtle and easier to slip through. This week as I was creating a new data structure as part of the data access layer component of our application, I found myself throwing in an aggregate field which summed together several others. The data structure was to be used in forming a data grid for a specific page and this would have made things easier for that particular page, but I saw where it could easily be useful elsewhere and wanted to of course make it generic. It was a little more work to therefore customize the data grid on my page to create an aggregate column, but looking back I can easily see where that was the proper place to put that piece of logic.

A lot of this is probably common sense or just a feel for software engineering that I haven't quite development yet, but I think keeping this idea in mind has helped me to put code in the right place.

Last.fm

2008-03-24T00:00:00+00:00

I've been using Last.fm for awhile now and (after a break) I've started using it again and placed a widget on this site for it (see sidebar). Last.fm is a social music sharing site that let's you "scrobble" songs (when you listen to music, the name of the song is sent to Last.fm and added to your music profile) and based on your listening trends you can discover artists you might like or connect with people who share your tastes. You can scrobble a few ways, including using the Last.fm client (which logs whatever you're playing in Winamp, iTunes, etc or let's you listen to personalized internet radio channels) or you can use a plug in such as iSproggler which logs plays from your iPod whenever you sync (I mostly do the latter). You can even listen to music through the site fairly easily.

Here's my profile page, and here's my music obsessed friend Sergey's. We have a music compatibility rating of "Medium" and, although I can deduce this by common sense, it's strangely comforting to be reassured by a cold, statistical algorithm.

After gathering enough data, it's exciting to look back and see your listening trends (just please ignore my fifth top artist at the time of this writing).

UPDATE (Mar 25, 08): I just found the MobileScrobbler app for the iPhone! Unfortunately you must have a jail-broken iPhone to install it until official iPhone apps are ready (this is the first time I've wanted to jail-brake my phone). Would be spectular to have whatever you listen to whereever you are be instantly logged (if you're a heavy iPod type user) or just be able to listen to Last.fm radio on the go.

Plans to Open ASP.NET MVC Source

2008-02-13T00:00:00+00:00

From a developer perspective, I like a lot of the ways that Microsoft is heading, especially concerning web development. Despite the bad press they get for many consumer products (think Vista's poor adoption rate, XBox 360 hardware failures, and the lackluster Zune), they have a lot of exciting development tools both existing and upcoming. This may be the naive fan-boy in me talking, but I also like the more open and progressive attitude they're taking on many fronts. Here's an excerpt from a recent post by Scott Guthrie about the new ASP.NET MVC framework:

Last month I announced that the .NET Framework source code can now be downloaded and debugged. Ultimately once it ships the ASP.NET MVC framework will be available via this mechanism as well (just like the rest of the ASP.NET source code).
Starting with this next preview, we are also going to make the ASP.NET MVC Framework source code downloadable as a buildable VS project solution. This will enable you to easily view and debug the ASP.NET MVC Framework source code. We are also going to include a license that permits you to optionally make patches to the ASP.NET MVC Framework source code in the event that you run into a bug in an application you are developing with it.
The license won't enable you to redistribute your patched version of ASP.NET MVC (we want to avoid having multiple incompatible ASP.NET MVC versions floating around and colliding with each other). But it will enable developers who want to get started building ASP.NET MVC applications immediately to make progress - and not have to worry about getting blocked by an interim bug that they can't work around.

It's good to hear that coming from a prominent manager and the co-creator of ASP.NET.

IE 8 and Version Targeting

2008-02-08T00:00:00+00:00

There's been quite a response to Internet Explorer 8's proposed system of Version Targeting. If you haven't heard of this, here's a quick overview: the IE team is proposing that there be a metadata tag recognizable by IE 8 that will instruct it how to render a page (as IE 6, IE 7, or IE 8). If the tag isn't present, then the default will be IE 7.

Why is this needed? Because the IE developers have a huge dilemma: version capability. They have loads and loads of sites designed specifically for IE 6 (for various reasons, some nefarious -won't go there) and had to make many compromises when designing IE 7 to maintain backwards compatibility while receiving a lot of flack from the web design community that IE 7 didn't do enough to address standards compliance. IE 8 just having passed the Acid2 test, there will probably be a lot of breaking changes in it that could harm tons of existing sites.

This seems to me like an elegant solution. They can effectively freeze existing sites to use IE 7 (since they don't specify the meta tag and will get an IE 8 rendering) while allowing web designers to explicitly take advantage of more advanced features and better standards compliance of IE 8.

From a developer perspective, this seems natural. I'm used to writing .Net code that's bound to a specific version of the .Net runtime, just as Java developers are with the JRE, PHP developers with the PHP runtime, etc. Rendering differences of HTML, CSS, and JavaScript across browsers are brutal for developers, and even though practices like progressive enhancement can help, it seems that version targeting (if widely supported) could make developers lives a lot easier. Software engineering is hard enough.

Instinctively, however, this may give off a bad Microsoft anti-competitive IE-only vibe. It reminds me a little of pages detecting your browser and denying access if you're not running IE. Browser sniffing has a fairly unreliable history as a technique and browser makers have often been misleading to put it mildly. In the past, Opera has placed "MSIE" in their user agent string, and at one point Safari had the phrase "like Gecko" in theirs (with unintended consequences that you can probably imagine if you've ever had to parse a string).

This is not like browser detection - it goes the other way. The metadata signal allows a web page to establish a contract between the page and the browser.

From what I've read, there seems to be a lot of negative perspectives on this issue, but here are a few voices I've run across that seem to have a more practical view of the situation:

http://alistapart.com/articles/fromswitchestotargets

http://www.boagworld.com/archives/2008/02/110_the_mighty_meyer.html

http://www.quirksmode.org/blog/archives/2008/01/the_versioning.html

http://blogs.msdn.com/ie/archive/2008/01/21/compatibility-and-ie8.aspx

Academic Versus Real World Development

2008-01-17T00:00:00+00:00

I think I've decided to take a break from my graduate course work at Auburn. I had a terrible time with the class I took last Fall (Formal Methods for Software Engineering) and this has discouraged me from continuing with school.

Not that I needed a big push, on the one hand: it's hard to work a regular job and have the discipline to come home and watch classes during the week, do regular homework and class projects, take exams, etc. And it can seem difficult to try to push yourself to learn seemingly abstract concepts that might not be directly applicable to the current technology you're using at work. [more]

However, hopefully I'm not being lazy and whiney. The formal methods class I took was about logically proving programs to be correct. In it, we learned a specification language called "Z" and tried to prove, using logical axiomatic systems, trivial programs that took many hours of thought and many pages of notes to prove. This is an interesting concept, but currently it seems not to be held as a very useful thing in software engineering practice. There are only a handful of mostly specialized examples of applications that I came across while taking the class, and I didn't really find any modern tools that use this in practice. Given this probably biased description of the class, it's probably easy to see the friction I felt while doing my course work at night, and trying to solve "real world" software engineering problems in the day at work.

Coincidentally, I saw several blog entries pop up in my feed reader towards the end of last year that seemed to express this same sentiment. Famed blogger Joel Spolsky, in a talk given to the computer science department at Yale, had this to say about the best course in computer science he ever took:

I worked on that problem for hours and hours. I had her original proof in front of me, going in one direction, which, upon closer examination, turned out to have all kinds of missing steps that were “trivial,” but not to me. I read every word about Dynamic Logic that I could find in Becton, and I struggled with the problem late into the night. I was getting absolutely nowhere, and increasingly despairing of theoretical computer science. It occurred to me that when you have a proof that goes on for pages and pages, it’s far more likely to contain errors in the proof as our own intuition about the trivial statements that it’s trying to prove, and I decided that this Dynamic Logic stuff was really not a fruitful way of proving things about actual, interesting computer programs, because you’re more likely to make a mistake in the proof than you are to make a mistake in your own intuition about what the program “f := not f” is going to do. So I dropped the course, thank God for shopping period, but not only that, I decided on the spot that graduate school in Computer Science was just not for me, which made this the single most useful course I ever took.

ASP.NET developer and blogger Phil Haack related an experience he had in college solving math problems with the importance of testing in software practice versus provability:

...trying to prove the correctness of computer programs is a lot like trying to solve a set of partial differential equations. It works great on small trivial programs, but is incredibly hard and costly on anything resembling a real world software system.

And, most recently, .Net developer Oren Eini also commented on the appropriateness of using academic knowledge in the field:

Finding a path in a graph? Design a compiler? Analyzing an image? Choosing a search algorithm? Selecting appropriate data structure for a task?

For each of those I would head for the academia, directly. Those are technical issues, and I want the academic proofs and experience there. I want the mathematical foundation for the solution.

Designing a maintainable system? Building a usable framework? Creating the domain model?

For those I am going to not going to go to the academia. I am going to go to the real world practitioner. They guys (and gals) that have been burned in the field and learned from their mistakes.

I don't think the graduate level CS courses are totally useless, by far, and I might even get the urge to continue my degree later, but for now, I'm going to focus on learning more practical technologies and drinking gently from the fire-hose of new languages, frameworks, and tools that are constantly being churned out of the interwebtubes.

Scott Hanselman on CodeMash

2008-01-11T00:00:00+00:00

Scott Hanselman has a short post about CodeMash here, and I think he describes the general spirit of openness and collaboration between languages promoted at the conference well.

CodeMash Report

2008-01-10T00:00:00+00:00

I drove up to Sandusky, OH yesterday, and attended the first of two days of the CodeMash conference today. Here are some of my impressions:

But first, a tangent...

On my way there, I was caught speeding in Kentucky (80 in 55 zone - bummer). Luckily, I got off with a warning, but the copy asked if he could use the drug sniffing dog in the back of his SUV to search my car for drugs (I think he noticed the curious pill box full of vitamins I had sticking out of a bag in the passenger seat). "Sure!", I said, just happy to not be getting a ticket. So, I got out of the car (in a white t-shirt and comfortable jeans, redneck style), while another cop car arrived (making the total 3, because 2 cars pulled me over). So, I'm standing beside the interstate in my t-shirt with 3 cop vehicles behind me and a very spirited German sheperd sniffing his way around and inside the car, when suddenly the dog signals that my bag has something in it. Great. To shorten things a bit, basically I ended up successfully convincing the cops that somehow the dog must be confused with my vitamins, and eventually they let me go. Whew! So glad they didn't search in the gas tank, though ;)

Sorry - back to the conference.

The opening keynote, I think, summed up the current state of software engineering nicely: SE is, at its current state, at the same point that structural engineers building bridges were at when they didn't understand physics and math enough to be able to successfully specify bridges and ended up building one, rolling a cart across it, and, if it fell, then they knew they needed to improve things and try again. Fortunately, testing in SE is much cheaper that said bridge testing and, for the time being, testing is the engineering underpinning of software. Since software is the stuff of thought, and we don't have physical laws to rely on (as civil engineers do), test driven development seems to be the way to go (so they say).

That being said, there seemed to be common theme of test driven development throughout the session talks. This has another side affect as well - TDD seems to deemphasize slightly the role of compiliers and strongly-typed languages (such as Java, C#, C++, etc), since the compiler error messages shouldn't be trusted as a measure of code quality as much as unit tests should. Therefore, there seems to be another trend throughout the sessions of meriting various dynamic languages (such as Ruby, Python, Groovy, and JavaScript). Interestingly, people are often choosing to run these languages on top of established runtimes (such as Java's JVM or .Net's CLR). So, basically, instead of writing Java code to run on the Java runtime, you can write Ruby code which compiles to Java bytecode and is executed on the established and stable JVM. Someone quoted Martin Fowler in a talk today as saying that Java's legacy won't be the Java language itself, but the runtime. One way of thinking about this is that the Java language could be used for more lower level programming on the JVM while you could leverage a more loosely-typed and possibly productive language to write your main application code. Talk about layers of abstraction!

There is also several sessions being presented about Rich Internet Applications (such as Microsoft Silverlight and Adobe Flex). I was able to see back to back talks today about Silverlight and Flex, and it made for an interesting comparison of the types of developers that are attentive to these two platforms. Enthusiasm for the promise of Silverlight seems to be very high, although it's still in the fairly early stages. Attendance at the Silverlight talk was high, while that of the Adobe Flex talk not so much (I'm note sure why - maybe it's just the demographics at this conference or region, or maybe it's that Microsoft has a stronger developer prescence than Adobe). Silverlight's strategy certainly seems to be solid, with good developer and design tools, but what can be accomplished with it is still mainly limited to video deliverly or basic rich clients. Adobe Flex, on the other hand, seems to be much more mature in control support and interface mastery (although code is still mainly written in ActionScript, compared with the .Net languages that Silverlight can leverage). I was very impressed with the sophisticated demoes that the Adobe evangelist demonstrated with Flex and also AIR. They really seem to grok UI design. Slick.

Another great presentation was given by one of my favorite podcasters, Scott Hanselman (now working at Microsoft), who gave a very entertaining presentation on IIS 7 called "Mashing it up with IIS 7". I think his talk partially reflects the more open stance Microsoft is trying to promote now, as he demonstrated how he could integrate PHP and ASP.NET by plugging the PHP Qdig photo gallery library alongside ASP.NET and using functionality from both platforms. Very interesting stuff, IMHO, but he seemed to have a hard time getting the audience into it - looks like it's hard to convince a general audience that Microsoft is not evil.

Lastly, I saw a sponsored session by several developers from Amazon. What was intersting about it was its lack of interstingness. The audience kept probing for some secret IT processes that they use interally that explains the company's wild success, but all we got were simple, mundance answers. I'm now convinced that they fuel their fire by hiring super genius developers and maintaining a humongous QA department.

New respect for JavaScript

2007-12-13T00:00:00+00:00

I've been watching some great videos over at Yahoo's YUI Theater and have especially enjoyed ones about JavaScript and Ajax by Douglas Crockford (a JavaScript architect at Yahoo). Listening to his talks, I've come to respect JavaScript more. As a programming language, it has a very interesting history, and although it has many deficiences, it's actually a very powerful, expressive, and in many ways innovative language. [more]It supports some interesting programmatic constructs: objects are associate arrays (obj.x = 10 and obj["x"] = 10 are equivalent, it uses prototypal inheritance (instead of inheriting from classes, objects just inherit from other objects), and functions are first class (meaning functions are objects and can be acted on just as regular objects - a very Lisp-like idea - JavaScript is probably the only mainstream language that supports this). JavaScript was partially designed to be lightweight, script version of Java hosted in a web browser (initally Netscape Navigator), and yet today it is better than Java in applications that Java was originally intended for.

However, JavaScript does have many problems. Weak typing can be a turn-off for programmers familiar with more traditional, strongly-typed languages. JavaScript's runtime is the web browser, and differences in browsers has caused havoc over the language's history. Pile on top of that design errors in the language, a poor official standard by ECMA, and inferior development environments, and you can see why many "serious" programmers might be hesitant to work with it. In fact, there has been a lot of effort to insulate developers from JavaScript (take the Google Web Toolkit's strategy [Java to JavaScript] or Microsoft's Volta [.Net to JavaScript] as examples - there are many others as well). I like a comment I heard recently in an interview with Erik Meijer (one of Volta's principal architects), in which he said something like, "We're viewing JavaScript as a nice, cross browser, cross platform runtime. It's a good runtime, but you don't want to work with JavaScript as a language."

Home Theater PC Experiences

2007-11-28T00:00:00+00:00

I first tried setting up a home theater PC several years ago when I upgraded my then current computer and happen to have a spare machine and TV tuner card laying around. That first install didn't turn out so well: the machine was an underpowered Pentium III, my wireless network was too slow to stream video well (802.11b was the standard then), and even if I would have run an Ethernet cable across my apartment, the picture was so horrifying on my 27" CRT TV when I hooked my PC to it that it wouldn't have mattered anyway. It was just too early, and I didn't have the necessary, then-expensive equpment to make a HTPC (home theater PC) work. [more]

Fast forward about 4 years, and things have improved. Living rooms are being equipped with bigger and sharper screens, the use of digital music and even video has become more widespread, people are becoming accustomed to more advanced forms of recording and time shifting cable TV with tools such as Tivo, and there are several good options for bringing digital music and movies into the living room, often while enhancing cable TV. Microsoft has been pushing its Media Center software for awhile now (packaged with select editions of Windows XP and now Vista) as an option for running a PC on your TV, Apple has leveraged their popular iTunes music and video store service to provide a solution ala Apple TV, and there are several other standalone network media players from companies like D-Link and LinkSys as well as software packages that can be added to Linux and Windows (MythTV, SageTV, GBPVR, etc). Since I'm a Windows power user and burgeoning Microsoft fanboy, I've tended to really only use Windows Media Center software, so this is what I'll be detailing in this post.

I've been using Windows Media Center for awhile now. Before building my latest machine, I had Windows XP Media Center Edition installed on my 4 year old Athlon machine, with good results. Media Center Edition is just like XP, but includes the Media Center program front end, which gives you easy access to TV (live, recorded, as well as a TV schedule - provided you have a TV tuner card or device) and your media (pics, music, videos). When we had cable, I would often schedule TV shows to record and view them later when more convenient (just like a Tivo - but viewable only on the computer). Things worked fairly well, and I was really happy with usability of the media center software.

When I built a new main computer, I upgraded some components on my old box (see my upgrade album here) and installed Windows Vista Ultimate (they don't have a Media Center Edition anymore, but instead include the media center portion with the Home Premium and Ultimate editions). The interface has been refined a bit, but still seems very similar to the Windows Media Center 2005 edition. This interface is very polished and usable, with large, easy to read text and icons showing that it's best viewed at full screen on a TV. The interface can easily be navigated with the directional arrows on a keyboard or (preferably) with some type of media center remote (more on this later). The interface is very intuitive, and after a minimal amount of setup, it's very easy to start programming in shows and watching various media. For a more refined description of the Media Center interface, you might want to read the Windows Media Center section of this review.

To the best of my knowledge, it uses Windows Media Player internally to play everything. At first glance, this means that, by default, it will only play files that WMP will play. However, in practice this really hasn't been an issue, as, after installing a codec pack (like ones here or here), it plays all the common video formats very well.

Media Center scans your computer for media and makes it available without too much fuss, and, as I store my iTunes music library on the same machine, I am able to browse my music collection pretty well from Media Center without having to jump to iTunes. Accessing shared media is easy, also. Currently I have shares on a different computer for TV shows and movies, and you can fairly easily tell media center to monitor these shared folders for content and automatically update. As for TV, I can't really say much: Jam and I cancelled cable awhile back (although I'm sure it would work fine as a Tivo-like device). One other note: it seems Microsoft has partnered with many news and entertainment companies to develop specialized plugins for Media Center, and these are available in a section of the Media Center interface (one example of note is access to MTV's Overdrive portal, where you can view many MTV shows and access tons of music videos online for free - very slick).

Although I'm very happy with my current setup, there are several problems I've stumbled upon while using Media Center. For one, you need a pretty decent machine with a good graphics card to run Vista very well (after all, you are running a full install of Windows). Although my four year old machine is holding up fairly well, I've installed more memory, a faster and more spacious hard drive, and a specialized HTPC case and am in need of another video card (the onboard video I have now is just not cutting it, although it's usable, and periodically crashes because of a driver issue - not Vista's fault, but an annoyance nevertheless). Understand this can run you into some money, and it may be cheaper to buy an integrated solution rather than piecing together a custom system (although, if you're a tinkerer like me, it might not be quite as fun). Also, since, again, you're running a full install of Windows, the setup can seem more complex than your typical piece of stereo or cable TV equipment (although this can also be viewed as an advantage, because you have more flexibility if you want to run custom software, browse the net sometime, or maybe watch a YouTube or ABC online clip). Another thing to consider is the screen you'll be using the Media Center with. I actually bought my TV (a flat panel LCD - basically just an oversized computer monitor) with my HTPC setup in mind. Although the Media Center software can be left open for most of the time, for those times when you're setting up the system or running regular Windows apps, you probably want to have a clear, readable picture rather than what you might get from a lot of TVs not designed for computer use. Also, there's the issue of an input device: while I'm currently using a standard wireless keyboard and mouse, this is often cumbersome, and something like a specialized media mouse (like here or here) or an all in one keyboard and trackball (like here) would be much more usable.

Hosting media in your living room is probably still in its relative infancy, and it seems there are tons of options out there that have not yet jelled into a clear picture. Windows Media Center is one answer, and although it's great already, to me it seems Media Center and other hardware and software packages will become even more interesting as media companies keep offering various broadband content.

Huntsville .NET Users Group and a Brief ReSharper Review

2007-11-27T00:00:00+00:00

We have a good .NET user group here in Huntsville called HUNTUG (for Huntsville Users Group). They have a meeting at least once a month and are able to bring in talented speakers from the Southeast and beyond via sponsorship from Microsoft and other supporting companies. They always have lots of free food and technical magazines at the meetings, and often give away door prizes such as books, shirts, or software. I was lucky enough to win a great Visual Studio 2005 add-on called ReSharper at one of the latest meetings, and one of the chairpersons asked me to write a review of it for the software reviews section of the user group's site.

Here's said review: [more]

ReSharper for Visual Studio by JetBrains is a Visual Studio add-on that, after using for about a week, I realize I can no longer live without. It has helped me to look at existing code in a new light and has even shown me several good coding tips and tricks. Before using the tool, I was appreciative of the many coding tools included with Visual Studio 2005 (such as code formatting, refactoring, and code snippets support), but after using ReSharper for a substantial amount of time, I realize that I have been missing out on more advanced, helpful, and more productive features that 3rd party tools like this can offer.

ReSharper comes in editions for C#, VB.NET or both, and is priced at anywhere from free for a classroom license to $350 for a commercial license. The current version that I evaluated is 3.0 for Visual Studio 2005. They also offer a version for Visual Studio .NET 2003, and are tentatively planning a version 4 release for Visual Studio 2008 (including support for C# and VB.NET 3.5) in January 2008.

While ReSharper has many features (which are highlighted on the tool's website), I found several to be particularly useful. The tool gives more detailed error messages and more advanced warnings that Visual Studio does by default and includes the ability to rectify many of these potential problems automatically. ReSharper includes a more advanced "find usages" dialog and list that is more polished than the default feature. Also, the add-on makes navigating to references easier by providing a hyperlink interface on class or method names from anywhere when the control key is depressed (it even does this for declarative, plain-text event handlers in aspx files).

ReSharper is not without its faults, however. It re-routes many of the standard Visual Studio keyboard shortcuts and, although this can be configured to closely mimick the default behavior, it is still confusing sometimes. Visual Studio takes a performance hit when running ReSharper too (especially when first loading a project or if working on a slow machine). Also, the tool leaves a few meta data files and directories littered about your project folder (which are fairly harmless but can be a little annoying if you're a neat freak like me).

All in all, highly recommended.

CodeMash Conference

2007-11-20T00:00:00+00:00

I was fortunate enough to have my company sponsor me, so it looks like I'm going to the CodeMash conference in Sandusky, Ohio in early January. What is CodeMash? From the site:

"CodeMash is a unique event that will educate developers on current practices, methodologies, and technology trends in variety of platforms and development languages such as Java, .NET, Ruby and PHP."

Although I mostly work with ASP.NET and Microsoft technologies in general, I still like to keep my eyes open to what other tools and perspectives are out there. Really looking forward to being immersed in a diverse environment like this for a few days.

Day of .Net in Memphis

2007-11-14T00:00:00+00:00

Last weekend, I went with Sergey to the Memphis Day of .Net conference held at the University of Memphis. It consisted of a series of .Net-centric talks given by senior professionals mostly from around the southeast on various topics such as ASP.NET, Visual Studio, Silverlight, and Test Driven Development. I had a great time and got a lot of good info from the conference.

The keynote presentation was given by Charles Petzold (who's written a few books about programming windows) and was well delivered and entertaining. He and the conference room where he presented are shown in the picture above. (Side note: The auditorium is called "The Zone"... and it's sponsored by AutoZone.... get it?? hilarious! ;) In the lower right side of the pic you can barely see the consoles that were present at each attendee's seat. These consoles contained a microphone and button that, when pressed, signaled one of the four automated cameras in the front of the auditorium to zoom into the questioning attendee, at which point they would be shown on screen and his or her microphone would become hot. Neato! -- Updated, Nov 15: Here's a video of the space one of the presenters posted.

While in Memphis, we also managed to catch B.B. King playing at his club on Beale Street. I had never been to Memphis and was hoping to catch a bit of good blues music, but wasn't prepared for anything like that. Even at 82 years old, B.B. King can still put on a great show.

10,000 Ft View of Work

2007-10-26T00:00:00+00:00

We've been testing out an excellent suite of database tools for SQL Server here at work from Red Gate Software, and I captured this image while using their SQL Dependency Tracker tool. What you're seeing is a very high-level view of the database for a project I'm working on. Each one of those tiny dots is a database object (table, view, stored procedure, etc), and the lines between them show relationships. The layout is the one automatically generated by default.

I haven't used many database or code analysis tools like this, so it was striking to see such a high level (and admittedly pretty, in an abstract art sort of way) view.

Cyborg Dad

2007-09-27T00:00:00+00:00

My Dad, who's been suffering with severe back pain for the past several years, just got a neurostimulator implanted along his spinal cord yesterday. For the time being, he has wires sticking out from his back and controls electrical impulses to his back and spine with a wired remote. However, after the initial trial period, he can get a fully internal apparatus which is controlled with a wireless remote (the internal batteries are said to last around 9 years). So far, he says the results are good, and hopefully this will allow him to depend less on pain medication. Dad's been having a rough time with his back for awhile now, and I really hope this helps in even the slightest way to alleviate his pain.

I remember hearing about these devices several years ago on the news as an upcoming technology, and I'm amazed that Dad's doctor was able to get his hands on one this soon. In a way, also, I'm a little jealous - I wsh they would hurry up with the iPhone headset implants (and I'm only half joking).

iPhone Woes

2007-09-18T00:00:00+00:00

The recent $200 price drop for the iPhone has triggered a lot of anger from early adopters. It's a nuanced issue, and there are several ways of looking at it.

Two hundred dollars in ten weeks - what a slap in the face to Apple's core customers, some of whom waited hours in line for the device and were notoriously broadcast doing so in the news. Tech products do tend to rapidly fall in price (as Apple noted in its open letter to iPhone owners after the price cut was announced), but this seems particularly steep. In the beforementioned letter, Apple sites ramping up sales for the coming holiday season as one of the reasons for the price drop. Holiday season? but it's September? Looks like Apple is getting caught up in the Christmas creep too. [more]

To sweeten the deal, a $100 Apple Store credit (not applicable to iTunes purchases, however) for iPhone owners was announced the day after the price drop (presumably after negative customer feedback). Nice gesture, certainly, but not announcing this at the same time that new iPods and a new iPhone price was announced seems to be a mistake (one of several, perhaps). Such a mistake, that Apple stock fell after the announcements at a time when the stock should have risen on the news of re-designed iPods (the iPod Touch and the new "fat" video Nano). Not only did the price drop anger me personally, but peaved Jamilya a little, as I had excitedly told her to buy Apple stock the night before for her mock stock trading exercise in her finance class (I really should just stick to programming).

And what do I hear this morning while listening to one of my favorite podcasts, MacBreak Weekly, in an episode entitled "Repeal the Nerd Tax" (taken after a Bill Maher segment)? Apparently, $200 is not a big deal and was worth it to have the iPhone for an extra two months of nerd bragging rights over people getting it for cheaper. Well then, maybe I'm just a sour puss. But wait... let me think for a minute about the web celebrities I'm listening to:

There's host Leo LaPorte, who talks about getting sent a free iPhone from a fan so he could try various hacks on it while not risking any down time with his main iPhone. Then there's famous GTDer Merlin Mann, who held out for several weeks after the iPhone was released in seeming defiance of the mainstream only to be given an iPhone by someone just for, ya know, simply being Merlin Mann. Lastly, there's Scott Bourne, who produces the Apple Phone Show podcast, brags about giving an iPhone to each member of his staff, and personally owns so many iPhones that he has his own Chuck Norris-like facts page. Maybe there's a little bias here.

Even still, I still very much love my iPhone. It's the best smartphone I've seen, and I use it so much that I've come to think of it as an integrated augmentation to my brain (and I'm only half joking). I also really enjoy MacBreak Weekly as well as several other This Week in Tech podcasts, and I'm very grateful for the free content they deliver.

-----

This post proudly published using Microsoft Windows and ASP.NET

Frustrated

2007-09-16T00:00:00+00:00

It seems I've been punished for making my earlier (and now, seemingly arrogant) comments about building my latest PC without a hickup. For the last week or two, I've been struggling with what eventually I found to be a faulty motherboard. Since this piece is so central to the whole computer, and since I wasn't getting any error code from the board (with its "helpful" on-board LED error indicator) and nothing appeared on screen, I had to patiently troubleshoot various components (CPU, video card, RAM) until I found the culprit. After isolating everything, I finally reduced it down to the mobo. Everything turned out well in the end, as I was able to submit a warranty claim to EVGA (the manufacturer) and, after grudgingly paying for one-way shipping on a replacement board and swapping out boards, I'm now writing this post from my restored machine.

This brings up a few points. [more]

Although I might have saved around a grand making my own PC versus buying a pre-built Dell, I'm sure that a good portion of this "savings" has been eaten by the time I spent dissassembling the system, troubleshooting, then shipping and resintalling the motherboard. Luckily I had a spare PC and I back my data up regularly, so I was quickly able to switch over to another box when the new PC crashed, but still I don't know if I could call the adjustment totally negligible.

However, luckily I wasn't totally naive when I started planning the computer build, and, having done this before, I knew there would be problems that arose and didn't plan on getting away unscathed. Also (masochistic overtones aside), there is a certain pleasure I can take now as I look back and see where the problem arose and how I was able to deduce a solution and produce a remedy. This is probably part of the geekiness in getting your hands dirty building your own computer and having to understand and learn about the various componenets that comprise the system. And hey, even Google's early servers were a fairly cobbled together.

Another realization was how valuable online forums and product feedback can be. I noticed when I first ordered my mobo from NewEgg (which has a vibrant communicty of shoppers and whose comments are displayed prominently alongside products) that a few people commented on how several heatsinks seemed poorly attached to the motherboard. Apparently, this could lead to improper cooling of several componenets and could cause the board to burn up. This turned out to be useful, as I later referred back to these comments and heeded their recommendations when I applied better quality termal grease to a few heatsinks on the replacement mobo.

So a little nerd drama and I'm back to 100 %.

Building a Quad Core PC with the Experts

2007-08-23T00:00:00+00:00

I had been using the same home PC for over 4 years now, and, having cash in hand from my recent motorcycle sell, it was time for new hardware. Luckily, around this same time, one of my favorite .Net podcasters and bloggers Scott Hanselman, from the show Hanselminutes, published a show on building a new PC. He gave a detailed parts list, and was to have Jeff Atwood, another one of my favorite bloggers from CodingHorror.com, assemble the machine and give commentary. I was very fortunate to be able to follow along with Scott and Jeff, taking their advice and experience into consideration as I assembled my own machine. [more]

Not only did I want this new PC to be a powerful update from my old computer, but I also wanted it to be quiet. I was tired of the annoyingly loud fans of my current system and of being amazed at how much quieter the house became whenever the power went out.

Also, I took this as an opportunity to upgrade all 3 Windows machines I have currently (main PC, media center PC in the living room, and file/backup server). I'm currently working on the media center PC next (will have details on it when it's up and running), and I plan upgrade and my file server and test a beta copy of Windows Home Server on it when the media center PC is stable.

Here is a list of the parts I ended up buying:

Intel Core 2 Quad Q6600 Kentsfield 2.4GHz 2 x 4MB L2 Cache LGA 775 Processor - Retail
Price: $290
Scythe SCMN-1100 100mm Sleeve CPU Cooler - Retail
Price: $39
EVGA 122-CK-NF68-A1 LGA 775 NVIDIA nForce 680i SLI ATX Intel Motherboard - Retail
Price: $200
Antec P182 Gun Metal Black 0.8mm cold rolled steel ATX Mid Tower Computer Case - Retail
Price: $160
Antec True Power Trio TP3-550 ATX12V 550W Power Supply with Three 12V Rails 100 - 240 V UL, CUL, FCC, TÜV, CE, C-tick, CCC, CB - Retail
Price: $120
2 x Patriot eXtreme Performance 2GB (2 x 1GB) 240-Pin DDR2 SDRAM DDR2 800 (PC2 6400) Dual Channel Kit Desktop Memory - Retail
Price: $140 (for 2)
Western Digital Raptor WD1500ADFD 150GB 10,000 RPM 16MB Cache Serial ATA150 Hard Drive - OEM
Price: $180
Western Digital Caviar SE16 WD7500AAKS 750GB 7200 RPM 16MB Cache SATA 3.0Gb/s Hard Drive - OEM
Price: $200
MSI NX8600GTS-T2D256E-OC GeForce 8600GTS 256MB 128-bit GDDR3 PCI Express x16 HDCP Ready SLI Supported Video Card - Retail
Price: $150
Microsoft Windows Vista 64-Bit Ultimate for System Builders Single Pack DVD - OEM
Price: $200 (Yes, I actually bought Windows ;)
LITE-ON Black 20X DVD+R 8X DVD+RW 8X DVD+R DL 20X DVD-R 6X DVD-RW 12X DVD-RAM 16X DVD-ROM 48X CD-R 24X CD-RW 48X CD-ROM 2MB Cache E-IDE/ATAPI DVD Burner with LightScribe Technology - OEM
Price: $37
Arctic Silver 5 Thermal Compound - OEM
Price: $11

Total price: $1,727 (includes shipping but also includes discounts for mail-in rebates)

I priced a similar system with Dell at $2,808 - a savings of over $1,000. Of course, this doesn't include the cost of my time to build the machine (which is not trivial), but as a hobbyist, it's fun to build my own PC and I like to know exactly what componenets are going into my system.

I decided to go with an Intel quad core processor clocked at 2.4 Ghz. Intel CPUs recently had a substantial price cut, and this processor was formerly around $550 whereas I was able to pick it up for $290. For around the same price, I could have picked up a dual core CPU clocked at 3.0 Ghz, but decided against it. The higher clocked CPU might be better for gaming, but I'm not a big gamer, and I think I'll appreciate the multitasking benefits of more cores and hopefully the future benefits more and more cores start appearing in systems and software is, hopefully, better designed to make use of them.

I also decided to go with 2 hard drives: a fast, smallish one for OS and program files, and a larger one for user data and media. I picked the fast Raptor as my system drive in part due to a good write up at Coding Horror, and I got the 750 GB Western Digital drive as per advice at Tom's Hardware. I thought about going for a full terabyte drive, but the cost seemed a little too prohibitive for the extra amount of storage over 750 GB.

As for my experiences building and using the system so far, they've been unexpectedly smooth. The Antec case was a joy to work around, and I didn't run into any problems getting the machine to boot after everything was assembled (which has never happened with the computers I've built in the past). The PC has been outrageously fast so far. The Vista Aero Glass UI runs very smoothly, and I'm even able to run a full screen hi-def video ala Vista Dreamscene (a video of a river running towards me, in my case) as my desktop background with no noticeable slow down. The components that I bought are well suited to overclocking, so I should be able get the processor up to 3.0 Ghz fairly easily, (as Scott Hanselman and Jeff Atwood did), but the box has been running so quickly and smoothly that I haven't felt the need to. Also, the system is substantially quieter than my old PC.

I was a little skeptical about switching to a 64 bit OS, but working with Vista 64 has been surprisingly smooth and I've had little compatibility problems so far. There is one glaring problem, however: my iPhone doesn't work with Vista 64. When I plug it in, iTunes prompts me to "Please plug the iPhone into a computer running Windows XP or Vista 32 bit edition". The iPhone does, though, show up as a drive in Vista and the import photos dialog automatically launches when I plug it in. So, until Apple fixes this problem, I've got the iPhone syncing with another PC running XP. A hassle, but not a deal breaker.

I've got a set of pictures of the build on Flickr, and I have more detailed descriptions of various components and build steps in the picture descriptions. You can find the set here.

Here are several resources I found helpful during the build:

Scott Hanselman - Ultimate Developer Rig: Part 1, Part 2, Part 3, and Gone Quad
Coding Horror - Building a PC: Part 1, Part 2, Part 3, and Part 4
Hanselminutes Podcast: Building a Developer PC and Jeff Atwood Overclocks the Ultimate PC
Silent PC Review
End PC Noise

Intro

2007-08-17T00:00:00+00:00

I'm trying to get my personal site in order, and I've decided to launch this new blog to get things under way. The site's been neglected for quite awhile now, so now I'm hoping to give it the attention it deserves and have a little fun in the meantime. [more]

Personal Update

All in all, things have been going very well at home. Jamilya and I still aren't sure of a wedding date, although we're tentatively shooting for the first half of next year (need to get on the ball about this one). However, we're still a very happy couple I'd say (and hopefully she would too), and I think she's learned to put up with my geeky quirkitudes very well.

I sold my motorcycle. It was sad to see her go, and she was a great bike, but I just wasn't riding enough lately. Riding on the streets became less and less appealing, and although track days are great, they can be a little pricey. Maybe I can manage to get a dedicated track bike in the future and ride just there (where there are no cars, trees, or fence posts and everyone is going in the same direction).

Having sold my bike, with extra cash in hand, and with an expiring Verizon contract, wasn't it only natural that I get an iPhone? I won't bore with too many details (as I think enough... has... already... been... written about one of the most highly-anticipated consumer electronics devices in history). It was funny, however, when I called Verizon to cancel my contract and port my phone number -- The operator asked me why I was leaving Verizon and if there was anything they could do for me to make me stay. I simply said "iPhone", and the lady excitedly asked me how I liked it and told me that, in this case, she totally didn't blame me for leaving Verizon (true story!). The thing has been great so far, and is a real joy to use.

I'm still pursuing my masters at Auburn (in software engineering), and I'm slowly but surely fulfilling my 33 required hours (my just-completed summer class made my total 17). I'm taking it at the relaxed pace of one class per semester, and this, with work, gives me ample time to concentrate on each individual class. Even though it's tiring to come home and watch streaming video courses, then keep up with homework and assignments after a brain sapping day at work, I'm thankful for them, as they keep my neurons firing about exciting areas of software engineering. It's also been interesting to see how I've been able to apply my, albeit limited, work experience to courses in ways that I was too ignorant to do while I was an undergraduate student.

In my last class (on software environments), I was able to experiment with creating a custom plug-in for the Eclipse development environment. For this, I created a stripped-down duplicate of this plugin from scratch (with the teacher's approval of course - the idea was to get an overview of Eclipse's architecture), which calls the Google Code Search web service to search for relevant source code within the development environment. The Fall semester just started, and I'm taking a class on formal methods for software engineering, where I'll be learning the Z specification language.

I'm still enjoying my job at ASI, and am still working on back-end web development using ASP.NET. On my current project, we've been able to explore several interesting areas of AJAX development, as well delve into some intersting data acess patterns using Visual Studio 2005. I've been there for a little over a year now, and it's turned out to be a great environment where I've learned a lot.

Site Technical Background

Since I stopped using Blogger many months ago, I've had several ideas for using different blog platforms to create a new blog and personal site. Since I work with Microsoft technologies and ASP.NET, I wanted to stay close to home, so I investigated a few .Net blogging platforms (SubText and DasBlog). In fact, the previous version of the site was made using SubText as a prototype. While these are very established and capable projects, I was looking for something a little more stripped down and easier for me to get my head around.

I also experimented with creating a custom web application that used the web solely for data storage, with a private Blogger account storing my blog entries (as, I think, William Gibson's blog does), and my other bits of information (blogroll, amazon wish lists, videos, music lists) stored somehow online too. I went down this path for awhile, but then an up and coming .Net blog engine called BlogEngine.Net caught my eye. It's aimed towards simplicity, and I delving into the source doesn't seem, to me at least, as intimidating as other .Net blogging platforms.

Purpose

I have a few major purposes that I hope this site will serve as:

A place to share my personal info (personal blog entries, pictures, movies and music lists)
A place to share professional or technological bits
A test area for experimenting with new technologies (VS 2008, AJAX, BlogEngine.Net customizations, Silverlight, etc)
A playground for experimenting with web design
A way for me to work on writing skills
Not a system that makes me feel pressure to write necessarily lengthy (or even frequent) entries.

Roadmap

Things I have planned for the immediate future are:

Create a custom theme that uses the blog's standard functionality using this theme (maintaining complete compatibility with BlogEngine .Net's theming mechanism).
Fork development on this custom theme and create a site that I can more heavily customize.
Integrate custom parts into the site (such as a Flickr badge, del.icio.us list, and last.fm list).

That's all for now. I'm in the middle of a few computer upgrades now, so I'll have details on this coming in a bit.