My current app setup is this, I have 2 Xcode projects for each app. One project is the actual app, ScoutTrail. The other is a project, ScoutTrailData, I use for generating a SQLite database that is used to preload ScoutTrail Core Data store with all rank and merit badge requirements data.

The better design would be to include the ScoutTrailData project inside the ScoutTrail project. In addition to consolidating both projects into a single git repository, it will allow me to consolidate the Core Data model files.

But just copying ScoutTrailData as a subdirectory to ScoutTrail is not ideal. Why? I would lose the git history of ScoutTrailData. I am not a git expert. In fact, I am a novice. I can handle your basic init, add, commit, checkout, diff, pull and push. I’ve even been known to create a branch and try my hand with merge. But combining two local repos into one while maintaining history was beyond my skillset. So, I did what any self-respecting indie developer would do. I typed in “move git repo inside another one” and let the power of internet search supply me with knowledge. 2nd on the search results was a post on Greg Bayer’s (of Pulse) blog.

Create remote repos on GitHub

Create remote repos on GitHub for ScoutTrail and ScoutTrailData. Once I have everything moved and working correctly inside of ScoutTrail, I’ll go back and remove ScoutTrailData. After creating private repos, GitHub provides the commands for pushing an established local repo to a remote repo.

1
2
3

cd ScoutTrailData
git remote add origin <git repo ScoutTrailData url>
git push -u origin master

Prepare ScoutTrailData repo for the move

1
2
3
4
5
6
7
8
9
10
11
12

mkdir mergeDir
cd mergeDir
git clone <git repo ScoutTrailData url>
cd ScoutTrailData
# create subdir
mkdir ScoutTrailData
# mv * into it, needed to create ScoutTrailData subdirectory in ScoutTrail repo
mv * ScoutTrailData
git add .
# cleanup deletions caused by mv
for i in `git st | grep deleted | awk '{print $3}'`; do echo $i; git rm $i; done
git commit

Merge ScoutTrailData into ScoutTrail repo

1
2
3
4
5
6
7

cd mergeDir
git clone <git repo ScoutTrail url>
cd ScoutTrail
git remote scoutTrailData-branch ../ScoutTrailData
git pull scoutTrailData-branch master
git remote rm scoutTrailData-branch
git push

Now, ScoutTrailData is a subdirectory of ScoutTrail and both git histories have been saved.

Most developer types are introverts. We are at home sitting in front of our computers coding. However, it is hard to make a living while secluded in our own little world. To learn, we need to hear about other’s ideas and experiences. In order to get client work, you need to make contacts and build a reputation.

There are no secret formulas for this, just Get Out. Leave the confines of your home.

Here is a rundown of my getting out in the past 2 years for iOS devstuff:

• Attended MoDevDC in October 2010. Met Ken Yarmosh during his App Savvy book release.
• Attended 360iDev 2010 in Austin, TX. Met many, here are a few: Kirby Turner, Julio Barros, Saul Mora, Tom Ortega, Manton Reese, Charles Perry, Tom Frauenhofer, John Wilker, Doug Sjoquist, Brandon Alexander and many others.
• I occasionally attend NSCoderNightDC, where I met Luis de la Rosa and Jose Vazquez.
• Attended WWDC11. Luis introduced me to Bill Dudney, whose book iPhone SDK Development was my introduction to iOS development. Ken introduced me to David Smith, another iOS developer here in northern Virginia. And many more…
• David opened up his office on Tuesdays for local devs to co-work. There, I met Rob Rhyne, cofounder of Martian Craft.
• Attended 360iDev 2011 again. Met more folks.

So, big deal. I went to meetups and conferences and met more devs. True, but my iOS dev knowledge has grown. Plus, these folks have been a huge resource for my knowledgebase. And one added bonus, work. I worked 6 months on a client job with Luis. The introduction to Rob and a recommendation from Luis led to my current work with Martian Craft.

I feel very fortunate to have given these opportunities and none of it would have happened if I didn’t get out of the house and my comfort zone.

I am striving for simplicity. I’m trying to clean up my office of clutter. I like clean simple UIs. I liked my website when I initially set it up, but now I don’t. The black background no longer appeals to me and even writing blogs using WordPress’s tools is no longer fun. After reading a post on a friend’s site, I looked further at his site and just plain liked the simple, but clean look and feel of it. I saw the Octopress tag at the bottom of the page and looked further. After talking with Dave, I was convinced this was the system I wanted to use for blogging.

