TweetFollow Us on Twitter

Efficient C
Volume Number:9
Issue Number:8
Column Tag:C Workshop

Efficient C Programming

High-level optimizations

By Mike Scanlin, MacTech Magazine Regular Contributing Author

This article explains and gives examples of how to get better code generation for common operations and constructs in C on the Macintosh. These higher level optimizations will, on average, produce faster and smaller code in other languages as well (C++, Pascal). Some of them will make your code harder to read, more difficult to port, and possibly have a negative performance impact on non-680x0 CPUs. However, for those cases where you’re optimizing your bottlenecks for the 680x0 CPUs, these tricks will help you.

There are several things you can do to your code independent of which language or compiler you’re using in order to improve performance. Let’s start with those.


There are three things to know in order to produce optimal file I/O: (1) always read/write in sector aligned amounts, (2) read/write in as big of chunks as possible and, (3) be sure to disable Apple’s disk cache.

From the Mac file system’s point of view, files are made up of blocks. From a disk driver point of view blocks are made up of sectors. A sector is usually 512 bytes. On large disks a block can be 10K or larger (files are a minimum of 1 block in size). You can get the exact block size by doing a GetVInfo and checking the volumeParam.ioVAlBlkSiz field. Your buffers should be multiples of this amount when reading and writing to that particular volume (and if not, then they should at least be multiples of the sector size) and should begin on a block boundary (or, at a minimum, a sector boundary) within the file. Your reads/writes will be 2x faster if you read/write aligned sectors than if you don’t.

Recently while implementing a virtual memory scheme I had to determine the optimal VM page size for maximum disk throughput (measured in bytes/second). After testing a variety of page sizes on a variety of CPUs and hard disks, I determined that the optimal size was 64K. If you read and write less than 64K at a time you will not be minimizing disk I/O time (and for very small reads and writes you will be paying a significant throughput penalty). Here’s an experiment for the unbelievers: write a little program that writes an 8MB file 512 bytes at a time and then writes another 8MB file 64K at a time. You should find that the 64K at a time case is 8x to 40x faster than the 512 byte at a time case. Then try reading in that 8MB file 512 bytes at a time and then 64K at a time. It should be about 35x to 40x faster for the 64K case (your actual times will depend on your CPU and your hard drive).

Lastly, if you are using large aligned I/O buffers you should turn off Apple’s disk cache for your reads and writes. IM Files pg. 2-95 says that you can do this by setting bit 5 of ioPosMode before a Read or Write call. In those cases where the cache is kicking in, you’ll be 13x faster by forcing it off. For a complete explanation of Apple’s disk cache, see “Apple’s Lame Disk Cache” on pg. 75 of April 1993 MacTech.


In a previous MacTech article (Sept 1992) I droned on and on about aligning your data structures and stack usage. That’s true in any language on the Mac (because it’s a result of the 680x0 architecture). Do it.

One thing you can do to reduce the calling overhead of your functions is to use fewer parameters. Sometimes you’ll find that a general purpose routine that takes several parameters is being called in a loop where most of the parameters aren’t changing between calls within the loop. In cases like this you should make a parameter block and pass a pointer to the parameter block rather than passing all of the parameters each time. Not only does this make aligned-stack calling easier to implement and maintain but it really reduces the pushing and popping of invariant stack data during your loop. For instance, you could change this prototype:

void   MyWizzyFunction(short wizFactor, long numWizzes, Boolean 
 doWiz, short fudgeFactor, short wizHorz, short wizVert);

to this:

void MyWizzyFunction(WizParamBlockPtr wizPBPtr);

with this parameter block:

typedef struct WizParamBlock {
 long   numWizzes;
 short  wizFactor;
 short  fudgeFactor;
 short  wizHorz;
 short  wizVert;
} WizParamBlock, * WizParamBlockPtr;

You’ll save a lot of time from reduced stack operations on each call to MyWizzyFunction.


