Crystalis

Tiny Toon Adventures

River City Ransom, Pinball, Tetris, Monopoly, Uninvited

DuckTales

Castle of Dragon

Donkey Kong/Donkey Kong Jr.

Adventure Island II

Faxanadu

Shadowgate

Where in time is Carmen Sandiego?

Maniac Mansion

Dragon Warrior III

Dragon Warrior IV

Background

I despise boilerplate code in general, but I really hate writing the same code over and over to check if a variable equals some “default” value and acting on that case. That’s why I wrote SafeDataReader (article to come) years ago. SafeDataReader is constructed with a DbDataReader and adds a ton of new Get method that let you easily and safely access fields on the underlying data reader with strong typing.

One of the key benefits of SafeDataReader is that every Get method has an override for supplying a default value. If you use this version of a method, it will return your default value if the field is null (DBNull.Value).

Unfortunately, I wrote SafeDataReader before the much needed Nullable type was introduced to .NET. I also have not taken the time to go back and update it to support nullables. That leads us to the “dilemma” behind today’s code snippet.

The Problem

Have you ever written something like the following?

DateTime? someDate;
DateTime someTemporaryDate = GetSomeDate();
if (someTemporaryDate == DateTime.MinValue) {
  someDate = null;
} else {
  someDate = someTemporaryDate;
}

The GetSomeDate function may be legacy code, but it only returns DateTime (or another value type). However, you write code for the new millennium and want to use nullables for a clearer intent of the unknown value. Regardless, this type of code block is a PITA that bleeds unreadability.

Going back to my SafeDataReader example, here is some code that is nice and tidy until the DateTime value needs converting to a Nullable<DateTime>.

var setting = new Setting {
  Title = reader.GetString("Title"),
  Quantity = reader.GetInt32("Quantity", 1),
  BeginDate = reader.GetDateTime("BeginDate"),
  EndDate = (reader.IsDBNull("EndDate")
      ? (DateTime?)null
      : reader.GetDateTime("EndDate"))
};

Ugh! I hate that bit with the EndDate. Since Setting.EndDate is a nullable DateTime, I have to jump through ugly hoops to handle a null just because my GetDateTime method doesn’t yet support nullables.

The Reusable Solution

Nothing beats a generic reusable solution to such a problem. Let’s see it!

protected static T? ConvertToNullable<T>(T value, T defaultValue)
  where T : struct {
  if (value.Equals(defaultValue)) {
    return null;
  }
  return value;
}

protected static T? ConvertToNullable<T>(T value) where T : struct {
  return ConvertToNullable(value, default(T));
}

Now, we have something that will clean-up those previous examples.

DateTime? someDate = ConvertToNullable(GetSomeDate());

