# Work the Shell - Coping with Aces

## Linux Journal

by Dave Taylor

Somehow, writing this Blackjack game is starting to feel like the programmatic equivalent of that Three Stooges skit where “slowly he turned, step by step...”, but we're still going to have to work on the core logic of the game before we're ready to write the fun interface elements.

This month, in fact, we might well find that we have to tear some of the earlier script apart and rebuild it to compensate for a troubling aspect of the game of Blackjack: an Ace can be either high or low, which is to say that it can be worth one or 11 points. Dealt two aces, you then have a number of different possible values, and that's a problem.

The First Ace Is Always Worth Eleven

It turns out that there's a sneaky way you can solve this problem simply by maximizing the value of the first Ace encountered, as long as the overall value of the hand doesn't exceed our cap of 21 points. So, two Aces would be worth 11 + 1 automatically (the first is maximized, but the second is not because it would push us over 21 points).

The portion of the code that must be rewritten to compensate for this Ace valuation strategy is the handValue function:

```function handValue
{
# feed this as many cards as are in the hand
handvalue=0  # initialize
for cardvalue
do
rankvalue=\$(( \$cardvalue % 13 ))
case \$rankvalue in
0|11|12 ) rankvalue=10   ;;
1       ) rankvalue=11   ;;
esac

handvalue=\$(( \$handvalue + \$rankvalue ))
done
}
```

This is the “before” picture from last month. Notice that the second line in the case statement currently assigns a rank value of 11 to every Ace encountered. Clearly that's a bug!

To change it, however, I need to add a new variable that keeps track of whether I've already seen a previous Ace in the hand. I ingeniously call that seenAce:

```function handValue
{
# feed this as many cards as are in the hand
handvalue=0  # initialize
seenAce=0
for cardvalue
do
rankvalue=\$(( \$cardvalue % 13 ))
case \$rankvalue in
0|11|12 ) rankvalue=10   ;;
1       ) if [ \$seenAce -eq 1 ] ; then
rankvalue=1
else
rankvalue=11 ; seenAce=1
fi ;;
esac

handvalue=\$(( \$handvalue + \$rankvalue ))
done
}
```

Looks like it'll do the job—or will it?

The problem here is best illustrated with a hand like 9 + 10 + A. That's a valid Blackjack hand and should be worth 20 points. But handValue will score it as 30 points, and the program will incorrectly classify that hand as a bust.

Solving this isn't too hard once the problem is recognized, but that's the great challenge of writing any code, isn't it? To anticipate and characterize bugs and glitches properly. The solution is often quite simple, but knowing there's a bug in the first place, ah, that's where the great programmers find their calling!

The solution in this situation is that we need to deduct ten points from the hand score if it's more than 21 points and there's an Ace—a condition that turns out to be added easily to the tail end of the function:

```     handvalue=\$(( \$handvalue + \$rankvalue ))
done

if [ \$handvalue -gt 21 -a \$seenAce -eq 1 ] ; then
handvalue=\$(( \$handvalue - 10 ))
fi
}
```

This is the first time I've used a complex conditional statement in our script, but you're already familiar with this type of multi-expression conditional. If we were using a C-like language, the conditional might look like:

```
if ( ( handvalue > 21 ) && (seenAce == 1))

```

The snippet in the shell script shown above is the equivalent conditional, with the -a serving as the logical AND statement. It wouldn't work in this context, but -o is the logical OR statement in a shell test conditional too, and if you need to, you can use parentheses for grouping.

To test our new code, I'm going to replace the main body of the program temporarily with a few preloaded test hands and see what kind of hand values are returned:

```echo "Starting out with two aces..."
handValue 1 14
echo "handvalue = \$handvalue"

echo "now testing 9 + 10 + A"
handValue 9 10 1
echo "handvalue = \$handvalue"

echo "and, for good luck, testing K + A"
handValue 12 1
echo "handvalue = \$handvalue"
```

First, I'll run this with the original handValue function, anticipating mistakes:

```Starting out with two aces...
handvalue = 22
now testing 9 + 10 + A
handvalue = 30
and, for good luck, testing K + A
handvalue = 21
```

Yup. That's not good. We'd be quickly run out of Vegas for that sort of counting.

Now, I'll slip in the new seenAce code segments explained earlier and try this same set of test hands:

```Starting out with two aces...
handvalue = 12
now testing 9 + 10 + A
handvalue = 20
and, for good luck, testing K + A
handvalue = 21
```

What do you know, it looks like we've come up with a savvy way to allow the Ace to have two possible values without a major rewrite of the code.

The Virtue of Lazy Coders

Good. Indeed, it's my belief that the best programmers are actually lazy and want to solve problems in the easiest and most efficient way possible. Laziness breeds ingenuity, remember, so although I could have rewritten the blackjack script to use an array of possible hand values to model the multivalue hand, why bother? The fact that a given hand has more than one value isn't really important as long as we can compensate for that fact correctly in the code.

A lot of programmers talk about highly efficient code as being “elegant”, but in my experience, most elegant code is also lazy code. I know that I'm constantly looking for those smart shortcuts, those insights that let me create something that might be less efficient in its performance, but far easier to code, far faster to debug and far speedier to deploy in the field.

One great skill that programmers can nurture is being able to recognize quickly the good enough solution too. Highly analytic by nature, we code geeks suffer from a little bit of perfectionism, and writing the perfect routine at the cost of additional days or weeks of development easily can end up being less utilitarian and less useful than having a pretty decent routine that does the job and can be improved later, in the next release, a maintenance patch or whatever.

Is this laziness what causes us to have software with so darn many bugs though? I don't think so. I think bugs in products are due to the ever-increasing level of complexity of software, be it an administrative tool for a Linux box, an Apache module or an Ajax-y Web-based utility. And software like an operating system or kernel? Of course it's going to have bugs. It's far too complex ever to test for all possible conditions, cases and situations. In fact, seeking efficient solutions that can be pushed out into the field can help reduce bugs. It's not testing software that finds the most egregious problems, but customers putting software through real-world tasks.

I'm not advocating that we should ship sloppy code, however. Simply that in the classic model of alpha and beta releases, getting code into the field ultimately can produce far more robust applications than having it stay in development forever as more and more complex test cases and usage scenarios are pushed through simulators.

But, ahem, I digress!

For now, we've come up with a nice, simple solution to the dual-value problem with Aces, and let's leave our script here for this month. Next month, we'll reintegrate the new code into the main game and add some additional code to detect when either the player or dealer has a blackjack (a two-card 21).

Dave Taylor is a 26-year veteran of UNIX, creator of The Elm Mail System, and most recently author of both the best-selling Wicked Cool Shell Scripts and Teach Yourself Unix in 24 Hours, among his 16 technical books. His main Web site is at www.intuitive.com.