If you’ve been in the technology field for any length of time, you witnessed some variation of this logic:

1. The company has a budget X for a certain project/product.
2. We need as many people as we can get for that budget.
3. Let’s avoid top talent and instead target the market average (or below) to get as many people as possible.
4. Let’s apply the latest hot methodology to produce a great product (a topic for another day).

In other words, I’m going to create a team of C players but expect A results.  C + C = A.

The major breakdown here is, of course, #2: the assumption that quantity begets productivity.  While that is true in some cases (you can’t build a massive, multi-million-lines-of-code enterprise system in a reasonable timeframe with 2-3 sharp developers), it is not true when you measure across quality levels.  Ten C-players will probably not out-produce 5 A-players.  In fact, they might not even outproduce 1 A-player.  If the problem is complex, the C-players may never deliver an acceptable solution.

I’ve seen many variations of these cases play out in the real world.  I’ve seen a large development team shed 1/3 of it’s (bottom ranking) staff and improve productivity by 50% or more.  I’ve seen a small group of A-players produce an order of magnitude (yes, 10X) more features in a given time period than a larger group of C-players.  But most of all, I’ve seen teams of C players produce lots and lots of C results, followed by inevitable surprise and confusion at the management level.

So if it’s clear that, in many or most cases, net productivity improves when you go up-talent, why don’t companies do so?  In my experience, the number one reason is concerns about cost (actual or perceived).  Paying 20-40% more for an A player (vs. a C player) seems prohibitive on a person-by-person basis, but once you look at the ratio of productivity to cost at the team level, it quickly becomes apparent that going up-talent is probably a net cost savings.  If I had a budget of X, I’d much rather hire 6 A players than 10 C players, knowing full well that I’ll get a 2-3X productivity boost even with fewer bodies.

But management (especially CFOs and financial types) generally can’t get past the cost of the individual resources.  Large companies are often driven by the CFOs, who are by and large focussed on raising the top line and reducing the bottom line on a quarterly or annual basis; in their quest to squeeze out all costs, they get a little gassy when they see high-dollar individuals on the payroll.  In short they see top-performers as an expense item, and not as an investment in future success.  Great for the short run; not so good if you want to be competitive 3-5 years from now.

A more reasonable excuse is finding that talent- there are not many A players on the market, and the companies that have them keep them.  But it’s not impossible to move up-talent over time.  Companies that are brutally honest in their evaluations and ones that refuse to keep low-talent can move up-talent over time.  I believe it’s possible to bump up a full grade level within a year or two with some firm commitment.  But again, this is tough.  Companies and made of people, and people live by relationships, and relationships make it sometimes hard to do what is best for the team.  Likewise companies (and their management) like to think they’ve done a great job building a great team (like the old adage about 70% of people thinking of themselves as above average)… deep down many of these managers are resistant to going up-talent.

Another reason is “thrashing”, which results when C players produce a faulty, leaky system, and then massive amounts of manpower have to be thrown at the problems to keep them at bay.  In this case you are caught between a rock and hard place- you can’t shed too many bodies since you simply need numbers to spread them out over all the problems.  Once you’re at this point, good luck.  I’m sure you’ll spend many painful sleepless nights wishing you (or your predecessor) had invested in A players and avoided the problems altogether.

I’m running out of time for this entry, but suffice it to say that there are more reasons for the perpetuation of this insanity, and I see no evidence that it will stop (in aggregate).  That said, there are plenty of exceptions to the rule- teams that have invested in A-talent and are reaping the benefit; teams that are working hard to move up-talent; etc.  Kudos to these teams.  And if you’re on the wrong side of the insanity, just know that it’s never too late start moving up-talent.

By the way, there is a variation of this myth known as outsourcing, but we’ll hit that another day.

William asked me to lunch to catch up and to discuss some challenges he was having in a new position; not surprisingly, his style was creating some friction.  He was perplexed because, for the most part, he was “in the right”.  The new organization needed some serious discipline and procedural house cleaning, and William was doing everything in his power to make the changes as quickly as possible.

William was caught in the classic trap- he was “right”, but he wasn’t being “effective.”  I see this all the time, and I’m guilty more often than I’d like to admit.  When you know you’re right, it is very seductive to take what appears to be the shortest route, which is ofter to simply announce that “this is the way it will be, because I’m right” (or some variation).

