Goalscape - Friendly Goal Mapping You Love

Knowing what’s important to you is the first step to getting or keeping what you love. Successfully achieving important things requires prioritization, constant attention, and a multitude of baby steps.

How can you see the big picture, the small steps, and what’s most important at any time? You need a map or tool.

I have tried many tools. Yet, I have found none better than Goalscape.

Goalscape lets me:

• Map out and identify the big important things
• See how important each goal is with respect to the other
• Get a clue as to where I am spending my time
• Feed the explorer in me and enjoy the whole process of goal exploration

First impressions are important and Goalscape gave me a wonderful first impression. The application is professional and one can tell that user experience is paramount to its design. In other words, I liked it from the start!

After admiring how nice the user interface looked, I saw a detailed goal / subgoal “Get Started” screen which is designed to help one “Get started with Goalscape.” The amount of detail took me aback for about two seconds.

However, a nice tooltip popped up which shared with me that I could either explore this “Get Started” Goalscape screen or create a new Goalscape. So, I created one.

I created “Financial Security” as my main goal, and a couple sub-goals. Quickly, I  realized that “Financial Security” is not the only important thing in life. So, I created a new Goalscape with “Improve Well-Being” as my topmost goal.  From there I added those 3 subgoals most important to me now; “Health”, “Financial Security”, and a third one.

As opposed to some web-only solutions I have used, working with this application felt wonderful! I can use shortcut keys to my heart’s content such as Undo. As an explorer, one of my favorite features is Undo. So, I can boldly try things out and then Undo as I wish!

For fun, I right clicked and marked the “Financial Security” goal as complete by choosing “Complete progress” from the popup menu. It immediately shades in the subgoal and the parent goal (one higher up) is partially shaded as well to signify part of the goal is complete. This is a very satisfying and fun effect! I liked it so much that I showed my son who played with it too.

At this point, I need food. So, I close up Goalscape, save off the goal I was creating, and checkout how big the file. Size of the file matters for me since I want to save it on the cloud which has limited space. My Goalscape file is only needed 879 bytes. That’s less than 1 KB! No problem there.

After eating, I decided to get serious and fill out my subgoals with subgoals. Once I created goals within goals within goals, I saw the need for using the vertical gray stick at the top. It helps one visually collapse goals or expand them as needed.

While demo-ing the application to a family member, I was able to quickly understand, show, and adjust the “Importance” of a goal. The app has all I need.

Collapsed Goals And Colors

Subgoal Health

I was able to do all of these things without looking at the help documentation. Out of curiosity, I looked it over though. I start casually checking out the Help menu. It has a feature called Infopoints. If you click on one, you get helpful videos and instructions. Nice!

To top it all off, I can see they truly support their customers. They say, “We answer most queries straight away and always respond within 24 hours.” I rarely see such great support in anything I use.

To sum up, Goalscape is both user friendly and yet a power tool when you need it. The company is dedicated to their users. I sense this goal map product is part of a bigger mission of helping people help themselves. In other words, they have only good intentions.

I enjoyed using Goalscape, have made it part of my daily routine, and I invite you to do the same!

Method Callers in Xcode 4.4

I love that I can see the callers of a method in Xcode!

From the Find and Search Additions section of the New Features in Xcode 4.4 documentation, it says:

"...function is accessed from the Show Related Items menu, or by using the Assistant editor and selecting Callers or Callees in the jump bar pop-up menu..."

So how does one easily popup the Show Related Items menu? Press Control-1 aka ^1 and you will see "Callers(x)" where x = the number of methods calling the method.

There is also the comprehensive Xcode Keyboard Shortcuts and Gestures documentation which covers multi-touch gestures and other shortcuts.

Enjoy this feature while you explore your code!

gitflow and the Apple Store

I have started using gitflow with my iOS (iPhone / iPad) development work. If you want to know why one should use gitflow, read Why Aren't You Using git-flow?

A Getting Started - Git Flow tutorial was helpful, especially in the "git flow release" section. One question arises quickly is: When should I do the command git flow release finish?

The answer lies in the following text that comes from the tutorial: "..and your operations team has deployed the Release Candidate to Production..."

In this case, Apple has taken care of releasing the candidate to production through the App Store. Apple is our "operations team." Once the application is available for download from the App Store, you can perform the git flow release finish command. 

The example from the tutorial is: git flow release finish -F -p Version_1.0

To sum up, adding gitflow to your workflow is simple. It makes managing your code fun all the way to the App Store! 

Power With LLDB Objective-C Debugger

I have come to realize there is a huge and powerful tool called the LLDB debugger which is used by Objective-C programmers now instead of gdb. In the past, I have used some of the commands of the gdb debugger, however this map at
http://lldb.llvm.org/lldb-gdb.html shows me a wonderful number of things at my disposal that I never knew existed in gdb.

The current command of interest is the replacement for gdb's info symbol command which shows "information for a raw address in the executable or any shared libraries"

(gdb) info symbol 0xa0b06174

That replacement in lldb is image lookup

(lldb) image lookup --address 0x1ec4

I highly recommend all Objective-C programmers skim http://lldb.llvm.org/lldb-gdb.html aka The LLDB Debugger command map and smile at all that you have available!

Update:

We ended up switching back to gdb. 


We were able to see the offending code once we switched back to gdb from lldb and applied what we could from http://coderslike.us/2009/05/05/finding-freeddeallocated-instances-of-objects/


The solution to the memory issue was:

• create a UIColor
• store that in a variable such as someUIColor
• pull out from someUIColor.CGColor the CGColorRef and pass that on to whatever needs it

It seems that doing something like this is bad in ARC and one should use UIColor (which is an NSObject):

CGColorRef crashingColor = [[UIColor colorWithRed:1 green:1 blue:160.0/255.0 alpha:1] CGColor];

iOS and Threads

While watching the Free Stanford Class Videos About iOS, iPhone, iPad, Objective-C and Xcode, I came across the Blocks and Multithreading lecture.

It does a great job of describing how to avoid locking up the user interface (iPhone or iPad) while the application needs to do something that is time intensive.

In general, one would call the following things in their proper context.

    dispatch_queue_t downloadQueue = dispatch_queue_create("widget download", NULL);
    dispatch_async(downloadQueue, ^{
        
        NSArray *fetchedWidgets = [KTWidgetFetcher widgets];
        NSLog(@"done fetching widgets");

        dispatch_async(dispatch_get_main_queue(), ^{
            
            NSLog(@"UI update is happening");
            self.widgets = fetchedWidgets;
        });
        
    });
    dispatch_release(downloadQueue);

Fun stuff!

Frames vs Bounds in UIView

In the context of UIView of the iOS, I came across frame and later came across bounds. To the casual observer, one may think they are the same. They are not.

I like how this stack overflow user, amattn, puts it in his post:

Here's the cheatsheet:

• frame is where the view is (with respect to the superview)
• bounds is where the view is allowed to draw (with respect to itself)

Also, 40 minutes and 50 seconds into the "4. Views (October 6, 2011) - HD" lecture by Stanford, discusses the difference in depth using a drawing which really helps.