The function atoi is shorthand for ascii to integer.  You call it like this:

    int fooval = atoi("123");

It can be written in a few lines of code, but it hinges on your awareness of the Ascii table.  ASCII stand for American Standard Code for Information Interchange; it’s the fundamental building block that allows computers to exchange information.  There are codes for uppercase alphanumeric characters (A-Z) in the range 65-90, and the lowercase alphanumeric characters (a-z) in the range 97-122.  Numerals 0-9 are in the range 48-57.  Your knowledge of the Ascii table can help you not only with these interview coding exercises, but many others as well.

Another concept that will aid you is the knowledge of how C works with character pointers:

char* index = "123";

The index variable is a pointer, but it points at the first character in the char string (1).  If you increment the index, it will point at the next char value (2).  You can determine when you’ve reached the end of the string by testing the value to see if it is the NULL character, \0.  All C strings are terminated by this value.  You have to remember to look for the NULL character when searching C strings, and if you are creating a new string, you have to remember to place that at the end.

Now that we are armed with this knowledge, we can write atoi:

int atoi( char* pStr ) 
{
  int iRetVal = 0; 
 
  if ( pStr )
  {
    while ( *pStr && *pStr <= '9' && *pStr >= '0' ) 
    {
      iRetVal = (iRetVal * 10) + (*pStr - '0');
      pStr++;
    }
  } 
  return iRetVal; 
}

This implementation starts off by clearing out iRetVal with 0.  In case the string is NULL or empty, the return value will be 0.  We loop through the string, looking for numeric characters.  When we encounter one, we determine the integer value (*pstr - ‘0’) and add that iRetVal.  iRetVal gets multiplied by 10 to make the correct scale value.  Note that the first time around, iRetVal is 0.  Finally, we increment the char index to move to the next character in the string.

This is pretty simple and straightforward, although it isn’t perfect.  What if there is a negative sign in the string (“-123’).  Whenever you write code during an interview, it won’t be perfect.  It’s important to be able to identify weaknesses and bugs in your code to the interviewer.

The reverse function for integer to ascii, itoa, is a bit more complex.  I was asked to write this just a couple of years ago during an interview.  Funny enough, the engineer who asked me to write it was an ex-Microsoft engineer.  I solved it correctly for a default case where the number is base 10.  He showed me a way to write it for base 10, base 16, or any base value.  You will call itoa like this:

    printf("itoa(123) = %s\n",itoa(123));

This is the default way of calling itoa.  The return value is “123” which is output by the printf function.  But, as this ex-Microsoft engineer asked me, what if we wanted to output the hexadecimal value, “7b”?  You would call an overloaded itoa function like this, with the base (16 for hexadecimal) like this:

    printf("itoa(123) = %s\n",itoa(123, 16));

Now let’s write the function.  We will actually write two functions here.  If you do this during interview, you will score extra points.  First the itoa function that takes the base as the second parameter:

char *itoa(int n, int b) 
{
    static char digits[] = "0123456789abcdefghijklmnopqrstuvwxyz";
    int i=0, sign;
    char *s = new char[100];
    
    if ((sign = n) < 0)
        n = -n;

    do {

        s[i++] = digits[n % b];

    } while ((n /= b) > 0);

    if (sign < 0)

        s[i++] = '-';

    s[i] = '\0';

    return strrev(s);

}

And now the default itoa function, which assumes the most common case, where we call it for base 10 numbers:

char *itoa(int n) 
{
    return itoa(n, 10);
}

This itoa function with the base parameter makes use of a character array called digits.  This array contains the values 0-9, followed by the lowercase alphanumeric values a-z.  These values will be used for the individual characters in the return string value:

    static char digits[] = "0123456789abcdefghijklmnopqrstuvwxyz";

The first thing we need to do is check the sign of the number we need to convert.  Is it less than 0?  If so, we’ll need to remember this for later.

Now we do a tight compact loop through number n:

    do {
        s[i++] = digits[n % b];
    } while ((n /= b) > 0);

The char string holding the return value starts getting the individual digits chopped off number n.  We chop them off using the modulus operator: %.  When b is set to 10 and n is 123, n % b becomes 123 mod 10.  The value of that mod is 3.  Index 3 inside the digits array is the character ‘3’.

The loop prunes the digits off the number n.  N gets reduced (by the base number) as the loop goes on with the expression “n /= b”.  When N is 123, the first time through this loop, it becomes 12.

Let’s picture what happens to the return char string s and integer n as the loop progresses:

First pass:  n = 12, s = “3”

Second pass: n = 1, s = “32”

Third pass: n = 0, s = “321”

The loop terminates when n reaches 0.  Now we take a look at the sign value.  If the number was negative, we had the char minus sign (1).  Don’t forget to mark the end of the string with the NULL character as I mentioned previously.

Now we almost have the return string value, except it is in reverse.  You can call strrev to reverse it back to the proper form and return the value.

This may lead into writing a function to reverse a string value…which I will write next time.

While Microsoft, in my opinion, treated software engineers better than any company on Earth, I don't regret leaving when I did.  If I hadn't moved away from Seattle, I wouldn't have met my wife in California and I've always said she's worth a billion dollars to me.  Oracle, however, was located a few miles away from my wife's condo in Burlingame.  Leaving Oracle to work at various failed startups was a bad decision in hindsight; I wish I had deeply considered what I was tossing away when I left.