But the truth is that being right is not enough if you actually want to make a difference.  Sun Tzu said it well: “In war, then, let your great object be victory, not lengthy campaigns.”  You can be “right” over and over and never get out of the campaign.  Being effective requires you to expand your definition of “victory.”  Your “great object” (i.e. goal) is to bring about some change, not to achieve a state of moral righteousness.

So how do you go from being “right” to being “effective”.  That’s more art than science, but here’s a few guidelines I try to keep in mind:

-  When possible, take some time socializing the idea.  Change is scary to many people, so allow for some time.  Once a critical mass of the group believes its a good idea, then it’s a done deal.

-  Get buy-in from the leadership (peers or superiors).

-  Create a sense of ownership; make it everyone’s idea, not just yours.

-  Listen.  Let people voice their objections or concerns.  Address them with respect.  Use them to beter the idea.

-  Let others fight the battle.  If you can convince a few “thought leaders” of your idea, let them run with it.  Don’t hesitate to give them credit (or even let them take credit).

-  Stay focussed on the real victory conditions.  It’s easy to get bogged down in tactical conflicts, but if you stay focussed on the end-game, you’ll be in a great position to compromise or even back down in areas that are not critical to getting the idea done.  ”Lose the battle but win the war” is a great tool to have in the toolbox.

-  Be willing to compromise and be patient.  If you can get 50% of your idea implemented without much fuss today vs. 100% with major push-back, I’d take the 50% and then go after the remainder in the next round.

-  Use Guerilla tactics (carefully).  It’s sometimes helpful to throw an idea on the table that is so unpleasant that your original idea looks positively great by comparison.  This works best if someone else floats the idea.

-  Last, but perhaps most important, lead by example.  If you can show personally or within your organization that your idea not only works but gives you and your team a competitive advantage, others will be highly motivated to get on board.

Here’s an example.  I’m finishing on an app for a nationwide company that decided a couple of weeks before the portal was to go live that it needed to support co-branding for all of their clients- basically, display a custom logo depending on who was logged in.  The right answer should have been “No!” since we were short on time and had limited resources available, but I had a hunch that Grails would make it easy enough to take on despite the risk.  So I branched the code (just in case), started a timer (literally) and dove into it.  I developed a “Brand” table that would store name, styles, and logos.  I developed full featured CRUD pages for admins to add, change, and delete brands.  I added the Brand section to the Admin section of the portal.  I modified the portal pages to show the brand logos when available.  And I developed a servlet (“controller” in Grails) to serve up images out of the database.  Grand total:  35 minutes and maybe 50 lines of handwritten code.  (To be fair, I should also add another 30-60 minutes for automated test development and testing.)  My guess is that this would have been a couple of days in any other framework.

If you’re a Java web developer do yourself a favor and have a look.  I think you won’t be disappointed.

You can read more about the app in the product section. Here are some additional screenshots:

1. I chose to develop a generalized XML processing engine that would allow the creation and deployment of new conversion sets on the fly.
2. we developed a proxy server to feed currency updates
3. I developed a full calculator stack that runs inline with the converter
4. I created a flexible “favorites” or bookmarking mechanism
5. we “invented” the Zone Scheduler, which helps schedule meeting across time zones

Attached are some screenshots. Should be in the iTunes store shortly.

Conversion View

Calculator View

Currency View

Zone Scheduler View

This is version 1- version 2 will have a host of new features and user friendly options.

Here are some screen shots (more to follow):

Search Page

I looked for an ORM solution and found EntropyDB and SQLitePersistentObjects… the former requires a license for use in commercial applications, and the latter was quite immature when I first looked at it (though it appears to have move forward significantly and is worth another look). While it would be challenging and fun to develop a “Hibernate for iPhone”, I simply didn’t have the time, but I figured I could leverage the “80/20″ rule and get most of the benefit with minimal effort. So I created a couple of base classes that, with minimal custom configuration, make any Objective C object into a “pseudo-DBO”. Here’s the source- use it as you see fit. (Note: This is an early version and has not been exhaustively tested, so keep that in mind. And yes, I know there is a great deal that could be done with Protocols and other Objective C capabilities that would significantly improve this concept… this is something that’s grown organically and I hope to someday get around to cleaning it up.)

