How To Write A Program From Scratch (Hints and Tips)

Enjoy

My pain today has been trying to work out a software reuse procedure for iPhone development. In some ways I have been very unsuccessful, but un the end I believe I have worked out a reasonable way to do it. Note that I have googled many different searches and have usually come up with no help. There were a few good tutorials which have been useful, and I have derived my procedure based on these posts…

• Creating a Static Library for iPhone
• Building static libraries with the iPhone SDK
• Easy, Modular Code Sharing  Across iPhone Apps: Static Libraries and Cross-Project References
• How to (almost) create your own iPhone OS framework

Library

Step One: Create the library project

For simplicity I will keep out the SVN related stuff. I am in the process of creating my post on Subversion integration with my projects, stay tuned.

Jump into xcode and create a new window based application, call it MyLibrary for example. This is actually useful as we can use the project to test our library code as well.

Step Two: Create the static library target

Right click on the “Targets” node in the xcode project list. Select “add -> New Target…”.

Choose the “Cocoa Touch” option on the right, and the “Static Library” icon in the left pane. Call it “libMyLibrary”. When the information screen comes up, change the “Product Name” to “MyLibrary”. (note this can be changed later by right clicking the target and choosing “get info”.)

Step Three: Create some classes

To test the library lets create a new class (in the Classes directory). Select the NSObject as the super class, call it “MyClass.m”, and add it to the new target (by clicking the check box next to the “libMyLibrary” target).

Add some simple code, first the header…

#import <Foundation/Foundation.h>
@interface MyClass : NSObject
{
}
+(void)hello;
@end

And of course the implementation...

#import "MyClass.h"
@implementation MyClass
+(void)hello
{
	NSLog(@"Hello");
}
@end

Save the files.

Step Four: export the header as public

In the “Targets” node in the right hand list, click the “libMyLibrary” node. The filelist will now have your MyClass.h and MyClass.m files. You need to change the “project” role next to the MyClass.h file to say “public”.

Step Five: done with the library

For the moment…

Client

Step One: Create the project

Call it “MyApp”. Any more need to be said?

Step Two: Create a reference in the application to your library

This is a slightly tricky step. Basically all you need to do is in your library project there is a list on the right hand side showing up the top your library (MyLibrary) and nodes beneth it with classes, resources etc. Click and drag the “MyLibrary” icon (right up the top) over to your new project, drop it at the same place (where it says MyApp). Make sure the “copy” checkbox is not checked (you do not want to copy it, you just want it referenced). Click Add.

You may notice that underneath the reference you just created there are two items, MyLibrary.app and libMyLibrary.a.

• MyLibrary.app is your actual app. You can safely ignore this for the imported project
• libMyLibrary.a is the static library.

You will notice these correspond to the targets in the MyLibrary app.

Step Three: Tell your code where the header files are (this is for code completion to work)

• Right click the “MyApp” icon at the top of that right hand list, go down to “Get Info”.
• Click the “Build” section. This will show all the build settings defined for your project. The list is very long, so we’ll use the search box to narrow down what we see. Type in “header search” in the search box.
• The field we are looking to change is the “User Header Search Paths” option. Double click the blank area next to it (which will enable you to edit the paths).
• Click the [+] button to add another path
• Double click the new path blank area to type in the path you want

This is where you need to reference the actual path of your “MyLibrary” project. In my case I have used the same directory for both the MyApp and MyLibrary projects, so I can simply type into this field…

../MyLibrary/

Out of interest I also select the Recursive checkbox as well.

• Close that window

Step Four: Start Coding

Open up the “MyAppAppDelgate.m” file. If you have added the header include path correctly you should be able to add the following at the top of the file (just under the #import “MyAppAppDelegate.h” statement)…

#import “MyC

… and you should now see the auto completion kick in and see the remainder of the line…

#import “MyClass.h

… Of course you should now complete the line (#import “MyClass.h”)

Next you can add the following line of code in the applicationDidFinishLoading function (which is created for you). Modify it to say this…

- (void)applicationDidFinishLaunching:(UIApplication *)application 
{    
    [MyClass hello];
    // Override point for customization after application launch
    [window makeKeyAndVisible];
}

Build and run. You should see “hello” on the console. That was from our original library code.

Step Five: Add a linker reference and build dependancy on the library

For those that are following step by step and are a little savy may notice that…

a) the items under the MyLibrary.xcodeproj (which are the targets for the MyLibrary project) are both red. And…

b) we haven’t built the library yet.

This was done on purpose as we want the library to be built as a dependency on the current project. Of course you may not want this as part of your build process, but I like to keep my code sane, so rebuilding often means I need to check and fix bugs often. Not a bad thing. But before we add this dependancy lets tell the linker to link against our static library, then we can add the build dependency.