Managers at places like Microsoft, Oracle, Intel, IBM, and your own company dread the day a valuable engineer walks into their office and tenders their resignation.  In many cases, those employees are leaving to go to startup or smaller company that gives them something the larger company cannot.  A herd mentality can quickly develop and suddenly you are facing a brain-drain of epic proportions. 

Here's a short list of reasons why engineers will want to resign.  I know them all because I gave them, perhaps foolishly, at various points in my career:

1.  Company X gives the engineer a larger base salary than the current company does.

When I worked for Microsoft and Oracle in the 1990s, the base salary was lower than many other companies in the same industry.  Both companies could make up for it in terms of stock options.  In the present day, that doesn't work for them as well as it does for Google (although their stock has been deflating along with everything else).  I heard recent stories that Oracle engineers were dissatisfied with their pay, leaving for a higher salary, then returning a few years later, retaining their new base salary.  That's because it's difficult for managers to justify raises over 3-5% per year.  Nevertheless, Oracle HR dreads seeing former employees return, because it costs more and makes the existing engineers envious.

Solution:  If the discrepancy in the salary isn't too large, point out the other benefits your company offers.  Both Microsoft and Oracle have superb health benefits and nice little perks like health club memberships.  Health benefits are increasingly more important as we get older.  Point out that smaller companies often cut benefits when times are tough.  If the salary difference is really large and you can't bump it up, try to compensate with a bonus. 

2.  Company X gives the engineer a greater direct impact on the final product.

Larger companies are notoriously top-heavy, bureaucratic, and slow to react to change.  When the development process becomes so bureaucratized that no voice of common sense can prevail, engineers start to feel suppressed.  I think the most effective description of this is Moishe Lettvin's description of working on the Vista shutdown menu at Microsoft.  An engineer who is unhappy working under those conditions will look forward to working at a company where they can check in code that appears in the product very quickly.

Solution: This is a tough one to fight against.  I think it is one of the top reasons why people get frustrated and leave.

The best solution I can think of is to tell the engineer to stick around and eventually things will change.  The Vista example is a good one.  Steven Sinofsky became the senior vice president over the Windows team in 2007, after Vista was released.  Sinofsky is extremely intelligent, an able prognosticator of where technology is leading, but he's also retained what I call "the common sense factor", the ability to look at when things are obviously not working and figure out how to turn that around.  While I have no inside knowledge of what it is like to work on the Windows 7 team, from what I've seen at the PDC and read about the build discipline that has been instituted, it appears to have changed.

It's happened to me at many other companies as well.  There were many times when a manager or VP seemed to be driving our development team into a concrete wall.  Eventually, these individuals moved elsewhere and better management replaced them.  All of sudden, it seemed like we were working for a different company.

Based on personal experience, this is the best thing for an engineer at a company with a steady future.  It's a tough sell with people who want immediate gratification.  When an engineer leaves, they get the gratification of making an impact, but at the same time, they lose what they attained (seniority, vacation, etc) at the larger organization.  If they had stayed longer, they might have had more impact as a result of the inevitable reorg.

1.  The simple string.IsNullOrEmpty method. 

 if (string.IsNullOrEmpty(imageFileName))
   return false;

Before I encountered this, I was always writing C++ style tests like "if (string != null) && (if string.Length > 0)".  Doing both in one shot is a great piece of shorthand.

2.  The powerful Path object. 

Path.GetDirectoryName(filePathName);

One of the first things I did in C# was to port over a number of C++ methods that dissected a path string, chopping off the extension, returning the folder path, etc.  A nice exercise, but it was totally unnecessary.  The Path object has the following methods: GetDirectoryName, GetExtension, GetFileName, GetFileNameWithoutExtension.

3.  The beautiful BackgroundWorker object.