Basically- extend DatabaseObject in any object you want to have persisted, implement the “abstract” methods, and start using it. Pretty straight forward.

Here’s an example of usage:
——
Workout* workout = [[Workout alloc] init];
workout.name = @”Workout 1″;
workout.notes = @”some desc”;
workout.startTime = [NSDate date];
[workout persist];
[[DBWrapper getInstance] databaseDump];

Workout* w2 = [Workout findById:workout.localId];
NSInteger res = [Workout countAll];
NSArray* res2 = [Workout findWhere:@"name = \"Medium workout\""];
—-

DatabaseObject.h
——————–

#import
#import

@interface DatabaseObject : NSObject {
NSInteger localId;
NSDate* createdDate;
NSDate* modifiedDate;
BOOL isDirty;
}

// abstract methods
+ (NSString*) generateCreateSql;
+ (NSString*) getTableName;
- (NSString*) generateInsertSql;
- (NSString*) generateUpdateSql;
- (NSString*) generateDeleteSql;
+ (id) constructDboFromResults:(sqlite3_stmt*)stmt;
+ (void) test;

// props
@property (readwrite) NSInteger localId;
@property (readwrite) BOOL isDirty;
@property (readwrite, retain) NSDate* createdDate;
@property (readwrite, retain) NSDate* modifiedDate;

// methods
+ (void) createTable:(BOOL)dropFirst;
- (void) persist;
- (void) unpersist;
+ (id) findById:(NSInteger)id;
+ (NSArray*) findAll;
+ (NSArray*) findWhere:(NSString*)where;
+ (NSInteger) countAll;
+ (NSInteger) countWhere:(NSString*)where;

@end

—————-

DatabaseObject.m
—————-
#import “DatabaseObject.h”
#import “DBWrapper.h”

@interface DatabaseObject()
+ (int) executeSql:(NSString*)sql;
+ (void) executeQuery:(sqlite3_stmt*)stmt sql:(NSString*)sql;
@end

@implementation DatabaseObject
@synthesize localId, isDirty, createdDate, modifiedDate;

- (id) init
{
[super init];
self.localId = -1;
self.createdDate = nil;
self.modifiedDate = nil;
return self;
}

- (void) dealloc
{
self.localId = -1;
self.createdDate = nil;
self.modifiedDate = nil;
[super dealloc];
}

+ (void) createTable:(BOOL)dropFirst
{
NSLog(@”DatabaseObject::createTable %@”, [self getTableName]);
NSMutableString* sql = nil;
if (dropFirst) {
NSLog(@”dropping table”);
sql = [[NSMutableString alloc] init];
[sql appendString:@"DROP TABLE \""];
[sql appendString:[self getTableName]];
[sql appendString:@"\""];
@try{
[DatabaseObject executeSql:sql];
}
@catch (NSException* e) {
NSLog(@”Exception caught dropping table: %@”, e);
}
}

sql = [self generateCreateSql];
[DatabaseObject executeSql:sql];

}

- (void) persist
{
NSLog(@”DatabaseObject::persist”);
if (self.localId < 0) {
NSLog(@”insert”);
self.createdDate = [NSDate date];
self.modifiedDate = [NSDate date];

NSString *sql = [self generateInsertSql];
self.localId = [DatabaseObject executeSql:sql];
} else {
NSLog(@”update”);
self.modifiedDate = [NSDate date];

NSString *sql = [self generateUpdateSql];
[DatabaseObject executeSql:sql];
}
}

- (void) unpersist
{
NSLog(@”DatabaseObject::unpersist”);
NSString* sql = [self generateDeleteSql];
[DatabaseObject executeSql:sql];

}

+ (id) findById:(NSInteger)id
{
NSLog(@”DatabaseObject::findById %d”, id);
NSString* sql = [[NSString alloc] initWithFormat:@”SELECT * FROM %@ WHERE id=%i”, [self getTableName], id];
sqlite3_stmt* stmt = nil;
if(sqlite3_prepare_v2([[DBWrapper getInstance] database], [sql UTF8String], -1, &stmt, NULL) != SQLITE_OK) {
[NSException raise:@"DatabaseException" format:@"Error while creating statement. '%s'", sqlite3_errmsg([[DBWrapper getInstance] database])];
}
if (sqlite3_step(stmt) == SQLITE_ROW) {
return [self constructDboFromResults:stmt];
}
else
{
return nil;
}
}

