What does that mean for 2012? I’ve got a couple ideas.

iOS (Apple)

Apple leaves 2011 in a comfortable position – they aren’t the largest smartphone vendor any more, but they still have the most widely distributed handset and a sizable amount of the profit. Though Android is applying significant pressure, consumers still seek out Apple’s mobile products, which should maintain their control – if not dominance – of the mobile space through 2012.

Look for Apple to continue to iterate on its mobile products, incorporating popular features from other platforms (with the usual Apple polish) while introducing new features that are unique to their platform, some of which will go on to define what it means to be a smartphone. Given Android’s increasing sales, also look for Apple to bend to the desires of the carriers somewhat more than in the past; core areas (UI, battery life) will be unaffected, but carrier apps that provide features unavailable to regular App Store developers are likely.

Android (Google)

2011 was a massive year for Android – two big releases (Gingerbread, Honeycomb), a big push into the tablet space, and a large number of innovative phones across all price ranges were released. 2011 was a bit rocky, too – Android faces some serious patent challenges from Microsoft and others, and consumers are starting to see the downside to Android’s customizability, especially when it comes to updates.

2012 will be a good year for Android on inertia alone, but Google needs to use the time to position themselves well for the future. Google’s purchase of Motorola and the increase patent litigation will put pressure on Android manufacturers to think twice about betting their future solely on Android, a fear that Google will have to calm. Furthermore, Android isn’t looked to for new ideas – it’s looked to for common features, cheaply. For them them to gain mindshare (and, eventually, marketshare), they will have to invest resources in making Android a truly excellent platform to use, not just a platform with impressive technical qualifications.

Windows Phone 7 (Microsoft)

2011 was a year that really didn’t happen for Windows Phone. The one big release saw much love from owners but little attention from the market, and the Nokia partnership did not impact consumers until the last quarter of the year (and not at all in North America). Even Microsoft’s already miniscule marketing campaign for the platform petered out, with no major ad campaigns that caught my eye (at least in Canada).

Microsoft’s challenge for 2012 isn’t technical – it’s marketing. They have a very capable platform with competitive – and in my personal opinion, compelling – features that don’t try to play the ‘me too!’ game with Apple. Furthermore, the introduction of the Metro design language to the Xbox and in Windows 8 could introduce users to a new way of thinking about computing. That’s not going to happen if Microsoft doesn’t step up to the plate and aggressively market Windows Phone as compelling alternative to the other phones in the space.

BlackBerry (RIM)

Any way you slice it, 2011 was a bad year for RIM. Despite increased sales, and layoffs designed to appease the markets, RIM saw a continually declining stock price, constant takeover rumours, and calls for its executives to resign. Even their flagship product release for the year, the PlayBook, saw massively underwhelming demand and markdowns in excess of $200 in the latter portions of the year.

To top it off, 2012 looks to be even worse for RIM, with little hope for recovery. Their much-heralded “new OS”, BB10, won’t arrive until the fourth quarter.  There may be new devices running old software, but savvy consumers will be cautious when purchasing the last of a dead technology. No exciting new features for BB10 have been announced, either – it will do email, show videos, and surf the web in a new way, but one that is unlikely to be much different from the old way and certainly not enough to reverse the trend away from BlackBerrys to more engaging platforms. A takeover is possible, though there aren’t many companies up to the task – others in this space have already made their purchases, and RIM has been quick to spurn recent pursuers.

…and some broad themes

There are a few themes that, in my opinion, will come to define the year 2012 in the mobile space. The first of these is that 2012 will be the year that smartphones will become the primary units sold by carriers. Carriers today have a large user base on so-called feature phones, and still sell a large number of these low-cost phones. However, with the potential for new revenue through data add-ons, a general decline in traditional (voice) revenue, and the availability of low-cost smartphones (less than $200 off-contract), I expect carriers to aggressively reduce feature phone selection in their product offerings.

A second theme I expect for 2012 is a general decline in native mobile applications. HTML 5 gives developers incredible flexibility to build good applications with web technologies, applications that will work across devices. Maintaining three separate codebases – one for iOS, one for Android, and one for the web (covering desktops and other phones) – is time-consuming and expensive.  Using the “same” application everywhere will allow companies to put more effort into core features over pure platform parity. Now, that doesn’t mean that apps won’t be available through the App Store/Android Marketplace – they will – or that we won’t see separate versions of an app for iPhone and Android – we will. Rather, what we’ll see is that the technologies new apps are built with will shift from platform-specific to platform-independent HTML and Javascript, allowing developers to re-use core logic while maintaining device-appropriate visuals.

Finally, I expect that we will see the importance of cloud-based services to the smartphone ecosystem play a more visible role. Consumers don’t choose smartphones for their hardware, their fancy looks, or their enterprise-grade reliability; they choose them for what they allow them to do, and how they allow them to communicate. That means these devices must support the services they already use, and the communities they are already a part of. If I’m a Facebook/Dropbox/Instagram user, then my device must support that combination. Platforms that allow user combinations to happen – iOS through its strong developer base and simple cloud services, Google through the introduction of apps for its services (which many already use), and Microsoft through first-party support for third party services (Facebook chat, the People hub) – will have a significant edge on those who dont (RIM).

EXIF in .NET

The .NET framework provides two ways of accessing EXIF data; functions in the System.Drawing namespace, and functions in the System.Windows.Media.Imaging namespace.  There are also a number of libraries available to read EXIF data in .NET – which are generally easier to use than the built-in classes – but I’ve found that costs associated with loading and deploying an extra library are not worth it for the simpler programming interface.  Most of the time I’m only reading a couple properties, so doing it directly isn’t that difficult.

Given those two namespaces each provide a way of reading EXIF data, which one is better?  In my view, neither.  Each provides the same functionality, and though the System.Windows.Media.Imaging namespace does provide properties to allow reading some values directly – like the camera’s manufacturer or the date the photo was taken – they are limited enough in practice that you’ll end up using the tag values anyway.

So which one should we choose?  It’s actually quite simple; if you are using Windows Forms, use the System.Drawing version, since you’ve already loaded the appropriate DLL.  Likewise, if you are using WPF, use the System.Windows.Media.Imaging version.  And if your application doesn’t have a UI (or is using an alternate framework), then the choice is up to you – though I’d suggest using the System.Drawing version.  The System.Drawing namespace resides in System.Drawing.dll, which weighs in at 612 KB on my system, while System.Windows.Media.Imaging resides in PresentationCore.dll, which weighs in at 4112 KB (PresentationCore contains the majority of WPF).  The increased size of the latter DLL results in a slightly slower first-image processing time, as the framework loads the DLL into memory.

Accessing EXIF data with C#

Using the System.Drawing/Windows Forms version of accessing EXIF data is relatively straight forward: load the image, request a property by number, and then parse the property bytes into the desired format (string or integer). Let’s have a look:

using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.Text;

class EXIF
{
    static void Main()
    {
		// Create an Image object
		using (Image photo = Image.FromFile(filename))
		{
			// Read out the date taken property (string)
			PropertyItem dateProperty = photo.GetPropertyItem(0x9003);
			string dateTaken = (new UTF8Encoding()).GetString(dateProperty.Value);

			// And the ISO (unsigned short integer)
			PropertyItem isoProperty = photo.GetPropertyItem(0x8827);
			ushort iso = BitConverter.ToUInt16(isoProperty.Value, 0);

			// other properties can be read using similar methods...
		}
    }
}

