Category: Uncategorized

Wasn’t it your own Hartley who said, nothing reveals humanity so well as the games it plays? Almost right. Actually, you reveal yourselves best in how you play.
– Q to Riker, “Hide and Q”
Star Trek: The Next Generation

How someone writes code can tell you a lot about them.

Fizzbuzz, although simple, provides plenty of fodder for discussion, and in that discussion can show you whether or not a programmer has the chops to produce quality code.

Fizzbuzz can be used to validate resume buzzwords.  If someone declares themself as an ‘Expert’ in C#, it’s really easy to see if they really are. I mean, an Expert should know the modulus operator, right?

Take this example:

There are a few good starting points to be made from this piece of code: 1. What is the modulus operator in your favorite languge? 2. Where’s the bug? 3. How can we improve this code to reduce duplication?

If the candiate believes that the modulus operator for their favorite language is mod, and they aren’t in Visual Basic, then the interview should be terminated. There’s no sense in going past that point.

While there isn’t a bug in this code per se, it could use some refactoring; the logic is left wanting, to put it simply. The order of operations is opposite of what you’d expect.  3 comes before 5, and in any loop 3 will always come before 5. This isn’t a bug, but it is a logical error, and fixing logical errors are central to debugging harder problems.  If your maintanence programmer has to figure out why you did something counter intuitively, it heightens the chance that he’s going to make a mistake.

Finally, the code can be improved substantially by using a string variable and appending each part to it.  If a candidate has gotten past the first gate and into the second, this question will help shape your mind on what sort of programmer they are.

Example ‘fixed’ code:

It doesn’t have to be a complex code sample to be of use in an interview, but it does have to be done on the spot. Using a code sample is the only way to really see what sort of code the programmer turns out.

Don’t neglect this tool when interviewing programmers, or your bottom line will regret it.

But all the colors mix together – to grey. – Dave Matthews Band “Grey Street”

I wrote about my colorblindness yesterday.

It was hard to write that sentence, and even harder to write that post yesterday. I used the word ‘disability’ in my post yesterday.  I didn’t put that word in there, my fiancee did. That’s how hard it is for me to write about it. 

It shouldn’t be, but it is. 

There’s embarassment, sure. Even more is that when you’re blind, people get why that’s an issue. There are best-practices out the wazoo. But when you’re colorblind, the level of caring about your web experience ranks somewhere between apathy and ignorance.

But it is a disability. It is not as severe as blindness or deafness, to be sure. But unlike blindness, it has no representation in the minds of website designers. It’s a non-issue.

At one time we had to worry about colors. Remember these?

We’ve come a long way in the battle for web design. We’ve even come to the point where we can laugh at our former works of art. At one time, there was a notion of web-safe colors. As soon as technology allowed, we tore down that wall and kept its ruins as mementos of a barbaric time. We congratulated ourselves and heralded a new age, instituting best practices for accessibilty and starting an entire cult based around fixing web accessibilty. We thought we won, but we didn’t.

Date Usability, Don’t Just Flirt With Her

 Accessibility is usability’s sister. The one you have to impress to score a date with Usability. The annoying one that you’d rather tune out completely, but can’t. we missed this in our celebration.

Examples of our failure are everywhere, even from Google:

The annoying sister butts in again. Were it not for the numbers, there’d be no way for me to tell which one is which.  Even with the numbers, I still have to do mental gymnastics, the very kind usability experts rail against.

Stack Overflow recently started including vote totals; If you click on a vote it tells you how many were upvotes and how many were downvotes.  The original implementation (left) was fine. No need to change it. But the website creator decided to change it to a green color to indicate ‘good’ and a red color to indicate ‘bad’:

So, which one’s better?  I see color, but they both look an annoying shade of red, one darker than the other.  It would have been better never to institute the ‘fix’ at all.  The newest iteration shows a + and a – next to the votes — which is also helpful, but it doesn’t take away from the pain the second image induces when I look at it.

Let me say that again:

Trying to distinguish red from green is painful.

Design for Colorblindness

You may wonder why you even need to design for colorblindness.

If you’re a web-based business, 1 in 12 of your customers are colorblind.

Here’s how to cater to the colorblind demographic:

1. Keep conflicting colors apart. Red and Green shouldn’t be in the same zipcode. We can see them fine when they’re apart, but when they’re together, we get headaches.

2. Study up on Colorblindness. See what it’s like to be colorblind.

3. Don’t use colors as the only distinguishing information; and obey rule #1.

4. If you must use colors (like on a graph) then make sure to use Colorblind safe colors.

Bottom line: paying lip-service to accessibility means paying lip-service to your customers.

I’m Red-Green Colorblind, and it embarrasses me.

I didn’t realize I was red-green colorblind until I enlisted in the Army.  During my trip to MEPS, I took a red-green colorblind test for my Military Occupational Specialty (A fancy phrase for ‘Job’) 13F (Another fancy code that means ‘Forward Observer’).

I failed the test. 

I’m not sure how I was still placed in that job, because by all rights someone should have stopped the placement — but who am I to argue? I enjoyed the hell out of my time in the Army and am really glad someone screwed up their job that day. 

That was the day I woke up; the day I found out I’d been missing something all those years.  I was 17.

I’m 27 now. Being fully aware of my disability I have to ask my fiancee if what I’m wearing ‘works’. She spends extra time ribbing me for this. I think she’s getting paid to do it. She mutters something about kindergarteners knowing their colors. I wonder why I fell in love with a teacher.

Being red-green colorblind means that I can’t tell red and green apart when they’re together. 

Christmas is a nightmare for me.

There are different levels to color-blindness, I happen to fall in the deuteranopic category.  That means that dark green looks black to me, and red and greens resemble each other when they’re close together.  I can tell a shade difference at times, but it’s only for specific shades. 

It’s embarrassing because whenever I think of my colorblindness,  I think of how we’re an unrepresented minority, almost forgotten in the web-design landscape. You often hear Web designers talk about accessibility for blind people, but how often do you hear them talk about accessible websites for colorblind individuals?

Where you see a cascade of colors, I see grey. 

Where you see joy and festivities around the holidays, I dread parties because I might comment on someone’s red dress and then find out it is green. 

Where you look at clever color schemes and see that the voting mechanism is seperated by more than one dimension, I’m constantly reminded of what I cannot see. 

Is it the end of the world?  No.  Does it royally suck?  Yeah. 

Tell someone in a wheelchair that they can’t have access to the building simply because it’s old and doesn’t have a ramp.  See how far that gets you.  We cater to all other disabilities, but if you’re colorblind, you get nothing.

If you’re a web developer, design for colorblindness.You wouldn’t antagonize any other disability, so antagonize us?

Spend time in our shoes: see what it’s like to be colorblind on the internet.

I’ve been working on an ASP.NET MVC project and needed to nest an <h2> element inside of an anchor tag because of a CSS-only menu I am using.

<a href="http://somethinghere.com/page/1"><h2>Link Text</h2></a>

If you use the traditional ActionLink method in ASP.NET MVC, you can’t do that. At least, I haven’t found a way how.

I did find a work-around, courtesy of Stack Overflow:

<a href="<%= Url.Action("show", "page", new { id = Parentpage.Id }) %>"><h2><%= Parentpage.PageName %></h2></a>

It’s a hack, but it produces the correct output.

In the Army, there were generally questions about soldiering that personnel looking for promotion would be asked. They would spend a day going before a promotion board in their crisp uniform and be asked questions about being a soldier.  Questions like: What are the different MOPP Levels? What is the process for clearing a weapon jam in an M16?  What is the effective range of a M16? What is “Danger close” for an MLRS? 

In case you were wondering, “Danger Close” for an MLRS is a whopping 1km x 1km.

Sadly, software development doesn’t let me ask such cool questions. I have to stick with things like “What is inheritance and what is composition, and when would I use either?”

However, much like the questions the Army promotion boards ask, these questions we ask developers are just as useless.  A great soldier may not know the effective range of an M16, but he can hit what he can see — and that’s even better.

A software developer may not know the word ‘composition’, but they recognize bad design when they see it; and they recognize good design when they see it.

This makes a change of tactics necessary, as it were.

Don’t ask questions about Object Oriented design — have the candidate design something for you.  Don’t ask questions about code — have the developer write code for you.