+ (NSArray*) findAll
{
NSLog(@”DatabaseObject::findAll”);
NSString* sql = [[NSString alloc] initWithFormat:@”SELECT * FROM %@”, [self getTableName]];
sqlite3_stmt* stmt = nil;
if(sqlite3_prepare_v2([[DBWrapper getInstance] database], [sql UTF8String], -1, &stmt, NULL) != SQLITE_OK) {
[NSException raise:@"DatabaseException" format:@"Error while creating statement. '%s'", sqlite3_errmsg([[DBWrapper getInstance] database])];
}
NSMutableArray* res = [[NSMutableArray alloc] init];
while (sqlite3_step(stmt) == SQLITE_ROW) {
[res addObject:[self constructDboFromResults:stmt]];
}
return res;
}

+ (NSArray*) findWhere:(NSString*)where
{
NSLog(@”DatabaseObject::findWhere %@”, where);
NSString* sql = [[NSString alloc] initWithFormat:@”SELECT * FROM %@ WHERE %@”, [self getTableName], where];
sqlite3_stmt* stmt = nil;
if(sqlite3_prepare_v2([[DBWrapper getInstance] database], [sql UTF8String], -1, &stmt, NULL) != SQLITE_OK) {
[NSException raise:@"DatabaseException" format:@"Error while creating statement. '%s'", sqlite3_errmsg([[DBWrapper getInstance] database])];
}
NSMutableArray* res = [[NSMutableArray alloc] init];
while (sqlite3_step(stmt) == SQLITE_ROW) {
[res addObject:[self constructDboFromResults:stmt]];
}
return res;
}

+ (NSInteger) countAll
{
NSLog(@”DatabaseObject::countAll”);
return [self countWhere:@"1"];
}

+ (NSInteger) countWhere:(NSString*)where
{
NSLog(@”DatabaseObject::countWhere %@”, where);
NSString* sql = [[NSString alloc] initWithFormat:@”SELECT COUNT(*) FROM %@ WHERE %@”,[self getTableName], where];
sqlite3_stmt *stmt;
if (sqlite3_prepare_v2([[DBWrapper getInstance] database], [sql UTF8String], -1, &stmt, NULL) != SQLITE_OK) {
[NSException raise:@"DatabaseException" format:@"Error while creating statement. '%s'", sqlite3_errmsg([[DBWrapper getInstance] database])];
}

if (sqlite3_step(stmt) == SQLITE_ROW) {
NSInteger res = sqlite3_column_int(stmt, 0);
NSLog(@”DatabaseObject::countWhere returning %d”, res);
return res;
}
else
{
NSLog(@”DatabaseObject::countWhere: could not get count err=%s for sql %@”, sqlite3_errmsg([[DBWrapper getInstance] database]), sql);
}
return -1;

}

#pragma mark utils
+ (int) executeSql:(NSString*)sql
{
NSLog(@”DBWrapper::executeSql: executing %@”, sql);
sqlite3_stmt* stmt = nil;
if(sqlite3_prepare_v2([[DBWrapper getInstance] database], [sql UTF8String], -1, &stmt, NULL) != SQLITE_OK) {
[NSException raise:@"DatabaseException" format:@"Error while creating statement. '%s'", sqlite3_errmsg([[DBWrapper getInstance] database])];
}

if (SQLITE_DONE != sqlite3_step(stmt)) {
NSLog(@”DBWrapper::executeSql: sql failed; %s”, sqlite3_errmsg([[DBWrapper getInstance] database]));

//Reset the add statement.
sqlite3_reset(stmt);

[NSException raise:@"DatabaseException" format:@"Error while executing sql statement. '%s'", sqlite3_errmsg([[DBWrapper getInstance] database])];
}
else
{
NSLog(@”DBWrapper::executeSql: success”);

//Reset the add statement.
sqlite3_reset(stmt);

return sqlite3_last_insert_rowid([[DBWrapper getInstance] database]);
}
return -1;
}