Like the previous version, accessing the EXIF data with System.Windows.Media.Imaging/WPF is relatively easy and follows a similar pattern. However, in this case the BitmapMetadata class exposes some of the EXIF values through properties on the BitmapMetadata object. The rest must be accessed using the GetQuery method, using the WIC Metadata Query Language. This query language unifies the types of embedded information that can be accessed (EXIF, XMP, IPTC, ID3, etc.) into a general-purpose syntax. We’re only concerned with the EXIF ones here, which have the form /app1/ifd/exif:{uint=999} or /app1/ifd/exif/subifd:{uint=99999}, depending on the tag you’re accessing. In general, tags less than 1000 (decimal) are accessed using the former syntax, those greater using the latter syntax.

using System;
using System.IO;
using System.Windows.Media.Imaging;

class EXIF
{
    static void Main()
    {
		// Load and decode the photo
		using (FileStream stream = new FileStream(filename, FileMode.Open))
		{
			JpegBitmapDecoder decoder = new JpegBitmapDecoder(stream,
										BitmapCreateOptions.PreservePixelFormat,
										BitmapCacheOption.None);

			// Extract the photo's metadata
			BitmapMetadata metadata = (BitmapMetadata)decoder.Frames[0].Metadata;

			// Read out the date taken property...
            // ...  via the built-in property (as a System.DateTime)
			DateTime dateTaken1 = DateTime.Parse(metadata.DateTaken);

			// ... or via a query (as a string)
			string dateTaken2 = (string)metadata.GetQuery("/app1/ifd/exif/subifd:{uint=36867}");

			// And the ISO (unsigned short integer)
			ushort iso = (ushort)metadata.GetQuery("/app1/ifd/exif/subifd:{uint=34855}");

			// other properties can be read using similar methods...
		}
    }
}

Accessing EXIF data with Powershell

Since PowerShell has easy access to the .NET framework, grabbing metadata from a photo using PowerShell is just as easy as doing it in C#, which makes it great for scripting photo tasks.  First up is the System.Drawing/Windows Forms version:

# Load the System.Drawing DLL before doing any operations
[System.Reflection.Assembly]::LoadWithPartialName("System.Drawing") > $null

# And System.Text if reading any of the string fields
[System.Reflection.Assembly]::LoadWithPartialName("System.Text") > $null

# Create an Image object
$photo = [System.Drawing.Image]::FromFile($filename)

# Read out the date taken property (string)
$dateProperty = $photo.GetPropertyItem(0x9003)
$dateTaken = (new-object System.Text.UTF8Encoding).GetString($dateProperty.Value)

# And the ISO (unsigned short integer)
$isoProperty = $photo.GetPropertyItem(0x8827)
$iso = [System.BitConverter]::ToUInt16($isoProperty.Value, 0)

# other properties can be read using similar methods...

# Dispose of the Image once we're done using it
$photo.Dispose()

We can also use the System.Windows.Media.Imaging/WPF version from PowerShell.  Like the C# version, some values are exposed through properties on the BitmapMetadata object directly; the rest must be accessed using the GetQuery method.  Queries take the form /app1/ifd/exif:{uint=999} or /app1/ifd/exif/subifd:{uint=99999}, depending on the tag you’re accessing.  In general, tags less than 1000 (decimal) are accessed using the former syntax, those greater using the latter syntax.

# Load the System.Windows.Media.Imaging DLL before doing any operations
[System.Reflection.Assembly]::LoadWithPartialName("PresentationCore") > $null

# Load and decode the photo
$stream = new-object System.IO.FileStream($filename, [System.IO.FileMode]::Open)
$decoder = new-object System.Windows.Media.Imaging.JpegBitmapDecoder($stream,
           [System.Windows.Media.Imaging.BitmapCreateOptions]::PreservePixelFormat,
           [System.Windows.Media.Imaging.BitmapCacheOption]::None)

# Extract the photo's metadata
$metadata = $decoder.Frames[0].Metadata

# Read out the date taken property...
# ...  via the built-in property (as a System.DateTime)
$dateTaken1 = $metadata.DateTaken
# ... or via a query (as a string)
$dateTaken2 = $metadata.GetQuery("/app1/ifd/exif/subifd:{uint=36867}")

# And the ISO (unsigned short integer)
$iso = $metadata.GetQuery("/app1/ifd/exif/subifd:{uint=34855}")

# other properties can be read using similar methods...

# Dispose of the FileStream once we're done using it
$stream.Dispose()

EXIF Tag Reference

The numbers used in the examples above can be found in the table below.  This table is not intended to be comprehensive – there is far too much complexity in the EXIF format for that.  Most manufacturers add their own information in proprietary formats (you can usually decode this, but you need to support each manufacturer separately – Canon camera’s don’t write the Nikon fields), and not all cameras write all fields, and there are non-EXIF storage formats that are used as well (XMP, IPTC, ID3, and more).  If you are looking for comprehensive, I’d recommend this page on Phil Harvey’s ExifTool site; otherwise, here’s a list of the most common, relatively standard ones. All integers are 32 bits in length, except those with the notation ‘short’; they are 16 bits in length. Integer rationals are stored XY, where the value is equal to X/Y; most are 64 bits in length (two 32 bit integers back-to-back).

For as long as I can remember, my parents have been labelling the back of the photos in their photo albums with the month they were taken.  That way, when browsing an album years in the future it is easy to see exactly when something happened and how old I was at the time (they sometimes label the people and the places as well, depending on how non-obvious these attributes are in the photo itself).  Though it takes a bit of work to make all these annotations, the outcome is well worth it in the end.

With traditional film, there are few alternatives to manually annotating photos; ‘burning’ the date into the photo itself is one technique, but obscures some of the image as a result.  But with digital photos, this information – and much more – is stored alongside the photo by the digital camera.  And on the back of the prints we get back from Photolab/Zehrs, they conveniently print the photo filename on the back of the photos.  Wouldn’t it be nice if we could put the date into the filename to make annotating our photos easier?

Naming photos for printing with PowerShell

With my new-found interest in scripting with PowerShell, I figured that there must be a way to automatically name files based on the date they were taken.  Sure enough, there was – the Image class, part of the System.Drawing namespace, allows reading of the EXIF data stored by the camera in the photo.

# Load image and get EXIF date
[System.Reflection.Assembly]::LoadWithPartialName("System.Drawing") > $null
$photo = [System.Drawing.Image]::FromFile($file)
try
{
	$dateProp = $photo.GetPropertyItem(36867)
}
catch
{
	try
	{
		$dateProp = $photo.GetPropertyItem(306)
	}
	catch
	{
		continue
	}
}
$photo.Dispose()

While it is rather straightforward to get EXIF metadata in general from a photo, it takes a bit more work to get the precise data you want.  EXIF data is stored as key:value pairs in the image, with the keys being standardized numerical identifiers.  Here, we first try to access the ‘Date Taken’ value with key 36867, and should that fail, the ‘Date Time’ value with key 306.  These numbers are completely unintuitive, but can be found at various places on the web; an extensive list (if you already know what you are looking for) is in enumeration format here.  If neither can be accessed, we skip renaming the file; this is likely the result editing the photo with a program that does not preserve this data.