• open up the “Targets” node in the list in xcode
• You will see the Link Binary with Libraries node.
• Drag the “libMyLibrary.a” from our imported project into this node.

Now we are ready to add the build dependency.

• Right-click the “Targets -> My App” node and go down to “Get Info”
• Click on the General button, up the top of that screen you should see the option “Direct Dependencies” box.
• Click the [+] button
• Click the libMyLibrary target
• Click the “Add Target” button
• Close the window.

Step Six: Build and run the project

Try building the project now.

The simulator should run, and the words “Hello” should be written in the debug console. Success

You will also notice the “libMyLibrary.a” target in our imported project is now black – hence its been built.

Changes to the Library

You can now add another method to your MyClass, get it to do something else. Save it.

Head back to your client project, use the new method, build and run. The library should now be rebuilt and the new method available immediately for use.

Conclusion

This is about the easiest method I have found through my research today to create a library of reusable code for the iPhone. Why I am unable to create a framework to be used in an iPhone app is a bit of a loss to me (thank you Apple for making this so hard). In my opinion, to foster reuse of code, the ability to create a framework and add it to a project far outweighs the eleven steps outlined above. C’mon Apple.

Well. If anything has annoyed me about my new MacBook is the lack of page up and page down keys. There are substitutes for a few applications, but I find myself wondering how to navigate by pages in most of my work so far.

Fn – up/down arrow keys

This one appears to me to be the most common one. However it has some pitfalls…

Take Thunderbird mail for instance. This keyboard shortcut does nothing (really, I want the selected message to be the one a page higher, so I can navigate my sometimes overly full inbox, with ease). As another instance, take editing an email in Thunderbird mail. This shortcut scrolls the view up by a page, but thats not what I want – I want to move my cursor up by a page. Highly annoying.

So I thought it may just be that Thunderbird did not correctly map these key strokes, but after opening the standard TextEdit application that comes with the OS, the same happens, the view is scrolled, but the cursor stays where it is. If anyone knows a way to move the cursor up the page with the keyboard (without hitting the up arrow 40 times), I’de greatly appreciate it.

But wait, Google Docs to the rescue, or is it?

So then of course I tried a few other applications, the first one being Google Docs Spreadsheet. I tried page up and down, and by golly it worked. This is fantastic. I hit fn-up and the selected cell at the bottom of the page becomes unselected, and the unselected cell at the top of the page gains focus. Awesome!

But of course trying it in wordprocessor just happens the same way.

Conclusion…

Page up on the mac does not work like page up on linux/windows. This is actually confirmed by this post… Move the cursor during Page Up, Page Down scrolling … in case anyone is interested. Apparently you *can* get it to work in some applications, but not all.

PS: Vim seems to have its own mapping

There are probably not a lot of Mac users out there using VIM, but as I am from a Linux background, and a programmer, I simply love the power and simplicity with VIM. (For those who do not know, VIM is a console based text editor, everything can be done on the keyboard to navigate and edit the document). But of course I do a lot of navigating large source files using pageup and pagedown keys. I found this trick that helps me do that…

ctrl-f and ctrl-b

I can only guess, but I think my guess is very good… If you want to page down (or move forward in the document) try ctrl-f, and of course ctrl-b for moving backward in the document. Its not exactly intuitive, and a little awkward for the muscle memory to adjust to, but seems as though when I’m paging up I usually hit it about 10 times (until I find the place I want to stop, or I could simply be reading the document quickly) its not too much of an issue.

Enter Garbage Collection.

I have had very little to do with cleaning up after myself in the past with software and memory allocation. Of course at Uni when we used C/C++ then every time we allocated memory we needed to deallocate the memory when we were finished. But from memory we were only really marked on the topics like linked-lists and stacks, where the only real way to create such structures is to allocate memory and fill it up. That was later in the course. Soon after that I had moved universities and entered into Java, a garbage collector is included as part of the virtual machine, and was never even spoke about, let alone concentrated on as a topic.

All the languages I use currently either a) have a garbage collector, or b) lifetime of the program is too short to worry about garbage collection.

Why is picking up garbage useful?

Essentially for software to be useful it has to store data. To store data it needs to be put in the memory on your computer, using virtual ones and zeros. Its almost like a storeroom or a warehouse. To store a box you need somewhere to put it. You may have a glance around the storeroom, find somewhere that the box will fit (or course different sized boxes require different sized storage spaces), then you go and put the box there. This is pretty simple for small storerooms, but if you are doing this in a warehouse then you really do need some way of finding that box again in the future. You might mark the box with what it is (useful thing to do anyway) but if you have millions of boxes then you need another way of finding that box later. You might create an index card (if you can forget about computers/barcoding/gps/rfid/etc) that has the contents of the box, the owner of the box and the location of the box. It might be in isle 35, 14 meters down on the left, 4 boxes high. That index card gets stored alphabetically so you can find the card quickly, and then you know where the box is in the storeroom.