+ (void) executeQuery:(sqlite3_stmt*)stmt sql:(NSString*)sql
{
NSLog(@”DBWrapper::executeQuery: executing %@”, sql);
if(sqlite3_prepare_v2([[DBWrapper getInstance] database], [sql UTF8String], -1, &stmt, NULL) != SQLITE_OK) {
[NSException raise:@"DatabaseException" format:@"Error while creating statement. '%s'", sqlite3_errmsg([[DBWrapper getInstance] database])];
}

}

@end
————–

DBWrapper.h
————–
#import
#import

@interface DBWrapper : NSObject {
sqlite3* database;
}

+(DBWrapper*) getInstance;

- (BOOL) openDatabase;
- (void) closeDatabase;
- (void) databaseDump;
- (NSString*) nsStringFromResult:(sqlite3_stmt*)res column:(unsigned)col;

- (void) setDatabase:(sqlite3*)db;
- (sqlite3*) database;

@end
——————

DBWrapper.m
——————
#import “DBWrapper.h”

@interface DBWrapper()
- (NSString *) getDBPath;
- (void) createDatabaseIfNeeded;
@end

@implementation DBWrapper

- (void) setDatabase:(sqlite3*)db {
database = db;
}

- (sqlite3*) database {
return database;
}

static DBWrapper *INSTANCE = nil;

+ (DBWrapper *)getInstance
{
// @synchronized(self)
// {
if (!INSTANCE) {
INSTANCE = [[[DBWrapper alloc] init] retain];
}
return INSTANCE;
// }
// return nil;
}

- (BOOL) openDatabase {
NSLog(@”opening database”);
[self createDatabaseIfNeeded];
if (sqlite3_open([[self getDBPath] UTF8String], &database) == SQLITE_OK) {
NSLog(@”database open”);
sqlite3_extended_result_codes(database, 1);
return YES;
}
else {
sqlite3_close(database); //Even though the open call failed, close the database connection to release all the memory.
return NO;
}
}

- (void) closeDatabase {
NSLog(@”closing database”);
if(database) {
sqlite3_close(database);
}
}

#pragma mark utils

- (NSString *) getDBPath {

//Search for standard documents using NSSearchPathForDirectoriesInDomains
//First Param = Searching the documents directory
//Second Param = Searching the Users directory and not the System
//Expand any tildes and identify home directories.
NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory , NSUserDomainMask, YES);
NSString *documentsDir = [paths objectAtIndex:0];
return [documentsDir stringByAppendingPathComponent:@"com.lumenova.workouttracker.sqlite"];
}

- (void) createDatabaseIfNeeded {

//Using NSFileManager we can perform many file system operations.
NSFileManager *fileManager = [NSFileManager defaultManager];
NSError *error;
NSString *dbPath = [self getDBPath];
BOOL success = [fileManager fileExistsAtPath:dbPath];

if(!success) {
success = [fileManager createFileAtPath:dbPath contents:[NSData data] attributes:nil ];
if (!success)
NSAssert1(0, @”Failed to create writable database file with message ‘%@’.”, [error localizedDescription]);
}
}

- (NSString*) nsStringFromResult:(sqlite3_stmt*)res column:(unsigned)col {
char* string = (char *)sqlite3_column_text(res, col);
if (string == NULL) {
return nil;
} else {
return [NSString stringWithUTF8String:string];
}
}

- (void) databaseDump {
NSLog(@”databaseDump”);
sqlite3_stmt* stmt = nil;
NSString* sql = @”SELECT name FROM sqlite_master WHERE type=’table’ ORDER BY name”;
if(sqlite3_prepare_v2(database, [sql UTF8String], -1, &stmt, NULL) != SQLITE_OK) {
NSAssert1(0, @”Error while creating statement. ‘%s’”, sqlite3_errmsg(database));
}

while (sqlite3_step(stmt) == SQLITE_ROW) {
NSString* tableName = [self nsStringFromResult:stmt column:0];
NSLog(@”TABLE: %@”, tableName);

sqlite3_stmt* stmt2 = nil;
NSString* sql2 = [[[NSString alloc] initWithFormat: @”SELECT * FROM %@”, tableName] autorelease];
if(sqlite3_prepare_v2(database, [sql2 UTF8String], -1, &stmt2, NULL) != SQLITE_OK) {
NSAssert1(0, @”Error while creating statement. ‘%s’”, sqlite3_errmsg(database));
}
int cols = sqlite3_column_count(stmt2);
for (int i = 0; i < cols; i++) {
// can get names here with sqlite3_column_name
}

while (sqlite3_step(stmt2) == SQLITE_ROW) {
NSMutableString* sb = [[[NSMutableString alloc] init] autorelease];
[sb appendString:@" row:"];
for (int i = 0; i < cols; i++) {
NSString* ret = [self nsStringFromResult:stmt2 column:i];
if (ret == nil) {
[sb appendString:@"NULL"];
} else {
[sb appendString: ret];
}
if (i < (cols – 1)) {
[sb appendString:@", "];
}
}
NSLog(sb);
}

}

}