I have been following the steps from Octopress website for basic site setup. Octopress requires that posts be written in Markdown, but Wordpress posts are html (although technically php generated html from mysql database contents. Thankfully, Thomas Frossman created exitwp, which I used to convert my WP pages and posts for Octopress. I’ve had to edit these Markdown files to fix image links, code snippets, etc. But exitwp did a good job of converting my past posts to Markdown.

Looking forward to further exploration of Octopress, but mainly just looking for the simplicity it provides. The other features are just a bonus.

However, be more proactive is not a SMART goal. It is generic and immeasurable. To make it SMART, I need to break it down into a list of specific objectives that can improve my reactive skills. So here is my list:

1. Re-read David Allen’s book Getting Things Done: The Art of Stress-Free Productivity by the end of next week (1/13/2012). I read his book years ago and even attended his 1-day seminar, but I failed to apply what I learned. I consider myself my own worse critic, and with that revelation, my planning skills stink. And one of the first steps to planning is know what to plan, and the key factor to GTD his gathering and trapping that which needs to be planned.

1. Implement my GTD system by the end of this month (1/31/2012). An iPhone-based system is a must. One that I can also use on my computer is ideal. So, native-iOS required, with computer or web-based backup or synching system being ideal. I don’t expect the system to be working at 100% efficiency by the end of the month, but I do want the tools to be in place and working.

2. Read 2 communication-related books by 5/31/2012 and write a review for each. One book should cover verbal interpersonal communication skills. The bigger goal here is to improve how I communicate with my family and close friends. I am an independent loner by nature, which suits me just fine but not the rest of my house. The second should cover what I would consider professional communication, most likely presentation skills. I like attending technical conferences to improve my development skills, but I’ve been developing an itch to start presenting. Having the technical knowledge and presenting it are two different skills, and both are required for great tech talks.

So there are my 3 SMART goals to make me a more proactive person this year.

• Specific - Set specific goals, not vague ones. Answering one or more of the W’s can help.
  • Who is involved?
  • What do I want to accomplish?
  • Where will I do this?
  • When will I do it?
  • Why do I want to complete this goal?

Vague - “I want to lose weight.” Specific - “I will go to the gym three times per week so that I will lose 10lbs in 6 months.”

• Measureable - If you cannot measure it, how do you know when you are done? Ask these questions:
  • How much?
  • How many?
  • What does done look like?

“Begin with the end in mind,” is the 2nd Habit in Steven Covey’s “The 7 Habits of Highly Effective People”

• Attainable - Your goal should stretch you, but not break you. When the goal is important to you, you will figure out ways to make them come true. You will develop the attitudes, abilities, skills and capacity to reach them.

  • How can I accomplish this?

• Relevant - The goal-setter must be willing and able to work towards completion.

  • Is it worthwhile?

• Timely - Set a due date. Commit to complete the goal on or before the due date.

  • When?
  • What can I do in 6 months? In 6 weeks? In 6 hours?

This should define a little better what a SMART goal is and how to set them. Hopefully, by being SMART, or should I say, using SMART…resolutions will become goals which become accomplishments.

1. A resolution is a commitment that a person makes to one or more lasting personal goals, projects, or the reforming of a habit.

2. A plan is a list of steps with timing and resources, used to achieve an objective. A commitment to a goal is great, but without a plan to detail how the goal will be achieved, success is unlikely.

So first, here is my list of goals for the year. Later posts will turn them into plans.

• Be More Proactive & Less Reactive
• Get in Shape
• Increase Productivity
• Fix my Finances

Something I have learned is that to achieve a goal, it must be SMART.

• Specific
• Measurable
• Attainable
• Relevant
• Time-bound

My goals are not SMART, yet. I’ll expand and refine them this week.

Please donate at PayPal by clicking  Or, you can send a check made out to: Help End Local Poverty, PO Box 26716, Raleigh, NC 27611 - in the memo please put “McAlister - Haiti November Trip”.

Please watch these videos from Help End Local Poverty to see why we are going and who we are helping.

Help End Local Poverty Haiti Trips, 2010 from Help End Local Poverty on Vimeo.

Restore Haiti from Help End Local Poverty on Vimeo.

Haiti: We Have Not Forgotten 2.0 from Help End Local Poverty on Vimeo.

This November, I will be on a team heading to Haiti. We’re partnering with Help End Local Poverty and local Haitian leaders to love and serve the people of Haiti.

As most of you know, Haiti suffered a severe earthquake in January of 2010. Haiti is considered a 4th world country, or what’s called a least developed country. Extreme poverty has created a massive orphan crisis. The sex-trafficking industry is exploding, hunger and disease runs rampant and many people are suffering! However, there is hope and God is moving in Haiti through local Haitian churches and leaders. We want to come along side of these brave men and women and help serve Haiti together. We want to co-partner in the work God is already doing!

Part of Help End Local Poverty’s mission is to build 100 homes and drill 25 water wells. On this trip, we will actually help fulfill part of this vision. Every team member has to raise an additional $500 that goes towards a key project, which will help our Haitian friends long-term. It will also help create jobs for our Haitian friends. So by going to Haiti, we will help a family move into a new home or help a community receive clean water, and we will also create jobs in the process. Our ultimate goal is to help restore Haiti while Haitians lead the way!

On this trip, we will be provide health care to Haitians (by running medical clinics), lead a kids camp for 35 orphans and work in a tent city with vulnerable kids!

Here’s where we need your help:

• We need you to pray for us.
• We need your help financially. The trip cost is $2100, which includes $500 for the project.

Would you be willing to support me financially? If so, you can donate at PayPal by clicking . You will get an automatic receipt emailed to you as soon as you donate.

Or, you can send a check made out to: Or, you can send a check made out to: Help End Local Poverty, PO Box 26716, Raleigh, NC 27611 - in the memo please put “McAlister - Haiti November Trip”. Help End Local Poverty will send you a receipt for your end of the year taxes, via mail.

To learn more about H.E.L.P. please visit their site: www.helpendlocalpoverty.com

If you have any questions, please let me know.

Thank you,

Scott

Look for a website redesign in the future and more posts, both technical and well, non-technical.

- nock an arrow

1. A check all requirements feature - a useful quick-entry for the scout that has already completed all the requirements.

2. New Geocaching patch design The not visible feature was a minor change to the underlying database. The problem with changing the data model of your database is that previous versions are not compatible with the new version.

However, the iOS SDK provides the tools to migrate previous data to the new model. As long as the migration works, this change remains invisible (other than a slightly longer startup delay while migration occurs). If it doesn’t work, then the app crashes. That was the cause for the delay in being released last week. Apple saw this happen in their testing. I was able to repeat it with the build I uploaded to Apple for approval. So, I did a clean rebuild of the app, and it worked fine. So, I concluded that my build was bad for some reason, such as I got in a rush as a I got closer to release and missed a step in my build process, etc.

Apple approved and released the app yesterday, so I assumed their testing concluded the same. However, a user contacted me last night and described the problem above. It felt like a gut punch. Here I am trying to develop a useful app and my first “major” update has a bug in it that will cause the user to lose their data. Because the quick solution for a user is to delete ScoutTrail from their device and reinstall.

Here is what I will do for those of you affected by this, you will get a free promo code for ScoutTrail Pro (when it is released) or CubPath when it is released. All I need from you is that you email me your crash log. Email it to support@4arrowsmedia.com. To get your crash log, follow these steps:

• Synch your device, and depending on your desktop OS, the log will be located at location listed
• Mac OS X
  • /Users//Library/Logs/CrashReporter/MobileDevice//ScoutTrail*
• Windows XP
  • C:\Documents and Settings\Application Data\Apple computer\Logs\CrashReporter<your iPhone’s name>\ScoutTrail*
• Windows Vista
  • C:\Users\AppData\Roaming\Apple computer\Logs\CrashReporter\MobileDevice<your iPhone’s name>\ScoutTrail* Lastly, my apologies for the bug in ST and the inconvenience it will cause you.

1. Create New Project in Xcode. Mine is called CubPath.

2. Add a New Target… by Right-click or Control-click on the Target item in the Groups & Files pane in Xcode. Since we are creating are own test suite, select Application instead of Unit Test Bundle. Name it using convention ”Tests”, CubPathTests.

3. Download GHUnitIOS from Github.

4. Add GHUnitIOS.framework to your project by dragging the folder from the Finder to the Frameworks item in the Groups & Files pane in Xcode. Select “Copy items into destination group’s folder (if needed) and select your Tests target and deselect the Project target in “Add to Target”.

5. In Finder, go into your projects folder. Duplicate your project’s precompiled header, <Project Name>_Prefix.pch and rename it to <Project Name>Tests_Prefix.pch. For me, it is CubPath_Prefix.pch, which I renamed to CubPathTests_Prefix.pch.

6. Right-click or Control-click Other Sources in Groups & Files pane, and Add Existing Files… <Project Name>Tests_Prefix.pch. Make sure it is only added to Tests target.

7. Edit <Project Name>Tests_Prefix.pch. and add #import <GHUnit/GHUnit.h> to the import statements. Doing this allows you to avoid including that import in every test file.

8. Now we need to configure the Tests Target. Right-click or Control-click in the Groups & Files pane and select Get Info.

   1. On the General tab, add your Project Target (CubPath for me) to the Direct Dependencies section and add CoreGraphics.framework, Foundation.framework and UIKit.framework to the Linked Libraries section.
   2. On the Build tab, add -all_load and -ObjC to Other Linker Flags. (Typing ”other linker” in the Search bar can help find it.)
   3. Also on the Build tab, search for GCC_Prefix. GCC_PRECOMPILE_PREFIX_HEADER should be set to YES and GCC_PREFIX_HEADER should be set to <Project Name>Tests_Prefix.pch. Correct them if they are not.

9. Select <Project Name>Tests-Info.plist and clear the Main nib file base name field. Its default setting is MainWindow.

10. Download and add GHUnitIOSTestMain.m into your project in the Other Sources folder in the Groups & Files pane.

11. I like to keep my unit-test source files separate from my project source files. To do this, in Finder I’ll create a Tests folder inside my project folder. Then, back in Xcode, I’ll Right-click/Control-click in the Groups & Files pane, and Add Existing Files… I’ll select the recently created Tests folder and Add. Uncheck Copy items into destination group’s folder (if needed) and <Project Name> target, and check <Project Name>Tests target.

12. Now we can finally add a unit-test file. Right-click/Control-click the Tests folder in the Groups & Files pane, and Add New File… Select Objective-C class with Subclass of NSObject and click Next. Give it an appropriate file name. Since we want to make sure our setup is good, I named it SetupTests.m. I unchecked Also create “SetupTests.h”, and selected <Project Name>Tests target. Notice how location is set to your project directory/Tests created in step 11 above.

a. Since I didn’t create SetupTests.h, I had to add the interface to SetupTests.m. And I added two unit-test methods: testFirstUT and testSecondUT.

1
2
3
4
5
6
7
8
9
10
11

@interface SetupTests : GHTestCase {}
@end

@implementation SetupTests
- (void) testFirstUT {
       GHAssertEquals(1, 2, @"Should fail");
}
- (void) testSecondUT {
       GHAssertEquals(1, 1, @"Should pass");
}
@end

b. Click Build and Run. This screen should appear in the Simulator unless if you are configured for Device.

c. Tap Run and you should see testFirstUT fail and testSecondUT pass.

Seems like a lot of work for a little output. Hopefully, with time, you will see the benefit unit-testing will have not only with the quality of your code, but the the quality of your software skills. Unit-testing is a part of agile development which is the rage these days and having this in your set of tools will only benefit you as a developer in today’s market.

Why Unit Test?

The goal of unit testing is to prove that your smallest software components, or units, work correctly in isolation. Units are generally the individual functions or methods of a software class. There are several benefits:

• Facilitates Change - The unit test establishes the expected behavior for the unit. If the developer has a future need to modify the unit, the change must still pass the test to prove that the expected result has not changed.

• Simplified Integration - Proving that the units work correctly first eases the integration effort of the units into the completed software app.

• Documentation - Unit testing provides a “living document” of the system. Most coders, especially this one, dislike coding then documenting the code, modifying the code then fixing the documentation to match the modifications, and so on. Unit testing establishes the API and shows the functionality of the unit.

• Design - The unit tests are like a design document in that they specify the classes, methods and behavior. One advantage that test-driven development as design has over diagram-based design, such as UML, is in verifying adherence to design. The unit-tests themselves verify implementation adheres to design.

Since a class may use or reference other classes, testing a single unit can end up testing other units because of this coupling. To reduce or prevent close-coupling during unit-testing, items such as mock objects or method stubs are used. By design, a unit-test should not leave its own class boundary. When it does, determining cause of failure becomes more difficult.

I’ll be starting out CubPath with Saul’s techniques and suggestions, and I’ll keep you posted along the way.

What to do?

I remembered an article in the April 2010 Inc magazine about online services that run contests to assist small-business owners like myself. I went with the recommended service, Hatchwise.com.

After only 7 days of the contest, I narrowed down 185 entries down to 4 and with Susan’s input, we chose one. Here are my top 4 choices with the winner:

The Winner

What I liked about the winner?

The simple and elegant integration of the number 4 with an arrow. Plus the designer posted a second version that looks great on a dark background, and made a color change at my request.

What I liked about Hatchwise?

• Their easy to use interface.
• That I could view the designers’ previous work before I had to commit any money.
• That I could rate the entries as I viewed them.
• That I could communicate with the designers, providing them feedback and making special requests during the contest.
• The high quality of the designers’ work.

What’s next?

I have been working on a website redesign in preparation for the new logo as well as the upcoming App Store approval of ScoutTrail.

First, to disable in Safari, open up the Terminal application (in Applications/Utilities folder) and paste the following:

defaults write com.apple.Safari WebKitShowsURLsInToolTips 0

Press enter, quit and restart Safari. To re-enable tooltips, same command except change the 0 to 1.

Now for Firefox. In the address bar, type about:config. Click the “I’ll be careful” button if it appears. In the filter box, type browser.chrome to find browser.chrome.toolbar_tips which should have a value of true. Just double-click to change to false and close that tab or window so that you don’t accidentally do something “not careful.”

To start with, I had 2 choices (based on what I found on Ray Wenderlich’s site):

1. Fill in Core Data on startup from external source. For this the app can start up, notice that the database hasn’t been imported yet, and start reading in data from an external source (such as an SQLite database or XML file) and then start inserting the data into Core Data.

2. Provide pre-filled in SQLite database. For this we’ll let Core Data create the database structure for us based on the model, and then we populate the database with a utility app. The utility app could be a Mac or iPhone app that uses Core Data to populate the database via Core Data APIs, or some kind of program that fills in the SQLite database directly. Once the database is populated, just include it with the app and make the app use it as the default database if no database already exists.

I chose the latter. Ray’s example uses a Python script to preload a SQLite db and he admits that using the Core Data API interface to do this would be safer in case something in the Core Data to SQLite API changes in the future. But as he says

Note that by using a Python script to import the data rather than working with a utility app that uses Core Data APIs, it’s more likely to break in the future because we’re kind of going under the hood here… but for this tutorial I thought a) it’s a better learning experience since we just covered SQLite and it shows how things are working more clearly, and b) it is simpler!