Computer memory is almost exactly the same. When you allocate a piece of memory, the “memory allocation” code works out where it will be stored, based on the size of the memory you wish to allocate. It will mark that space as being allocated (so it doesn’t accidentally store something else in there) and return a pointer to that space back to the code that wanted the space. So far so good. When you are finished with that memory you then need to tell the “memory allocation” code to release that memory (remember that the memory allocation code is remembering to not give that memory to anything else).

With languages like Java, this is done by setting your object to Null. Note this does not deallocate the memory there and then. Periodically the “garbage collection” code will as the “memory allocation” code for a list of all the objects that it has allocated, and see if any of them are being used. It goes through the list, one by one, and see how many pointers are pointing to the memory. If it finds at least one pointer, then that memory is still being used and then moves onto the next piece of allocated memory. When it finds allocated memory that has no pointers pointing to it, then it will ask the “memory allocation” code to deallocate that memory. This is done periodically, and is a little overkill for processing power than some small devices can handle. Remember on phones like the iPhone that extra processing power means lower battery life.

Just a side note to say that the Google Android powered phones do have garbage collection, where as the iPhone doesn’t. Although the whole battery life argument makes sense, I still think garbage collection is an important programmers tool, especially as you have the option of turning it on or off using Objective-C and the COCOA framework.

Why not pick up after yourself?

Programmers are lazy. Thats why they program. If programmers didn’t mind doing the same thing over and over again, then they would just do it. The fact that doing things over and over is boring enlightens a programmer to code a solution so next time they have to do it, click a button or type a command and let the computer do it for you.

Unfortunately programming isn’t easy. Well, it is, but the more complex a problem, the more complex the solution becomes. From the early days when programmers used puch cards to do their programming, designing a solution for even a simple problem was a complicated process. Until of course someone created a simpler process that enabled input to the computer via a keyboard, rather than puch cards (note I’m not an historian, I’ve probably missed a few steps here). However entering ones and zeros into a computer was not only mundain but practically impossible to memorise the sequence required for each command, and then of course do the decimal to binary conversion required to get numbers into the machine. A typical command (made up, dont try this at home, it wont work) might be to add two numbers together. So you need a command to add (00010001) and then the two numbers, say 5 (0000101) and 11 (00001011). The machine (made up machine again) might expect the sequence to be “command arg1 arg2″ in which the programmer would need to enter (via keyboard or puchcard) the sequence…

000100010000010100001011

Just to add the numbers 5 and 11 together. Of course there were 10’s or 100’s of commands. Practically impossible to get things done without manuals. Enter Assembly. Assembly was a program that took a sequence of charaters and converted them to the ones and zeros required for computation. So a programmer could write, for instance…

add 5 10

and the exact same sequence of ones and zeros above would be created. Neat! But of course the programmers needed to do things like jumps and jump-if’s and all nasty stuff that could potentiall lead to bad things happening (which by the way still happens!). So higher level languages evolved to do loops and jumps and all the nice things to help make programming easier and more reliable. Paradigms popped up like Object-Orientation, Aspect Programming and the likes to help solve problems that lower level langauges introduced, like memory leaks.

Memory leaks happen when you have a long running software process that allocates memory, but does not deallocate it. Example. Say you are writing a program to generate lotto numbers for people. Say it is a server, so it runs constantly. When a request comes in you need to generate 8 random numbers and provide that to the person making the request. First you allocate memory for 8 numbers, fill the memory with the random numbers, send the number to the person makeing the request, job done. Or is it? You havn’t told the memory manager to free up that memory. The next request comes in, you allocate more memory (note now you have memory allocated for 16 numbers now!). Each request will come in, filling up more memory until finally it will exhaust your computer memory and the server will crash. Of course you could reuse that memory each time, but what happens when two requests come in quickly? One of the results will be tainted with the other requests results. Not that its that much of an issue with random numbers, but if it was more critical information then you would have a disaster on hand.

Allocating and deallocating memory is a bit of a hassle. In my opinion higher level languages should work out when you no longer are using an object, and deallocate that for you as required. This is why I quite like Python as a programming language. Python takes out the bits that computers can do for you, while the programmer is only interested in telling the computer what needs to be done. Whilst I like Objective-C, I do like the Python language better. Its cleaner (no need for header files and implementation files), the syntax is minimalist (why do i need semi colons at the end of lines, and end  of line tells me its the end of line, also, for cleaner code its best to put each statement on a different line), I have control over my objects (if I need to add a method at runtime, no problem, if i need to use another classes method on my own object, no problem) and last and probably least, I’m not locked into what i call my object (this?, self?). Okay, that last one is not really that important, but I find it very neat. Note of course all this is my opinion only, and there are a ton of pro’s and con’s for each language.