public class PSPUnpackWorker : BackgroundWorker 
{
    public PSPUnpackWorker()
    {
        WorkerReportsProgress = true;
        WorkerSupportsCancellation = true;
        DoWork += PSPUnpackWorker_DoWork;
    }

Have you ever wanted to perform a task in a background thread?  You can easily spawn off a worker thread on your own by creating a Thread object and calling Start.  But what if you wanted your worker thread to raise an event, to tell you it's completed step X out of 100?  And perhaps hook up this data to a progress bar control?

Don't do it the hard way, the .NET Framework is all setup to accommodate this pattern already with the BackgroundWorker object.

The ComicShowControllerDemo in the Crystal Toolkit has an example of a BackgroundWorker communicating to a ProgressBar control.  First, as shown above, I derive my own specialized class from the BackgroundWorker.  In the constructor, I set the properties in base class to true, WorkerReportsProgress and WorkerSupportsCancellation.  The former property allows me to call the ReportProgress method.  The control containing the ProgressBar can subscribe to the ProgressChanged event of the background worker and determine the percentage of completion.

PSPUnpackWorker _unpackWorker = new PSPUnpackWorker();
_unpackWorker.ProgressChanged += unpackWorker_ProgressChanged;
_unpackWorker.RunWorkerCompleted += unpackWorker_RunWorkerCompleted;
_unpackWorker.RunWorkerAsync();

When RunWorkerAsync is called, the DoWork method inside PSPUnpackWorker is executed:

void PSPUnpackWorker_DoWork(object sender, DoWorkEventArgs e)
{
    foreach (CrystalImageItem imageItem in Collector.GridModel)
    {
        if (CancellationPending)
        {
            e.Cancel = true;
            return;
        }        
        ....
        if (CanRaiseEvents)
        {
            float percent = ((float)++index/(float)Collector.GridModel.Count)*100f;
            int percentDone = Convert.ToInt32(percent);
            ReportProgress(percentDone);
        }
    }
    e.Result = true;
}

Inside the DoWork method, you can perform whatever tasks are required in the background worker.  I've sandwiched these between checking to see if a cancel action was requested at the beginning, and reporting the progress at the end.

4.  The mighty MethodInvoker object.

_imageForm.Invoke(new MethodInvoker(delegate
 {
     _viewerMain.SetImageInfo(imageInfo);
     _viewerMain.ToolTipText = imageItem.ToolTipText;

     SetScale();

 }));

In Windows Forms programming, you often encounter the problem of needing to update the controls on the main form, running in the main UI thread.  If you try to update these controls without using Invoke or BeginInvoke, you will no doubt encounter an error such as "Cross-thread operation not valid: Control X accessed from a thread other than the thread it was created on."

You could take the main Windows Form, test InvokeRequired, and then call Invoke or BeginInvoke.  You would have to create a delegate and pass this as a parameter.  The delegate would take care of calling the controls on the main form.

There's an easier way: use an Anonymous method, coupled with the MethodInvoker (as shown above).  Using this technique, it's like creating an inline delegate.  The code inside the delegate has access to the outerscope variables, such as imageInfo.  It's another great piece of shorthand.

When the code inside the delegate portion becomes too large, I will place them inside a new method, and call that method within the MethodInvoker:

ImageGridView.BeginInvoke(
    new MethodInvoker(delegate
    {
        InitInitialImageImp(index, ignoreGroupHeader);
    }));

You can find some other interesting tips about MethodInvoker and using invoke with UI controls on TimL's .NET Blog.

        public static string ConvertToHexString(uint value)
        {
            StringBuilder builder = new StringBuilder("0x");
            builder.Append(Convert.ToString(value, 16).PadLeft(8, '0'));
            return builder.ToString();
        }

This is pretty self-explanator, but the ToString method on Convert takes an optional second parameter for the base, which we sit to base 16 for the hexadecimal string value.  If you run this test code:

string test = ConvertToHexString(177);

The hex string value for 177 returned is: 0x000000b1.  The PadLeft method after the ToString call gives us the leading zeroes.  Without PadLeft, all we would see is 0xb1.

I will present a solution in C, perhaps not the perfect one, as there are many approaches.

First of all, let's define a Node structure that is the building block of the linked list:

// Node structure representing a single item in the list.
struct node
{
    node(char val) {a = val;}
    char a;
    node* next;
};

This is a very simple Node structure, it contains a single char, and a pointer to the next node in the linked list.  The constructor takes a char value so we can construct the object and set the value at the same time.  You want to keep this simple during the interview.  You could create a C++ solution to this problem, using templates, but that could take much longer.

Let's create a linked list, four nodes, with the values ABCD.  It won't be necessary for you to write this code during the interview, but just in case you were born after 1980 and never saw a linked list constructed before, here it is:

    // Test revlist with a list of 4 items, abcd.
    node* head = NULL;
    node* node1 = new node('a');
    head = node1;
    node* node2 = new node('b');
    node1->next = node2;
    node* node3 = new node('c');
    node2->next = node3;
    node* node4 = new node('d');
    node3->next = node4;
    node4->next = NULL;

Now let's write the function that reverses this list.  There are a few ways to do it.  One way is to loop through the list, create a temporary node pointer, and swap node pairs until you get to the end.  That's perfectly valid, yet when I see this type of problem, I think about using recursion, which is how I tried to address it:

// Reverse a singly linked list.
// Take the head of the list and return the new head of
// the reversed list.
node* revlist(node* head)
{
    node* ptr = head;
    node* newHead = NULL;
    // if the list is empty, return NULL, or
    // if the list has only 1 item, return that item.
    if ((ptr == NULL) ||  (ptr->next == NULL))
    {
        return ptr;
    }
    // Linked list has 2 or more items.
    // Are we at the end of the list?
    if (ptr->next->next != NULL)
    {
        // no, keep traversing the list until the end.
        newHead = revlist(ptr->next);
    }
    else
    {
        // the new head of the list is the last item.
        newHead = ptr->next;
    }
    // next item points to the previous item.
    ptr->next->next = ptr;
    // previous item is now the tail, it points to NULL.
    ptr->next = NULL;
    // return the head of the reverse linked list.
    return newHead;
 }

This is pretty straightforward.  The function starts at the head of the singly linked list and returns the new head of the reversed linked list.  It does not leave the original list untouched.  For that, we would need to make a copy, but we're trying to keep this solution simple.

Let's examine this section by section.  The first if-statement is vital:

    // if the list is empty, return NULL, or
    // if the list has only 1 item, return that item.
    if ((ptr == NULL) ||  (ptr->next == NULL))
    {
        return ptr;
    }

If the linked list has 0 items, the head ptr is NULL.  We must detect this and return NULL.  Alternatively, if this list has only 1 node, there's nothing to reverse.  We must detect this and return back that node to the caller.