Once we’ve retrieved the date the photo was taken from the EXIF metadata, we still have to parse it into a string that we can use for our filename.  The data is stored using UTF8 encoding, so we first transform the raw bytes into a string, and then pull the useful parts of the date out into separate variables.

# Convert date taken metadata to appropriate fields
[System.Reflection.Assembly]::LoadWithPartialName("System.Text") > $null
$encoding = New-Object System.Text.UTF8Encoding
$date = $encoding.GetString($dateProp.Value).Trim()
$year = $date.Substring(0,4)
$month = $date.Substring(5,2)
$day = $date.Substring(8,2)

With that data (and a simple regex), I finished the script by renaming the file into the form ‘YYYY.MM.DD.iNNNN.jpg’, where NNNN is the four-digit image number of the original file (my parent’s camera, a Canon, names files IMG_NNNN.jpg; other manufactures use similar formats).  Now when we print our photos, we don’t need to add the date by hand – the script ensures that a string like ‘2010.01.05.i1234.jpg’ is printed on the back of our photo, which tells us the date (January 5th, 2010) as well as what to search for if we need to print another copy (‘1234’, which finds the original image ‘IMG_1234.jpg’ (again, this example is for Canon cameras)).

Renaming Files with Date Taken: The Full Script

The next time you need to send photos for printing, give the script a try.  Running the script is easy; simply make a copy of all the photos you want to print into a new folder, and save the following PowerShell script into the directory with the photos for printing.  Then, right-click on the script and select ‘Run with PowerShell’.  The script scans the directory, finds all of the images, and then renames them based on the ‘Date Taken’ EXIF field.

PowerShell Date Taken Naming Script [ps1, 6.7K]

Enter PowerShell, the Windows scripting language that purportedly brings together the power of Unix shell scripts with the flexibility of the .NET framework. And it’s installed by default on Windows 7, to boot.  I’d seen an interesting demo of how WPF and PowerShell worked together, so when I recently found the need to send a bunch of mark reports out, I figured it was time to give it a whirl.  There were a couple of tricky problems I encountered while I was throwing the script together; here’s a quick overview of sending email with PowerShell.

The Basics

First, we need an email to send.  This should do:

# Mail Message
$from = "user@domain.com"
$to = "user@domain.com"
$subject = "Hello from PowerShell"
$body = "This is a message saying hello from PowerShell."
$hasAttachment = $false
$attachmentPath = "attachmentPath.txt"

The primary requirement for sending email is access to an SMTP server; it needn’t be on the local machine.  We’ll use Gmail’s SMTP server:

# Mail Server Settings
$server = "smtp.gmail.com"
$serverPort = 587
$timeout = 30000          # timeout in milliseconds
$enableSSL = $true
$implicitSSL = $false

Pretty basic stuff; here we’re using smtp.gmail.com on port 587, and we’re using an SSL-encrypted connection.  We’re also not using implicit SSL, and instead using explicit SSL; wait, what’s the difference?

Explicit SSL

Explicit SSL, as described here, means that the client first connects to the server using an unsecure channel, requests that conversations be moved to a secure channel, and then both server and client switch to a secure connection and the rest of the communication is encrypted.  Though this sounds somewhat lengthy, it’s the standard procedure for setting up an SSL connection (see RFC 2228).  Gmail handles explicit SSL without any difficulties, as do many other mail servers; Gmail’s explicit SSL server runs on port 587.

Implicit SSL

In contrast, implicit SSL drops the SSL negotiation and jumps right into the SSL connection to begin with. Often, this is done through a connection to a specific port that only accepts secure connections.  There is no official standard for this mode of communication, though it’s widely implemented; Gmail also handles implicit SSL, this time on port 465.

The Catch

My local university SMTP server only handles implicit SSL, so I needed to find a way to work with this variant.  Unfortunately, the standard .NET library for sending mail, System.Net.Mail – the one often used from PowerShell to send mail – don’t support implicit SSL.  Luckily, System.Web.Mail – an older, now obsolete mail sending library residing in System.Web.dll – does support implicit SSL. 

Putting it all Together

Now that we’ve got a strategy for handling implicit and explicit SSL, let’s code up a section of our script to handle each of these servers so we can switch back and forth easily.

We’re also going to need a set of credentials if we’re logging into a secure server; the Get-Credential cmdlet is just the ticket:

# Get user credentials if required
if ($enableSSL)
{
    $credentials = [Net.NetworkCredential](Get-Credential)
}

We could also prompt at the command line for a username/password combo or just hardcode these values into the script, but the Get-Credential cmdlet is an easy way to get and store just the information we need.

Explicit SSL with System.Net.Mail

We’ll be using the System.Net.Mail namespace to send email to servers using explicit SSL, or to servers that do not require SSL connections.

if (!$enableSSL -or !$implicitSSL)
{
    # Set up server connection
    $smtpClient = New-Object System.Net.Mail.SmtpClient $server, $serverPort
    $smtpClient.EnableSsl = $enableSSL
    $smtpClient.Timeout = $timeout

    if ($enableSSL)
    {
        $smtpClient.UseDefaultCredentials = $false;
        $smtpClient.Credentials = $credentials
    }

    # Create mail message
    $message = New-Object System.Net.Mail.MailMessage $from, $to, $subject, $body

    if ($hasAttachment)
    {
        $attachment = New-Object System.Net.Mail.Attachment $attachmentPath
        $message.Attachments.Add($attachment)
    }

    # Send the message
    Write-Output "Sending email to $to..."
    try
    {
        $smtpClient.Send($message)
        Write-Output "Message sent."
    }
    catch
    {
        Write-Error $_
        Write-Output "Message send failed."
    }

}

Using System.Net.Mail is pretty straightforward – we create an SmtpClient to connect to the mail server with, and make the appropriate settings.  Setting Timeout isn’t necessary, but since the default is really high (something like 100,000 milliseconds) and most servers respond quickly, setting it to 30 seconds ensures that the script will fail in reasonably short order if it cannot connect.

Creating a message is easy too – we just create a new MailMessage and pass in our message to its constructor and attach any necessary files.  Then we call the Send function on the SmtpClient we created, and the message goes on its merry way.

Users of PowerShell version 2 or greater can also make use of the Send-MailMessage cmdlet, which wraps System.Net.Mail in an easy-to-use cmdlet.

Implicit SSL with System.Web.Mail

For servers that only support Implicit SSL, we’ll be using the System.Web.Mail namespace.  This namespace has been made obsolete in favour of the newer System.Net.Mail namespace, but at the current time it’s still included in the .NET Framework and so we can take advantage of it here. 

else
{
    # Load System.Web assembly
    [System.Reflection.Assembly]::LoadWithPartialName("System.Web") > $null

    # Create a new mail with the appropriate server settigns
    $mail = New-Object System.Web.Mail.MailMessage
    $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/smtpserver", $server)
    $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/smtpserverport", $serverPort)
    $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/smtpusessl", $true)
    $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/sendusername", $credentials.UserName)
    $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/sendpassword", $credentials.Password)
    $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/smtpconnectiontimeout", $timeout / 1000)
    # Use network SMTP server...
    $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/sendusing", 2)
    # ... and basic authentication
    $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/smtpauthenticate", 1)

    # Set up the mail message fields
    $mail.From = $from
    $mail.To = $to
    $mail.Subject = $subject
    $mail.Body = $body

    if ($hasAttachment)
    {
        # Convert to full path and attach file to message
        $attachmentPath = (get-item $attachmentPath).FullName
        $attachment = New-Object System.Web.Mail.MailAttachment $attachmentPath
        $mail.Attachments.Add($attachment) > $null
    }

    # Send the message
    Write-Output "Sending email to $to..."
    try
    {
        [System.Web.Mail.SmtpMail]::Send($mail)
        Write-Output "Message sent."
    }
    catch
    {
        Write-Error $_
        Write-Output "Message send failed."
    }
}