My solution was to duplicate my current ScoutTrail project and rename it to ScoutTrailData.

• I removed the UI code from ScoutTrailData (since I am only interested in parsing the XML and loading it into the db),

• Create the data model,

  1. Add a New Group, Model, to the project
  2. Right click Model and Add New File. Select iPhone OS->Resource->Data Model (see Core Data Tutorial for iOS for more info on data model creation specifics),

• Add the Core Data calls to load the parsed XML data into SQLite.

1
2
3
4
5
6
7
8
9
10
11
12
13

// To save the data, the basics are to create a NSEntityDescription for your model data:
self.award = (Award*)[NSEntityDescription
          insertNewObjectForEntityForName:@"Award" inManagedObjectContext:self.moc];

// Set the values:
[self.award setName:[attributeDict objectForKey:@"name"]];
[self.award setImageFileName:[attributeDict objectForKey:@"img"]];
      [self.award setEagleRequiredMB:[[NSNumber alloc]
  initWithBool:[[attributeDict objectForKey:@"eagleRequiredMB"] boolValue]]];

// And save it:
NSError *error;
if (![self.moc save:&error;]) NSLOG(@"Error: %@, %@", error, [error userInfo]);

• Copy the created db into my ScoutTrail Resources group and added code to ScoutTrailAppDelegate to load that db.
  • iPhone Simulator creates the SQLite db in the user’s Library folder. Find it and copy to your project’s Resource directory (usually the project’s root level dir).