    // Linked list has 2 or more items.
    // Are we at the end of the list?
    if (ptr->next->next != NULL)
    {
        // no, keep traversing the list until the end.
        newHead = revlist(ptr->next);
    }

This if-statement uses recursion to traverse the linked list all the way to the last two nodes.  If the list is ABCD, the first time this function is called, it's looking at B->next and detecting if that is NULL.  Since it is not, it calls revlist again, with B as the head of the list.  It will be called another time, pointing to C as the head of the list.

    else
    {
        // the new head of the list is the last item.
        newHead = ptr->next;
    }

When C is the head, the else clause will be executed.  At this point, we are at the next to last node in the linked list.  The new head of the reversed linked list will be the last node in the original list.  C->next points to D.  The D node will be the new head.

    // next item points to the previous item.
    ptr->next->next = ptr;
    // previous item is now the tail, it points to NULL.
    ptr->next = NULL;

Now that we've found the head of the reverse list, it's time to start swapping nodes.  The first time we execute this code ptr is really the C node.  C points to D, the tail of the list.  Now we swap them.  D points to the previous node, C.  C points to NULL, because it is now the tail.  As the recursive stack unwinds, the rest of the list is reversed:

ptr == C, C -> D, swap, reversed list is D -> C

ptr == B, B -> C, swap, reversed list is D -> C -> B

ptr == A, A -> B, swap, reversed list is D -> C -> B -> A

Finally, we need to return the new head of the reversed linked list:

