Tablet PC Head to Head

I typically use a Gateway M-285 Tablet PC.  However, this week it's in the shop and I've got a loaner E-155 Tablet PC.  Let me start off by saying that this is really an apple and oranges comparison.  About the only way's that they are similar is that they are both Tablet PC's from Gateway running Vista.  That's about where the similarity ends.

I found the E-155 reasonable for running applications but it was definitely slow compared to the M-285.  The difference was very noticeable when running Visual Studio.  The E-155 has a 1.2Gig processor with a gig of RAM.  The M-285 has a 2.0Gig (as best I can recall) processor with 2 gigs of RAM.  Both are Duo processors.

The E-155 has a WACOM screen which is active/passive.  What I mean is I can hover the stylus over the screen with out touching and it displays the pointer.  However, I can also just use my finger to push buttons as well.  The M-285 has an active only screen, which means you have to use the special stylus.  I must say, after experiencing the WACOM screen I do prefer the feel of it over the M-285's very slick glossy screen.  The WACOM screen seems to have sort of a matte finish which I like.  The E-155 screen is 12" which seems a little small, but the display is very crisp.  The M-285 14" is an outstanding display, although over time it seems to have gotten a little bit dimmer.

I typically use my tablet along with a docking station and external monitor.  Here the E-155 really falls down.  The video coming out of the external port is downright blurry.  I'm sure this is due to the fact that it's using an integrated video adapter with shared memory.  The M-285 I use has been upgraded to a video adapter that has dedicated memory and it was worth it.  The M-285 external video is very nice, I typically run an external monitor at 1280x1024 with it. 

A nice feature of these tablets is that they share the same docking station.  So the video comparison was with the same docking station and monitor.  I did also try plugging directly into the E-155's external video adapter and it was still just as bad.

The E-155 has the M-285 beat in the portability department.  I also like that the way the fan vent is arranged it is on the "top" side when in my typical tablet orientation.  The E-155 case is rubberized in the palm rest area which feels down right weird.  The E-155 is much lighter than the M-285.  A large part of the weight of my 285 is due to the 12-cell battery that I went with.  I typically get 4-5 hours of use out of it.  The E-155 gave me several hours of use on it's standard battery.  I started off in High Performance mode and dropped to Balanced before needing another battery.  Another thing I really liked about the 155 is it's built in fingerprint reader.  This made it very nice to be able to quickly unlock the machine.  It's something I'll look for on my next tablet.

Sound quality is good from both of the tablet's.  Better than many other laptops out there.  I haven't had much luck trying to record from the M-285's built in microphone.  I have not tried the E-155's dual mic's.

Overall, I very much like both tablet's.  The E-155 is a nice device for running Outlook and OneNote and doing general computing tasks.  It can be pressed into development service but it won't like it... neither will you!  The 155 is so slim and light weight you won't hesitate to grab it before leaving the office.  The M-285's weight help's keep up your arm strength.  But it won't balk at doing whatever you ask of it.  It is not unusual for me to have the 285 running Visual Studio, NUnit, SQL Server, IIS, Outlook and OneNote simultaneously.  If I could keep both machines, I could see some benefit in that.  I'd get rid of the PDA and use the 155 primarily for Outlook, OneNote, running a few client side tools and as an eReader.  If I could have only one machine, it would likely be the 285 with dock.  Gateway has the 295 out now.  The 295 it seems to me is a slightly upgraded 285 with the WACOM screen.

Doing TDD without a Test Runner

What can be done in VBA/VB6 and other environments is the following:

• Create a code module that will serve as your test fixture.
• Write individual methods to do your tests in this code module.
• Have a "master" method that calls all of the individual tests.
• The individual tests give you feed back ala debug.print with test name and"PASS" or "FAIL" also return a boolean to the master method.
• The master method can return FAIL if it picked up a false from any of the test methods that were called.

Now you can use the immediate/debug window to call your individual test methods or your master test method. I found this approach very helpful when working with a legacy Access 97 application.

Outline for introducing TDD

This outline is meant to serve as a guide for a developer that is experienced with Visual Studio, C# and NUnit to use in introducing Test Driven Development (TDD) to others. You, the trainer, will want discuss the why and how behind the tasks.

This guide was put together in the context of VS2005 & NUnit.

http://nunit.org/