1

cp "/Users/scott/Library/Application Support/iPhone Simulator/4.0.2/Applications/5E9724E0-37ED-44CF-8954-FBAFD68FE662/Documents/ScoutTrailData.sqlite" /Users/scott/Apps/ScoutTrail

1
2
3

// To load the db into ScoutTrail, change the storeURL code in persistentStoreCoordinator from: 
NSURL *storeURL = [NSURL fileURLWithPath: [[self applicationDocumentsDirectory]
  stringByAppendingPathComponent: @"ScoutTrailData.sqlite"]];

to:

1
2
3
4
5
6
7
8
9
10

NSString *storePath = [[self applicationDocumentsDirectory]
  stringByAppendingPathComponent: @"ScoutTrailData.sqlite"];
NSURL *storeURL = [NSURL fileURLWithPath:storePath];
NSFileManager *fileManager = [NSFileManager defaultManager];
if (![fileManager fileExistsAtPath:storePath]) {
  NSString *defaultStorePath = [[NSBundle mainBundle] pathForResource:@"ScoutTrailData" ofType:@"sqlite"];
  if (defaultStorePath) {
      fileManager copyItemAtPath:defaultStorePath toPath:storePath error:NULL];
  }
}

• and fetch the data with Core Data calls.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

NSEntityDescription *entity = [NSEntityDescription
  entityForName:@"Award" inManagedObjectContext:moc];