    // return the head of the reverse linked list.
    return newHead;

This seems obvious, but a mistake could be made in the previous if-statement if you don't set newhead in the recursive call.  Once the last node in the old linked list is found, it is returned through the recursive stack.

As I said at the beginning of this article, this isn't the only way to reverse a linked list.  There are many other approaches that are probably more efficient.

It's a great technique for detecting if the person really is a coder/programmer and not a poser.  (Or, as one of my college professors once said, to weed out the Spicolis.)  Whenever my company is hiring someone, myself or someone on my team will make the candidate perform this coding exercise.

However, when I am the candidate, I look forward to whiteboard coding about as much as a trip to the dentist.  I actively dread the moment when someone says, go to the whiteboard and write some code.  I feel a certain pain in my mind, akin to that dreaded pinch when the dentist injects Novocain into my mouth.  When I arrive at the whiteboard, my mind goes blank.  My knees feel weak.  I feel as if I suddenly belong in the marketing group.  Only I'm not thin or attractive enough to work in marketing.

Therefore, to overcome this fear, I've started collecting all kinds of interview whiteboard coding examples, and will share them with you here.  Most of the code you will see here is not the code I wrote during my interview.  But even if the interview went well or it was a disaster, I went home and tried to write the code when I was more relaxed.

I review these examples before going into a new interview.  I don't memorize the code per se; I do remember the general pattern of the solution and stumble through it on the whiteboard.

I'll be writing several articles in the weeks ahead, but this post will keep an index of all whiteboard code, which will be written in C:

Interview Coding: Fibonacci sequence

Interview Coding: Reversing a Singly Linked List in C

If you're unfamiliar with Fibonacci, the interviewer will usually prep you by giving you a list of the first few numbers:

0 1 1 2 3 5 8 13 21

The interviewer should explain the most obvious property of the Fibonacci sequence: each number is the sum of the previous two numbers, if N > 1.  1 is the sum of 0+1, 2 is the sum of 1+1, 3 is the sum of 2+1, etc.  There are other properties of the Fibonacci sequence, which you can read about on this Wikipedia article.

You will be asked to write a function that returns the result of Fib(n).  The Wikipedia article explains clearly, if N > 1, the Fibonacci result is F(n-1) + F(n-2).  If you see this, you can almost write the code, but it may not be explained to you in this fashion.  The interviewer may tell you that Fib(1) == 1, and Fib(5) == 5.  How can that be?  It's helpful to think of the Fibonacci sequence in an array, starting at index 0:

Now you can see, ironically enough, that Fib(5) is 5, but there's a logical reason, it's at index 5.  Fib(4) doesn't equal 4, it equals 3, because it is the 4th (after 0) in the sequence.  Once you understand that, you can start to write the code:

int fib(int n)
{
    if (n <= 1)
        return n;

    return fib(n-1) + fib(n-2);

}

This is the preferred way to write a Fibonacci function, because it uses recursion.  If N is 0 or 1, that value will be returned.  If N is greater than 1, the fib function calls itself recursively, not once, but twice, with the 2 previous numbers in the sequence, n-1 and n-2.  If you call this with N set to 2, then fib will call itself twice with fib(1) and fib(0), which will return 1 and 0, and the sum will be 1.  It works like this for any higher value as well.

The wrong approach would be to set the Fibonacci sequence in a pre-defined array, and going to the Nth index and returning the value there.  But the interviewer will point out that the sequence can go on infinitely and you could never set down all the values.

This is not a perfect function.  If the numbers are negative, a negative value is returned.  You can argue that there will be a buildup of recursive stack values (if N is 10000 the stack will be enormous), or that we are losing performance by making two recursive calls in one function.

Why is recursion the preferred method?  It makes the code simple and easy to understand.  If you look at the Fibonacci definition in the Wikipedia article, the code above resembles that pseudocode definition almost perfectly.  You've solved the problem in the fewest lines of code.  We always hope to hire programmers who can deliver elegant solutions to complex problems.

Minor Enhancements:

CrystalImageItem: Added DisplayName property.

This property will be used by CrystalImageGridView when it draws the text for the image item.  The DisplayName is separate and distinct from the ImageName.  ImageName for CrystalFileCollector is the name of the image file "image.png" whereas DisplayName could be "image1".

If DisplayName is not set, it will default to the value in ImageName.

CrystalImageItem: SplitImagePath now sets DisplayName as well as ImageName, ImageLocation.

CrystalImageItem: ToString() method uses DisplayName instead of ImageName.

CrystalImageGridModel, added new methods to help skip CrystalGroupItem objects...

1. FirstNonHeaderIndex:
       Finds the index of the first item in the model that is not a CrystalGroupItem.
2. LastNonHeaderIndex:
       Finds the index of the last item in the model that is not a CrystalGroupItem.
3. PrevNonHeaderIndex:
       Finds the index of the previous item in the model that is not a CrystalGroupItem.
4. NextNonHeaderIndex:
       Finds the index of the next item in the model that is not a CrystalGroupItem.

CrystalImageGridView: ShowThumbnails property added.

Set this property to false if you do not want anything displayed in the image grid view.  Only the gradient background will be shown. Setting the property back to true displays the thumbnail images.

CrystalImageGridView: DrawImageTitle now uses CrystalImageItem's DisplayName property for the title text.

CrystalComicShowController: unpack-wait dialog now positioned within the main form.

CrystalComicShowControllerDemo: Enhanced to convert images in CBR/CBZ files to a size compatible for viewing on the Sony PSP.  Fixed crashing bugs and sorting bugs from previous release.

Bug Fixes:

CrystalFileCollector: Images that have the hidden file attribute are now skipped when CollectImages is executed.

CrystalFileCollector, CrystalMemoryZipCollector, CrystalRarCollector:
Initial sorting of list was incorrect.  The sorting of the list must be done before the list/group item is added to the model.

CrystalImageGridView, CrystalPictureShow, CrystalPictureShowController:
Critical bug fixes where the controls tried to display or scroll to image item objects that were actually CrystalGroupItem objects.  The above methods are used to avoid them when necessary.

CrystalPictureShowController: Bug fix in DisplayImage.  Operations on the main GUI thread (_imageForm) synchronized with an Invoke and code inside MethodInvoker.

CrystalThumbnailer: Store method creates thumbnail folder if it does not exist.

CrystalThumbnailer: GetThumbnailName method bug fix, forward slashes '/' converted to '\'.  This was found in zip/rar files.

Code Cleanup:

CrystalImageItem: protected fields now change to private.
To access these values in child classes, you have to use the Properties encapsulating these fields.

CrystalTools: Class is now static (and therefore, sealed). 

Redundant Exception handlers were removed in various classes. 

NOTE: Exception handling will be revised in a near-future release.
Currently the toolkit is eating the exceptions and logging them; they obviously need to be thrown back to other objects in many cases.

Download: Crystal Image Toolkit 0.82.  Totally free, open-source, C# .NET Framework 2.0 for Windows Forms, works with both Visual Studio 2005 and 2008.

Here's a roundabout story about I've reinvigorated my Sony Playstation Portable, which would not have been possible without Cory Doctorow's excellent novel, Little Brother.

I've been flirting with the Amazon Kindle for months ever since it went on sale.  It's a cool device for a book lover.  Imagine being able to carry around tons of books everywhere you go.  Being able to download a book after reading a review in the Sunday newspaper.  It's fantastic...except for the limitations.  DRM on the books that you download isn't very cool.  I think what really galls me is that Amazon charges for downloading blogs (via RSS) when you can easily get them for free online.  Charging to email/convert documents to the Kindle device is another thing I cannot understand.  Combine all of these things with the high price of the Kindle and I just cannot make that purchase.

Which made me turn to my Sony Playstation Portable.  I've let this device languish for the past two years after I stopped commuting to San Francisco on BART.  In the back of my mind, I've had this idea that the PSP, with it's brilliant screen display and brightness controls, could be a great e-book reader.  After visiting Cory Doctorow's Little Brother download page, where he provides the novel in a variety of formats (under Creative Commons license), I finally decided to give it a try and see if one of those would work on the PSP.

The result is that none of them worked that well.  It's amazing that after being first sold in 2005 in North America, the Sony PSP still does not have an Adobe PDF Reader.  I found one that used to work, but apparently not on firmware 4.05.  I suppose I could have gotten that to work if I flashed the PSP with a hacked set of firmware, but I want to keep up with the official builds from Sony, as I have a Playstation 3 and want to use my PSP in conjunction with that. 

Next, I tried the HTML version of Little Brother, which I copied over to the PSP/COMMON folder and pointed the PSP's browser at that location.  The HTML version looked superb, the text was very readable, and you can increase/decrease the text size very easily.

However, there were some problems with reading books in HTML format on the PSP.  Paging/scrolling to see the next page is a pain, when you must use the arrow keys on the left hand side of the device.  If the entire book is in one HTML file, you cannot jump between chapters that easily.  When I stopped near Chapter 3, then the next time I started the PSP, I spent a long time scrolling down (using square button + down) to get to that section.  I read that some Sony ebook fans will break up novels into several HTML chunks and link the whole thing together in an index file.  Too much work for me!

A friend of mine suggested converting the document into a series of JPG files and using the Sony PSP Photo/Image viewer.  I was really dubious about this until I found the PSP EBook Creator on download.com.  What the heck, I decided to give it a shot.  The PSP E-book Creator takes a text file file as the input/source, parses it and creates a series of JPG images.  It gives you a number of options for formatting the text: you can choose the font that you want, the font color, the background color, etc.  It may take a while to determine the best font to read on the PSP screen, I've found that either Arial or Verdana works best for me.

The e-book creator parsed and split the Little Brother source text into 897 jpg files, which I copied over to the PSP's PHOTO folder, under a subfolder called LB.  When I turn on the PSP, I simply navigated to the Photo slot, select Memory Stick, select the LB folder, select page 1 and pressed X.  Voila, the first page appears and it's easily readable.  To go to the next page, you just press the right shoulder button on top of the PSP.  The PSP can easily be held in one hand with a finger resting on the next button to advance pages.  The left shoulder button allows you to go to the previous page.

Several things are great about this.  Little Brother took up about 40 mb on my Sony Memory stick, which is pretty small.  Having the book split up into X number of jpgs allows you to quickly find the last page you were on: just press the down arrow to scroll down quickly to page 222 or whatever.  The Sony PSP has a brightness control on the front that allows you to see the screen during the daytime or at night.  This is really convenient if you're reading in bed and don't want to disturb your partner with a bright screen--the lowest brightness level works perfectly in total darkness.  You have no idea how long I've searched for a solution to this problem! 

What are the disadvantages of this method?  There are two big ones.  You can't customize the text size dynamically, and the glassy Sony PSP screen is not readable outdoors in the sunlight, due to the glare bouncing off the screen.  I usually read indoors, so this is not a problem for me.

Unlike the Kindle, where finding/downloading books is a breeze, finding content to download and convert is a challenge, as not every author is as generous as Cory Doctorow.  But if you're used to downloading other media, you can find content to use with the PSP E-Book Creator, although usually the content will need to be converted to text.  You can look for books that are in RTF or HTML format and convert to text using a number of programs (Internet Explorer, Firefox, Microsoft Word, etc).  Books in PDF file format can also be converted to text.  You can also find books in the Microsoft Reader format (.LIT files), and use the free ABC Amber LIT Converter program to convert them.

I've got about a dozen books, many of them recent books that I purchased in hardback (plus all of Doctorow's other novels), on my Sony PSP.  I bought a SanDisk 4 GB memory stick for about $40 on Amazon to hold this content, along with 12 episodes of LOST and a number of comic books that I want to read on my next vacation.  With all this content available, playing games on the PSP seems like a bonus feature.