So back to garbage collection. The COCOA framework for Mac OS has garbage collection built in. Which is really neat. Unfortunately the iPhone has been stripped of this capability for performance reasons. So we need to pick up after ourselves if we write for the iPhone. I prefer to write for the lowest common denominator, so I’m going to try to code my Objective-C objects with my own cleanup in mind. Note there are a few different ways to do this, I’m going to describe one of them. One advantage to doing it this way is that if garbage collection is enabled, then the memory management code is ignored, so I do not need to write checks constantly to see if the garbage collection mechanism is turned on or not, I can just write the code, allocating and deallocating memory as required and let the compiler work out what to ignore and what to keep. Using the method below is also compatible with older Mac OS systems that do not have garbage collection, as well as the iPhone which also does not.

NSObject (which all COCOA Framework objects inherit from) has a mechanism built in which we can use to manually count references to the object. After memory for an object has been allocated and the object initialised, the releaseCount member gets set to 1. We can then ask that number be increased [obj retain], or decreased [obj release] as we need to. Instead of deallocating an object by calling [obj dealloc] the object itself will call it based on the release call. If releasing an object has no more interest in the object (releaseCount is 0) then the object will deallocate itself. This is pretty neat.

Enough, lets see some code…

As I am generally only new at garbage collection, I am going to try and create some conventions that will help me remember to release memory when required. Lets start with a simple example…

NSCalendarDate *now = [[NSCalendarDate alloc] init]; /// @todo release
// do something with now
now = nil;

Note that this is enough for the garbage collector to kick in and clean up for us. But unfortunately, its not enough for no garbage collection, the *now pointer no longer points to the allocated memory, but that memory is not deallocated yet. We have a problem as now we no longer know where that memory is (we have lost our pointer to it). Note also my todo comment, this is my way of reminding me I have to release that memory.

NSCalendarDate *now = [[NSCalendarDate alloc] init]; /// @done release
// do something with now
[now release]; // release before we loose the pointer to it
now = nil;

So the init message increased the count to 1, and the release message decreases it to 0 and the object is deallocated. Simple!

Object variables are slightly different, as you may not get a chance to deallocate them specifically. You must handle these when your object is being deallocated…

@interface MyClass : NSObject
{
     NSCalendarDate *now;
}
@end
@implementation MyClass
- (void) init
{
     [super init];
     now = [[NSCalendarDate alloc] init]; /// @todo release
}
@end

So here we have a very very basic class which as a NSCalendarDate allocated. We need to now override the dealloc method to release the NSCalendarDate object…

- (void) dealloc
{
     [now release]; now = nil;
     [super dealloc]; // dont forget to trickle up the inheritance tree
}

One other difficulty that has popped up is when you are returning an object from a method call.

- (NSString *) description
{
     NSString *result;
     result = [[NSString alloc] initWithFormat : @"say something useful here"]; /// @todo release
     return result;
}

As you can see the problem here is that I have allocated memory for an object (release) but I have not deallocated it. Its unreasonable for the caller to clean up for us. We also cannot call release in the method as we will no longer have an object to return. For this we have the autorelease message.

- (NSString *) description
{
     NSString *result;
     result = [[NSString alloc] initWithFormat : @"say something useful here"]; /// @done release
     [result autorelease];
     return result;
}

What we have done here is added our result object to the autorelease pool. When the event loop is finished the object will be sent a release and cleaned up if necessary. If the calling code wants to keep this object for its own use, then it will need to send the object a retain to keep it from being deallocated at the end of the event loop. That code could look like this…

NSString *desc;
desc = [myObj description]; // note this is in the autorelease pool
[desc retain]; // hold onto it until i want to remove it
// later on, possibly in dealloc or somewhere else.
[desc release];

Note that objects created by alloc, new, copy or mutableCopy have a retain count of 1, and are NOT in the autorelease pool. You will need to release these objects when they are not needed anymore.

Note also that if you get an object using any other method, then you should assume it is in the autorelease pool.

Note that if you do return objects then dont forget to put them in the autorelease pool.

The one last example I want to show you is using setter methods on your object. These are methods that allow you to set a data member. However you really do need to release the existing value, before you assign a new object to it. For this we use “retain, release”.

- (void) setNow : (NSCalendarDate *) newNow
{
     [newNow retain]; // remember the local code will probably release their copy if they want to, so we need to declare our interest in it.
     [now release]; // not interested in the old copy anymore
     now = newNow;
}

You could of course release the old object, then retain the new one, however there is a corner case where this is bad. If the message is to set the value with the value thats already there (which of course is a useless call, but certainly possible) then you would actually be releasing the value you have, possibly deallocating it at the same time, which would also deallocate the actual value thats being passed in, causing nil to be set to the variable, which is NOT what we wanted.