@end
—————

Example of a class the extends the DBO:
—————
#import “StrengthSet.h”
#import “DBWrapper.h”

@implementation StrengthSet
@synthesize exerciseId, reps, weight, notes, hint;

- (id) init
{
[super init];
self.reps = 0;
self.weight = 0.0;
self.notes = nil;
self.exerciseId = -1;
self.hint = MAINTAIN;
return self;
}

- (void) dealloc
{
self.notes = nil;
[super dealloc];
}

#pragma mark DBO methods
+(NSString*) getTableName {
return @”strength_set”;
}

+ (NSString*) generateCreateSql
{
NSMutableString* sql = [[NSMutableString alloc] initWithFormat:@”CREATE TABLE \”%@\” (“, [StrengthSet getTableName]];
// DBO
[sql appendString:@"\"id\" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, \"created_date\" INTEGER NOT NULL, \"modified_date\" INTEGER NOT NULL"];
[sql appendString:@", "];
// Exercise
[sql appendString:@"\"exercise_id\" INTEGER NOT NULL, \"reps\" INTEGER NOT NULL, \"weight\" REAL NOT NULL, \"hint\" INTEGER NOT NULL, \"notes\" TEXT"];
[sql appendString:@")"];
return sql;
}

- (NSString*) generateInsertSql
{
NSInteger now = [[NSDate date] timeIntervalSince1970];
NSString* sql = [[[NSString alloc] initWithFormat:@”INSERT INTO %@ (created_date, modified_date, exercise_id, reps, weight, hint, notes) VALUES (%i, %i, %i, %i, %f, %i, \”%@\”)”,
[StrengthSet getTableName],
now,
now,
self.exerciseId,
self.reps,
self.weight,
self.hint,
self.notes ] autorelease];
return sql;
}

- (NSString*) generateUpdateSql
{
NSInteger now = [[NSDate date] timeIntervalSince1970];
NSMutableString* sql = [[NSMutableString alloc] initWithFormat:@”UPDATE %@ SET modified_date=%d, exercise_id=%d, reps=%d, weight=%f, hint=%d, notes=\’%@\’”,
[StrengthSet getTableName],
now,
self.exerciseId,
self.reps,
self.weight,
self.hint,
self.notes];
[sql appendFormat:@" WHERE id=%d", self.localId];

return sql;

}

- (NSString*) generateDeleteSql
{
return [[NSString alloc] initWithFormat:@”DELETE FROM %@ WHERE id=%i”, [StrengthSet getTableName], self.localId];
}

+ (id) constructDboFromResults:(sqlite3_stmt*)stmt
{
NSLog(@”StrengthExercise::constructDboFromResults”);

StrengthSet* result = [[[StrengthSet alloc] init] autorelease];
result.localId = sqlite3_column_int(stmt, 0);
result.createdDate = [NSDate dateWithTimeIntervalSince1970:sqlite3_column_int(stmt, 1)];
result.modifiedDate = [NSDate dateWithTimeIntervalSince1970:sqlite3_column_int(stmt, 2)];
result.exerciseId = sqlite3_column_int(stmt, 3);
result.reps = sqlite3_column_int(stmt, 4);
result.weight = sqlite3_column_double(stmt, 5);
result.hint = sqlite3_column_int(stmt, 6);
result.notes = [[DBWrapper getInstance] nsStringFromResult:stmt column:7];

return result;

}

@end
—————–