var setting = new Setting {
  Title = reader.GetString("Title"),
  Quantity = reader.GetInt32("Quantity", 1),
  BeginDate = reader.GetDateTime("BeginDate"),
  EndDate = ConvertToNullable((reader.GetDateTime("EndDate"))
};

That is much better! Enjoy!

Next time your guy is playing one of the first person shooters, grab some mini Reece cups or some treat that is comparable and throw it toward him – not at him but in the general vicinity of where he might be able to catch the item and it has to be in his field of view. See how good his reflexes really are and not just in the game. This could bring some real live effects to his in-game action. Just beware since you might not know how he might react – gauge it on his normal personality to make sure he wouldn’t react angrily.

I just threw my husband two mini Reece cups while he was playing Uncharted 2 and he caught one in mid-air and the other dropped. He joked that it felt like he had grenades thrown at him.

Just a little fun!

I recently posted about an update to my WebPageSecurity module project to the newly named SecuritySwitch. One of the best ways to ramp up coding on the project again is to get it into a public code repository.

Get with Git?

I thought about using Git on GitHub, but I want to get moving on this and that would not be the case if I had to fumble through learning Git now. Although, I do really like the concept of a distributed version control system (DVCS). Instead, I will stick with Subversion (SVN) for now.

Google Code

That lands the project in the capable arms of Google Code, which I find to be a very nice new home for SecuritySwitch. I will likely have a dedicated page here on GeekFreeq for SecuritySwitch that refers visitors to the project on Google Code, and/or I will just pipe updates from the project site here via RSS.

Anyway, this is the first stage of a “grown-up” SecuritySwitch.

After a bit of a struggle supporting my WebPageSecurity module on Code Project, I’ve decided to put some quality effort into the project in the very near future. One of the first things that needed attention was the name.

What’s in a Name?

Could I have named it something more generic all those years ago? Perhaps, but not likely. After a few minutes of running through some of the key nouns and verbs that describe the project’s purpose, it will now be known as SecuritySwitch.

Educational Value vs. Quality Functionality

Another change to the project will be the maintenance of the dual source code languages. Since I originally started the module, a distinct project for C# and VB.NET have been maintained. While this was great for the educational aspect of the article and accompanying code, it is not ideal for a quality “product”.

After some consideration, I decided to drop the VB.NET version of the source code in favor of a single project written in C#. An immediate benefit to the community of this decision is faster releases.

What’s Next?

All of this change should be balanced with something to make it all worth while. I intend on stopping development on the 2.x version of the module for .NET 1.1 where it is now. Of course, I’ll fix any bugs, but no new features will likely be added. Version 3.x for .NET 2.0 will continue until version 4.0. That’s when I will add some of the new features in the queue and enable full support for ASP.NET MVC as well.

Keep checking back for more progress on this project.

Sometimes it takes us a whole year to play all of the games we get since we do have lives outside of gaming. Pitfall was one of those games we didn’t get to until early December 2009. As we were playing it and getting to the point of finding more idols so we could purchase more items from the shamans, we began to search online for a list of the locations of the idols to speed up the process. It wasn’t that we were unable to run around in the game and search for them, but it is just a matter of time and we didn’t want to waste it looking and looking in the game. So, on I looked online. I couldn’t find much of anything in the way of guides for Pitfall: The Big Adventure. I did find a lot of questions and answers but no true guides with people who could actually type full sentences and know how to spell.

I finally found a guide but it was under the name Pitfall: The Lost Expedition. It is one of my favorite sites for game guides: Gamespy powered by IGN. As I was looking at the pictures of the locations of the idols, I saw places and names I recognized. I then started to search for what was going on – two games with similar places, names and pictures? – there must be something odd going on.

After only a few minutes of researching, I found out that Pitfall: The Lost Expedition was released on the GameCube, PS2, Xbox, GameBoy Advance, and PC back in 2004 and has now been discontinued by the manufacturer. After the Wii came out, it was decided to re-release the same Pitfall game but under the new name Pitfall: The Big Adventure on the Wii in 2008. They changed the artwork on the box cover to make it look different but the game is the same other than it has controls that work with the motion of a Wii remote and nunchuk.

I never played the game released in 2004. The re-release has been a fun game that has its frustrating moments due to poor controls at times and a camera that has a mind of its own at the worst times. The graphics (especially) and other parts of the game make a lot more sense now that I know this game, released in 2008, was actually one released in 2004. There is a very cool bonus where you can play the original Pitfall.

So, Pitfall: The Big Adventure is Pitfall: The Lost Expedition. When you are looking for hints or where to find something for Pitfall: Big Adventure just look for Pitfall: The Lost Expedition and you will find tons of help!

A considerate bulk mail sender (that’s you), should respect your contacts’ privacy. Listing all of your receiving contacts in the “To” field reveals their e-mail addresses to each other. That could be thought of as plain rude! In addition, some of your friends and/or family will likely have an e-mail program that collects any addresses from incoming messages. That means, when they forward that wonderful e-mail to their entire address book, demanding that it be forwarded on to 15 others, everyone that you sent your message to will get that person’s bulk messages now. Very uncool!

Luckily, there is an extremely easy way to be respectful of your list of e-mail buddies.

To To, or to BCC

Instead of adding all the recipients of your choice message in the “To” field, add them to the “Bcc” field instead. Then, put your own e-mail address in the “To” field. Doing so, will prevent the recipients from seeing the e-mail addresses of each other. It will appear as if you sent the message to yourself to everyone.

A Step Further

The above technique can be taken a step further to add more polish/professionalism to your bulk mailings. Create a new contact in your e-mail program that is named “Undisclosed Recipients” with your e-mail address. After this simple step, you will still add your recipients to the “Bcc” field, but you can set the “To” field to the new contact.

The end result of this approach is the same. However, most of your recipients will see that the e-mail message was sent to “Undisclosed Recipients”. Believe it or not, this just feels more viable to most people.

Happy e-mailing!

ASP.NET Login Control

So, you’ve set the timeout value for forms authentication to a fairly large value, yet checking the “remember me” check box on the Login control still does not persist your users’ authentication, even after a fairly short period of inactivity.

<system.web>
    ...
    <authentication mode="Forms">
        <forms timeout="10080"/>
    </authentication>
    ...
</system.web>

Don’t spend hours trying to figure out why this, seemingly, basic functionality doesn’t perform as it should. The solution to this problem is very simple, albeit somewhat obscure.

Encryption is the Key

To make the “remember me” check box actually obey your users when they check it, you need to ensure that a static machine key is added to your website’s web.config file. That’s it! Really.

<system.web>
    ...
    <machineKey
        validationKey="xxxxxxxxx"
        decryptionKey="xxx"
        validation="SHA1" decryption="AES"/>
    ...
</system.web>

Generate Random Keys

Generate your own keys by using one of the machineKey generator websites available. After using a generator, copy and paste the machineKey element inside the system.web element of your web.config.

The “remember me” option for authentication should start working as expected.

Why this Works

When a user authenticates on an ASP.NET website with forms authentication enabled, an authentication ticket is generated for that user. This ticket is then stored inside a cookie in the user’s browser. The cookie’s purpose is to allow the forms authentication system to recognize subsequent requests by the same user as valid/authenticated.

Of course, this functionality works without issue even before the solution above. When a user leaves the “remember me” box unchecked, a session cookie is stored in their browser. Checking that box, sends a persistent cookie back to the browser instead. This persistent cookie is set to expire based on the timeout value mentioned earlier (i.e. it expires approximately timeout minutes from the current date/time). The persistent cookie is also created without issue. A quick look at your cookies during a test should prove this.

So, if the persistent cookie is getting created properly, why are users being forced to login again after only short periods of inactivity? Well, the authentication ticket is encrypted before being sent to the browser as a cookie. This is done to secure the details of the ticket and prevent tampering. However, the ticket must be decrypted by the forms authentication system on each request that follows.

Process Recycling

When the ASP.NET process recycles, the website’s validation and decryption keys may be randomly re-generated. In fact, the default behavior is to auto-generated these keys per application. If the keys are changed, those tickets cannot be decrypted. When the forms authentication system fails to decrypt a ticket from the user’s cookie, it sends them along to the login page for validation. No amount of checking the “remember me” box will help this situation; specifying your own keys in web.config will.

Causes of Process Recycling

There are a number of causes for the ASP.NET process getting recycled. Here just a few.

• IIS determines certain conditions were met
• any change in the bin directory of the website
• changes to the physical path of the virtual application or website
• a sub-directory of the website is deleted
• changes to Global.asax, web.config, or machine.config
• policy changes
• the count threshold of re-compilations is exceeded (numRecompilesBeforeAppRestart on the compilation element)

If your website is hosted on a shared server, odds are the process for your application will get recycled more often than on a dedicated server. Hosts set the thresholds for recycling pretty low for shared hosing servers to account for poor programming.

Final Recommendations

I almost always recommend that one of the first things a developer does with a new ASP.NET website is generate a random machineKey and add to the web.config. This will likely save you many headaches in the future. By the way, this step is absolutely necessary for Web farms/gardens.

Interfacing Your Demons

Like many version control systems, SVN utilizes a command-line interface (CLI) to interact with users. Some users frown upon the command-line; especially, Windows users. However, I want to point out how necessary it is that these tools use the command-line.

After you use a version control system for a good length of time, you should notice that there are routines you follow over and over again. Perhaps you lock certain files before editing them to prevent conflicts with other potential editors on your team. Maybe you always commit your changes when you build a project for release, or when you shut down your computer for the evening. The point is, these are things that can be automated with small scripts through build events or even Windows Task Scheduler. Having a command-line tool is essential to such automation.

On the other hand, there are many times you will want to issue commands to SVN on-demand. A nice graphical user interface can make things much easier and faster for those tasks. Enter TortoiseSVN.

TortoiseSVN and the Shell

I like to think that the tortoise stands for something meaningful. Granted SVN was created as an alternative to CVS, which had TortoiseCVS. For me, it’s all about the shell!

TortoiseSVN Context Menu

TortoiseSVN integrates with the Windows shell. That means a lot in the way of usability. When you right-click a file from anywhere in Windows, you will see contextual items on the menu for TortoiseSVN commands. Personally, I think this gives much more value to the program than those that just mingle with integrated development environments (IDEs). I use SVN to control more than just source code. In fact, I consider my other project assets to be just as important (i.e. original design images, documentation, research, etc.). Integration with the shell means I can open Windows Explorer and start managing my files with TortoiseSVN.

Repositories

Repositories are where your files, and their many versions, are stored. There are many theories on how to organize your repositories, from creating one for each project to creating one for everything. I prefer creating a repository for each solution I am working on. That is, I create a repository for every application, website, or stand-alone library that I work on. My reasoning stems from the fact that I may need to invite new team members into the development process for a given application or website, and I want to be able to ensure they only have access to what they need. It also makes it very easy to move a repository to a remote, shared location in the future.

I do, however, store all of my repositories in a single directory on the computer chosen to host them. This makes for a very clean and trivial backup structure. I can easily backup all of my repositories by simply pointing to this root directory. I name mine, “SVNRepositories”. Aren’t I clever?

Use Templates

As a programmer and architect, I am a huge fan of templates. They make things so much easier. Creating stuff from templates is quicker and less riddled with mistakes. The idea of using templates to create your repositories may seem too trivial to bother with, but it does speed things up and ensures that you stick to a naming convention. Many recommend the following directory structure for repositories.

• SVN Structure
  • branches
  • tags
  • trunk

The trunk is where your primary development line will be maintained. You will commit most of your changes to the trunk. You will most often update your working directory from the trunk (more on this soon). The trunk is the latest official version of your solution. There are conflicting views on exactly how to use the trunk, but this is the most widely accepted usage of it.

Branches are there for you to try new things and to experiment with the solution/project. Create a branch when you do not want to mess up the trunk with possible breaking changes. Branching is most common when a new feature is being developed that will take some time to implement. You would create a branch from the trunk and begin working on the branch; committing and updating to and from the branch instead of the trunk. Once the feature is complete, the branch should be merged back into the trunk and become part of the overall solution.

Note: It is good practice to merge the trunk into a developing branch every so often, so the branch can benefit from any changes made on the trunk.

Tags are ideal for marking milestones for the solution/project. It’s a good idea to “tag” each release of the software, documentation, or the like. This allows you to time travel back to a release at a future point if you need to troubleshoot an issue with that old release, or to revert back to a release if things go awry later. For example, a diet-tracking website I am constantly improving upon will soon be sent to a buddy of mine for his personal use. Each time I send him an update, I will tag that release so I can instruct SVN to find the difference between then and now in order to send him a patch.

Create a directory on your computer that has the 3 sub-directories above in it. The sub-directories should be empty. Name the parent directory as your template structure so that you can find it later. I named mine, “SVN Structure”, and have it in a folder named, “Templates”.

New Repositories

Follow these steps to create a new repository that is consistent with the best practices discussed above.

New Repositories

1. Create a new sub-directory in your SVNRepositories directory. Make sure you give it a meaningful name for the project/solution it will manage.
2. Right-click the new sub-directory, hover your mouse over the TortoiseSVN context menu, and click “Create repository here”.
3. You should see a confirmation message that the repository was successfully created.
4. Navigate to your “SVN Structure” directory template, right-click it, hover your mouse over the TortoiseSVN context menu, and click “Import…”.
5. Enter/select the URL of the new repository you just created. If the repository is on your network, you will use a URL in the form of file:///X:/SVNRepositories/RepositoryName. Otherwise, use a valid Web URL for the remote location.
6. Supply a nice message for the import. I recommend, “Structure import.”
7. Click OK.
8. Enjoy the log displayed that informs you of the successful addition of the 3 directories and click OK.

Feel free to right-click on any folder and choose the “Repo-browser” item from the TortoiseSVN context menu. After entering/selecting the URL to your repository, you should see the new structure eagerly awaiting files to manage.

Working Directories

A working directory is where you make the changes to your files. These are standard directories that have hidden SVN sub-directories tucked away for change tracking and property management. The presence of these hidden directories is what enables the icon overlays and most commands on the TortoiseSVN context menu.

You can have multiple working directories; even for the same repository. In fact, if you are working on the trunk and a branch of your project/solution, you will likely want to have separate working directories, as opposed to switching back and forth between each. Simply, create another directory separate from your current working directory, and checkout the other branch or tag to the new location. Then, you can work in both directories and update/commit to the appropriate trunk/branch/tag for each.

Setting Up in a Clean Working Directory

Consider setting up version control before you begin working on a new project. It will make setup easier, and it will ensure that you can start committing changes immediately.

Setting up in a clean working directory is a cinch! After you have created your repository from the structure template provided earlier, follow these steps.

Checkout

1. Create a new directory where you would like to start working on your project/solution (e.g. C:\My Documents\My Projects\New Project).
2. Right-click the new directory and click “SVN Checkout…”.
3. Enter/select the URL of your new repository.
4. Append “/trunk” to the end of your repository URL (i.e. file:///X:/SVNRepositories/RepositoryName/trunk).
5. Ensure that the checkout directory is set to the one you just right-clicked.
6. Keep the checkout depth set to “Fully recursive”.
7. Make sure the “HEAD revision” is selected.
8. Click OK.
9. Enjoy the success log and click OK.

You now have a working directory all ready to be filled with files. You may notice that the folder icon for your new working directory has a green check overlaying it  (if you do not see it, refresh Windows Explorer until it appears). This indicates that no changes have been made to files in that directory. Considering there are no files, this makes sense.

Setting Up in an Existing Working Directory

If you already began your project and have files inside your working directory, don’t worry. It isn’t too much of a pain to get your working directory synchronized with your new repository.

After you have created your repository from the structure template provided earlier, follow these steps.

Commit

1. Create a new directory, anywhere you’d like, to hold all of your existing project files temporarily. I often just create a temporary folder on my desktop.
2. Move (not copy, move) all the files and folders that are in your existing working directory to the new temporary directory you created in step 1.
3. Your existing working directory should be completely empty now.
4. Right-click the, now empty, working directory and click “SVN Checkout…”.
5. Enter/select the URL of your new repository.
6. Append “/trunk” to the end of your repository URL (i.e. file:///X:/SVNRepositories/RepositoryName/trunk).
7. Ensure that the checkout directory is set to the one you just right-clicked.
8. Keep the checkout depth set to “Fully recursive”.
9. Make sure the “HEAD revision” is selected.
10. Click OK.
11. Enjoy the success log and click OK.
12. Move all of your files and folders back to the working directory from the temporary folder you moved them to in step 2.
13. Feel free to delete the temporary folder after you verify all the files/folders moved over.
14. If you peek inside your working directory now, you should see a blue question mark image overlaying your file and folder icons . This icon indicates that the files/folders are unknown to your repository at this time. In other words, they are not versioned yet. It’s time to fix that!
15. Navigate to the parent directory of your working directory, so you can see the working directory in the list of folders. It should have the green check overlay.
16. Right-click the working directory and click “SVN Commit…”.
17. Enter a nice message for the initial commit. I recommend, “Initial commit”, or similar.
18. Select all the files and folders you want to add to the repository (drag a rectangle around them with your mouse, or Shift/Ctrl click them), right-click one of them, and click “Add”.
19. If there are any files you want to ignore from now on, select them, right-click one, and click “Ignore x items by name”. You may also select a single file and choose to ignore it or all files with the same extension.
20. Finally, click OK to commit the files to your repository.
21. Enjoy the success log and click OK.

Your existing working directory is now under version control!

What Next?

After you have a repository setup and a working directory linked to it, there’s not much more to do except…get to work. Just update your working directory, make changes to your files, and commit the changes back to the repository at the end of the day (or sooner if you feel the need). Of course, there are some minor caveats to keep in mind in your daily use.

Special Actions

Rename

Adding and editing files under version control is a no-brainer. However, there are special considerations for file renaming and moving. If a file is already under version control and you want to rename/move it or delete it, you must use TortoiseSVN to accomplish this in order for it to properly account for the action. Truthfully, you can just delete files and TortoiseSVN will let you mark those files as deleted the next time you issue a commit. The renames/moves are the real trouble-makers if you just make those changes outside of TortoiseSVN.

If you need to rename or move a file, right-click it, and select “Rename…” from the TortoiseSVN context menu. Enter the new name of the file to rename it, or enter the relative path and file name if you want to move it (i.e. SomeSubDirectory\MyFile.txt). Alternatively, you can right-click-drag (drag with the right mouse button) the file to another folder and select “SVN Move versioned item(s) here”.

This will instruct SVN to delete the original file and add a new one with the new name/location. If you rename/move an entire folder, you must commit the changes before editing any files inside that folder. In addition, make absolutely certain that you do not rename, move, or delete a directory that is under version control except via SVN or TortoiseSVN. Doing so, will change those hidden SVN sub-directories and that would be very bad. For all the details on these actions, read the Deleting, Moving and Renaming section of the Daily Use Guide.

Further Reading

I highly recommend that you learn all the capabilities of both SVN and TortoiseSVN. These are great products aimed at helping us stay organized and track revised files. Below is a list of resources I believe are helpful to beginners and seasoned users alike.

• TortoiseSVN – Daily Use Guide – this is a must-read
  • Branching / Tagging
  • Merging
  • Creating and Applying Patches
• TortoiseSVN – Most Forgotten Feature
• TortoiseSVN FAQ
• Version Control with Subversion (free online version) – the official Subversion book

Verizon? Open?

Android is an open source mobile operating system (OS). Yeah, open source. That means, you or I can go download the source code for the entire operating system and make changes to it if we please. Android is also an open architecture, in that applications developed for the OS have full-reign. Applications can change anything from the user interface (UI) to how a phone dials a number.

My confusion with this whole deal stems from Verizon Wireless’ past record with one huge issue: control. The company is notorious for locking devices to a mere fraction of their manufacturer’s default functionality. This is always done in order to control the things their customers can do on their network.

VW “customizes” the user interface of nearly all devices sold on their network. These changes are primarily made to prevent you, dear phone owner, from using the features that are built into your phone. That’s right! If you have a phone that was new within the past 3 years or so, it most likely has the capability to install custom ring tones. If you are a VW customer, I guarantee you cannot get custom ring tones on your phone without paying VW a monthly fee, or a per download fee, to get the simplest of tones you may have already downloaded to your computer. That last statement excludes only skilled geeks that hack around these limitations.

Another great “benefit” VW customers gain from the customized user interfaces is slow to unresponsive interfaces. The developers working for VW do not appear to be very talented programmers. The interface of nearly every device I have owned that has been ravaged by these folks is a horribly-performing, gaudy-looking, cluttered mess.

It’s just what Verizon Wireless does to its devices; that is cripple them.

So again, I am astonished at this deal. How in the world will Verizon Wireless maintain a stance of openness with these new Android devices? Will I be able to remove the inevitable garbage that the VW developers will come up with for these devices? Will I be able to browse the Adroid Market/Library and install any application I want to on my device?

What Google Will Not Stand For

Google will simply not stand for Verizon Wireless taking control over devices that make use of the Android OS. I am still concerned about VW’s track record though. I can only see them making every effort to control yet another class of devices. The public does not have access to the actual deal made between the two, but I certainly hope that Google stood by their morals on this one.

Bullies have never done well against Google. A case-and-point is the whole issue with Apple and getting Google Voice on the iPhone. Verizon Wireless is a well-known bully. How will this deal turn out? I guess, we can only wait and see.

The Future of the Mobile Market

If this deal plays out as announced, Verizon Wireless supporting an open device OS without governing it with their domination-nation, the mobile market will spike for the better. The new kid in town (Android) will finally have made enough friends to compete with the popular one (iPhone).

We need more of this kind of competition in order for true innovation to spark the necessary growth in this country (U.S.). We are well behind other countries in the mobile market. Most of Europe enjoys the next generation mobile infrastructure (currently, 4G) years before we begin to see it here. While there may be some provider issues abroad, generally mobile communication is much more affordable than here in the States. Our providers stifle the entire industry with their archaic practices and Band-aid methodologies.

My Final Take

I am actually excited about the deal between Google and Verizon Wireless. I know it seems surprising after reading all the above. The fact is, my family left VW last year for AT&T. I was so sick of the “device-crippling” that I just had to bail. One of the reasons Verizon Wireless has never been known for its cutting-edge devices is mostly due to their locking practices in order to make a buck on every single transaction you initiate from your VW device.

Now, I am unsatisfied with the coverage of AT&T. Granted, it was already second to VW, but it was acceptable for our needs a year ago. Since then, iPhone usage has snowballed and proven my point about our provider infrastructure problems. I feel certain that no matter which provider Apple teamed with, the iPhone would have totally discredited the network upon saturating it with streams of data requests. None of our providers can support that kind of traffic. AT&T is paying that price now.

I’ll switch back to VW for a truly open Android device on a network with the best overall coverage in the country. However, I still feel that all of the underlying infrastructure needs a total makeover. It won’t be long before VW suffers the same fate as AT&T, when an army of new Android users flood their network.

What is your take on this deal?