Final thoughts

Note that there are objects that will increase the retain count automatically, like NSArray for example. When you add an object to an array, you send the addObject message to the array, passing the object you wish to add. That code will retain the object (as it now has an interest in it). If your code is no longer interested in the object, you will need to release it still. When you are finished with the array, you send it the release message, and if the releaseCount is down to zero then the array will send release to every object it has in store before it is deallocated.

I guess the moral to the story is you have to clean up objects locally, in your own code. If you create objects you must release them. If you get objects from somewhere else assume they are going to disappear. If you want those objects to hang around you must retain them, and remember to release them later.

The first thing I needed was the development kit available for free from the Apple website. Just register as a developer (for free of course) and download the tool. Included in this download is XCode (which is an IDE, the place that holds all your code and resources together), Interface Builder (click and drag for building GUI’s), and the standard frameworks (including COCOA, the framework we need to know).

I just mentioned the COCOA framework. I’ll be up front and say that I’m probably not technically correct calling COCOA a framework. In reality it is a group of frameworks, the major ones being the Foundation Framework, AppKit Framework and Core Data Framework. There are more, but these are the three main ones. This collection of frameworks provide all the useful classes you need to build Apple Mac/iPhone software.

• Foundation Framework for providing base functionality.
• AppKit Framework provides the user interface classes
• Core Data Framework is essentially a persistance framework.

Although I cannot recommend the entire book yet, but so far I have been progressing through COCOA Programming For MAC OS X by Aaron Hillegass. So far I have found this to be an excellent read. Usually with technical books I end up skipping the first few chapters to get to the good stuff, but even from chapter one of this book I have been enthralled. The first chapter provides a very quick but amazingly informative overview of where the MAC OS and the COCOA framework have evolved from.

Coming from an Object-Oriented perspective I have found Objective-C to be quite easy to pickup, and so far I would have to say I am quite impressed with the language. I wish I had found this a long time ago! My background of Object-Oriented programming includes C++, Java, PHP, Python and JavaScript. Objective-C claims to be a mixture of pure C and SmallTalk.

What is this Object-Oriented programming I hear you ask? Basically it is a programming paradigm that models the creation of software on (real-life?) objects. For example, if you were to build an accounting system you may identify the following objects…

• Documents
• Journals
• Ledgers
• and of course… Accounts

These are of course a very high level of abstraction, they can all then be broken down into what is known as Sub-classes, a less abstract view of the system…

• Documents can be specialised as…
  • Memos
  • Invoices
  • Purchases
  • Receipts
  • Cheques
  • etc
• Journals can be specialised as…
  • Purchase Journal
  • Sales Journal
  • Cash Receipt Journal
  • General Journal
  • etc
• Accounts can be specialised as …
  • Liabilities
  • Assets
  • Owner Equity
  • Revenue
  • Expense

And so on.

Each of these classifications (classes for short) can specify certain data and code that work together to define the class. The way of reaching the code in an object is usually described as calling a method or function on that object. Once the class is defined, then a software program can instantiate that class into an “Object”. Yes, we have gone the scenic route to get to this point

One of the neat things about Object-Orientation as a software paradigm is that you can put very general code into a Base class, and then create a specific class that extends from the base class, inheriting all the code and data that was in the base class, and then add more specialty code and data to it. Then you can specialise that code further but extending that class again and again until you have the most specialised class that is practical.

For example, following our Accounting example above, we may have a base class Document. The Document class will more than likely have an amount attached to it that is added to the system as a journal entry. But for record keeping we need to know more information. My design of such a system would include a class “Document”. It would have a piece of data attached to it which I would name “totalAmount”, which would be of type currency. I would probably have a method or to that could fetch and/or set that field, and another one which would fetch a description or summary of the document. I would probably write a method that returned “Generic Document” as the description of this class. As the Document class is very generic, I would decide to extend that class with different specialities of that base Document class, to provide more functionality, depending on the type of document that has been entered into the system.

The next class I would define would be the Receipt class. A receipt would extend the Document class, and in effect enable a receipt to also have a totalAmount available for an instance of this class. As this class inherits everything of its base class, if a piece of code asks for the objects description it will return “Generic Document”. Not a great idea, as we know it is a Receipt, so what we do is “Override” the description method to return a different message, “Receipt” for example. We may also add other data to this class if we wish, it might specify who the reciept was issued to, what products/services was involved etc.

Ok. Object-Orientation 101 completed. Although all the above is not 100% accurate for every language and system, the basic ideas are there. All we need now is away to get these idea’s into a software program. Enter Objective-C.