As we can see, using System.Web.Mail is quite a bit more convoluted.  First up is loading the System.Web DLL, which is where this namespace resides.  Then, we configure the mail client using CDO fields; most of them have pretty obvious settings, though sendusing and smtpauthenticate are a little obtuse (see the comments in the script for what each value means).  Unlike System.Net.Mail, these server settings are made on the MailMessage class itself, which is also where we set the message properties and add any necessary attachments.  Finally, we send the mail using the Send static function on SmtpMail, and the message goes on its merry way just as before

A Final Note for Gmail Users

Gmail’s authentication settings are a bit strange; in my testing, I’ve found that you need to enter just your username (not username@gmail.com) in order to authenticate with their SMTP servers.  This causes a bit of a problem with Google Apps installations, which also use smtp.gmail.com as their SMTP gateway; username@domain does not work, and I’ve yet to find a workaround.

Also, while Gmail supports explicit and implicit SSL, it does so on different ports – 587 and 465, respectively.

Sending Email with PowerShell – Piece of Cake!

After a bit of hacking, I now understand just what those scripting folks feel when the advocate for scripting environments – it really is quite easy to accomplish what you need to accomplish without a whole lot of code.  And even though I needed to drop into the .NET framework to get classes to deal with explicit and implicit SMTP servers, that was hardly a problem – those classes integrated with the rest of my PowerShell script seamlessly.  PowerShell is certainly a very powerful environment, and I’m glad to add it to my technical bag of tricks.

PowerShell Email Script [ps1, 3.2K].

Though this example looks at farmers, it applies to countries as well.  However, the use of regulations can complicate the analysis, as regulations can be applied (through tariffs, import controls, or other measures) to artificially tip the scales in favour of one party.  If Farmer A were restricted to exporting 50 bushels of carrots, and not restricted on apples, then the market realities would result in Farmer A growing primarily apples even though he/she can grow carrots much more easily.  And as a result, the total output of the economy is reduced to 200 bushels, down from 275.  On the surface, applying regulations seems to be a pretty irrational thing to do – why would we work harder and produce less?

The answer to that question lies in the reasons behind applying those regulations, to which there are many.  The one I want to focus on today is protectionism – policies designed to ‘protect’ workers and businesses in a country from outside competition.  If India is able to produce technical workers more cheaply than North America can, then market pressures tend to result in those jobs being performed by Indian workers.  But, you exclaim, they’re stealing our jobs!  Outsourcing is bad!  Of course we should have regulations in place to stop it!

Economists have many good reasons why this isn’t be the case – foremost amongst them the principle of comparative advantage – as even considering these job losses the economy is still better off as a whole.  Though jobs are lost in the short term, in the longer term the local economy picks up the slack in areas the country is more suited to, resulting in a net gain.  The rise of information technology is one example of this; when computers were made domestically in North America, they were relatively rare and obtaining one was expensive.  By manufacturing them in countries with lower manufacturing costs, computers became mainstream and widespread – and we’ve subsequently built a massive business sector on top of them.  For all practical purposes, the Internet as we know it today wouldn’t exist without low-cost computers, and had we regulated the economy to discourage the outsourcing of computer manufacturing, we’d be years behind where we are today.  Granted, we missed out on the jobs that might have existed had we done that, but at the same time we’ve gained an entire sector of jobs in companies like Google, Microsoft, HP, Amazon, and the many, many tech startup companies.  And then we’ve created a whole host of jobs to support those jobs – would Google’s chef’s have a job if Google weren’t around?  Change is always hard, but by allowing it to happen we have indirectly benefitted ourselves – and the rest of the world!

The crux of this post is not comparative advantage and economic protectionism, but rather something I’m going to call technical protectionism.  In the tech field, the players aren’t so much people or companies, but rather, technologies themselves.  Few people would argue that Ruby is a better language to write web applications in than C, or that Photoshop is better than Paint, or that Mac is better than PC (just kidding!).  Actually, it’s that last one that is entirely my point; the Mac versus PC debate will continue indefinitely, as many of those doing the debating are debating for solely protectionist reasons.  There are completely valid technical (and non-technical) reasons why Mac is better than PC, and why PC is better than Mac, but more often than not the discussions seem to take place on a ‘it’s right for me, so it’s right for you’ level that lobs orthogonal arguments toward the opposing side in an attempt to win by attrition or disinterest.

The frustrating part in this whole issue is that, unlike with economic protectionism, technical protectionism is condoned by the tech community.  When the US introduced ‘Buy American’ clauses into some of their economic stimulus packages, experts on both side of the border – and the media to some extent – erupted in condemnation.  Now consider the last time you got into or observed a Mac versus PC, Windows versus Linux, Python versus Ruby style argument: those sorts of arguments are expected – and tolerated – by the technical community!

In my experience, these debates are intrinsically motivated by the participant’s own familiarity with a particular technology: I know how to build programs in technology X, therefore technology X is the right one to solve your problem with.  You see this all over the place – just look at small consulting firms, which often specialize in a single technology stack (Microsoft, IBM, Oracle, LAMP, etc.).  Having one of these firms pitch you a solution inevitably means them pitching a solution that runs on their stack without consideration of the others – if you want a vacation-planning application for 50 employees from an Oracle firm, then you’ll be paying for an enterprise grade Oracle database, regardless of whether a cheap LAMP application would have sufficed.  Sure, it may be unfair for them to pitch the value of another company’s services, but at what point should they be saying ‘this is not something we do well’, and voluntarily withdrawing from consideration so not to waste everyone’s time? 

Even taking a step back from companies, this behaviour is present even in the colleagues I interact with.  Since I worked at Microsoft, in technical debates I am automatically assumed to be the enemy of everything open source and the chief defender of everything Windows.  And while my experience gives me the ability to understand Windows’ capabilities and limitations, I’m not going to side with it automatically – it depends on the situation.  If you need a cheap server with a small application, Windows isn’t right.  If you need an expensive server with  a massive application, Windows isn’t right.  If you need a moderately expensive server with a medium sized application, Windows isn’t right.  And you know what?  You can replace ‘Windows’ in the previous three sentences with ‘Linux’, ‘Mac’, or any other technology – without looking at the precise details of the situation, it’s impossible to tell which combination of features and capabilities are appropriate for the problem at hand.

My fundamental point here is that it is impossible for one technology to solve every problem in the best way possible.  Comparative advantage tells us that the best way of solving all of problems is to choose the right tool for the job, regardless of what that tool might be.  Granted, choosing a tool is nowhere near as straightforward as counting bushels of produce, but the principle still applies: use the combined strength of all parties to the best of their individual abilities.  Sure, we have to make allowances for expertise and to minimize tool diversity to keep overall costs down, but supporting the notion that one can advocate for a particular approach solely because it’s what they know or believe is unproductive.  And yes, that means that you’re favourite solution won’t always win – and that’s OK.  By choosing the best tool for the job, we’ll have a better outcome in the end.

