Mythic Logos

Working on getting into iPhone dev. Started it a couple of months ago and got distracted. Now I am back. Working through, chapter by chapter, Dudney and Adamson. I like it so far.

It is a fairly neat development system (I have just been working with text editors up to now, so…) Essentially, you create a project, then define the interface headers, use interface builder to connect up GUI elements to code objects. Then write the code to do some action. It does not take much to get a functional app.

A little bit tricky to get the provisioning profiles and stuff. I had to get a private key from the old system (export from keychain), get the development certificate and install it, then each app, create an app id (or use a * for a suite of apps), then get provisioning profile, then load that, then compile it after telling the project what appid it is to use and provision profile. Then load it on to iPod. Soon I will be uploading an app to the store.

One key thing to be aware of is the memory management. Any item created with alloc or init must be released. There are also autorelease features, retain features…. Mastering this is important since doing it wrong will not be immediately apparent. Memory needs to be consumed because of the leaks before you will find out the problem. And even then, you need to know about it.

There are certificates that need to be installed into keychain along with a the private key. Development is for creating provisional, distribution is for adhoc and app store.

In order to create objects nicely in JavaScript, Crockford suggests:

if (typeof Object.create !== ‘function’) {
Object.create = function () { // create a method of the universal object
function F() {} //create an empty function
F.prototype = o; //load the function’s prototype with the old object to inherit from
return new F(); //use that function to create a new object and return it.
};
}

This implements inheritance from an existing object when creating a new object.
Crockford says changing o later will change new object.

I also need to create a little javascript lab, a notebook to record code, and to look back on.

More Crockford videos. I haven’t laughed that good in a long time.

One bit that was amusing is the following:

return {
ok : false
};

This works well to return an object literal

return
{
ok: false
};
is a total failure. So go with the first form.

Why does it fail? Well, the language inserts semicolons and does not care about useless statements so it sees:
return ; \\returns undefined
{ \\naked block. useless since no scope, but who cares
ok: false \\label in a totally useless fashion. which is fine. It evaluates false even if it is useless
\\ no semi-colon? no problem, we have insertion
}; \\not a statement so no semi-colon needed. But empty statement okay so it evaluates ;
\\and does nothing.

So all in all, this is a classic case of trying to do the right thing screws you.

JavaScript is a language with lots of power, but it requires good discipline.

One key pattern is encapsulation using closures and functions as data. So

var example = (function () {
var constant = [‘stuff’, ‘more’];
var state = 0;

return function (dig) {
state += 1;
if (constant[dig] !== undefined) {
return [constant[dig], state];
};
}) () );

example(0); //returns [‘stuff’, 1]
example(0); //returns [‘stuff’, 2]
example(1); //returns [‘more’, 3]

//end program

So in this one snippet we see how inner functions access outer functions either to save on initialization times (constants of the function) or to maintain state between calls. It can also be used to have generator functions that generate custom functions. Notice the outer parentheses in example–these are not needed by language, but human maintainers enjoy being told that this function is being evaluated, not assigned. It is the inner function (need not be a function) that is getting assigned as that is what is being returned.