Objective-C uses “messages” to communicate between objects. So if you have an object, call it “weatherStationGoldCoast” and it has a method on it called “whatIsTheWeatherLike”. Say you also have another object, “airportSydney”. Somewhere, somehow in your software the AirportSydney object is executing code and needs to schedule a flight to the Gold Coast. Before it does this it would be a great idea to check to see what the weather is like at the Gold Coast to know if it will be safe to land the plane there. Easy! Simply ask the WeatherStationGoldCoast object by sending a message to the whatIsTheWeatherLike method. Finally some code…

// file: WeatherStation.h
#import 
@interface WeatherStation : NSObject
{
        // define data here
        (NSString *) stationName;
}
// define methods here
- (WeatherStation*) init : (NSString*) stationName;
- (NSString *) whatIsTheWeatherLike : (int)futureMintutes;
@end

// file: WeatherStation.m
#import "WeatherStation.h"
@implementation WeatherStation
- (WeatherStation*) init : (NSString*) stationName
{
	// do something useful here, like load up the station data for the stationName
}
-(NSString*)whatIsTheWeatherLike : (int)futureMintutes
{
	// this would normall go and get some real data, say from the BOM for a point of time in the future
	// lets just say the weather is always fair on the coast (one day soon I'm sure it will rain, but not yet)
	return @"fair";
}
@end

// file: Airport.h
#import 
@interface Airport : NSObject
{
}
-(BOOL) scheduleFlightTo: (NSString *)where
					when:(int)when; // how many minutes in the future to schedule the flight
-(void) scheduleFlight: (NSString* )where when:(int)when;
@end

// file: Airport.m
#import "Airport.h"
#import "WeatherStation.h"
@implementation Airport
-(BOOL) scheduleFlightTo: (NSString *)where when:(int)when
{
	// first we need to get the gold coast object - lets make one now
	WeatherStation* gcWeatherStation = [[WeatherStation alloc] init: @"GoldCoast"]; // first allocate memory, and then run the init method on that allocated object - two calls in one 
	NSString* weather = [gcWeatherStation whatIsTheWeatherLike:when];
	if ([@"fair" isEqualToString:weather] == NO) return NO;
	[self scheduleFlight:where when:when]; // all is good, actually schedule it
	return YES;
}
-(void) scheduleFlight: (NSString *)where when:(int)when
{
}
@end

// file: main.m
#import 
#import "Airport.h"
int main(int argc, char *argv[])
{
	Airport* sydneyAirport = [[Airport alloc] init];
	BOOL result = [sydneyAirport scheduleFlightTo:@"GoldCoast" when:60]; // schedule flight in an hour
	if (result == YES) NSLog(@"Scheduled flight to the GoldCoast in 1 hour successfully");
	else NSLog(@"Flight cancelled - weather is no good");
	return 1;
}

Some important notes for this code…

Header files define the template, or the interface of your class (wrapped with @interface and @end). Identifies starting with the ampersat symbol (@) are Objective-C identifiers. Firstly your data is defined between braces, and then your methods are defined after that. The minus symbol (-) before the method name indicates it is an object instance method, where a plus symbol (+) indicates its a static class method. The type is then defined between parenthesis, followed by the method name and then the parameter list. The first parameter in the list only requires a type and a variable name, and may be followed by a space and further variables. The rest of the variables defines a message parameter name, followed by a colon (:) followed by the type in parenthesis and finally the variable name. The variable name is what we use in our method to reference that parameter. The message parameter name is what the caller uses to reference that variable. I see some similarities with Python in this respect (warning, subjective statement ahead…). I like it! Just like C this is followed by the semi-colon to say this is the end of the statement. Remember this is just the interface, the implementation will be in the .m file.

The .m files indicate Objective-C Files. They can be a mixture of Objective-C and straight C, in fact, Objective-C is a superset of C. All valid C code is valid Objective-C code. In this file the implementation of the class template in the header file is filled out between the @implementation and @end tags. The method header is exactly the same as in the .h files, without the semi-colon at the end, and with code beween following braces.

Objective-C code works by sending messages between objects. What is slightly different about Objective-C is that the messages may or may not get responded to. This is different to languages like Java for instance where if you call a method on an object, the compiler enforces that the method must exist, and return a correct data type. In Objective-C you can send any message you like, but if the method doesn’t exist, you wont get a response. This is very cool (note I come from using dynamically typed langages lately, python specifically). You will note that messages are sent to objects using brackets. For instance if I wish to allocate memory for an Airport object, then I can send the alloc message to it, hence [Airport alloc]. Once the memory is allocated we can then initialise the object, by sending it the init message. We can also roll it all into one, as you can see above. Note that its not considered good practice to nest more than two sets of brackets, it just gets messy (my argument with Scheme like languages is the same by the way). Calling a method with multiple parameters is almost as easy, just follow the message name with a colon and the list of parameters (separated by spaces). The first parameter isn’t named, but the other ones you use the name and value separated by colon’s. E.g. [{object} {message} : {firstparamter} {paramname}:{paramvalue} {paramname}:{paramvalue}].