That’s not to say that having opposing products and companies isn’t useful – it is.  Sometimes you need to go against the grain and tackle the hard problems.  But when you do, use the best tools for the job and not the ones you know just for the sake of doing so.  Firefox is the browser it is because IE languished at the top of the market, and made no effort to improve.  Competition from Firefox was good, as it made developers on both teams compete to have the better browser.  At the same time, however, notice that the Firefox team didn’t start from scratch – they took the best technology that was available to them (Netscape) and made it better, rather than taking a protectionist approach and using what they knew.  Innovation occurs when we create something new, not when we take the long way to get to where we’ve already been.

As a community, we need to dispel the notion that technical protectionism is an acceptable attitude to have.  Objective criteria and constraints can be found for every problem we need to solve, and technologies can be evaluated against them impartially.  The next time you encounter an argument from a protectionist position, make sure to call it out, and make it know that this sort of justification is unacceptable.  Just as with outsourcing and the Internet, eliminating technical protectionism can have profound benefits we cannot even imagine, and until we start down that road, we’ll never know what we’re missing.

In that spirit, I’ve decided to put together a handful of applications over the course of the term in order to demonstrate various features of the C# language for programming beginners.  All of the samples will be available via my ECE 150 page, and will be updated as the term progresses.  How many I get done is entirely dependent on the amount of time and number of ideas I have; those that do get made will roughly correspond to each week’s content, and we’ll use them in the final review.  Full source code for each application is also available for those who want a deeper look into some of the features of C# and the .NET platform.

Check them all out at http://nicholasarmstrong.com/projects/teaching/ece150/

Computer Engineering: A Graphical Overview

During my 4A term at the University of Waterloo, a set of events that I don’t fully understand myself resulted in me becoming the yearbook editor for the Computer Engineering 2009 (8-stream) class.  When I was putting together our pages, I stumbled across Wordle – a web application for generating word clouds – and thought that I could use it to sum up Computer Engineering at UW graphically.

For data, I used the ECE course descriptions from the UW undergraduate calendar, filtered down to only include courses taken by computer engineering students, and with the addition of the course descriptions for core non-ECE courses (e.g. those offered through math or science).  The result was a word cloud consisting of the top 50 words used to describe computer engineering courses at the University of Waterloo, sized by the number of occurrences in course descriptions.

For those of you with the 2009 yearbook, I encourage you to check out the result on page 169; for everyone else, a PDF link is below.  Besides the words ‘computer’, ‘engineering’, and ‘ECE’, which were artistically weighted to dominate the cloud, it turns out that the terms ‘design’, ‘systems’, ‘analysis’, and ‘control’ all play a big part of a computer engineers’ academic life.  Who’d have guessed?

Computer Engineering: A Graphical Overview [pdf, 538K]

Having used Windows 7 off and on since last October – and using Vista for the year prior to that – going back to the version of Windows XP that came with the Mini just wasn’t an option for me.  Windows 7 has thoroughly impressed me so far on all the machines I’ve used it on, not only on a newer Intel quad-core but also on my 7-year-old Athlon XP desktop machine.  So I decided to grab the RTM version of Windows 7 off of MSDN and install it on the Mini; a quick guide to the install process and my initial thoughts on the Mini with Windows 7 follow.

Installing Windows 7 on a HP Mini 110-1030CA

Step 1: Choosing an Install Method

Like Vista before it, Windows 7 comes on a DVD – an awkward proposition for netbooks, which usually don’t come with an optical drive.  There are three general ways of getting Windows 7 on to these machines; via external DVD drive, via USB key, or via a DVD drive on a networked computer.  Since I don’t have an external DVD drive and my largest USB key is less than the required 4 GBs, I decided to take the third option – doing a network install via a DVD drive on another computer – and that’s the process I’m describing here.  A quick Google/Bing search for ‘windows 7 install netbook’ or similar should yield you a ton of results on how to do it with a USB key if you’re interested in that route, though it seems much more complicated than doing it over a network.

Step 2: Share out your DVD Drive

If you’ve shared a folder on your computer before, then sharing your DVD drive should be pretty easy.  Go to the computer you wish to share the drive from, and insert your Windows 7 disc.  If you’re on Windows 7, open ‘Computer’ by pressing Windows-E on the keyboard (or choose ‘Computer’ from the start menu) and locate the DVD drive in which you placed your Windows 7 install disc.  Right click on the drive and choose ‘Properties’ from the menu that appears; then, click the ‘Sharing’ tab.  Then, share the drive (‘Advanced Sharing’ –> ‘Share this folder’).  Finally, check to make sure that your computer is set up to share files by opening the Network and Sharing Center (Start –> ‘Control Panel’ –> ‘Network and Sharing Center’ –> ‘Advanced Sharing Settings’) and checking to make sure that ‘File and printer sharing’ is set to ‘Turn on file and printer sharing’.  You might also want to make sure ‘Password protected sharing’ is set as well.  Then, make a quick note of your computer’s name by hitting the Back button to go back to the Network and Sharing Center, and write down whatever the name of the computer is in the network map at the top of the screen (it will be labelled ‘this computer’).  If you are on Vista instead, the above instructions should work, though some of the items may have slightly different names.  And if you’re on Windows XP, then the steps are completely different – follow this support article instead, except you’ll be sharing out a drive instead of a folder.

Step 3: Configure your hard drive

If you only want to have Windows 7 on your machine, this step isn’t necessary.  However, if you want to dual boot Windows XP and Windows 7, or want to keep your XP partition around for restore purposes (my HP Mini 110-1030CA didn’t come with restore discs or a restore partition), then you’ll want to partition the hard drive in order to create a separate partition for Windows XP.  I used the free version of Easeus Partition Master to do this, but there are other options (Partition Magic, GParted, etc.).  Using your partition tool, resize/shrink the Windows XP partition so that there is enough room leftover to install Windows 7 (at least 16 GB, though that won’t leave much room for applications – Win7 takes around 10 GB on its own).  Then, create a new partition in the empty space, formatted as NTFS.  Hit apply, wait for the changes to take place (a reboot is probably required), and once it finishes you’ll have two hard disk drives that show up, one (C:) your previous Windows XP drive, now smaller, and another one (D:, unless you’ve selected a different mount point) that’s completely empty and waiting for your Windows 7 install.

Step 4: Start the install process

Now it’s time to start the install.  Connect your Mini to the same network as the computer you are sharing the Windows 7 install disc from.  You may have to mark this network as a ‘Home’ or ‘Work’ network for the computer hosting the install disc, since by default Vista and Windows 7 don’t allow file sharing over public networks.  Then, on your Mini, open the ‘Run’ box by pressing Windows-R on the keyboard (or choose ‘Run’ from the start menu) and type two back-slashes followed by the name of the computer hosting the install disc (you wrote this down in step 2).  For instance, if your machine name was ‘dvd-pc’, you want to type ‘\\dvd-pc’ in the run box.  Then, press OK; after a few seconds, an explorer window should appear containing all of the shares on the host computer.  Double click on the share you created in step 2 corresponding to the computer’s DVD drive (by default, it’s a single letter matching the driver letter of the DVD device on the host computer).  The DVD should spin up on the host computer, and you should see a number of folders appear along with an executable named ‘setup.exe’.  Double click ‘setup.exe’, and wait as the Windows 7 autorun starts (it could take 30 seconds to a minute, depending on your network speed).  Once it starts, select the ‘Install Now’ option, and wait as the installer loads (another minute or two).  Follow the prompts that appear, selecting ‘Clean’ install and the drive you created in step 3 when asked, and then sit back and wait as the installer copies all of the necessary files off of the disc via the Mini’s network connection, reboots to perform the installation, and reboots once more to prepare everything for use.  Once it’s done, it’ll ask you to configure the time zone, license key, and password, then it’ll drop you into the Windows 7 desktop with everything installed.

