TweetFollow Us on Twitter

Sep 98 Prog Challenge

Volume Number: 14 (1998)
Issue Number: 9
Column Tag: Programmer's Challenge

Sep 98 Programmer's Challenge

by Bob Boonstra, Westford, MA

Big Baby

Fifty years ago this past June, the Manchester Mark I prototype computer, also known as "Baby", became operational. Baby was the first computer to store a program electronically, and was also the first computer to store instructions and data in the same memory. Because vacuum tube technology was too immature to store memory reliably, Baby was designed to test memory based on a cathode ray tube. Not much memory, mind you. Baby boasted a full 1K bits of memory, organized as 32 words (or lines) of 32 bits each.

In celebration of the birth of the first stored program computer on June 21, 1948, the Department of Computer Science at the University of Manchester recently reconstructed Baby and ran a programming contest to write the most imaginative program for Baby. Inspired by that contest, your Challenge is to write an assembler and an emulator for an extended ("Big") version of Baby. The prototype for the code you should write is:

#if defined(__cplusplus)
pragma extern "C" {

#define kMaxInstructions 32

typedef UInt32 CRT_memory[kMaxInstructions];

pascal void AssembleBabyProgram(
   char *program,
   CRT_memory memory,
   UInt32 address_bits

pascal void ExecuteBabyProgram(
   CRT_memory memory,
   UInt32 address_bits

#if defined(__cplusplus)

Baby has a single general-purpose register, called the Accumulator. The program counter is called the Control Instruction, or CI. The CI is incremented just before the next instruction is fetched, which means that a jump instruction, for example, is coded with a value one less than the actual target address. Baby also has a red light that indicates the program has halted. One interesting thing about Baby is that it lacks an addition instruction - addition is done by subtraction.

Baby's instruction repertoire is listed below. The function bits (or opcode) associated with each instruction is listed in parentheses after the mnemonic.

STO (110)
Store the contents of the Accumulator in the store line.
SUB (001 or 101)
Subtract the contents of the store line from the Accumulator. There is no ADD instruction; addition is done indirectly by combining the SUB and the LDN instruction.
LDN (010)
Copy the contents of the store line, negated, to the accumulator.
JMP (000)
Copy the contents of the store line to the CI (so the store line holds the number of the line one before we want to jump to). In modern terms, this an indirect jump, which uses up an extra store line compared to a direct jump.
JRP (100)
Add the contents of the store line to the CI. This looks forward to larger machines, where it would be important to be able to load the same code in different places, and hence would need relative jumps.
CMP (011)
Skip the next instruction if the contents of the Accumulator are negative, i.e. a conditional branch.
STOP (111)
Stop the machine and turn the red light on
An assembler mnemonic to initialize a store line to a data value.

For example, the following program computes the greatest common divisor of the number in locations 30 and 31:

0000 NUM 0
0001 LDN 30
0002 STO 29
0003 LDN 31
0004 STO 31
0005 LDN 31
0006 STO 30
0007 LDN 29
0008 SUB 30
0009 CMP
0010 JRP 27
0011 SUB 31
0012 STO 31
0013 SUB 28
0014 CMP
0015 JMP 00
0016 STP
0027 NUM -3
0028 NUM 2
0029 NUM 0
0030 NUM 3141593
0031 NUM 5214

Baby's instructions are assembled into a 32 bit word by placing the function code associated with the mnemonic into bits 13-15 (numbered with bit 0 as the most significant bit). In the original Baby, the store line associated with the instruction is placed in bits 0-4. Bits 5-12 and 16-31 are not used as part of the instruction, although they can be used as data. The program listed above assembles to the following:


Our contest will make one change to the original Baby: in our extended, Big Baby, machine, the store line is extended from 5 bits (0-4) to address_bits bits (0 - address_bits-1). This allows more than 32 words of memory and therefore larger programs.

Your AssembleBabyProgram routine should accept the mnemonic input listed above, pointed to by the program parameter, and assemble them into 32-bit Baby instructions in memory. Your ExecuteBabyProgram routine will be called to execute the program one or more times. Both of your routines will be provided an address_bits parameter that describes the size of memory. You will be asked to assemble more than one program, your assembled programs may be executed more than one time each, and you may be asked to execute a program that has been hand-assembled.

More information about the University of Manchester Baby programming contest can be found at Programming reference documentation for Baby can be found at and at

The winner will be the solution that assembles and executes a set of test programs in the minimum amount of time.

This will be a native PowerPC Challenge, using the latest CodeWarrior environment. Solutions may be coded in C, C++, Pascal or, as is our tradition in the month of September, in assembly language. Thanks to Eric Shapiro for suggesting this Challenge.

Three Months Ago Winner

Congratulations to Tom Saxton for writing the most successful simulated gambler at the blackjack table of our June Programmer's Challenge Casino. Tom beat out four other entries and was one of only two entries to actually come out ahead at the blackjack table.

Tom precomputed the expected winnings for each situation and created tables with the action that led to the best result. He uses the Hi-Lo card counting method to determine whether the remaining cards contain a disproportionate number of high-valued cards, and then uses that estimate to adjust his wager. Tom's solution is also not too greedy; it contains heuristics to quit when it has won a reasonable amount or played long enough, ensuring that it has wagered enough credits to avoid the "freeloader" penalty imposed by the problem.

A few words about our other gamblers are in order. The second-place solution, by Kevin Hewitt, also used precomputed tables, but his were based only on the initial pair of cards dealt. Kevin also spent more time at the table, quitting only when winnings or losses exceeded a threshold. JG Heithcock's solution spent the least amount of time at the table. He quit soon after the minimum total bet criterion was met. Ken Slezak kept playing until he lost 75% of his bankroll (or quadrupled his money) and Randy Boring played until he ran out of money or, as it turned out, until the house threw him out of the casino. Both of those players left with not much more than the shirts on their backs.

Here are the statistics for the entries to the Blackjack Challenge. Each player played a series of five games where the house varied the number of decks of cards used. Players were given the same number of credits at the start of each game, totaling 21000 credits for all of the games. The table below lists the total number of credits wagered by the player, the number of credits left when the player decided to quit, the number of hands played, total execution time, and the overall player score. Also listed are the code and data sizes for the entries, along with the programming language used. As usual, the number in parentheses after the entrant's name is the total number of Challenge points earned in all Challenges to date prior to this one.

Name Credits Wagered Credits Left Hands Played Exec. Time Score Code Size Data Size Lang
Tom Saxton (19) 47451 25199 327 7169 25194 1496 1924 C
Kevin Hewitt 438700 23800 1833 37923 23766 996 2156 C
JG Heithcock (20) 22616 20484 769 17950 20470 1304 232 C
Ken Slezak (20) 91760 9140 1701 36911 9106 1240 172 C
Randy Boring (81) 437230 8670 15425 460099 8213 4920 353 C

Top Contestants

Here are the Top Contestants for the Programmer's Challenge, including everyone who has accumulated more than 20 points during the past two years. The numbers below include points awarded over the 24 most recent contests, including points earned by this month's entrants.

  1. Munter, Ernst 190
  2. Boring, Randy 76
  3. Cooper, Greg 54
  4. Mallett, Jeff 50
  5. Rieken, Willeke 47
  6. Nicolle, Ludovic 34
  7. Lewis, Peter 31
  8. Maurer, Sebastian 30
  9. Saxton, Tom 29
  10. Heithcock, JG 27
  11. Gregg, Xan 24
  12. Murphy, ACC 24
  13. Hart, Alan 21
  14. Antoniewicz, Andy 20
  15. Day, Mark 20
  16. Higgins, Charles 20
  17. Hostetter, Mat 20
  18. Studer, Thomas 20

There are three ways to earn points: (1) scoring in the top 5 of any Challenge, (2) being the first person to find a bug in a published winning solution or, (3) being the first person to suggest a Challenge that I use. The points you can win are:

  • 1st place 20 points
  • 2nd place 10 points
  • 3rd place 7 points
  • 4th place 4 points
  • 5th place 2 points
  • Finding bug 2 points
  • Suggesting Challenge 2 points

Here is Tom's winning solution:

Copyright © 1998 Tom Saxton

#include "BlackJack.h"

// Naming Conventions:
// Without getting into the gory details of the Hungarian naming convention,
// here are some common prefixes and their meanings:
//      a       array
//      p       pointer
//      c       count
//      mp      map (one data type to another)
//      i       index
// The prefixes modify a base type. So, if FOO is a base type (like a struct,
// or an enum), the following declarations illustrate the above prefixes:
//      FOO     foo;
//      FOO *   pfoo;
//      FOO     afoo[10];
//      int     ifoo; // an index into an array of FOOs
//      int     cfoo; // a count of FOOs.
//      for (ifoo = 0; ifoo < cfoo; ++ifoo)
//         pfoo = &afoo[ifoo];

enum { fFalse = 0, fTrue = 1 };
#define DIM(a) (sizeof(a)/sizeof((a)[0]))

// Be sure to enable this define to pick up a couple of post-deadline bug fixes.
// #define BUGFIX

// disable debug code
#define Assert(f)

// The following tables determine the actions for all possible hands,
// divided into three groups: pairs, soft hands and hard hands, considered
// in that order. (A pair of aces is treated as a pair, not as a soft hand.)
// The tables were computed by taking the Dealer's up card and assuming
// a huge shoe with an even card distribution finding the probability
// for each of the possible final dealers scores (bust, 17, 18, 19, 20 and 21).
// Then, given that table, I computed the expected earnings (win, lose or
// push) for each of the possible actions, and recorded the action with
// the best result.
// I found the book "Best Blackjack" by Frank Scoblete (c) 1996 to be
// helpful, and my tables are close to his multi-deck tables.
// I modeled an infinite, evenly distributed shoe, he may have modeled
// a fixed number of decks.

// macros to make these tables manageable...
#define H kHitMe
#define D kDoubleDownAndHitMe
#define S kStandPat
#define X kSplitAndHitMe
#define B kClaimBlackjack

// For "hard" hands (no Aces scored as 11), plug in the dealer's up card
// (minus 1) and the hand's score to find the next action. If this isn't the
// first action of the hand, treat kDoubleDownAndHitMe as kHitMe.
Action mp_spot_score_actionHard[10][22] = 
//      0   - 21
   { H,H,H,H,H,H,H,H,H,H,H,H,H,H,H,H,H,S,S,S,S,S },   /*  A */
   { H,H,H,H,H,H,H,H,H,D,D,D,H,S,S,S,S,S,S,S,S,S },   /*  2 */
   { H,H,H,H,H,H,H,H,H,D,D,D,H,S,S,S,S,S,S,S,S,S },   /*  3 */
   { H,H,H,H,H,H,H,H,H,D,D,D,S,S,S,S,S,S,S,S,S,S },   /*  4 */
   { H,H,H,H,H,H,H,H,H,D,D,D,S,S,S,S,S,S,S,S,S,S },   /*  5 */
   { H,H,H,H,H,H,H,H,D,D,D,D,S,S,S,S,S,S,S,S,S,S },   /*  6 */
   { H,H,H,H,H,H,H,H,H,D,D,D,H,H,H,H,H,S,S,S,S,S },   /*  7 */
   { H,H,H,H,H,H,H,H,H,H,D,D,H,H,H,H,H,S,S,S,S,S },   /*  8 */
   { H,H,H,H,H,H,H,H,H,H,D,D,H,H,H,H,H,S,S,S,S,S },   /*  9 */
   { H,H,H,H,H,H,H,H,H,H,H,D,H,H,H,H,H,S,S,S,S,S }    /*  10 */

// For "soft" hands (at least one Ace used as an 11), plug in the dealer's up card
// (minus 1) and the hand's "other" card (or combined score without the ace)
// to find the next action.
Action mp_spot_spot_actionSoft[10][10] = 
   { H, H, H, H, H, H, S, S, S, B },   /*  A */
   { H, H, H, H, H, D, S, S, S, B },   /*  2 */
   { H, H, H, H, H, D, D, S, S, B },   /*  3 */
   { H, H, H, H, D, D, D, S, S, B },   /*  4 */
   { H, H, H, D, D, D, D, S, S, B },   /*  5 */
   { H, H, H, D, D, D, D, S, S, B },   /*  6 */
   { H, H, H, H, H, D, S, S, S, B },   /*  7 */
   { H, H, H, H, H, H, S, S, S, B },   /*  8 */
   { H, H, H, H, H, H, H, S, S, B },   /*  9 */
   { H, H, H, H, H, H, H, S, S, B }    /* 10 */

// If dealt a pair, plug in the dealer's up card (minus 1) and the spot
// value of the pair (minus 1) to find the suggested action.
Action mp_spot_spot_actionPair[10][10] = 
   { X, H, H, H, H, H, H, H, S, S },   /*  A */
   { X, X, X, H, D, H, X, X, X, S },   /*  2 */
   { X, X, X, H, D, H, X, X, X, S },   /*  3 */
   { X, X, X, H, D, X, X, X, X, S },   /*  4 */
   { X, X, X, H, D, X, X, X, X, S },   /*  5 */
   { X, X, X, D, D, X, X, X, X, S },   /*  6 */
   { X, X, X, H, D, H, X, X, S, S },   /*  7 */
   { X, X, X, H, D, H, H, X, X, S },   /*  8 */
   { X, X, H, H, D, H, H, X, X, S },   /*  9 */
   { X, H, H, H, H, H, H, H, S, S }    /*  10 */

// undefine shortcuts used in the above tables
#undef H
#undef D
#undef S
#undef X
#undef B

// Score bust as zero.
#define scoreBust            0
// The Player's hand is limited to five cards.
#define ccardMaxPlayer       5
// The dealer can never draw more than nine cards
// (nine 2's for example).
#define ccardMaxDealer      10

// Entry in the SPOT table, used for scoring and printing card values
typedef struct ESPOT
   char   score;
   char   sz[3];

static const ESPOT s_dnspot[kKing+1] = 
   {  0, "?" },
   {  1, "A" },
   {  2, "2" },
   {  3, "3" },
   {  4, "4" },
   {  5, "5" },
   {  6, "6" },
   {  7, "7" },
   {  8, "8" },
   {  9, "9" },
   { 10, "10" },
   { 10, "J" },
   { 10, "Q" },
   { 10, "K" },

// game statistics...
static int s_cdeck;
static int s_ccreditStart;
static int s_ccreditMinBet;
static int s_ccreditMidBet;
static int s_ccreditMaxBet;
static int s_ccreditBalance;
static int s_ccreditTotalBet;

// callback functions
static BetProc *s_pfnMakeABet;
static HitProc *s_pfnHitMe;

// function to score a hand
static int _ScoreHand(const Card acard[], int ccard,
                              int *pcAce);

// struct for counting cards...
typedef struct DECK
   int acspot[10+1];
   int cspotStart;
   int cspotRemain;
   int dcount;
   int fInfinite;
static DECK s_deck;
// calls to reset card counters and count the cards in a hand
void _InitDeck(int cdeck, int fInfinite);
void _CountCards(const Card acard[], int ccard);
// call to compute the proper action given the player's hand and
// the dealer's up card, and whether or not this is the first action
static Action _ActionLookupHand(Spot spotDealer, Card acard[], int ccard, int fFirst);

// Call to start a game
void InitBlackjack(
   int numDecks,       /* number of decks used by the dealer, 2..10*/
   int yourBankroll,   /* number of credits you have to start */
   int minBet,         /* minimum bet for each hand */
   int maxBet,         /* maximum bet for each hand */
   BetProc pfnMakeABet,/* callback to place a wager */
   HitProc pfnHitMe    /* callback to get a card */
   s_cdeck             = numDecks;
   s_ccreditStart      = yourBankroll;
   s_ccreditMinBet     = minBet;
   s_ccreditMaxBet     = maxBet;
   s_pfnMakeABet       = pfnMakeABet;
   s_pfnHitMe          = pfnHitMe;

   s_ccreditTotalBet   = 0;
   s_ccreditBalance    = s_ccreditStart;

// Call to play a hand
Boolean Blackjack(Boolean fNewDeck)
   int      ccreditBet;
   Card     acardPlayer[ccardMaxPlayer], acardDealer[ccardMaxDealer];
   int      ccardPlayer, ccardDealer;
   Action   actionFirst;
   int      ccreditWin;
   Spot     spotDealer;
   int      ihand, chand;
   int      count;
   Result   result;
   if (fNewDeck)
      _InitDeck(s_cdeck, fFalse /*fInfinite*/);
   // normalize the card count. A positive count means that the shoe is
   // heavy in large cards, which makes it more likely for the dealer to
   // bust. A negative count means that the shoe is heavy in small cards,
   // which makes it less likely that the dealer with bust.
   count = (s_deck.dcount*52)/s_deck.cspotRemain;
   // Make a bet that is proportional to our current balance, so that losing
   // streaks don't clean us out, and winning streaks rake in extra chips.
   // Bet more when the count is high, less when it's low, but stay within
   // the stated betting limits.
   ccreditBet = (count+2)*s_ccreditBalance/50;
   if (ccreditBet < s_ccreditMinBet)
      ccreditBet = s_ccreditMinBet;
   else if (ccreditBet > s_ccreditMaxBet)
      ccreditBet = s_ccreditMaxBet;
   // Place bet, get some cards
   (*s_pfnMakeABet)(ccreditBet, acardPlayer, acardDealer);
   ccardPlayer = ccardDealer = 2;
   // store and normalize the dealer's up card
   spotDealer = acardDealer[1].spot;
   if (spotDealer > k10)
      spotDealer = k10;
   // get the first action for the hand
   actionFirst = 
            _ActionLookupHand(spotDealer, acardPlayer, 2, fTrue);
   if (actionFirst == kDoubleDownAndHitMe)
      ccreditBet *= 2;
   chand = (actionFirst == kSplitAndHitMe) ? 2 : 1;
   // play out the hand(s) (there are two hands if we kSplitAndHitMe)
   for (ihand = 0; ihand < chand; ++ihand)
      Boolean   fInsurance;
      Action action = actionFirst;
      // take the "insurance" side bet when the dealer shows an Ace and there is
      // a better than one third chance of the dealer having a 10 for the other card.
      fInsurance = (spotDealer == kAce) && 
                        (3*s_deck.acspot[k10] > s_deck.cspotRemain);
         // play out an action
         result = 
               (*s_pfnHitMe)(action, fInsurance, acardPlayer, 
                           &ccardPlayer, acardDealer, &ccardDealer, 
         if (result != kNoResult)
         // If we didn't kStandPat or bust, calculate the next action
         action = _
         ActionLookupHand(spotDealer, acardPlayer, ccardPlayer, 
      // count the cards shown in this hand
      _CountCards(acardPlayer, ccardPlayer);
      if (ihand == chand-1)
         _CountCards(acardDealer, ccardDealer);
      // tally our win/loss
      s_ccreditBalance += ccreditWin;
      s_ccreditTotalBet += ccreditBet;

   // If we have lost most of our money, quit
   if (s_ccreditBalance < s_ccreditStart/3)
      return fFalse;
   // If we have won a lot, and will avoid the freeloader penalty, quit
   if (s_ccreditBalance > 7*s_ccreditStart/4 && 
            s_ccreditTotalBet > s_ccreditStart)
      return fFalse;
   // If we have won some, and played for twice the freeloader requirement, quit
   if (s_ccreditBalance > 5*s_ccreditStart/4 && 
            s_ccreditTotalBet > 2*s_ccreditStart)
      return fFalse;
   // If we haven't lost, and played for five times the freeloader requirement, quit
   if (s_ccreditBalance > s_ccreditStart && 
            s_ccreditTotalBet > 5*s_ccreditStart)
      return fFalse;
   // If we've played 10 times the freeloader penalty, quit before the time penalty
   // takes it all away...
   if (s_ccreditTotalBet > 10*s_ccreditStart)
      return fFalse;
   return fTrue;

// Call to get the next action for this hand
static Action _ActionLookupHand(Spot spotDealer, Card acard[], int ccard, int fFirst)
   int score, cAce;
   Spot spot;
   Action action;
   // get the hand's score, and the count of Aces scored as 11
   score = _ScoreHand(acard, ccard, &cace);
   Assert(kAce <= spotDealer && spotDealer <= k10);
   if (fFirst && ccard == 2 && acard[0].spot == acard[1].spot)
      // first action on a pair, check the pair's table
      if ((spot = acard[0].spot) > k10)
         spot = k10;
      action = 
   else if (cAce > 0)
      // "soft" hand, check the soft table
      spot = (Spot)(score - 11);
      Assert(kAce <= spot && spot <= k10);
#ifdef DEBUG
      if (ccard == 2)
         int icard = acard[0].spot == kAce ? 1 : 0;
         Assert(spot == acard[icard].spot || 
                        (spot == k10 && acard[icard].spot > k10));
      action = 
      // "hard" hand, chech the hard table
      action = 
   // If it's not the first play of the hand, we can only kStandPat or kHitMe
#ifdef BUGFIX
   // Another Bug Fix: be careful trying to catch illegal actions...
   if (action == kClaimBlackjack && ccard != 2)
      action = kStandPat;
   if (!fFirst && (action == kDoubleDownAndHitMe || 
                                    action == kSplitAndHitMe))
      action = kHitMe;
   // This code is wrong, it incorrectly returns kHitMe in two cases:
   //  1. If a pair of 10s or Aces is split, then one of them turned into a blackjack
   //  2. A score of 21 is reached with an Ace and two or more cards.
   if (!fFirst && action != kStandPat)
      action = kHitMe;
   return action;

// reset the counts for a fresh set of decks
static void _InitDeck(int cdeck, int fInfinite)
   Spot spot;
   int cspot = 4*cdeck;
   for (spot = kAce; spot < k10; ++spot)
      s_deck.acspot[spot] = cspot;
   Assert(spot == k10);
   s_deck.acspot[k10] = 4*cspot;
   s_deck.cspotRemain = s_deck.cspotStart = 52*cdeck;
   s_deck.dcount = 0;
   s_deck.fInfinite = fInfinite;

// This is the counting method used by the couple of people I've talked
// who have actually counted cards playing Blackjack. It's call "Hi-Lo"
// in "Best Blackjack". I tried several other counting models listed
// in that book, and this performed the best. It gives a simple assessment
// of how far off balance the shoe is with respect to small and large cards.
static const int s_mp_spot_dcount[k10+1] =
//    A  2  3  4  5  6  7  8  9  10
{ 0, -1, 1, 1, 1, 1, 1, 0, 0, 0, -1 };

// Remove the specified set of cards from the shoe
void _CountCards(const Card acard[], int ccard)
   if (s_deck.fInfinite)
   while (ccard- > 0)
      Spot spot = acard[ccard].spot;
// Bug Fix: we shouldn't count hidden cards...
#ifdef BUGFIX
      if (spot == kHiddenSpot)
      if (spot > k10)
         spot = k10;
      s_deck.dcount += s_mp_spot_dcount[spot];

// Determine the score for the given cards. When possible, score
// Aces at 11, and return the number of aces thusly scored.
static int _ScoreHand(const Card acard[], int ccard, int *pcAce)
   int cAceDummy;
   int score = 0;
   int cAce = 0;

   if (pcAce == NULL)
      pcAce = &cAceDummy;
   *pcAce = 0;
   while (ccard- > 0)
      if (acard[ccard].spot == kAce)
      score += s_dnspot[acard[ccard].spot].score;
   if (score > 21)
      return scoreBust;
   while (score + 10 <= 21 && cAce > 0)
      score += 10;

   return score;

Community Search:
MacTech Search:

Software Updates via MacUpdate

Star Wars: Galaxy of Heroes guide - How...
Star Wars: Galaxy of Heroes is all about collecting heroes, powering them up, and using them together to defeat your foes. It's pretty straightforward stuff for the most part, but increasing your characters' stats can be a bit confusing because it... | Read more »
The best cooking apps (just in time for...
It’s that time of year again, where you’ll be gathering around the dinner table with your family and a huge feast in front of you. [Read more] | Read more »
Square Rave guide - How to grab those te...
Square Rave is an awesome little music-oriented puzzle game that smacks of games like Lumines, but with its own unique sense of gameplay. To help wrap your head around the game, keep the following tips and tricks in mind. [Read more] | Read more »
Snowboard Party 2 (Games)
Snowboard Party 2 1.0 Device: iOS Universal Category: Games Price: $1.99, Version: 1.0 (iTunes) Description: Crowned the best snowboarding game available on the market, Snowboard Party is back to fulfill all your adrenaline needs in... | Read more »
The best games like Animal Crossing on m...
Animal Crossing amiibo Festival is out right now for the Wii U, reminding us of just how much fun that world can be. Or at least to go back and check in on our villages once in a while. [Read more] | Read more »
Between 2 Taps - Tap for Tap interview M...
Hello, and welcome back to Between 2 Taps, Tap for Tap’s Indie Dev interview series. [Read more] | Read more »
Facility 47 (Games)
Facility 47 1.0.1 Device: iOS Universal Category: Games Price: $3.99, Version: 1.0.1 (iTunes) Description: You wake up alone and freezing in an icy cell. You try the cell door but it’s locked, it seems that you are stuck with no... | Read more »
The best Photoshop alternative on iPad
Instagram and Lightroom are great and all, but sometimes people need to get extra creative with their image editing.Like, Photoshop creative. If you're one of these people, take a look at our pick for the best mobile Photoshop experience on iPad... | Read more »
The Walking Dead: No Man’s Land guide -...
A new update for The Walking Dead: No Man’s Land was released last week, making it the perfect time for you to head back to your base and take out some walkers. Here’s the lowdown on what’s new to the game, and how to take advantage. [Read more] | Read more »
Goat Rider guide - Tips and tricks to st...
We've all been there. One second, we're riding high on a crazed goat, and the next, we've been tossed off it like someone who's no good at goat ridin'. [Read more] | Read more »

Price Scanner via

Best Buy Black Friday deals: Up to $200 off M...
Best Buy has posted their Black Friday sale prices for 2015. Save on MacBook Pros, MacBooks, MacBook Airs, iMacs, iPads, and Apple Watches. Choose free shipping or free local store pickup (if... Read more
Save $30-$40 on new Apple TVs after rebate
Adorama has new Apple TVs on sale for up to $40 off MSRP after mail-in rebate, good through December 15th. Shipping is free, and Adorama charges NY & NJ sales tax only: - 32GB Apple TV: $119.99... Read more
13-Inch Haswell MacBook Air At Two Years – Th...
The 13-inch mid-2013 “Haswell” MacBook Air I ordered in Apple’s November 2013 Black Friday sale was my first new Mac in four and a half years — the longest interval I’ve gone between system upgrades... Read more
Target Black Friday Early Access deals: $100...
Target is offering early access to their Black Friday deals on Apple products on their online store for today, the 25th, only. Choose free shipping or free local store pickup (if available): - Apple... Read more
BlackBerry Q3 Mobility Index Report Finds iOS...
BlackBerry has announced results of its thirteenth Good Mobility Index Report, showing that organizations are increasingly building custom secure apps. Among Good Powered by BlackBerry (formerly Good... Read more
Wednesday roundup of early Black Friday Mac s...
Save up to $500 on a new Mac with these early Black Friday deals from Apple resellers, currently the lowest prices available for these models: (1) B&H Photo has all new Macs on sale for up to $... Read more
iPod nano on sale for $119, $30 off MSRP
Walmart has the 16GB iPod nano (various colors) on sale for $119.20 on their online store for a limited time. That’s $30 off MSRP. Choose free shipping or free local store pickup (if available). Sale... Read more
Adorama Black Friday deals: Up to $400 off Ma...
Adorama has released their Black Friday deals for 2015. Save up to $400 on MacBook Pros, $200 on MacBooks and MacBook Airs, and $270 on iMacs. Use code RYBFDEAL during checkout to see these prices.... Read more
B&H Photo Deals: $200 off 12-inch 1.2GHz...
In addition to the B&H Photo Black Friday week sales we posted yesterday, B&H has lowered their price on two products to $200 off MSRP: - 12″ 1.2GHz Gray Retina MacBook: $1399 save $200 - 13... Read more
Best Buy Early Access: Today only, Up to $125...
Best Buy has iPad Air 2s on sale for up to $125 off MSRP and Apple Watch models on sale on their online store for up to $100 off MSRP with special codes through midnight CT tonight. Choose free... Read more

Jobs Board

Hardware Systems Integration Engineer - *App...
# Hardware Systems Integration Engineer - Apple Watch Job Number: 39380139 Santa Clara Valley, Califo ia, United States Posted: Apr. 23, 2015 Weekly Hours: **Job Read more
Sr. Technical/Project Manager, *Apple* Educ...
# Sr. Technical/Project Manager, Apple Education Job Number: 36588557 New York City, New York, United States Posted: Jul. 30, 2015 Weekly Hours: 40.00 **Job Summary** Read more
*Apple* Retail - Multiple Positions (US) - A...
Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, you're also the Read more
Merchant Operations Manager: *Apple* Pay -...
Changing the world is all in a day's work at Apple . If you love innovation, here's your chance to make a career of it. You'll work hard. But the job comes with more than Read more
*Apple* Pay QA Manager - Apple Inc. (United...
Changing the world is all in a day's work at Apple . If you love innovation, here's your chance to make a career of it. You'll work hard. But the job comes with more than Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.