Another couple of notes. NSString objects can be created easily by sitting the ampersat symbol in front of it, hence @”this is a NSString”. You will also notice i’ve used the NSLog statement to print it out to the screen. You can use printf() type statements if you wish, you just need to convert the NSString object into a cstring (look for the cStringUsingEncoding method on the NSString class).

I have no doubt left out some things, possibly even vital things. I am only just learning this myself and all the views expressed are my interpretation of things etc etc etc. I hope this is useful for someone, somewhere at some time.

Moving to the Mac for me has been a pleasantly easy move. Sure there are a few quirks that I need to get used to, but I’m actually finding myself started to get frustrated with the keyboard shortcuts under Linux now. I keep going for the Mac equivalent and it just doens’t work. Thats a good sign that the mac shortcuts are very intuitive. So far so good!

I thought I would breif my first week on the mac by listing the third party tools I have downloaded so far. I expect to talk a little on each of the apps over time, but these are my must have first week apps (well, at least the ones that make me comfortable coming from the Linux perspective).

• Adium (multi-messenger client, no video yet wich really sux as I now have a webcam built into my laptop)
• Thunderbird
• Google Chromium (until Chrome is released)
• FireFox (mainly for the plugins, firebug, foxyproxy, yslow, etc)
• XCode (development suite from apple)
• DivX Player
• MacVIM (port of Vim to Mac, where would I be without VIM!)
• Remote Desktop Connection (from Microsoft – essential for administering remote windows machines)
• VirtualBox (virtualization from Sun)
• Google Voice and Video – Video chat from GMail

And of course these included apps that Apple have provided…