Step 5: Windows Update

The first thing you should do after installing a new operating system is to update it to the newest version, in our case by running Windows Update.  Simply type ‘Windows Update’ in the start menu, open the program that appears, and press ‘Check for updates’.  Once it comes back with a list of things to be installed, ensure there is a checkbox beside all ‘Recommended’ items and any important ‘Optional’ items (there was a network driver waiting for me under ‘Optional’, but I didn’t need any additional languages), and then press update to download and apply the updates.

Step 6: Install Missing Drivers

Once Windows 7 has finished update, you’ll have to install any drivers it wasn’t able to install during the install or update process.  On my HP Mini 110-1030CA, Windows 7 was able to find all of the drivers it needed, but there is one driver it doesn’t get perfectly right: the touch pad.  Don’t worry – the touch pad still works, but the scrolling functionality doesn’t work.  To fix it, head on over to the touch pad manufacturer’s driver site and download the drivers for Windows Vista 32-bit Edition (or Windows 7 32 bit, if they are there – they weren’t when I tried it).  Once the drivers are finished downloading, double click to start the install, follow the prompts, and reboot.  If you’re not using the same Mini I am, head on over to the Device Manager (type ‘Device Manager’ in the start menu) and locate the drivers for any device with an exclamation point beside it.  Windows will expand any item that has devices with missing drivers, to if all of the top-level categories are collapsed, you’re good to go.

Step 7: You’re Done!

Yep, that’s it – you’ve managed to install Windows 7 on your HP Mini!  Before you finish up, consider un-sharing your DVD drive by reversing the things you did in step 1; however, if you have more CD/DVD based software to install, do that first.

Windows 7 on a HP Mini 110-1030CA: The Results

I’m pretty impressed with how well the machine runs. I’ve upped it to 2 GB of RAM over the stock 1 GB since I had a spare 2 GB stick – and 2G RAM sticks are cheap enough now to make it worthwhile in any case – which allows Windows 7 to use it to speed up program launches.  It’s not perfect, of course – the screen often feels small, and I have encountered the occasional slow down, but outside of that it’s surprisingly usable for just poking around the Internet.

The Keyboard

I'd prefer a full-sized left shift, please and thanks

The keyboard’s pretty good (most places regard the Mini as having the best keyboard on a netbook, and I tend to agree), though my model has an odd copy of the ‘|\’ key where the rest of the left shift key should be which I keep pressing by accident when I try to type a capital.  It might be because I have a Canadian model (the keyboard has the French-Canadian keyboard markings too), though it’s something I’m sure I will eventually get used to (or I’ll learn to use the right shift key, which is full size).  In the meantime, I’ve used SharpKeys to remap the extra key to left shift so that it doesn’t interfere when hit by accident.  Incidentally, the other annoying key is the traditional ‘|\’ key; it is located on the middle row of the keyboard right before the two-row enter key, rather than above a single-row enter key.  Both my desktop keyboards have single-row enter keys, so this placement results in many accidental keypresses – and it’s not something SharpKeys can fix.  Outside of that, however, the keyboard has been great – a little smaller than I’m used to, but not enough to impact my typing.  The keys have a nice feel and travel, the arrow keys are arranged in an inverted T shape, both backspace and the spacebar are large, and the keys which have been removed from the keyboard to save space (home/page up/page down/end) have been function-mapped to easily memorable/accessible keys.  Surprisingly, HP didn’t function-map the number pad over the right half of the keyboard, but since I rarely use this feature I haven’t missed it.

The Screen

The screen is – as one would expect – quite small.  For web use, it hasn’t been a huge hassle; there’s just more scrolling than usual.  For regular application use, I’ve found it absolutely terrible at multiple windows.  At this point, I’ve basically given up using windows that aren’t maximized to the full screen size, and using more than one window at once is an exercise in alt-tabbing.  Even when using a single application, the small screen sometimes makes it difficult; there are a lot of applications that assume that vertical space is abundant, and fill it with 100+pixels of toolbars.  Careful selection and configuration can minimize this problem – I’ve found Google Chrome to be the fastest and leanest browser; Thunderbird (and Firefox) work better when using small toolbar icons, no toolbar text, no status bar, and this extension to get rid of the menu bar; Office’s ribbon can be minimized by double-clicking one of its tabs; and Windows 7 runs great with an auto-hide taskbar that’s mounted vertically along the side of the screen – but there are a few applications that perform poorly (I’m looking at you, Windows Live Messenger…).  Since more and more applications are on the web these days, the use of multiple windows is less and less of a concern.

The Horsepower

While I feared that the Mini would be underpowered, it has not turned out to be the case.  It’s not something I’d use for all my computing tasks, but for something small to tote around to check one’s email with and have something to do during otherwise wasted time, it can’t be beat.  The Mini has no trouble with regular-quality YouTube, even full-screen, though HD YouTube is too choppy to watch.  Microsoft Office runs great – heck, it’s even been handling Visual Studio admirably well.  With a Windows Experience Index of 2.0 (Processor: 2.2, Memory: 4.5, Graphics: 2.0, Gaming Graphics: 3.0, Hard Disk: 5.6), the HP Mini 110-1030CA is able to handle Windows Aero without trouble, too.  And it uses hyperthreading to present two ‘virtual’ processors to the operating system, which improves the interactivity of the system to the point where I haven’t noticed a foreground task being blocked by a heavy background one.  All in all, for the things I’m using the netbook for I can’t tell that this machine has significantly less power than the other machines I’ve used.

The Operating System

Windows 7 works great, no ifs, ands, or buts.  It’s modern, fast, and easy to use, and installing it (as the instructions above show) is a hassle-free experience.  And it’s certainly suited for netbooks – I’m running the Ultimate edition, and so far it has been consistently faster than the version of Windows XP that came with the Mini.  It responds instantaneously to keyboard and mouse input, and resuming from sleep or hibernate happens quickly.  With all of my commonly-used applications installed, it boots to the desktop in about 45 seconds, and it’s ready to go as soon as you see the desktop.  I haven’t experienced any stability problems, either with Windows itself or with the drivers it has loaded.  All in all, I’ve got no complaints whatsoever about Windows 7, and highly recommend that other netbook users out there install it as soon as they can get their hands on a copy.

Final Thoughts

Overall, I’m incredibly impressed with this little computer – and the emphasis there goes on both little and computer.  It’s sure easy to carry this thing around – it weighs just over a kilogram and measures 10.5” by 7.5”, making it smaller and lighter than most of my textbooks – and the battery life so far has been sufficient in every scenario I’ve used it.  And it’s an actual computer, not a glorified cell phone; I don’t feel myself avoiding typing on it or considering whether or not it supports something (Flash, Java, etc.), I just go ahead and do it.  The screen is large enough to read comfortably, and the speakers, while very definitely “laptop” sounding speakers, are clear and full.  Granted, there are some compromises one has to make – it’s certainly not a ‘desktop replacement’ laptop – but for me, those compromises are rare enough that I can work around them easily and still get a significant amount of utility from the Mini.  Final Vertdict: the HP Mini 110-1030CA is an excellent second (or third) computer for students and other people on the go, and works wonderfully with Windows 7.