I once met someone who told me that every computer science problem could be reduced to a table lookup. I guess that if your table was unlimited in size this might be true (but then the table initialization time might kill you). Nonetheless, there are many cases where code can be sped up with a relatively small table. The idea is to precompute some data and look it up rather than recalculate it each time through a loop. For example, this code:

!register Byte   n, *xPtr;
register short i, *yPtr;
Byte    x[1000];
short   y[1000];

yPtr = y;
xPtr = x;
i = 1000;
do {
 n = *xPtr++;
 *yPtr++ = n*n + n/5 - 7;
} while (--i);

is much slower than this code:

/* 1 */

register Byte    *tablePtr;
register short tableOffset;
short   table[256];

/* first pre-compute all possible
 * 256 values and store in table
yPtr = table;
i = 0;
do {
 *yPtr++ = i*i + i/5 - 7;
} while (++i < 256);

tablePtr = (Byte *) table;
yPtr = y;
xPtr = x;
i = 1000;
do {
 /* we do manual scaling for speed */
 tableOffset = *xPtr++;
 tableOffset *= sizeof(short);
 /* generates Move (Ax,Dx),(Ay)+ */
 *yPtr++ = *(short *)
 (tablePtr + tableOffset);
} while (--i);

This second version which only requires a 256 element table contains no multiplies or divides. The tableOffset *= sizeof(short) statement compiles down to an Add instruction since sizeof(short) evaluates to 2. The *yPtr++ = ... statement compiles down to Move (Ax,Dx),(Ay)+ which is as optimal as you can do (and what you would have written if you had been writing assembly).

One thing that’s really important to know when using lookup tables is that your table element size needs to be a power of 2 in order to have fast pointer calculations (which can be done with a shift of the index). If you only need 5 bytes per table element then it would be better to pad each element to 8 bytes so that you can shift the index by 3 (times 8) rather than multiplying it by 5 when trying to get a pointer to a given element.

Also, depending on the amount of data involved, you may want to declare the table as a static and let the compiler calculate its values at compile-time.


This one is obvious enough that most programmers assume that the compiler always does it for them. If you want to divide a value by 8, you might think that this would generate an efficient shift right by 3:

x /= 8;

It’s true that if x is unsigned then MPW and Think do the right thing but if x is signed they generate a divide. The reason is because you can’t shift a negative number to the right to divide by 8 (if the original value is -1 you’ll get -1 as the result, too, because of sign extension). To solve this problem, you should add 7 to x (when it’s negative) before shifting. Use this instead of the above for signed right-shifts by 3:

/* 2 */

if (x < 0)
 x += 7;
x >>= 3;

and use a shift left instead of a multiply when multiplying by a power of 2. Also, there may be brain-dead compilers out there that your code will be ported to some day so you should use the shift operator even when working with unsigned values. It’s a good habit to get into.


When moding by powers of 2, you should ‘and’ it by (value - 1) instead. Don’t do this:

x = y % 8;

do this (to save a division):

x = y & (8 - 1);

As before, this may yield incorrect results if y is signed but if the result is just to get the last 3 bits, it works fine. And if you want the remainder of a negative number when divided by 8 (i.e. what mod would return to you if you used it) you can do this to save a divide:

/* 3 */

x = y & (8 - 1);
if (y < 0)
 x += 8;


As you know, multiply instructions are expensive on the 680x0 and you should avoid them wherever possible. What you may not know, though, is the extent to which you should avoid them. For instance, some would say that this code:

x *= 20;

is acceptable. However, in a tight loop it would be much better to use:

/* 4 */

temp = x;
temp += x;
temp += temp;
x <<= 4;
x += temp;

It’s not necessarily intuitive that five instructions are better than one but, assuming temp and x are register variables, the times for the above are:

68000: 70 cycles for first one, 30 cycles for second

68030: 28 cycles for first one, 14 cycles for second

68040: 15 cycles for first one, 6 cycles for second