• Terminal (if your not comfortable here then you havn’t come from a Linux background!) (and its bash, double kudos)
• Subversion (version control) – SVN out of the box – COOL!
• SSH (secure shell) – As this is the main method I use to access remote machines, I would really be at a loss without it.
• rsync (remote sync protocol)
• iTunes (how else do I sync my iPhone
• iDVD – Very nice interface for DVD burning
• Garage Band – If only I had an interface to plug my guitar into this piece of software. Looks unreal, I would just like to start playing with it.

The first week would not be complete without a few essential items I have setup particularly to make life easier.

• Time Machine
  • This is the first app I used. Connect a removable hard drive, set it as a TimeMachine target, and it backs up your entire drive!
  • It even has an awesome GUI for retrieving older backups.
• Multiple Desktops (System Preferences -> Expose and Spaces -> Enable Spaces)
  • Use “Apple-<num>” to go directly to a screen
  • Use “Apple-<arrow>” to navigate to the next/prev/up/down screen
  • Check the “When switching to an application, switch to a space with open windows for the application
    • This is a weird one from a Linux perspective. When you click on an icon in the dock it goes to the open application. This is unlike GNome for example as when clicking on terminal a new window will appear. On a mac it will switch to that application. I turned this option off for a while but found it best to leave it on. The only real application I use that require a new window when I click on it is terminal, and so far I am right-clicking on the terminal doc icon -> new window -> basic, to get a terminal window. Its not too annoying as of yet, but I would like to not have to go through to basic – new window should bring up my default new window.
• Change keyboard shortcut to change between windows of a desktop
  • Unlike Linux (and Windows might I add) using “Apple-Tab” does not scroll through open windows, it scrolls through open applications. So once you are at an application you need another shortcut to scroll between the windows of that app, this one is “Apple-`”. Note of course this only switches through open windows of that application on the current desktop. If you want to cycle through all the windows, then simply click on the doc icon for the next window, this does go across desktops as well.
  • To change between windows on the current desktop, regardless of if they are of the same app, I have modified my shortcut key to “Apple-Opt-Tab”. It works well and is not too hard to either remember or type (from memory the default was “fn-Ctrl-F4″, and was quite annoying if you do it often)
• Page up and Page down keys are missing from my MacBook
  • Using “fn-<up/down>” seems to do the trick for me.
• Multitouch – AWESOME!
  • The multi-touch touchpad works really well.
  • Scroll up/down – double touch scroll. This is really easy and I find myself not even needing to use the keyboard for this.
  • Back/Forward when browsing – triple touch swipe left or right.
  • View destktop – quad touch swipe up
  • View Expose (overview of open windows) – quad touch swipe down

So for so good for the Mac. I dont feel like I’m too unproductive on it yet, so thats a good thing. I expect the next few weeks will be getting used to XCode and Cocoa libraries for mac/iphone development.

Wish me luck!

Commodore 64 was my first machine. It was a Christmas presant around 1984 I would guess. I almost even remember the day! I certainly remember the many hours typing endless lines of code out of books we found in bargain bins. I have to admit I did not learn much about programming, or much about anything really, but I did pick up the programming bug during those years. C64 Basic was kinda fun.

Next came school. Macs were all the rage there. Pascal was taught as part of senior year computer classes which I believe I did quite well. This is where I started actually programming, being able to turn lines of code into something that actually did something, by myself (no need to mindlessly type code out of a book).

Out of school was TAFE with a 6 month part time course in Visual Basic. Now with the right tools I was able to program database applications with graphical interfaces! Sure it was still basic, but I was developing more interesting utilities. I had even started using the internet and developing HTML based websites at this stage and found a library to help me turn my visual basic programs into DLL files to use with the Microsoft Personal Web Server. Now I could write programs for the web (not that I realised what that really ment at the time). My first (and only) program using this method was a computer system quoting tool for the computer shop I was working at. To be honest I thought it was quite neat. Nothing like that existed at the time from what I can tell, and I think my boss was quietly impressed. We could generate quotes, in house,  for customers in seconds rather than minutes (looking up supplier pricelists, getting cost prices, adding margin, writing up the quote etc). A few clicks of dropdown lists, a few checkboxes for options, click submit, click print, a semi-proffessional quote was printed out which we could explain to the customer and stand by the number that was printed out. That experience was fun.

At the same time I was experimenting with Linux. RedHat 5.4 from memory. Either I wasn’t ready for it or it wasn’t ready for me. I just wasn’t experienced enough to even get it to install. I could install windows 95 machines blindfolded (in fact I remember doing at least 2 installations without monitors, I had all the keystrokes practically memorized), I could fix numerous bugs with dos/windows3.11/windows95 machines, I was at the stage where I could fix peoples problems over the phone 90% of the time (although 90% of the problems were printer related and required talking through setting up print drivers). But I did not understand enough about actually how a computer worked to answer the relevant questions in the clunky install process of RedHat 5.4. Soon after I found RedHat 6.0, which I successfully installed and started using. Within a few months I completely wiped my harddrive and used Linux exclusively which was a challenge. It was 6 months before I could actually do the same things I was doing with MSWindows based machines. Frustrating at times, but I stuck at it. This is where I picked up a little perl, and was introduced to PHP.

After getting bored with the small town computer shop work I moved away to attend Uni. I continued to do a lot of perl programming but was also caught up with javascript (for part time employment) and c++ (subject matter). At this stage I was 100% Linux, using MSWindows only at Uni on their machines if I needed to do word or excel.

Moving on to second and third year of Uni introduced me to java, lisp, haskell and assembly. My honours year bought me back to the MSWindows world. It was a requirement for my thesis that I used MSWord with Endnote. I obtained a notebook with windows pre-installed and kept Linux on my PC at home.

This also happened out of Uni. I worked for a web-design company, using their computers which had Windows, developing mainly in ColdFusion and a little PHP. My second job was fulltime PHP, with a supplied laptop which had MSWindows, but also enabled me to maintain a Fedora based server for their website, and a duplicate for the test server. It wasn’t long until I scrapped the MSWindows partition and just went fulltime Linux once again (also running VMWare Server ‘just in case’ some of the windows programs I was using was needed again). My current position has me maintaining linux based servers, so the first thing I did with the supplied computer was to trash it and put linux on it.

I must admit I have spent endless hours over the years fixing issues between linux drivers and hardware which already have windows drivers. Every time it has been extremely satisifying to get things working that seem almost impossible to do. I remember the entire weekend getting the HP laptop to even recognise it had a wireless ethernet card in it. And then the entire next weekend to get it to recognise an encrypted signal. My time was probably worth more than a windows disc, but the satisfaction of getting everything to work using Free and Open Source Software (FOSS) was well worth the effort put into it.

However…

I do get frustrated sometimes at how compatible linux drivers are with current hardware, and the lack of certain support of some devices, and the less than satisfactory support of linux on laptop computers. I understand all the arguments, but it is still frustrating that my laptop takes 4 minutes to hibernate (using windows it takes about 30 seconds) and can take up to 10 minutes somedays to come out of hibernation (I suspect its because it had certain usb devices when it was hibernated, and missing those devices on wakeup, but I am not sure). So after some particularly bad news, and feeling like a change is as good as a holiday, and after owning an iPhone for about 4 months and really wanting to get into iPhone development, all thrown into a pot and boiled for a day or two, it was decided that a Mac was a fantastic idea (probably not the best time to actually make decisions, but history will tell if it was a good one or not).

So here I am, with a Mac, writing my first serious blog post.

More experiences to follow…

To be continued…