This series is written for computer engineering students in the University of Waterloo’s cooperative education (co-op) program, which consists of a series of 6 work terms in a repeating 4 months school/4 months work pattern for four years of the student’s five year degree.  Most of the information presented here is not unique to UW students, however; students in a more traditional university program can still apply these tips by ignoring the term specifications and applying them in order to their work opportunities instead.  Longer (8-, 12-, or 16-month) work terms also fit into this model; aim to be done the same things as a 4-month UW co-op student would be at that level of work experience (for example, a 16-month intern should try to complete items up to the 4th work term level by the end of their internship).

Your Sixth Work Term – Teeing Up the Rest of Your Life

Return to your previous employer, get a better job, or try something different – it’s up to you.  If you were lucky enough to land a job with a company you could see working for full time – and don’t have any higher aspirations for a starting position – then certainly consider returning to this employer for your last work term.  As was the case on your fourth work term, doing two consecutive work terms with the same employer allows you to leverage the company experience you obtained in your previous work term and gain more responsibility with less ramp up time.  Unlike on the fourth work term, however, there isn’t any pressure from older students on the job supply, so if you’re not completely happy – or just want to try something different – then take the opportunity to go through the interview process one last time.  Most employers hiring at the fifth and sixth work term levels evaluate their co-op students against the same standards they use for new graduates; this turns out to be a huge benefit for UW students.  To start with, most co-op students have significantly more experience by their fifth work terms than students from other universities do by the time they graduate, making it very easy to surpass this standards.  Secondly, most employers are very understanding of you taking your sixth work term to do something different and then returning to them full time, and will provide you with the contacts you need to land a job with the company in the future.  When you combine these things, you end up with a situation that is incredibly advantageous for you, whatever you decide to do on this work term.  And as long as you got a job on all of your previous work terms, you can even take this term off (though I’d suggest taking time off once you graduate instead; employers are well accustomed to it, and you’ll likely already have a full time job lined up and can afford to spend more).

Get a job with a company you want return to.  Getting a job with a company via co-op is usually significantly easier than the process new graduates follow, so using your sixth work term as an opportunity to get into a company is an excellent strategy.  To give you an example, co-op students at Microsoft returning full-time to the same team usually have no other interviews than their initial 1 hour co-op interview, held on the UW campus.  Switching teams requires more interviews, but its often more of a “can we work with this person” interview lasting an hour or so; your work for your former team vets your technical skills.  New graduates who haven’t done an internship with Microsoft, on the other hand, face one or two 8 hour days of interviews – a very gruelling process – on the Microsoft campus, which requires flying all the way out there and back if the student is not from the area.  Not only that, students from other schools start from scratch on their first day with the company, while you’ll already be an old hand by the time your first (full time) day rolls around.  Using your sixth work term this way makes life a lot simpler, so consider it when applying for jobs.

Negotiate upward.  It’s hard to overstate the value of a co-op student returning to an employer; hiring good people is hard work, and your 4-month co-op term(s) with an employer serve as an extended audition.  You can take advantage of this to negotiate a better position than is traditionally available to new grads – with a few caveats, of course.  First, for bigger companies you’ll probably be entering on their standard “new grad” employment package, so negotiating salary/benefits/vacation time is not generally useful – college recruiters typically aren’t authorized to go outside the “standard” package.  Some companies have a range of “standard” packages, but the choice of package is based on how valuable you are to the company; there’s not much you can do to change it (besides doing well on your co-op terms, of course).  So what do you negotiate on?  Your position!  If there is a project area you want to lead, a committee you want to be on, a job description you want to have, whatever it is that relates to your job duties – just ask!  Especially if you are returning to the same team under the same management, you’ll often get good results by discussing with your current manager what you are looking for in a full time position, and so long as it is reasonable, most managers are willing and able to hook you up.  Even if it means working on a different team – talented people are good for a company, regardless of which department they work in – there is a good chance that your manager has been around long enough to develop relationships with the right people to get you a better job than you would normally get, and one that is precisely what you are interested in to boot.  You’ll still end up starting as a new grad just like all of the other new grads, but while the other new grads are getting up to speed, you may be leading a feature area – which looks especially good come review time.

Plan for the future.  If you’ve found a company that you would consider returning to, plant seeds for the future.  The people you meet may be your future colleagues, so make sure to network and do all of the things you need to do to start getting people on your side so that you have a pool of allies to help when you need stuff done.  Indeed, as a co-op student you have the neat ability to use the naïveté defence of “I’m just a (dumb) co-op”, so you can even get away with asking senior people questions without repercussions – so forge relationships with some of these people by asking their advice.  And since there are likely aspects of your job that will rely on the goodwill of others, make sure to start contributing when others need help.  Always put your best effort into everything you do – you don’t want a colleague shooting down an idea of yours in a few years because their only experience of your track record was a couple of shoddy projects you did while you were a co-op.  The boundary between co-op and fulltime employee becomes blurred on the last few co-op terms – especially if you return to the company full time – so make sure to take note and foster the image you want to have as a full time employee.

That’s it – have fun!  In the end, everybody’s co-op experience is different, and there is no right or wrong way of doing things.  I hope this series has provided some guidance for the things you need to do and think about when you are working your way through co-op so that you can put yourself in a good position for a fulfilling (and lucrative) career in the computer industry.

Each work experience provides a different viewpoint on the set of skills necessary to make it to the top.  If you’ve had experience in co-op and want to share your thoughts or (dis)agree with any of the points I’ve made, post a comment or send me a note (‘contact’ at this domain) and I’ll amend these posts with your feedback. 

This series is written for computer engineering students in the University of Waterloo’s cooperative education (co-op) program, which consists of a series of 6 work terms in a repeating 4 months school/4 months work pattern for four years of the student’s five year degree.  Most of the information presented here is not unique to UW students, however; students in a more traditional university program can still apply these tips by ignoring the term specifications and applying them in order to their work opportunities instead.  Longer (8-, 12-, or 16-month) work terms also fit into this model; aim to be done the same things as a 4-month UW co-op student would be at that level of work experience (for example, a 16-month intern should try to complete items up to the 4th work term level by the end of their internship).

Your Fifth Work Term – Making a Name for Yourself