This type of C programming, which I call “writing assembly language with C syntax” requires a detailed knowledge of your compiler and your register variables allocation. It also requires a little knowledge of assembly language which, if you don’t have, would be a good thing to start learning (use Think’s Disassemble command and MPW’s dumpobj to see what the compiler is doing with your C code).


Many people resist this optimization but it falls into the category of convenient syntax vs. efficient syntax. The basic point is that you can always do at least as good as a ‘for’ loop by using a ‘while’ (for 0 or more iterations) or a ‘do-while’ loop (for 1 or more iterations), and in most cases you can do better by not using a ‘for’ loop. (In fact, Wirth removed the ‘FOR’ keyword from his latest language Oberon because he considered it unnecessary.)

Here’s an example. This code:

for (i = 0; i < NUM_LOOPS; i++) {

is better as:

/* 5 */

do {
} while (--i);

because the first one generates:

 Moveq  #0,D7
 Bra.S  @2
@1 <body of loop>
@2 Addq #1,D7
 Cmpi   #NUM_LOOPS,D7
 Blt.S  @1

and the second one generates:

 Moveq  #NUM_LOOPS,D7
@1 <body of loop>
 Subq   #1,D7
 Bne.S  @1

Now, it’s true that I’m comparing apples and oranges a bit here because the first loop counts up and the second loop counts down but the first loop is representative of how I see a lot of inexperienced programmers write their ‘for’ loops. Even if they were to make the optimization of counting down to zero, the do-while loop is still more efficient because of the extra branch instruction at the top of the ‘for’ loop.

As an experiment, try writing your code without ‘for’ loops for a while. I think you’ll find that it often becomes clearer and in many cases it will become more efficient, too.


While register variables are certainly a good tool for making your code faster, if you don’t use them right you might be hurting yourself.

When writing an application on the 680x0, you have 3 address registers (pointers) and 5 data registers to play with. Do NOT declare more than that. And if something doesn’t really need to be in a register (because it’s only read from once or twice, for instance) then don’t put it in a register. The time to save, initialize and restore the register will cause a performance hit rather than gain.

The most important thing is to write your functions so that they have a reasonable number of local variables (no more than 3 pointers and 5 non-pointers, ideally). If you just can’t split the function up or use fewer variables then try to use register variables with restricted scope (some subset of the function) so that you can reuse them later in the function for other things.

Even if you don’t use register variables, big functions with lots of locals make it extremely difficult for any compiler to allocate registers efficiently. This applies to many different machines and compilers.


Similar to the above trick, there are times when even the simplest statements, such as:

x = 131;

can be improved:

x = 127;
x += 4;

The reason is because the first generates one of the instructions that you should never use when programming on a non-68040:

Move.L  #131,x

That’s a 6-byte instruction which is better replaced with this 4-byte version:

/* 6 */

Moveq   #127,x
Addq    #4,x

On the 68040 you won’t notice any improvement from this optimization because 32-bit immediate operands are one of the optimized addressing modes. But on 680x0s less than the 68040 you will get a size and speed benefit from using the two instruction version (which must be written as two statements; if you do “x = 127 + 4” the compiler will combine the compile-time constants for you).


It was hard for me to believe it when I first saw it but this code:

#define COUNT    (600 * 60)
register long    x;
x = COUNT;

actually generates a run-time multiply instruction in Think C. The problem is that the result of the 600*60 multiplication is larger than the maximum positive integer. So the assignment at run time is x = -29536 (the 32-bit signed interpretation of an unsigned 16-bit 36000), which is probably not what you want. To get what you probably want, and to eliminate the run-time multiply instruction, add an “L” after the “600” in the #define. That way the compiler treats it as a 32-bit constant and will do the multiply at compile-time.


Square brackets [] are usually a sign of inefficiency in C programs. The reason is because of all the index calculations the compiler is going to generate to evaluate them. There are some exceptions to this rule, but not many. For instance, this code:

for (i = 0; i < 100; i++)
 x[i] = blah;

is much better as:

/* 7 */

p = x;
for (i = 0; i < 100; i++)
 *p++ = blah;

because the compiler doesn’t have to calculate the effective address of x[i] each time through the loop.

Likewise, the following code (which is notationally convenient) to append ‘.cp’ to the end of a Pascal string:

char  *name;
name[++*name] = '.';
name[++*name] = 'c';
name[++*name] = 'p';

is much less efficient (and many more bytes) than this code:

/* 8 */

char  *namePtr;
namePtr = name + *name;
*namePtr++ = '.';
*namePtr++ = 'c';
*namePtr++ = 'p';
*name += 3;


If you find that you must use array addressing with square brackets, you can improve the efficiency by using a signed 16-bit index rather than an unsigned one (of 16 or 32 bits). The reason is because something like this:

x = p[i];

can then be coded as (assuming everything is a register variable and p points to an array of bytes):

Move    (p,i),x

whereas, if i were unsigned you’d get:

Moveq #0,D0
Move    i,D0
Move    (p,D0.L),x

If generating 68020 instructions or higher then this same trick improves efficiency even if p points to an array of 16-bit, 32-bit or 64-bit quantities because most compilers will use the auto-scaling addressing mode:

Move    (p,i*8),x

for example, if p points to a table of 8-byte entries.


This one is really only a shortcoming of Think C’s code generation and nothing else. I hope they fix it soon because it drives me nuts. If you do this in Think C:

i = *--p;

you’ll get this code generated:

Subq.L  #2,A4
Move    (A4),D7

instead of the obviously more efficient:

Move    -(A4),D7

If you have a large buffer that you’re walking through backwards then the time penalty for pre-decremented pointers can be significant (and would be a good place to drop in a little in-line asm). The funny thing is that Think is smart about the post incrementing case. i.e., this code:

/* 9 */

i = *p++;

generates the optimal:

Move    (A4)+,D7

I’m not sure why they have this asymmetry in their code generator. Probably a function of shipping deadlines...


In some cases, it’s better to do what appears to be more work. This code:

x = (expr) ? y : z;

or its equivalent:

if (expr)
 x = y;
 x = z;

can be made to execute faster and take fewer bytes like this:

/* 10 */

x = z;
if (expr)
 x = y;

The reason is because the unconditional branch instruction generated by the compiler before the else statement is slower than the extra assignment instruction.


Not too long ago I was asked to investigate why a certain application was running slow. The developers had made several recent changes, one of which was to use temporary memory, and noticed a slow down. I traced one of the problems down to the TempNewHandle call itself. It turns out that it’s 5x slower than NewHandle. Try allocating 80 handles of 64K each with NewHandle and then the same thing with TempNewHandle. The results are a strong argument against using TempNewHandle for places where you do lots of allocations and deallocations (in those cases where you have a choice).


If you pack several boolean flags into a byte, put your most commonly tested flag in the highest bit position because the compiler will usually generate a Tst.B instruction for you rather than a less efficient Btst #7,<flags> instruction.


When clipping a value to a certain range of values, be sure to use an else statement. I’ve seen this code several times:

if (x < MIN_VAL)
 x = MIN_VAL;
if (x > MAX_VAL)
 x = MAX_VAL;

The insertion of a simple ‘else’ keyword before the second ‘if’ will improve performance quite a bit for those cases where x is less than MIN_VAL (because it avoids the second comparison in those cases where you know it’s false):

/* 11 */

if (x < MIN_VAL)
 x = MIN_VAL;
else if (x > MAX_VAL)
 x = MAX_VAL;


You might think that these two instructions were the same:

Byte    x;

x += x;
x <<= 1;

Or, if not, you might think that one of them would be consistently better than the other. Well, while they are the same functionally, depending on whether or not x is a register variable you can get optimal code with one or the other, but not both.

Let’s look at the code. If x is not a register variable then you get this for the first one (in Think C):

Move.B  nnnn(A6),D0
Add.B   D0,nnnn(A6)

and you get this for the second one:

Move.B  nnnn(A6),D0
Add.B   D0,D0
Move.B  D0,nnnn(A6)

So, as you can see the first one, x += x, is better. However, if x is a register variable then the first one generates:

Move.B  D7,D0
Add.B   D0,D0
Move.B  D0,D7

and the second one generates:

Add.B   D7,D7

And now the second one, x <<= 1, is clearly better. Don’t ask me why (cause I don’t know) but if it bothers you like it does me then write a letter to the Think implementors.


Now that I’ve covered several C optimization tricks, let’s look at an example I encountered last week. Listing 6 of the ‘Principia Off-Screen’ tech note builds a color table from scratch:

/* 12*/

#define kNumColors 256 

short   index;

/* Allocate memory for the color table */
newColors = (CTabHandle)
 NewHandleClear(sizeof(ColorTable) +
 sizeof(ColorSpec) * (kNumColors - 1));

if (newColors != nil) {

 (**newColors).ctSeed = GetCTSeed();
 (**newColors).ctFlags = 0;
 (**newColors).ctSize = kNumColors - 1;

 /* Initialize the table of colors */
 for (index = 0;
 index < kNumColors; index++) {
 = index;
 red = someRedValue;
 green = someGreenValue;
 blue = someBlueValue;

What’s inefficient about it? For starters, it’s a little wasteful to clear all of the bytes with NewHandleClear since the code then proceeds to set every byte in the structure to some known value. Second, it’s wasteful to dereference the newColors handle every time a field of the color table is referenced. Nothing in that code except for the NewHandleClear call is going to move memory so, at a minimum, we should dereference the handle once and use a pointer to the block. Third, the evil square brackets array indexing is used in a place where a post-incrementing pointer would do. Forth, a ‘for’ loop is used where a do-while will suffice.

Here’s a more efficient version of the same code that fixes all of these problems:

/* 13 */

#define kNumColors 256

CTabPtr newColorsPtr;
short   index, *p;

/* Allocate memory for the color table */
newColorsHndl = (CTabHandle)  NewHandle(sizeof(ColorTable) +
 sizeof(ColorSpec) * (kNumColors - 1));

if (newColorsHndl != nil) {

 newColorsPtr = *newColorsHndl;
 newColorsPtr->ctSeed = GetCTSeed();
 newColorsPtr->ctFlags = 0;
 newColorsPtr->ctSize = kNumColors - 1;

 /* Initialize the table of colors */
 p = (short *) newColorsPtr->ctTable;
 index = 0;
 do {
 *p++ = index; /* value */
 *p++ = someRedValue;
 *p++ = someGreenValue;
 *p++ = someBlueValue;
 } while (++index < kNumColors);

Now, to be fair, I’m sure the authors of that tech note wrote the code the way they did so that it would be clear to as many people as possible. After all, it is for instructional purposes. So please don’t flame me for picking on them; with the exception of the inefficiencies in the example code, I happen to like that tech note a lot.


Many Mac programmers I’ve met have the impression that if you’re programming in a high level language like C that many of the known assembly language peephole optimizations don’t apply or can’t be achieved because the compiler’s code generation is out of your control. While that’s true for some of the low-level tricks, it’s certainly not true for all of them, as we have seen. It’s just a matter of getting to know your compiler better so that you can coerce it to generate the optimal set of instructions. But if you’re writing portable code, these types of CPU-dependent and compiler-dependent optimizations should probably not be used except in the 5% of your code that occupies 80% of the execution time (and even then you’re probably going to want a per-CPU and per-compiler #ifdef so that you get optimal results on all CPUs and with all compilers).


Community Search:
MacTech Search:

Software Updates via MacUpdate

1Password 6.6.1 - Powerful password mana...
1Password is a password manager that uniquely brings you both security and convenience. It is the only program that provides anti-phishing protection and goes beyond password management by adding Web... Read more
Safari Technology Preview 10.2 - The new...
Safari Technology Preview contains the most recent additions and improvements to WebKit and the latest advances in Safari web technologies. And once installed, you will receive notifications of... Read more
Eye Candy - 30 professional Pho...
Eye Candy renders realistic effects that are difficult or impossible to achieve in Photoshop alone, such as Fire, Chrome, and the new Lightning. Effects like Animal Fur, Smoke, and Reptile Skin are... Read more
Microsoft Office 2016 15.31 - Popular pr...
Microsoft Office 2016 - Unmistakably Office, designed for Mac. The new versions of Word, Excel, PowerPoint, Outlook and OneNote provide the best of both worlds for Mac users - the familiar Office... Read more
Spotify - Stream music, crea...
Spotify is a streaming music service that gives you on-demand access to millions of songs. Whether you like driving rock, silky R&B, or grandiose classical music, Spotify's massive catalogue puts... Read more
QuickBooks R13 - Financial...
QuickBooks helps you manage your business easily and efficiently. Organize your finances all in one place, track money going in and out of your business, and spot areas where you can save. Built for... Read more
Dash 4.0.1 - Instant search and offline...
Dash is an API documentation browser and code snippet manager. Dash helps you store snippets of code, as well as instantly search and browse documentation for almost any API you might use (for a full... Read more
Tinderbox 7.0.0 - Store and organize you...
Tinderbox is a personal content management assistant. It stores your notes, ideas, and plans. It can help you organize and understand them. And Tinderbox helps you share ideas through Web journals... Read more
Apple Remote Desktop Client 3.9 - Client...
Apple Remote Desktop Client is the best way to manage the Mac computers on your network. Distribute software, provide real-time online help to end users, create detailed software and hardware reports... Read more
Sparkle 2.1.1 - $79.99
Sparkle will change your mind if you thought building websites wasn't for you. Sparkle is the intuitive site builder that lets you create sites for your online portfolio, team or band pages, or... Read more

Tavern Guardians (Games)
Tavern Guardians 1.0 Device: iOS Universal Category: Games Price: $2.99, Version: 1.0 (iTunes) Description: Tavern Guardians is a Hack-and-Slash action game played in the style of a match-three. You can experience high pace action... | Read more »
Slay your way to glory in idle RPG Endle...
It’s a golden age for idle games on the mobile market, and those addictive little clickers have a new best friend. South Korean developer Ekkorr released Endless Frontier last year, and players have been idling away the hours in the company of its... | Read more »
Tiny Striker: World Football Guide - How...
| Read more »
Good news everyone! Futurama: Worlds of...
Futurama is finding a new home on mobile in TinyCo and Fox Interactive's new game, Futurama: Worlds of Tomorrow. They're really doing it up, bringing on board Futurama creator Matt Groening along with the original cast and writers. TinyCo wants... | Read more »
MUL.MASH.TAB.BA.GAL.GAL 1.0 Device: iOS Universal Category: Games Price: $2.99, Version: 1.0 (iTunes) Description: ENDLESS UPGRADES. CONSTANT DANGER. ANCIENT WISDOM. BOUNCY BALLS. Launch Sale, 40% OFF for a very limited time!!! MUL.... | Read more »
Dungeon Rushers (Games)
Dungeon Rushers 1.0 Device: iOS Universal Category: Games Price: $4.99, Version: 1.0 (iTunes) Description: Dungeon Rushers is a 2D tactical RPG combining dungeon crawler’s gameplay and turn based fights. Manage your team, loot dusty... | Read more »
Blasty Bubs is a colorful Pinball and Br...
QuickByte Games has another arcade treat in the works -- this time it's a mishmash of brick breaking and Pinball mechanics. It's called Blasty Bubs, and it's a top down brickbreaker that has you slinging balls around a board. [Read more] | Read more »
Corsola and Heracross are the new region...
Generation 2 finally launched in Pokémon GO, unleashing a brand new batch of Pokémon into the wild. Even before the update went live people were speculating on how to catch elusive Pokémon like the legendary "dogs", Unknown, and whether or not... | Read more »
The Warlock of Firetop Mountain (Games)
The Warlock of Firetop Mountain 1.0 Device: iOS Universal Category: Games Price: $4.99, Version: 1.0 (iTunes) Description: An epic adventure through a mysterious mountain filled with monsters, magic and mayhem! “ looks downright... | Read more »
Fantasy MMORPG MU Origin’s receives a hu...
Developer Webzen are looking to take their highly popular fantasy battler MU Origin to the next level this month, with its most ambitious overhaul yet. The latest update introduces the long sought after Server Arena, new treasure dungeons, and much... | Read more »

Price Scanner via

Apple restocks refurbished 11-inch MacBook Ai...
Apple has Certified Refurbished 11″ MacBook Airs (the latest models recently discontinued by Apple), available for up to $170 off original MSRP. An Apple one-year warranty is included with each... Read more
Apple Park Opens to Employees in April With T...
Apple has announced that Apple Park, the company’s new 175-acre campus, will be ready for employees to begin occupying in April. The process of moving more than 12,000 people will take over six... Read more
Manhattan Neighbors for Safer Telecommunicati...
A new education and advocacy group focused on cell phone and wireless risks, Manhattan Neighbors for Safer Telecommunications, launched today at Manhattan... Read more
Portable Dual DisplayPort Monitor Dock Enable...
IOGEAR has announced the launch of its USB-C Dual DisplayPort Monitor Portable Dock (GUC3CMST). The dock enables users to easily connect two DisplayPort monitors to a USB-C or Thunderbolt 3 laptop to... Read more
13-inch 2.7GHz Retina MacBook Pro on sale for... has restocked the 13″ 2.7GHz/128GB Retina MacBook Pro (MF839LL/A) for $200 off MSRP including free shipping: - 13″ 2.7GHz/128GB Retina MacBook Pro: $1099 $200 off MSRP This model tends to... Read more
Apple’s New iPad Ads Don’t Address Pro Users’...
Apple launched a new tranche of iPad Pro TV ads last week addressing actual queries and challenges from the Twitterverse, albeit using actors for the visuals. That’s great. As an iPad fan and heavy... Read more
Free Verbum Catholic Bible Study App For iOS
The Verbum mobile app runs on Logos’ powerful Bible software and is an advanced resource for mobile Catholic study. The Verbum app surrounds the Bible with the Tradition. Verbum comes with 15 free... Read more
27-inch Apple iMacs on sale for up to $200 of...
B&H Photo has 27″ Apple iMacs on sale for up to $200 off MSRP, each including free shipping plus NY sales tax only: - 27″ 3.3GHz iMac 5K: $2099.99 $200 off MSRP - 27″ 3.2GHz/1TB Fusion iMac 5K: $... Read more
15-inch 2.2GHz Retina MacBook Pro on sale for...
Amazon has 2015 15″ 2.2GHz Retina MacBook Pros (MJLQ2LL/A) available for $1849.99 including free shipping. Apple charges $1999 for this model, so Amazon’s price is represents a $150 savings. Read more
Apple refurbished iPad Air 2s available start...
Apple has Certified Refurbished iPad Air 2 WiFis available for starting at $319 including free shipping. A standard Apple one-year warranty is included: - 16GB iPad Air 2 WiFi: $319 $60 off original... Read more

Jobs Board

Manager *Apple* Systems Administration - Pu...
Req ID 3315BR Position Title Manager, Apple Systems Administration Job Description The Manager of Apple Systems Administration oversees the administration and Read more
*Apple* Retail - Multiple Positions - Apple,...
Job Description: Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, Read more
Manager *Apple* Systems Administration - Pu...
Req ID 3315BR Position Title Manager, Apple Systems Administration Job Description The Manager of Apple Systems Administration oversees the administration and Read more
*Apple* Retail - Multiple Positions - Apple,...
Job Description: Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, Read more
Manager *Apple* Systems Administration - Pu...
Req ID 3315BR Position Title Manager, Apple Systems Administration Job Description The Manager of Apple Systems Administration oversees the administration and Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.