Little Brother is a very engaging book, I devoured it in a couple of days after getting on my PSP.  Little Brother is a young adult novel (although just as good for adults) about a high school kid named Marcus Yallow (aka w1n5t0n) in San Francisco. San Francisco is attacked by terrorists and the Department of Homeland Security swoops in and starts heavily monitoring all citizens. Marcus fights back against the DHS by hacking his Xbox with an operating system called "Paranoid Linux" and inspiring a group of young techno-geeks to help him out.  I highly recommend it.

Link: PSP E-Book Creator

Link: ABC Amber Lit Converter

Link: Cory Doctorow's Craphound

Link: Little Brother site

Download: Little Brother for Sony PSP (Image files, zipped).

New Feature: Header group items are now part of CrystalCollector, CrystalImageGridModel, and CrystalImageGridView.  You can now assign a group of thumbnail images to a collapsible header.  To illustrate this, here’s a screenshot from the demo application “HeaderGroupItemDemo” which is included in the project:

There are four header groups visible that you can see here (FF, Hulk, Iron Man, Spider-Man).  Each contains a set of thumbnails.  The arrow icon indicates the expanded state; you can replace this icon in the framework as I am just using a free icon here.  Likewise you can replace the folder icon to represent something unique about this group of images if you wish.  But what’s important to note here is that the header group can be collapsed/expanded by clicking on it:

Here I’ve collapsed two of the header items and left the other ones open.  You can see I have CrystalImageItem objects selected in each of the header groups.

In the C# code, Header groups translates to a CrystalGroupItem object containing a List of CrystalImageItem objects.  Each object now has a Parent property so it knows the group that it belongs to.  The biggest change in the collector is that now every GridModel has at least one root header. In the default mode, for backward compatibility, the header item is not displayed (ShowHeaders is set to false in CrystalImageGridView). This may cause problems in older applications that use CrystalImageGridView and try to navigate to item 0 in the GridModel.  You will need to do a test, such as: "if (theImage is CrystalGroupItem)".  See InitInitialImageImp in CrystalPictureShowController.cs for how to deal with this situation.

CrystalCollector now has an additional abstract method that requires you to CollectImages on a CrystalGroupItem object.  CrystalFileCollector implements this method and creates a default root header for simplicity.  But if you want to explicitly create CrystalGroupItem objects and add them to the collector, you do it like this:

   1: CrystalGroupItem groupItem = new CrystalGroupItem();

   2: groupItem.ImageName = "Fantastic Four";

   3: groupItem.ImageLocation = "..\\..\\SampleImages\\Fantastic Four";

   4: // Optional: set a unique image icon for this group header item in the image grid.

   5: //groupItem.FullImage = my Image icon;

   6: _theCollector.CollectImages(groupItem);