NSFetchRequest *request = [[NSFetchRequest alloc] init];
[request setEntity:entity];
  
NSPredicate *pred = [NSPredicate predicateWithFormat:@"type == 'rank'"];
[request setPredicate:pred];
  
NSSortDescriptor *sort = [[NSSortDescriptor alloc]
      initWithKey:@"displayOrder" ascending:YES];
[request setSortDescriptors:[NSArray arrayWithObject:sort]];
  
NSError *error;
self.data = [moc executeFetchRequest:request error:&error;];
if (self.data != nil) {
  int count = [self.data count];
  for (int i=0; i<count; i++) {
      NSLOG(@"rank[%d]: %@", i, [[self.data objectAtIndex:i] name]);
  }
} else {
  NSLOG(@"Error with fetch");
}
[request release];
[sort release];

Not all the aspects of adding Core Data has been covered in this post, such as adding the CoreData framework, the required Core Data methods in your AppDelegate, etc., but hopefully enough has been covered to help you along with using a preloaded db in your app.

Ram’s 10 principles to good design

1. Good design is innovative
2. Good design makes a product useful
3. Good design is aesthetic
4. Good design makes a product understandable
5. Good design is unobtrusive
6. Good design is honest
7. Good design is long-lasting
8. Good design is thorough down to the last detail
9. Good design is environmentally friendly
10. Good design is as little design as possible

Looking for a good book on iPhone app design? Check out Tapworthy: Designing Great iPhone Apps by Josh Clark. It is my current read. In addition to the above items:

• Develop your ideas from initial concept to finished design
• Build an effortless user experience that rewards every tap
• Explore the secrets of designing for touch
• Discover how and why people really use iPhone apps
• Learn to use iPhone controls the Apple way
• Create your own personality-packed visuals

The real highlight of the book are the interviews with app designers like Josh Williams (Gowalla), Joe Hewitt (Facebook), and others.

Instead, I spent most of my time in the “Scoutmaster’s Lounge” with my laptop working on the ScoutTrail app. This turned out to be a good thing. I completed the XML parsing code. This led me to the next problem: displaying all of the rank and merit badge requirements in UITableView. The issue with this is that the requirements are variable length from 10 - 100 words. This will not fit in one of the default UITableViewCells. I would need to customize.

With the help of Google search, I found some help over at Cocoa is My Girlfriend. Matt Long wrote up a post on how to create UITableViewCell’s with Dynamic Height. I still need to customize for my specific needs, but it was a great help for getting me past this latest roadblock.