The easiest way to do the first is to use something like Monopoly to conduct the interview. To do the second? Something like Fizzbuzz would do just as well.

The great thing about Fizzbuzz (even though it’s shockingly simple) is that it can serve to show a few things:

1. Does the candidate know the language? (If someone is using ‘Mod’ in C#, that’s a good sign they don’t really work in that language much (which is doubly disconcerting if the word ‘Expert’ is next to ‘C#’ on their resume)

2. How do they structure their code? Do they go for the elegant solution? The Simple solution?

3. It provides a basis for refactoring. This shows you if they can think about the potential problems in their code.

    for (int i = 1; i <= 100; i++)
    {
        string result = String.Empty;
        if (i % 3 == 0)
            result += "fizz";
        if (i % 5 == 0)
            result += "buzz";
        if (result == String.Empty)
            result = i.ToString();
        Console.WriteLine(result);
     }

In our next wonderful adventure, I’ll go into how to use a simple programming exercise to determine a candidate’s ability.

You know those kids who learn to program in assembly at age 12?

I wasn’t one of those.

I grew up around PCs, I was even the first kid on my block with a Local Area Network, but I didn’t program for a long time. I didn’t even know it was possible.  My journalist father was on the cusp of the Computer User revolution; but he didn’t know enough to know how computers were programmed.

Ergo, he didn’t tell me.

In 1993, my school’s computer lab received 386 and 486 PCs. I found the BASIC interpreter and did stupid things like:

I was sure I could do more with it; but didn’t have the vision to know what the ‘more’ part was. It was a novelty, but not a terribly interesting one without context.  Later on that year I opened up the GORILLA.BAS file; but I just didn’t have the vision to play around with it. The game worked the way I wanted it to; why muck with it?

Then I was introduced to the TI-93+; a programmable calculator with its own assembly language. Cool, now this has potential, I thought. I had no idea what to do with it; but I at least knew it was there.

I gamed through High school; but never took Mathmatics past Algebra III — I had a high school teacher who was more interested in her Yearbook duties than she was in teaching math.  That was a bummer because up until that point, I thought I was pretty good at math.

I attempted to get into a public university for Computer Science, but was told quite pointedly that I didn’t have the math pre-requisites to do so. I ended up winning a four year full Leadership scholarship for a local Catholic college — and they had Computer Information Systems. Huzzah.

I took Java the first semester along with Introduction to Computer Architecture and Systems; but again the vision thing blocked my path. The Architeture class took me through the physical bit flipping and memory address allocation and whatnot that happens at the very core of the microprocessor, but the Java course was so far removed from that that it didn’t make sense to me how they connected. I needed to go lower level. So I took C++. At the time the public view of Java centered around rotating cubes, and while I dig rotating cubes, I didn’t see how a rotating cube mapped to a memory address instruction.

While taking C++, I had a healthy dose of Data Structures and Algorithms and Database Design. Now this had potential. Finally, something that made sense. The courses were a lot of fun, and although I momentarily bombed on Pointers, I figured those out and was well on my way to doing fun things… Except for the fact that these classes were for the lowest common denominator, in a school that was defined as a Liberal Arts school.

Once again: bummer.

To pass the time, and because someone told me that it was the basis for all web development at that time, I learned Perl (this was right around the time PHP 4 was released, back when it was called Personal Home Page (yikes!)). and proceeded to use it for every day scripting.

Junior year I rounded out the rest of the undergrad CS curriculum (save the senior project courses that closely mirror what software developers actually do on a day-to-day basis), and started drawing up ideas for websites. My first idea was a website that users could log on to to rate and share their experiences at private retailers, a la Kudzu.com (which came 2 years later). I never got very far because I was called up, but I always wonder what would have happened if I had launched that site.

Right as I began my senior year, the government decided that it needed me to fulfill my reserve obligation. My Army National Guard Unit was called up and off I went to Iraq.

After I got back from Iraq, I wrote VBA code in for the Army unit I was assigned to. They used an Access Database to track everything that happened in their unit. My job was to make it generate pretty reports and create whizbang features that allowed them to track the disposition of members of the unit daily, and then generate pretty reports for multiple government agencies.  Before I got there, it took an entire day and coordinating with 5 people to do. After I finished, it took 10 minutes and no coordination.

Not bad, huh?

After that ended, and three years after I was called up, I took off the uniform for the last time and went to finish college.  My senior year consisted of a senior project that required us to pick from a stack of problems and fix one of them.  Typically, the local non-profits would ask the College’s CIS chair if he could spare a few students to write a program for them; we were those few students.

I led a group to design, implement, and deploy a Winforms based client-tracking system for a local non-profit charity. The code wasn’t tiered very well, it had an ugly 1-form-tabbed interface, and it crashed a lot. But it worked. This was my second real taste of success.

Due to domestic constraints at the time, I lived in an area that had very little programming prospects for me; and ended up taking a job as a Perl Web Application Developer about 60 miles away.  The work wasn’t much fun, but that was because I was the lone contractor on that particular project.  Thinking that this was how programming was, I opted to leave the job when the contract was up and go into Systems Administration.

How different these two worlds are!  As a programmer I rarely spoke with others, but as a System Administrator, I was in a new environment almost daily, doing something new and different. The job was as varied as the day is long; and there were always improvements to be made.  I promptly used Perl to automate system administration tasks (like waking up the PCs for disk defrags, keeping an active display of which computers were up, etc). Once I finished there, I used C# and the SendKeys API to automate the startup of the Point of Sale computers.

I was good at System administration, but I was in a place where there wasn’t much of a future.  How many SysAdmins do you know that start their own company?

So I went back to programming, and have been for the past few years.

Did I mention that I love every minute of it?

I recently had a chat with a recruiter about why I wasn’t interested in a prospect. This is the answer I gave him:

In answering your question, it’s necessary to list the categories we (Software developers) put companies into.  Depending on where a developer is at in his career, different types of companies may occupy a different order.  The ordering of the list changes depending on the developer. This is by no means canonical.

Software development jobs generally fall into one of a few categories:

1. Startup – ‘Fun’ atmosphere, chaotic, making new things, generally at the cutting edge; fails easily, pay isn’t as good, but the other benefits (working from home, relaxed dress code, casual work atmosphere) make up for it. Long hours at times. Developers care about the company and their work. Selling environment may dictate ‘ship now, fix later’ mentality (that normally leads to project failure down the road)

2. Private Company that sells software as its primary business function – Developers treated well, first class citizens; pay is very competitive and benefits are outstanding. Normally right around 40 hour work weeks (there’ve been numerous studies that show as knowledge workers work longer hours, they perform more poorly mentally); dress code varies, but normally Jeans and button down or something along those lines. Well defined process; Developers care about product and company, vested interest to see it do well.

3. Private firm that sells something else and makes software as a ‘supporting’ function – Developers more often than not are second class citizens; restrictions on what developers can do; working with new technology or making changes ‘for the better’ is hard. Pay is great, but it’s a mixed bag as to whether the other developers really care or if they’re just collecting a paycheck. Dress code is conservative.

4. Private Firm support government entity – Somewhere between 2 and 3, depending on the company.

5. Public (government) entity – Not cutting edge at all (in most cases); heavy restrictions on what a developer can do; watched like a hawk; change is unheard of.

In my travels around the blogosphere, there is a common refrain in technical advice. For any given problem, there are n number of ways of doing it, but there is one most right way.  When writers write, they have a limited amount of time, so they tell you the ‘right’ way.  They may tell you not to solve your problem a certain way; but often times they don’t tell you *why*.

Why the hell not?

The answer you didn’t choose is as important as the answer you chose.  The reasons behind it are just as important, if not more so.

Recently, I was tasked with improving the performance of an advanced search query.  The query was taking about 5 minutes to execute.  No, that’s not a typo.  After diagnosing and benchmarking the query with the resident Oracle DBA, we started brainstorming fixes; and the idea was to get the low hanging fruit out of the way.  Here are the list of possible ways to fix this issue:

1. Force the user to use more than scant criteria for an advanced search (in this case, by requiring the user to enter more information into other indexed fields)
2. Improve the query performance through adding the appropriate indexes
3. Parallelizing the query since parts of it used a full-table scan.

Pros and Cons:
Approach 1:
Pro: Allows us to defer the actual query performance issue
Con: Makes user unhappy; alters existing functionality

Approach 2:
Pro: Low hanging fruit. Easy fixes; easy to benchmark
Con: May not get us ‘all the way there’; may have un-intended side effects.

Approach 3:
Pro: Divvies up the Query into multiple threads
Con: Possible to slow the query down since those threads have to share information

We tried the latter two approaches.  I documented the first one; but did not implement it. The second approach netted a 78% performance increase when we added two indexes.
 The third approach ended up actually reducing the original query by a miniscule amount but it was three times slower than approach #2. Ultimately we added the indexes and reduced the query time by 78%; a non-trivial amount; and sufficient since the feature is used very rarely.   To put more man-hours into a fix for a feature that is so rarely used would be folly.

My point is, it’s important for the developer that comes after me to know all of this.  If the client says, “78% isn’t good enough” then the next developer will need to know what I already tried; otherwise he’ll simply waste time re-duplicating effort.

The next time you see a blog post on the internet detailing a fix, ask them what didn’t work — you may be surprised at the answer.

I’ve got a few blog posts nearing various states of completion (that’s blogspeak for “not done yet”); and in the meantime I wanted to hand off a public service anouncement about Windows 7.

I’ve been running Windows XP since the Release Candidate in 2001. I’m not the first to claim this but it felt like Microsoft’s first ‘real’ operating system. It’s like they joined the rest of the world.

Today I installed Windows 7.  Since there is no upgrade path from XP to 7, I simply bought  a new harddrive, installed 7 on it; and keep my secondary drive with my XP Files; so that I can still get to them if anything happens.  I’ll slowly recreate my Subversion repositories and whatnot on this machine, as well as Visual Studio.

Installing Windows 7 was painless.

I’m still in shock.

Prologue

I was at DevDays yesterday; and during my time there I frequented the Amazon booth.  The same Amazon that Steve Yegge worked at.  The same Amazon that has essentially revolutionized online shopping. The same Amazon that… Ok, I’ll stop drooling now.  Amazon == programmer mecca. It ranks right up there with Google, Microsoft, and Fog Creek Software.  If you’re a programmer you want to work at one of those places.  It’s the Ivy league of programming careers, and about as tough to get into.  I had a ‘conversation’ with Joel Spolsky via twitter recently, and if I remember correctly an interviewee had no less than 6 interviews to determine whether or not he was ‘good enough’ to work at Fog Creek software.  I imagine the distribution of failure would scare most people away.

Act I: Epic Failure

So I went up to the Amazon booth and checked out their trivia questions.  The first one had to do with a variation of the fizz-buzz problem, and I recognized it for what it was.  But I was nervous, and the big Amazon (not a pun) guy with a goatee (BAGWG) was staring at me, so I stammered out something like: Well the ++i would evaluate to one higher the first time through. I botched it because I was studying the trees and didn’t pay attention to the fact that the forest would burn to the ground.  The answer was that while the problem accounted for either fizz (4) or buzz (5), it logically did not account for what would happen if there was a multiple that happened to have both fizz and buzz as factors (like 20). 

One of the PHD students that was hanging out with Rick Schott and I solved it (both Rick and I concentrated on the trees); and the exchange itself was somewhat funny:

BAGWG (to me): So you think you know the answer?

Me: Well the ++i would cause it not to iterate through…

BAGWG (interrupting): Doesn’t matter; any other ideas?

PhD Student: It won’t print anything anytime a number is a factor of both 4 and 5.

BAGWG (Turns so his back is towards me and separating us from the PhD Student): Have you ever thought about working for Amazon?

Rick and I looked at each other and walked away, dejected.

Act II: Victory Strikes Back

A little later, still smarting from missing the obvious, I walked back to the table and saw they had listed a new problem.  Essentially it was a problem where you had x,y coordinates defined, and you had to figure out based on the code shown whether or not the rabbit would get the carrot.  The answer is that no, the Rabbit would not because the carrot was hidden beyond the bounds checked by the code. I explained as much to the PhD student and Rick (who were coming to the same conclusion), and they told me I was wrong. 

I was, because I had used the word bounds to describe ‘out of bounds‘ instead of physically located outside of the array, which it was not.  Knowing that I had the answer correct this time, and remembering to use the correct terminology lest I get interrupted, I went up to the Amazon booth and chatted with another gentleman from Amazon (trying feverishly to avoid BAGWG, he was intimidating), and he gave me a Ninja for getting the problem right and asked me if I ever considered working for Amazon.

Have I ever considered working for Amazon?

OMGWTFBBQ PONIES!!!111!!!.

Of course I have. Who hasn’t?!?!?!

I didn’t say this to him, though — I just nodded and he proceeded to ask me if I knew anything about EC2. I was still high from hearing the first question, so I stammered a question out that made it sound like I’d never even heard of Amazon and then proceeded to bolt from the table out of horror for my brain shutting down right when I could have had a networking session with the hiring manager for Amazon EC2. 

I swear the recently-won ninja in Rick’s shirt pocket laughed at me.

Act III: The Return of Defeat

The final question of the day (I’m recalling from memory) was about biased coin flips.  Specifically, let’s say you had a boolean method that acted like a coin flip and returned true or false and did so so that it was evenly distributed.  How would you construct a replacement method so that it would generate true only 31.416% of the time.  My thoughts were that I could get close with the following hacky code that I wrote just to test it out quickly:

       static void Main(string[] args)
        {
            Dictionary<int, bool> Flips = new Dictionary<int, bool>();
            Flips = flipCoin();
            int TrueCount = 0;
            int FalseCount = 0;
            foreach (var item in Flips)
            {
                if (item.Value)
                {
                    TrueCount++;
                }
                else { FalseCount++; }
            }
            Console.WriteLine(“True : ” + TrueCount);
            Console.WriteLine(“False : ” + FalseCount);
            Console.Read();
        }

        private static Dictionary<int, bool> flipCoin()
        {
            Dictionary<int, bool> _Flips = new Dictionary<int, bool>();
            bool result;
            Random rand = new Random();

            for (int i = 0; i < 1000; i++)
            {
                result = rand.Next(2) == 0 ? true : false;
                if (result)
                {
                    result = rand.Next(2) == 0 ? true : false;
                    if (!(result))
                    {
                        result = rand.Next(2) == 0 ? true : false;
                    }
                }
                _Flips.Add(i, result);
            }
            return _Flips;
        }

But that returns True about 33% of the time, give or take, so I knew this solution wasn’t correct.  I kept thinking about the Monty Hall problem and thought maybe that was related somehow, but I couldn’t figure out how.  I figured I could try a naive implementation of Rand() by keeping a ratio of true/false so that over a series of rolls, the probability would end up being 31.416%; but I also knew instinctively that that was wrong. What’s funny is that when it comes to matters of probability, lots of people get it wrong, including Blaise Pascal.

Something the BAGWG said to another passer by is still bouncing around in my head: It’s an easy one-line change.

I have no idea what that one-line change is; but I will figure it out.  It’s probably something really easy; something that once someone tells you you realize the piece you were missing.  It is driving me nuts because I know I should be smart enough to know the answer, and I don’t — and that bugs me.

Epilogue

I’ve been staring at the Amazon business card they gave me; both because I want to go download a barcode library and decode the barcode on it, and also because I really really want to submit my resume.

There are lots of reasons why I shouldn’t:

• I can’t even figure out a simple probability problem
• I’m just now learning Emacs
• I’ve never even written a compiler
• I’ve never used pointers in a production application

Reasons I should:

• Not trying is much worse than trying and failing
• Between ‘slim’ and ‘none’, I’ll take slim any day
• Because that’s what I’d tell other people to do

To Be Continued…

Note to any employer (present or future): If I work for you, it’s because:

• I like the work.
• I like what I do.
• I like where I work.
• I like the people.
• I like bullet points.

However, if Amazon or Google or Fog Creek Software or any other company that was universally recognized as a great place to work as a programmer contacted me and subsequently offered me a job, I’d probably put in my notice and leave.

It’s nothing personal.

Why would I leave? It’d probably have to do with the Joel test.  It’s the Ladder Theory for programming: we’re always going to go to the place that scores the highest on that test. One way to  keep good programmers is to score very highly on the Joel Test, the other is to hand out Porsches. I think the former is less costly for you.