This is a bit of an early release of the header group feature.  In the future, I will add additional style bits for the header text font, add a border state around the header item, perhaps add mouse over events for it.

There are several bug fixes to the toolkit, which is why I wanted to release it now, even though this feature is a bit early.  To see all the bug fixes, please read the release notes in the zip file.

Download: Crystal Image Toolkit 0.81.  Totally free, open-source, C# .NET Framework 2.0 for Windows Forms.

New Features:

• CrystalImageGridView now has ZoomFactor: allows scaling of thumbnail images!
  See ZoomImageGrid demo and Crystal Picture Show Controller demo.
• CrystalPictureTracker: Pan Window that works with CrystalPictureShow.
  See Crystal Picture Show Controller demo.
• CrystalPictureShow: Hand cursors that allow the user to drag zoomed images around.
• CrystalImageGridView now has a new rounded rect border style.  Check out the groovy red borders in the Picture Show Controller demo.
• Crystal Toolkit now integrates log4net.  See CrystalLogger object.
  You can get even more debug logging by declaring CRYSTAL_DEBUG in project properties/build.

And now it's demo time, with Marvel comics pictures, of course:

CrystalImageGridView: ZoomFactor applied to zoom to a larger thumbnail image.  See my earlier article that explains how to set this up.  Changes were made to CrystalPictureShowController to add a second trackbar object to control thumbnail zooming. 

CrystalPictureTracker: Panning (controlling CrystalPictureBox) in separate window.  Tracker window appears when image is larger than client area.  You can close it, make it appear again by clicking on the Pan Window button.

CrystalImageGridView: Rounded borders on selected images.  There is now a property called BorderState that allows you to switch between these rounded borders and the old square frame.  Also, notice that in the split view mode, the CrystalPictureShowController hides the thumbnail trackbar and toolstrip objects auto-magically.   Thumbnail sizes in the split mode are fixed, whereas in the vertical orientation (with a sheet of thumbnails) they can be scaled.

This release comes in a ZIP file. Simply unzip the contents to your hard drive, navigate to the root Attilan folder, and double click on CrystalDemo.sln. This solution file contains the Crystal Toolkit plus demo programs. Just build the solution (which compiles the CrystalToolkit library first) and run the demo programs to see how they work. You can run the demo programs without building the source by clicking on "StartDemo.bat" in the root Attilan folder or CrystalDemoLauncher.exe in Attilan\bin.

Download: Crystal Image Toolkit 0.80.  Totally free, open-source, C# .NET Framework 2.0 for Windows Forms. 

Here's a big feature, coming very soon in Crystal Toolkit 0.80, that I've wanted for my own image viewing programs: zooming the thumbnail images that are contained within CrystalImageGridView.  Previously I was only able to allow users to set the CellSize property and that was it.  If you had a thumbnail image that was 300 x 300, you were stuck with that until you changed that property and had the internal grid recalculate itself.  It might have worked, but the images would all have to be re-thumbnailed at that new size, and a lot of time would be wasted.

   1: /// <summary>

   2: /// Sets up the Matrix object used for displaying the image.

   3: /// </summary>

   4: /// <param name="gfx">Graphics object used for drawing.</param>

   5: /// <param name="zoomScale">Scale used for matrix.</param>

   6: protected virtual void SetupMainImageMatrix(Graphics gfx, float zoomScale)

   7: {

   8:     gfx.ResetTransform();

   9:  

  10:     // Set up the transformation to handle zooming and panning.

  11:     Matrix mx = new Matrix();

  12:  

  13:     // Account for the scroll position.

  14:     mx.Translate(AutoScrollPosition.X, AutoScrollPosition.Y);

  15:  

  16:     // Account for the zoom factor.

  17:     mx.Scale(zoomScale, zoomScale);

  18:  

  19:     // Set the transform into the global transform for the specified Graphics context.

  20:     gfx.Transform = mx;

  21:  

  22:     // Set the interpolation mode.

  23:     gfx.InterpolationMode = _interpolationMode;

  24: }

To make thumbnail scaling work in the new release, I've taken some code and patterns found in CrystalPictureBox.  In that class, I used a Matrix object and set the scale according to a property I called ZoomFactor.  This enabled me to present an image in CrystalPictureBox at any scale I desired, like from 30% of full size to 300% of full size.

CrystalImageGridView now has a property called ZoomFactor.  Using this, the entire grid can be displayed at a percentage of the full sized grid.  To implement an image grid that goes from small images to medium images to large images, you would just set the ZoomFactor in the image grid, and the object takes care of the rest.

How it works:

First, setup a Form and drop the CrystalImageGridView onto the form.  Set the CellSize property to the largest possible size that you wish to display.  In this case, I chose a cell size of 375 x 375.  If you set it up this way, the thumbnailer object (internal to the grid) will make thumbnail images at this size, providing users with a crisp view.  It's easier to downscale a larger image than it is to upscale a smaller image.  Now, an alternative way to do this could have been a different pattern--where we send out a signal that we are changing the size and thumbnail the viewable images on the spot.  Windows Explorer and several other programs do this.  Perhaps in the future I will provide an alternative method like this.  The advantage of this method is that the image scaling is pretty fast.  The disadvantage is that the thumbnailed image requires more disk space at the largest possible size.

   1: private float[] zoomFactor = { .30f, .45f, .60f, .75f, .90f, 1.0f };