Apply for your dream job.  If you’ve been following the tips so far, you should be in striking range of your dream job – apply for it!  If the job is offered through the university’s Jobmine system, it’s likely that your employer is familiar with the co-op process – so be sure to participate in all of their activities.  Employer information sessions, group interviews, interview prep sessions, etc. – all are important to attend, even if they aren’t taking attendance (your competition is there, and employers often share tips about what it takes to impress them).  For the same reasons, consider going to the employer information sessions for other employers of similar calibre; though each person has their own opinions on what makes a good resume and what to ask during an interview, most of the top-tier employers agree on a common subset of these items, and their tips can ensure you nail every one of them.  Remember too that your goal is still to stand out, so be sure to introduce yourself to the recruiter, spend time on a good cover letter and tailored resume, and include a link to your portfolio – the top positions easily see more than 200 applicants a term, and while your experience to this point will get you on to a much shorter list of candidates they’d actually consider, you want to use every technique at your disposal to ensure you are in their interview set.  If instead you’ve decided that your dream job is with a company that doesn’t do co-op hiring through Jobmine, you’ll face a lot less competition but a lot more work.  First off, start early – landing an out-of-system job can take 3 months or more to set up, so make sure to start working at it midway through your previous work term.  Second, make it easy on the company you’re looking to work for – make sure your cover letter clearly explains why you want to work for them, when you are available to work, and how the co-op process works (if you get a response from a company you contacted, CECS can help out with the specifics).  Finally, be prepared to do everything yourself; you’ll need to arrange your visa if you are working out of country, you’ll have to find housing, and you’ll have to coordinate with CECS to ensure your work term gets counted for credit.  If it’s truly a dream job, though, the rewards should be worth it – and at the very least, you’ll get experience that no other student on campus has!  Regardless of where you’re looking for a dream job, the fifth term is the term to do it – in the best cases, you’ll have two terms to spend with the company (or one term with each of two companies); in the worst case, you’ll likely to still end up with interviews for a few of the top positions – which is great practice for your sixth work term interviews.

Be passionate.  The one thing that struck me about top-tier job interviews is how little they focused on the routine stuff (the “will this person play nicely with the other employees” type questions); in some fifth work term interviews, no questions of this type are asked.  Rather, they tend to be focused on technical details, and specifically, determining whether a person is passionate about technical details.  A lot of this is exposed through tricky technical questions – for those in the .NET world, it’s questions like those in this list by Scott Hanselman – but some also focus on what I like to equate with passion.  Looking back, I’d say that most of the questions I got while interviewing for my fifth work term were an attempt to figure out how passionate I was about technical things – though in most cases, I’d wager that the interviewer themselves didn’t realize that it was passion they were specifically looking for.  I only picked up on it through an interview with a technical architect on the Microsoft Office team, who repeatedly drilled me for more and more detail on my previous work term, where I had done a lot of work in WPF.  At the time, I couldn’t figure out why he was so interested – he admitted having no background in WPF – but he still rooted around in the details, had me justify why certain decisions were made, what was wrong with our project after we had finished, what we would do differently given different constraints (more people, more time, etc.), and generally poked around for technical details that had no apparent utility to him.  It was only afterwards that I figured out what it was he was doing – he was finding out whether I was interested in the details, whether I was motivated enough to figure out why things the way they were before making a decision that depended on them, and whether I was cared enough to see the flaws in my project – or broadly, whether I was passionate about the software I was building.  Whether or not I was passionate about the things he or his company did was secondary; his primary goal was to find out if I had the capacity to be just as passionate about his company’s products.  To a competent engineer, the technical aspects will come naturally out of that passion; if you encounter a problem where you need to know some arcane algorithm, then your passion to do your job well will result in you learning what you need to know to make a great product.  After recognizing this, I began seeing this search happening in other interviews, often not so explicitly but with the same (implicit) end goal in mind – if hired, will I care about what it is the employer does?  So be passionate about the things that you do, and make sure it shows in the interview.  Don’t just memorize the answers to common interview questions – know how they work and why your answer is correct.  Be able to provide more detail on any question you answer, and admit that you don’t know when you don’t have sufficient knowledge to give a defensible answer.  If passion isn’t one quality you possess about the work you are doing, then perhaps it’s time for a career change – the best employers will certainly be able to pick up on this, so don’t count on being able to land a great job without passion for what you do.

Be an expert.  By the time you’ve made it to your fifth work term, you will have accumulated more than a year’s worth of work experience – and three years of university – which is plenty of training to understand just about any practical technical topic out in industry.  However, it’s highly likely that your technical knowledge is spread out over a number of different areas, and it’s certainly the case for your academic experience, which may include such varied topics as physics, calculus, software, hardware, communications, controls – and the list goes on.  While a broad base of experience is always a good thing to have, detailed knowledge in a particular area (or areas) is more and more important as you progress through the co-op process.  The simple fact is that businesses hire employees to solve their problems, whatever those problems happen to be (from improving efficiency of the company itself, to figuring out what their customers want, to building things that solve their customers problems).  People who have detailed knowledge in solving a particular set of problems tend to come up with better solutions than those who don’t, and do so faster; both of these qualities are beneficial to a business.  Becoming one of those people with detailed knowledge in an area can make you a very valuable asset to the companies you work for, so find an area you are interested in or working on, and go deep.  Learn everything you can about it, by reading books and blogs, following industry developments in that area, and practicing your hand at it.  Often, some of these areas will develop naturally for you as you are assigned work in them, but you still want to make and effort and take steps to improve your knowledge.  Secondly, you want to volunteer your assistance in your expert areas to your co-workers; if your company can’t use your skill, then it effectively the same as you not having it.  You want to be the go-to person for people looking for details on topic X; it doesn’t matter how specific or broad topic X is, just that you are the go-to person for it.   Not only does it make you somewhat difficult to replace (for your current employer), but it’s one more defining characteristic that potential employers can use when hiring.  And the skill of being an expert in an area is often the first skill you will have that your interviewer doesn’t – they’ll have more overall experience, sure, but might not know your area of expertise to the same level you do, making you an attractive hire.  In my opinion, being an expert in an area is one of the most important characteristics of an employee; not only am I free from the responsibility of needing to know about everything and can instead rely on the experts nearby, but I am also secure in the knowledge that whatever it is that we’re building is the best that it can be, since each aspect was checked by an expert. 

Network.  For me, networking is all about outsourcing, in the quite literal sense of the ability to outsource some of your tasks to a network of friends, family, colleagues, coworkers, etc. instead of completing them entirely on your own.  Granted, in order to maintain your network, you are often required to contribute to the tasks of others, but the primary benefit your network has for you is its ability to outsource.  My network is most efficient at two sorts of outsourced tasks: knowledge gathering or transfer and distributed job hunting.  The network you build might have other capabilities, but those two are the ones I’ve found most useful.  The first, knowledge gathering, is all about asking your network for help on a specific problem you are encountering that you cannot find the solution to.  When your network is made up of experts (see above), this is an incredibly effective technique to use when you get stuck.  For example, on my last work term my demo machine started freezing when WPF applications were launched.  After a couple hours of fruitless investigation, I asked my network, and was quickly directed to one of the team testers, who found the problem in minutes.  As it turned out, it involved an early version of Windows 7, an early version of the multi-touch API, and buggy touch panel drivers – a combination I never would have suspected, much less identified as fast as he did (nor would I have been able to come up with a fix).  In a similar vein, those who had trouble finding jobs (or wanted a particular good job) often got great results by using their networks to get them into a good position to do so, either through references or through direct introductions by someone who already works at the company.  Even now, when jobs are scarce, my network is still working to identify job opportunities for those still without; often, those opportunities haven’t made it to the open market.  Building a network that is capable of taking some of your most difficult tasks and producing results is incredibly valuable – there is a lot of truth to the notion that “it’s not what you know, it’s who you know”.  I’m not going to go into any strategies for actually going out and building a network – there are plenty of resources on the topic already – but it’s something you should be especially focused on during your last couple terms.  Your network could very well mean the difference between an good job and a great one, so cultivate those relationships and use them in your times of need.