You may opt to have developers work in pairs for this training.

Learning the basics

Start off by discussing why tests are set up in a different project.

Create new projects Polynomial & PolynomialTests

Delete class1.cs under both of them

Include a reference to the project under test

Include a reference to the test framework

Create test fixture BasicPolynomialTests (class)

We will be implementing a compute method which returns the result of f(x) = x^2 + 5x + 6

the using statements that are needed by the test framework

using NUnit.Framework;

using NUnit.Framework.Constraints;

using NUnit.Framework.SyntaxHelpers;

Don't forget to make the test fixture public

Reviewed that there are reflection tags for the test fixture, fixture setup/teardown, test setup/teardown and the test itself

When and when not to use the different setup's/teardowns

We talked about setting up test classes based on what kind of set up they need

Talked about arrange-act-assert (See William Wake) http://weblogs.java.net/blog/wwake/archive/2003/12/

It can take a little bit to show/explain "this method doesn't exist yet, we're writing the way we want it to work"

With a nice IDE the method stub is generated for you (they really liked that) .

Create BasicPolynomial class, make it public - watch for namespace conflict

review the red-green-refactor sequence

make sure everything compiles now and you have a red bar in the test runner

implement the code that computes f(x)

compile and check out the green bar

Now refactor f(x) - it can be refactored to (x+2)(x+3)

Show them were they can find reference material on both the "classic" and new "constraints" assert methods

(we used the new NUnit constraints syntax)

http://nunit.org/index.php?p=assertions&r=2.4.3

Discuss how unit tests can be used to verify expected behavior

I think a string replace does this, is my expectation correct?

Talk about how we can do TDD in environments that don't directly have a testing framework - i.e.

Access

A little thinking for the trainees

Now the user wants to be able to solve all problems of the form Ax ^ 2 + Bx + C

Create a GeneralPolynomialTests fixture

Create a new GeneralPolynomial class

Need a constructor that takes (A,B,C)

Test classes with different set up revisited

Add an empty constructor() that defaults to 2,3,5

Don't forget your test first! (in a new class)

Refactor: the empty constructor can be implemented in a number of ways

• Setting initial values on declaration of private variables (yuck)
• Setting the private values in the new empty constructor
• Constructor chaining GeneralPolynomial():this(2,3,5)

http://www.c-sharpcorner.com/UploadFile/rajeshvs/ConsNDestructorsInCS11122005010300AM/ConsNDestructorsInCS.aspx

Move the new test class to it's own file

Summary

As you can see, when it's listed out, that's a lot of material for a new comer to digest for a fairly simple example.

I worked through the above in about an 1 hour and 45 minutes with a team.

After you've gone through this guide, ask if there are any questions. Let them know you are available to help.

Pick up a slew of books on TDD/xUnit topics and add them to the corporate library.

OO Confidence Course

Right now some of my team is in Object-Orienteed Analysis and Design training.  They appreciate that they are learning the concepts.  However, the instructor has not presented them with code in any language.  Therefore, we are going to do an "OO Confidence Course."  The idea is that we will briefly discuss the foundations of OO, look at the language specific implementation and then work through implementing the concepts in code.

This VB.Net and C# comparison guide from Frank McCown will provided to serve as a handy reference to language specific constructs.

If you are working to learn OO on your own or want an additional book to read on the topic that includes code, I can recommend Head First Object Oriented Analysis and Design.

After an initial session with this course, it's likely that someone new to OO would likely take around 4 hours to complete this confidence course.  I think an experienced developer could rapidly complete this course.

At a later date, in the course of professional duties, would be a good time to look at defining properties in an interface, CRC cards and unit tests.  The purpose of this exercise is to build OO confidence, so we're working hard to avoid "scope creep."  Also, because this is an exercise we ended up having an abstract Person and Concrete Person classes.  We needed to create the concrete class that others inherit from so we can show off the inheritance polymorphism in the demo section.  It's also significant to note that when demonstrating the interface polymorphism that the student class does not inherit from another class.

Here is the "OO Confidence Course"

 OO Confidence Course

For Group Discussion

• What is polymorphism?
• How does inheritance work?
• Why do we use encapsulation?
• Language specific discussion
• C# this/subclass, base/superclass

Abstract Person class

This class should have properties/accessors/mutators for:

• Age
• Gender
• Name

Override ToString method to display name and age

Create an abstract method ContactPhoneNumber that returns a string

Concrete Person class

Inherits from Person

Implements the abstract method ContactPhoneNumber
    Return "123-555-1212" for the phone number

Employee

Diagram and create an employee class that inherits from ConcretePerson

This class should have properties/accessors/mutators for:

• ID #
• Job Title

The constructor should give the person a default ID of -1 and a blank title, age, gender and name

Overload the constructor to accept an ID#, Title and Name

Override the ToString method of employee to display the data in all of the fields

Create a method that calls the base/superclass toString()  - call it superToString

Implement the abstract method ContactPhoneNumber
    Return "987-444-3535" for the phone number

Create an Interface called IStatusInfo

The interface definition should require a method isEmployable that returns a boolean

Citizen

This class inherits from person

Implements the IStatusInfo interface (return true)

Student

This class has a single property of name

Implements the IStatusInfo Interface  (return false)

Demo Program - Console application

Create an array/arraylist of ConcretePerson objects

Populate the arraylist with data

• 3 employee objects
• 2 Citizen objects

Loop through all of your person objects

• print the base/superclass toString (does this work?)
• print the this/subclass toString
• Print the ContactPhoneNumber

For one employee object

• print the base/superclass toString (does this work?)
• print the this/subclass toString
• print the string returned by superToString 

Create 4 IStatusInfo objects

• Set them equal to the 2 citizens you created earlier + 2 students

Loop through all of the IStatusInfo objects

• Print the result of the call to isEmployable

Distributed Version Control System

After watching this Google Talk by Linus Torvalds I'm really wanting to give a distributed version control system a try.  I'd like to give git a go, but from what I've read it looks to be a pain under Windows.  First blush looks like Mercurial may be a candidate.  I thought it interesting that Mercurial needs an external merge tool like TortoiseMerge to do the actual merging.

After doing a little more reading, I'm probably going to give Bazaar a try.  A big reason is it's explicit support of Windows.

Kyle Cordes has a good write up about this topic on his blog.

Need a source code control solution?

If you are looking for a source control solution...

You should definately check out and read up on Subversion (SVN), TortoiseSVN and Ankh. Subversion is the version control system. It can run under a windows service, file system type repository or under Apache.

We have it running with Apache on a port other than 80. TortoiseSVN is for windows shell integration. Ankh is for Visual Studio IDE integration. There are articles out there that talk about how to use SVN with SQL server.

SVN uses a different process than VSS. It doesn't really do locking. It's more of an optimistic merging/updating process when needed. The documentation covers in depth how the tool/process works http://svnbook.red-bean.com/

We are successfully, using these products at work. They are far superior to VSS. At home, I use Ankh and TortoiseSVN with an external USB drive for the file repository.

http://subversion.tigris.org/ http://tortoisesvn.tigris.org/ http://ankhsvn.tigris.org/

Bryan

Developer Tool: Digital Camera

I have found having a digital camera to be an indespensable and freeing tool. One of the ways I have used the camera is to take a picture of design work done on a whiteboard. We then stick it in OneNote notebook which is shared out for the team.

Taking a picture keeps the process simple. You are constrained if you want to change the design, but it's easy to just do a new drawing on the white board, working off of the existing digital version. I have found this process to be more lightweight and creative than huddling around a monitor and trying to do something with Visio.

And with the resolution of today's camera's, I've been able to pictures of print outs or blue prints at a high enough resolution that they are legible when viewed on the computer.

The other day when we were having difficulty describing a prolbem to a component vendor's tech support, we used the camera to shoot a short ~1 minute video that showed the problem. We uploaded the video to a website where the tech guys could view it and we had our answer the next day. It was way quicker and easier than trying to put together a sample project with a readme to illustrate (if it behave the same for them!) the problem.

To make the process painless, it's important to have a media reader attached or built in to your computer for pulling the images off of the SD, XD card whatever. I have found it's simpler to just work with the media rather than mess with hooking up the camera to USB and going through it.

Vista Sidebar Gadget

I put together a little Vista Sidebar Gadget. Using the information found here and more specifically here, it wasn't difficult to do. The gadget I created is useful for those that follow the Legislative process of the Missouri House of Representatives.