The ZoomFactor property is set by a trackbar in my little example program (which will be in Crystal Toolkit 0.80).  The zoom factors are predefined in array.  At the lower end of the scale (represented by setting the trackbar all the way to the left) we have 30% of the full size 375x375, which is 125x125.  At the upper end, we have 100% of the thumbnail size.  There is a trackbar on the form with Minimum set to 0 and Maximum set to 5, to match the settings in the array.

When the program is launched, the default ZoomFactor is set to 0.30 (125x125).  I've got about 24 thumbnails displaying here.  Notice how the text for the image is still visible at this 30% setting, this was actually the trickiest part of the whole deal (and there may be bugs left to find in that regard).  OK, I've got the Hulk selected in the middle of the screen, keep an eye on him.

Here the ZoomFactor is set close to 50%.  The grid has repositioned the images as the ZoomFactor increased in size.  The Hulk remains selected, in the center of the grid so that the user can view his beautiful face.  Is that a booger in his hose?  Let's zoom it up further.

Finally, here's what the CrystalImageGridView looks like with the ZoomFactor at 100% (375x375).  We've got two images side by side, the Hulk is still selected and viewable.  And it's not a booger, it's this wild Marvel character called Ant-Man, making a quick exit from the Hulk's gamma irradiated body.

With good luck, I should be posting Crystal Toolkit 0.80 with this feature this Memorial Day.  Nuff said.

When things like this go wrong, most people would just give up or go back to the laptop. But this is the sort of the thing that makes me crazy until I find out what the problem is. I had my laptop--which worked with the same SVN settings on my home network. The difference was the work laptop was Windows XP SP 2--and my home desktop computer was Windows Vista. A-ha! Windows Firewall? Turned it off, same thing. McAfee Virus Scan? Uninstalled it, same thing. DLink router? Disabled the firewall, allow network access, same thing.

Searched SmartSVN forums--no answer. Tried TortoiseSVN--same problem. Tried another product called Syncro SVN--again, same behavior. I'm falling further behind on my deadline, when I give up and write to our terrific IT captain from Ancient Geek that he was right--Vista sucks.

Luckily, I did, because he told me what the real problem was--the TCP/IP auto tuning feature that Vista has. According to this article at ChapterZero:

Microsoft Windows Vista has auto-tuning enabled for TCP/IP which continually adjusts itself. It increases file transfer speed on the network but in some cases it may actually slow down everything which is accessing network. Auto-tuning also slows down network browsing of other machines on the network.

It's easy to check and see what your current TCP/IP receive tuning level is. Open up a CMD window with admin priviliges and type:

netsh interface tcp show global

Then if it's on and you want to turn it off:

netsh interface tcp set global autotuning=disabled

More detailed steps are given for this at SpeedGuide.

No wonder I drove myself nuts. I kept searching and searching for anything network related in the Control Panel and it wasn't there. Now that I've disabled this feature, both SmartSVN and TortoiseSVN are working fine. Thank you, Ancient Geek!

As most Windows Forms programmers know, setting the BackColor to Transparent is the way to allow transparent backgrounds in most controls. I wanted to support the same convention. However, setting the BackColor to Transparent result in a nasty message ("Control does not support transparent background colors"). To fix this, I had to call SetStyles to declare that my color does support transparency:

public CrystalGradientControl()
{
  SetStyle(ControlStyles.SupportsTransparentBackColor, 
           true);
}

Next, I wanted to override the property (from the base class Control), BackColor. Why? Because when BackColor is set to Transparent, I needed to set an internal property called TransparentMode to True. TransparentMode triggers a number of things best described on Bob Powell's article on transparent controls. This was all I needed to do:

public override Color BackColor
{
    get
    {
        return base.BackColor;
    }
    set
    {
        if (base.BackColor != value)
        {
          base.BackColor = value;
          TransparentMode = 
            (base.BackColor == Color.Transparent);
          this.InvalidateEx();
        }
    }
}

Now my controls allowed the transparent color, but the background was still getting painted black. Why? Because in my override of OnPaintBackground, I needed to call the base class when TransparentMode was set to true, to allow the parent Form to repaint the background:

protected override void OnPaintBackground
                    (PaintEventArgs pevent)
{
    if (TransparentMode)
    {
        base.OnPaintBackground(pevent);
        return;
    }

    PaintGradientBackground(pevent.Graphics);
}

There you have it, a few simple fixes. When I first started this toolkit, I didn't know how programmers set the transparent color. I made a mistake in having the TransparentMode property be public and totally ignoring BackColor. Now I've hidden TransparentMode from the Forms designer and allow programmers to do it the traditional way.

How do you set these controls to have a Transparent background? By default, you have the gradient mode set when you drag CrystalLabel and CrystalPictureBox onto your form:

To attain this gradient setting, you need to have BackColor set to Control, and then Color1 and Color2 make up the gradient blend of colors:

Now, if you want the Transparent background, simply set BackColor to Transparent (on the Web tab of the color property dialog). This is the standard way to set transparency with other .NET controls. When I started this toolkit, I was ignorant of that fact. Internally within the CrystalGraidentControl class, setting BackColor to Transparent makes the TransparentMode property true.

The end result is that both the CrystalLabel and CrystalPictureBox controls have a transparent background and allow the wallpaper in the form to show through. This sample code is in the CrystalToolkit 0.77, called TestAttilanTransparent.