Planet Cocoa

F-Script for Automator

2008-10-07T22:35:20+00:00

Dominique Dutoit has released an F-Script action for Automator. It lets you add custom F-Script code within your Automator processes. You can get it here.

The input of the action (i.e., the output of the previous action) is automatically bound to a variable named “input” in the F-Script workspace. Usually, it is an NSArray object. The output of the action is the value of the last F-Script expression executed in the custom F-Script code (automatically boxed in an NSArray if needed).

You’ll need to have the F-Script framework (download here) installed in /Library/Frameworks/ or ~/Library/Frameworks/.

Enjoy!

Survey

2008-10-07T19:22:45+00:00

This is a survey that I saw on a friend’s weblog. I won’t call out the friend to put pressure on his answers to these questions, and I don’t normally participate in this sort of thing, but I think these are important questions. It hasn’t gone unnoticed that the survey seems predisposed towards US citizens, but I’ll answer anyway.

Do you have the guts to answer these questions and re-post as The Controversial Survey?

Lame and self-fulfilling question. Let’s skip the rile-up showboating. Next!

Would you do meth if it was legal?

Alcohol is legal and I don’t even do that. It does nothing for me. What’s left is what it does to me, which I could achieve by banging my head against the wall, shredding a few bills and possibly peeing in inappropriate places.

Abortion: for or against it?

For.

Some people will do it anyway, and they risk getting sick. Some people won’t do it anyway, and they risk getting miserable. (Yes, you could also be entirely happy, but if you’re approaching it from the “I need an abortion” angle, I’m going to assume that all the conditions aren’t there to help enable that.)

The important thing about the abortion isn’t about punishing the woman (for being “promiscuous” or “poorly educated” or even “bad at self-defense” — are you kidding me?). The important thing is about minimizing suffering. Abortions should only be had when you’re deeply convinced that you wouldn’t be able to give the baby a good life; and the decision shouldn’t ever be taken lightly.

If you don’t abort and the baby grows up under bad circumstances, what have you won? The baby is alive but miserable. Don’t we call this torture? Isn’t there a phrase called “wish you’ve never been born”? Why is this desirable at all to not being born?

And yes, life begins at conception, if you take “life” to mean the dictionary definition “it can die”. But the part of this where morals are involved is for most of us about human consciousness; sentience. My personal opinion, not by default but by argumentation, is that to prevent suffering in the future where the odds are bad, terminating a person that’s technically alive but isn’t yet self-aware is… it’s not good. It’s not even acceptable. It is bad and when faced with the choice, I wouldn’t blame anyone for choosing either, even though I consider abortion markedly less evil than the alternative. I would however blame anyone even trying to obscure the choice. Hard questions with this level of reprecussions deserve our attention and we need to be able to answer them ourselves if we’re going to be able to live as free people.

Do you think the world would fail with a female president?

This question is pointed, suggestive and biased. I think the world would be extremely more likely to fundamentally fail if a person who regarded this a legitimate, interesting, non-insulting question was appointed president. Judgement and ability determines a good president.

This question also puts too much into interpretation. What does “fail” mean? “Fail” as in “that wasn’t really quite smart, was it?”? “Fail” as in “please hide under your desk, the nuke’s coming”?

Do you believe in the death penalty?

That it’s working as a deterrent? No. That it’s a practical and expedient way of getting rid of people? Yes, apparently.

The death penalty seems to exist only in those countries where people demand a blood-drawing ending. This isn’t normally an environment that’s conductive to reliable verdicts. The false positive rate is too high.

A reflection: if some people are incurable, and if death penalty works as a deterrent, why not just execute those repeat, hard-hitting, incurable offenders?

Do you wish marijuana would be legalized already?

No.

Are you for or against premarital sex?

For. As long as it doesn’t hurt anyone, I can’t believe why you’d want to restrict someone else’s pleasure. What kind of disadvantaging attitude is that?

Do you believe in God?

No. No. No. No. No.

I will quote Douglas Adams because he put into words exactly how I feel:

If it turns out that I’ve been wrong all along, and there is in fact a god, and if it further turned out that this kind of legalistic, cross-your-fingers-behind-your-back, Clintonian hair-splitting impressed him, then I think I would chose not to worship him anyway.

If you need a god to force you to not be a dick, I don’t think I’m impressed. If you need to thank someone else when you’ve accomplished something yourself, I don’t think I’m impressed. If your way of dealing with facts that are inconsistent and unbelievable is telling me that I can’t disprove them instead of trying to find a better answer, and if you believe that’s an attitude worth spreading, I think you already failed the not-being-a-dick test.

Do you think same sex marriage should be legalized?

To the extent that it’s treating people different legally, yes. (It’s unfair, but I’m not invoking that word on account of what some people see as “waah-waah entitlement”; I’m invoking it because the benefits are arbitrarily held back on account of a distinction that really doesn’t play into many of these benefits at all in that special “some animals are more equal than others” way.) I also think that whatever you call that level of partnership is up to you.

Do you think it’s wrong that so many Hispanics are illegally moving to the USA?

Yes, because I believe it unfair of them to have to evade the authorities to have the enormous privilege to work at Wal-Mart.

A twelve year old girl has a baby, should she keep it?

Not unless her birthday’s February 29th.

Should the alcohol age be lowered to eighteen?

It is 18 here in Sweden, and the problems are worse in the US. The problem’s fundamentally about culture and attitude.

Should the war in Iraq be called off?

Not overnight, but as fast as possible given that the Iraqi government steps up to solve the problems.

Assisted suicide is illegal: do you agree?

Is assisted suicide euthanasia or is it simply tool use during normal suicide? I don’t get these paraphrases. Assuming it means euthanasia, a free person must be able to control this aspect of her life like any other. If you can be trusted to have the mental acuity to make the decision that your plug should be pulled when you’re miserable later and can’t say that you’re miserable, why shouldn’t you at least be able to state that you think you’re miserable now?

However, the assisting person carries a tremendous responsibility to make sure that no one else is unfairly affected. It seems predator-like to seek people out to do this; I’m having trouble taking their good intentions seriously if they get a kick out of it one way or the other. If nothing else, the risk of collateral damage is too high.

Do you believe in spanking your children?

No.

Violence breeds violence. Teaching your children in any way that violence is a persuasive or legitimate way to reason is irresponsible.

Would you burn an American flag for a million dollars?

Yes. Or maybe not; a million dollars isn’t as much as it once was. American or Canadian?

I kid. Some of the fundamental values espoused by any civil nation, I wouldn’t waste for money. But a piece of cloth; no problem. See also.

Who do you think would make a better president?

Barack Obama.

Are you afraid others will judge you from reading some of your answers?

I am certain that others will judge me. I am certain that some will disagree and some will agree. I am also certain that some people will behave as if I said “if you don’t believe all of this in this order, I’ll have Chuck Norris kick your teeth in”. I’d never do that. I’d tell Chuck Norris to hold his foot up and your teeth would flee on their own.

Moreover, I advise that the iPhone software platform must be opened.

Podcast@Delphi.org Episode 8 Live

2008-10-07T11:06:17+00:00

I can't believe it's already been two weeks again, but the next episode of the delphi.org roundtable podcast is up. Get it here at or on iTunes.

In addition to whats becoming "the regular gang" of myself, Roland Beenhakker and Jolyon Smith, we had Anders Ohlsson of CodeGear/Embarcadero join us, and we've chatted about a lot of interesting things, including – if i remember correctly – version control, exception handling, the MVC pattern in VCL and Cocoa and a cool new language idea for Delphi proposed by Jolyon.

I also hope my sound is a bit better this time – but there's just not much i can do about the 3.5 meter ceiling height in my apartment ;)

Again, make sure to let us know what you think, in comments here, on Delphi.org or as feedback on iTunes.

Enjoy,
marc

dynamic

2008-10-06T21:46:13+00:00

It’s been kicking around for a while, but the first C# 4.0 keyword has been confirmed: dynamic. (In the slides to Anders Hejlsberg’s “Where Are Programming Languages Going?” keynote at JAOO.)

The code sample presented is this:

dynamic calc = GetCalculator(); 
int sum = calc.Add(10, 20);

The slide presents calc as being “statically typed to be dynamic”, the second row’s assignment as being a “dynamic conversion [to int]” and involving a “dynamic method invocation”. I can step to most of that. The parts that worry me are:

The var keyword and anonymous types worked perfectly with the existing type systems — the types exist and they are reproducibly the same at compile-time unless you change the initial assignment, you just can’t name them. Dynamism, on the other hand… What does dynamic calc; var type = typeof(calc); return?
Can you make methods that pass dynamic parameters? Can you make a generic class with dynamic parameters? (If not, are you just supposed to stuff these into ArrayLists or List<object>s.)
Consider a dynamic method that returns an array of two objects, both of distinct types. Chain the method call to an extension method on IEnumerable<T> that returns either the first or last object randomly — what type is a variable that calls this method? If you were to call this again, would the variable type change?
Can you write code that calls plain old CLR objects using dynamic? — crippling the code of everything that’s useful and efficient, sure, but avoiding a rift in the type system.

The big question is eventually “is this a compile-time alias (like var) or something that delivers a deeper change (invokedynamic-like) to the CLR?” My guess is that the usage suggests a generated interface. For the code sample above, there might be something like — and at any rate this might be what the IntelliSense store needs to remember:

interface <>_GeneratedDynamicInterface { int Add(int a, int b); }

(The int parameter types are simply because integer literals are 32-bit integers if they don’t exceed the range or carry suffixes like ‘u’ or ‘L’.)

Meanwhile, other parts of the slides suggests that it’s just going to wind up as the same thing rewritten in reflection calls (to things like InvokeMethod, only resolved a lot more resolutely thanks to the information the compiler can deduce in the same way that it finds the correct overloads for, uh, non-dynamic method invocation).

I have absolutely no idea how it’s going to work, though. It’s going to be very interesting to find out.

Moreover, I advise that the iPhone software platform must be opened.

CocoaHeads München

2008-10-06T17:49:04+00:00

Ich habe gerade erfahren, dass eine CocoaHeads-Gruppe in München in der Planung ist. Treffen sind jeden zweiten Donnerstag im Monat also ist diesen Donnerstag das erste Treffen. Da gehe ich doch glatt mal hin. Würde mich freuen, die von Euch Mac-Programmierern, die auch im Raum München sind, dort zu treffen!

SseCGSConvertXXXX8888TransposePermute crash

2008-10-06T12:50:27+00:00

When getting a CGImage via [myNSBitmapImageRep CGImage] to feed a CALayer, Core Animation may crash as detailed here : Changing CALayer's contents too rapidly causes CoreAnimation to implode. The given solution is to keep myNSBitmapImageRep around, retaining it.

Another workaround is to render the bitmap now : after creating your layer and setting its contents , use [CATransaction commit] and CA will draw it right away. CA will then display everything correctly, and you can forget about myNSBitmapImageRep.

Obama ‘08 talk @ CocoaHeads Portland on Wednesday 8th October

2008-10-06T12:45:15+00:00

Raven Zachary and myself are going to be at the Wednesday Oct. 8 meeting of Portland Cocoaheads discussing the Obama ‘08 application and its development.

TouchMap

2008-10-06T00:31:23+00:00

I was going to make a more in-depth posting about TouchMap, but then something kind of big happened. The code is however in the TouchCode google code repository. So have at it. (You’ll probably want to check out all of TouchCode, TouchMap currently depends on other code within the repository).

Brick

2008-10-05T21:56:26+00:00

Please, let the “Brick” rumor be the one where they cut strong endurable laptop enclosures out of hunks of /alumini?um/ with water jets. Not only is it unspeakably cool, it would reduce the need for infrastructure like screws holding the thing together, which means it’d be slimmer and more solid.

Moreover, I advise that the iPhone software platform must be opened.

Looking for iPhone Software Professionals?

2008-10-04T21:38:10+00:00

The problem:

I make my living by writing iPhone and Mac OS X for hire. I’ve been doing this for a while with some level of success. But ever since the iPhone SDK was announced earlier this year I’ve been getting many, many more work enquiries than I could possibly handle. I’ve often referred enquiries to friends who I have either worked with in the past or whose work I respect. But this ad-hoc system doesn’t scale very well.

The Solution:

To try and make this informal referral approach work I’ve set up a private invite only Google Group called “iPhone Software Professionals”. Currently this group is made up of a handful (more than 10 less than 1000) software developers who specialise in iPhone development (although I’d say all are equally capable on Mac OS X). The group is made up of either people I have worked with personally (and would love to work with again) or people whose work has generated such a reputation that I would have no problem recommending them to a potential client.

The list is currently made up of software developers but I would like to open it open it up to any independent professional involved in the production of iPhone software. This includes, but is not limited to usability experts, graphic designers, quality assurance experts and so on.

The group will probably remain quite small, with new members invited and referred only by current members. There is no commission or finder’s fee involved, the group is just an informal group of professionals forwarding work that would otherwise be rejected.

Looking for an iPhone Software Professional?

So if you have some iPhone software that needs to be written then I think I might be able to find someone to help you out. I might be able to help you myself, but if I have more work than I can handle (which currently is very likely) I’ll forward your request to the group. Either way contact me directly at iphoneswpro@toxicsoftware.com and I’ll try make sure your software gets written.

Announcement: Marcus will be a Panelist at O’Reilly’s iPhoneLive conference

2008-10-04T16:34:50+00:00

Now that the NDA has been lifted we can all finally come out of the closet :)

If you have not heard, O’Reilly is hosting a conference on November 18, 2008 to discuss all things iPhone. I have been invited to attend the conference as a Panelist.

Please come and join the conference, if nothing else, to heckle me :)

iPhone Live

The list of speakers (as opposed to panelists), is quite impressive and definitely worth the trip.

Speakers

Sliding UITextFields around to avoid the keyboard

2008-10-04T17:26:30+00:00

It's an iPhone post because I finally can. Here's a good way to slide your view around when editing UITextFields so that they never get trapped under the onscreen keyboard.

I'll be giving a talk at the Brisbane Cocoaheads meeting this Monday evening (Oct 6). Come along and heckle.

Hidden text fields

The iPhone's onscreen keyboard occupies the bottom 216 pixels on screen (140 in landscape mode). That's around half the screen, so if you ever have a text field you want to edit in the bottom half of the screen, it needs to move or it will get covered.

You can just animate the whole window upwards by the height of the keyboard when editing a text field in the bottom half but this doesn't work well for text fields in the middle (they can get moved too far up).

Instead, I'm going to show you a method which divides the window as follows:

Everything in the top section will stay still when edited. Everything in the middle section will animate upwards by a fraction of the keyboard's height (proportional to the field's height within the middle section). Everything in the bottom section will animate upwards by the keyboard's full height.

Implementing the delegate methods

All of the methods shown here should go into a view controller probably the "main" view controller for the current screen (i.e. the visibleViewController of the current UINavigationController, your RootViewController or other top-level view controller).

You will need to make this view controller the delegate (in Interface Builder) for every UITextField you want to animate.

Your view controller will need the following instance variable:

CGFloat animatedDistance;

The following constants should also be declared somewhere (likely the top of the view controller's implementation file):

static const CGFloat KEYBOARD_ANIMATION_DURATION = 0.3;
static const CGFloat MINIMUM_SCROLL_FRACTION = 0.2;
static const CGFloat MAXIMUM_SCROLL_FRACTION = 0.8;
static const CGFloat PORTRAIT_KEYBOARD_HEIGHT = 216;
static const CGFloat LANDSCAPE_KEYBOARD_HEIGHT = 140;

Animate upwards when the text field is selected

Get the rects of the text field being edited and the view that we're going to scroll. We convert everything to window coordinates, since they're not necessarily in the same coordinate space.

- (void)textFieldDidBeginEditing:(UITextField *)textField
{
    CGRect textFieldRect =
        [self.view.window convertRect:textField.bounds fromView:textField];
    CGRect viewRect =
        [self.view.window convertRect:self.view.bounds fromView:self.view];

So now we have the bounds, we need to calculate the fraction between the top and bottom of the middle section for the text field's midline:

    CGFloat midline = textFieldRect.origin.y + 0.5 * textFieldRect.size.height;
    CGFloat numerator =
        midline - viewRect.origin.y
            - MINIMUM_SCROLL_FRACTION * viewRect.size.height;
    CGFloat denominator =
        (MAXIMUM_SCROLL_FRACTION - MINIMUM_SCROLL_FRACTION)
            * viewRect.size.height;
    CGFloat heightFraction = numerator / denominator;

Clamp this fraction so that the top section is all "0.0" and the bottom section is all "1.0".

    if (heightFraction  0.0)
    {
        heightFraction = 0.0;
    }
    else if (heightFraction > 1.0)
    {
        heightFraction = 1.0;
    }

Now take this fraction and convert it into an amount to scroll by multiplying by the keyboard height for the current screen orientation. Notice the calls to floor so that we only scroll by whole pixel amounts.

    UIInterfaceOrientation orientation =
        [[UIApplication sharedApplication] statusBarOrientation];
    if (orientation == UIInterfaceOrientationPortrait ||
        orientation == UIInterfaceOrientationPortraitUpsideDown)
    {
        animatedDistance = floor(PORTRAIT_KEYBOARD_HEIGHT * heightFraction);
    }
    else
    {
        animatedDistance = floor(LANDSCAPE_KEYBOARD_HEIGHT * heightFraction);
    }

Finally, apply the animation. Note the use of setAnimationBeginsFromCurrentState: — this will allow a smooth transition to new text field if the user taps on another.

    CGRect viewFrame = self.view.frame;
    viewFrame.origin.y -= animatedDistance;
    
    [UIView beginAnimations:nil context:NULL];
    [UIView setAnimationBeginsFromCurrentState:YES];
    [UIView setAnimationDuration:KEYBOARD_ANIMATION_DURATION];
    
    [self.view setFrame:viewFrame];
    
    [UIView commitAnimations];
}

Animate back again

The return animation is far simpler since we've saved the amount to animate.

- (void)textFieldDidEndEditing:(UITextField *)textField
{
    CGRect viewFrame = self.view.frame;
    viewFrame.origin.y += animatedDistance;
    
    [UIView beginAnimations:nil context:NULL];
    [UIView setAnimationBeginsFromCurrentState:YES];
    [UIView setAnimationDuration:KEYBOARD_ANIMATION_DURATION];
    
    [self.view setFrame:viewFrame];
    
    [UIView commitAnimations];
}

Since we're writing the delegate methods...

This next method has nothing to do with animation but since we're writing the delegate methods for a UITextField, this is essential. It dismisses the keyboard when the return/done button is pressed.

- (BOOL)textFieldShouldReturn:(UITextField *)textField
{
    [textField resignFirstResponder];
    return YES;
}

Result

For a window that looks like this:

Editing text fields in the top, middle and bottom sections will look like the following:

Notice in particular how the middle section remains in the middle of the visible area after the keyboard appears. This is the primary benefit of the presented approach.

Acorn free for registered DrawIt 3 users

2008-10-03T18:32:20+00:00

Pieter Omvlee: Compensating for Bitmap: Acorn for registered DrawIt users

'''Those of you who read my previous post will know that I removed the bitmap editing from DrawIt Pro. It’s fairly uncommon to remove features, especially if they are this important, but DrawIt’s bitmap editing has never been that good.
...
When I decided to remove it, I knew I had to compensate the current users and I think I succeeded here and I’m sure you’ll agree. Some time ago I contacted Flying Meat’s Gus Mueller with a shy attempt at maybe getting a discount for Acorn for current DrawIt users. To my joy he even proposed to give away a free licenses of Acorn to all registered DrawIt users.'''

Helpful

2008-10-03T18:20:04+00:00

Omni Group releases their Python Help Book builder scripts. Takes OmniOutliner files and emits an Apple Help Book, apparently. Awesome. Huge. It’s a great move.

(And I don’t know if my recent posts had anything to do with tipping the scale, but I assume not; they were about code documentation, not help generation. )

The Future of TV

2008-10-03T11:32:33+00:00

Is this the future of TV? An endless stream of Twitter chatter overlaying everything everyone says?

Obama 08

2008-10-03T04:54:41+00:00

Well, the project I was so excited about last week has now officially seen the light of day and is on the iPhone AppStore. The project is the Official iPhone application for the Obama/Biden ‘08 campaign (Direct link to AppStore!).

The application was created in less than three weeks by an all volunteer team of ten developers, artists, web designers, quality assurance specialists and project managers. You can see the name of everyone who worked on it in the credits of the application itself.

I started work on the application the day after C4[2] after some very clandestine meetings in Chicago. After about a week of writing TouchRSS code on my own, the project suddenly jumped into high gear, with the indomitable Mike Lee, Tristan O’Tierney and incredibly talented Louie Mantia (responsible for the application’s amazing and distinctive look).

I feel really honoured to have worked with such a great team (see Raven Zachary’s blog posting for links to everyone). The project was a sprint and of course suffered from a lot of ups and downs. But I think we managed to create a really great application in a very short space of time.

Here are some blog postings from the other team members

Official Links:

Alpha 6

2008-10-02T19:38:00+00:00

You can now download F-Script 2.0 alpha 6. It contains the latest developments, including:

Better error detection and reporting when defining new classes
Support in the runtime for subclassing F-Script classes in Objective-C
A literal syntax for hexadecimal numbers (finally!). Standard Smalltalk syntax; e.g., 16rFF5A.
Support for using the ~~ message with nil as a receiver
Various internal improvements

In addition, there will be a couple of language adjustments in F-Script 2.0, and this alpha contains one of them, as described below.

In F-Script 1.x, equality and inequality operators (i.e., = and ~=) are provided for all objects. They are implemented in a category of NSObject, and rely on the standard Cocoa isEqual: method to determine equality.

This is convenient but leads to a small amount of added conceptual complexity in a few situations related to array programming. Since life is better when even the slightest unneeded complexity is taken away, F-Script 2.0 changes this (remember that F-Script integrates array programming and Cocoa together and we want to do it with zero impedance mismatch). In F-Script 2.0, = and ~= are no longer provided at the NSObject level. The standard generic method for testing objects equality in Cocoa is isEqual:, and you can use it with F-Script too.

Of course, just removing = and ~= and be done with it would horribly break compatibility between F-Script 2.x and code written for F-Script 1.x. In addition, we would really miss these nice operators…

Well, don’t panic. While these operators are no longer provided by default for all objects, they are implemented for a number of objects, such as NSString, NSNumber, NSDate, NSValue, FSBoolean… This covers the vast majority of current and desirable usage and you can also implement them for your own classes if that make sense.

In addition, F-Script 2.x comes with the magic needed to maintain backward compatibility with existing code in the few remaining cases where your F-Script 1.x code might send = or ~= messages to objects that relied on the default implementation provided by the NSObject category in F-Script 1.x. In such cases, all will work as usual and F-Script will log a warning suggesting you change your code to use isEqual:.

If you want to, you can turn off this magic backward compatibility system by using the MaintainFScript1EqualityOperatorsSemantics user default, on an per application basis. For instance, to turn it off for the F-Script application, type the following in the Mac OS X terminal:


defaults write org.fscript.fscriptapp MaintainFScript1EqualityOperatorsSemantics NO

To reactivate it, type:


defaults write org.fscript.fscriptapp MaintainFScript1EqualityOperatorsSemantics YES

Nokia 5800

2008-10-02T19:04:25+00:00

They get it.

Buzzword Bingo

2008-10-02T17:32:46+00:00

Microsoft is running a feature week on Channel 9 in honor of Visual Studio Team System 2010.

I live in Visual Studio at work. I should be excited at at least something. I’m not.

Update: This is a bit more like it.

Logbook for Backpack Journal

2008-10-02T16:37:05+00:00

Just a quick note that Logbook by Transmissions has been released today. It’s a client for the Backpack Journal from 37signals (part of Backpack), and lets you manage your tasks and status right from your Mac OS X menubar.

Instinctive Code (my OS X/iPhone development persona) is pleased to have been part of the development team for Logbook, providing custom UI work amongst other things.

If you’re a Backpack user, be sure to check it out - and keep an eye out for future releases from SignalApps to integrate with your favorite other 37signals web apps.

Clarification: please contact Transmissions themselves (support at transmissionapps.com) with any enquiries or comments regarding Logbook - I’m not actually part of the company. :)

MGTwitterEngine works on iPhone

2008-10-02T16:29:02+00:00

Now that the iPhone SDK is to be lifted, this is just a brief official announcement that MGTwitterEngine works on both OS X and on iPhone - as has quietly been the case for quite some time.

Previously, in order to ensure that MGTwitterEngine did not violate the NDA, iPhone developers needed to change a few constants to valid iPhone SDK values in order to make the code compile for that platform, but this is now thankfully no longer necessary. The ReadMe file included with the source now makes explicit reference to the iPhone, and restores Craig Hockenberry’s original notes on linking to libxml on each platform.

I’m sure you’d all discovered all this for yourselves already, but it’s nice to no longer have to obfuscate the code or avoid mentioning a significant benefit - that of being dual-platform. I have some other iPhone code I plan to release soon too, once I get a chance to clean it up a bit, so stay tuned.

I’ve Been Macbroken

2008-10-02T16:19:16+00:00

I was honored this week to be invited as a guest host on the excellent MacBreak Weekly podcast.

MacBreak Weekly 108: Pull My iTunes

I listen to the show regularly so it was a bit strange to record with the guys I’m normally listening to passively. Every so often I had to remind myself that I could actually open my mouth and add something to the conversation!

A particularly well-timed (or poorly-timed, depending how you look at it) topic was that of the iPhone developer NDA, which we discussed a bit, carefully tip-toeing around any actual violation of the NDA, which was still in effect when we recorded, but was lifted a day later.

Developer Austin Meyer of X-Plane fame was also on the show, and one of the points we disagreed upon was whether or not it is productive for people outside Apple to present dissenting opinions or otherwise make a fuss about the inner workings of the company.

Austin tended to believe that we should trust Apple to work its magic in secrecy and with autonomy. I believe those of us on the outside can offer a unique perspective which Apple is itself sometimes blind to. A number of positive changes have happened in the past few years only after the public collectively agreed that Apple was taking the wrong course. It’s possible that Apple’s decision-making process has always been completely independent of outside influences, but I prefer to believe that they value the collective wisdom of their customer base, and are at least taking it into consideration as they develop their products and services.

I really appreciate Leo Laporte’s letting me take part in the show this week. If you haven’t given MacBreak Weekly a try before, this would be a great week to start!

Implementing countByEnumeratingWithState:objects:count:

2008-10-02T16:02:22+00:00

If you want to use fast enumeration on your own classes, you must implement countByEnumeratingWithState:objects:count:. Unfortunately, it's a confusing method. Here are two sample implementations that show the steps needed to implement this method in most cases.

Some sample NSFastEnumeration implementations

You need to implement NSFastEnumeration if you want to use your own classes in the Objective-C 2.0 "for...in" fast-enumeration language feature.

The documentation for its only method (countByEnumeratingWithState:objects:count:) is pretty cryptic and overwhelming — mostly because the method needs to be flexible and Apple don't want to tell you how to write your code. I have no such qualms and since there aren't many examples on the Internets at the moment I thought I'd show you some easy approaches for implementing it in your own programs.

There are two different ways to enumerate. The first is where your class already has, or is willing to create, a C array of Objective-C id values which point to the objects being enumerated. The second is where you don't have this storage and want to use storage passed to you.

Warning: These examples do not use the mutationsPtr and are therefore only safe for use with immutable collections. If the enumerated collection is mutable, you will need to point mutationsPtr to an appropriate mutation guard value (normally a mutations count value).

First case: already have a C array of storage

Our class looks like this:

@interface SimpleStringArray : NSObject <NSFastEnumeration>
{
    NSString *stringArray[ARRAY_LENGTH];
}

In this case, the implementation of countByEnumeratingWithState:objects:count: would look like this:

- (NSUInteger)countByEnumeratingWithState:(NSFastEnumerationState *)state objects:(id *)stackbuf count:(NSUInteger)len
{
    if (state->state >= ARRAY_LENGTH)
    {
        return 0;
    }

    state->itemsPtr = stringArray;
    state->state = ARRAY_LENGTH;
    state->mutationsPtr = (unsigned long *)self;
    
    return ARRAY_LENGTH;
}

Quick explanation:

we've ignored stackbuf and count (because we already have storage)
as required, we've set state->state to a non zero value (the iteration index after the current items are iterated)
as required, we've set state->mutationsPtr to a non zero value (the self pointer since we have no "array has changed" flag that we can point it to)
we've returned the complete length of the array, so it will all be iterated in one pass (on the second pass, state->state will equal ARRAY_LENGTH and we'll return "0", ending the loop)

Second case: need storage

If our class' data is a collection of NSString objects stored in a list of linearly connected C structs, then we might have no C array value to return.

Assume our list is declared like this:

typedef struct
{
    NSString * stringPtr;
    struct MyList * nextNode;
} MyList;

and our class is declared like this:

@interface StringList : NSObject <NSFastEnumeration>
{
    MyList * _startOfListNode;
    MyList * _endOfListPlusOneNode;
}

This is more complicated example because we need to actually gather the data from the list and store our traversal state between iterations. Here is how it might look:

- (NSUInteger)countByEnumeratingWithState:(NSFastEnumerationState *)state objects:(id *)stackbuf count:(NSUInteger)len
{
    MyList *currentNode;
    if (state->state == 0)
    {
        // Set the starting point. _startOfListNode is assumed to be our
        // object's instance variable that points to the start of the list.
        currentNode = _startOfListNode;
    }
    else
    {
        // Subsequent iterations, get the current progress out of state->state
        currentNode = (struct MyList *)state->state;
    }
    
    // Accumulate nodes from the list until we reach the object's
    // _endOfListPlusOneNode
    NSUInteger batchCount = 0;
    while (currentNode != _endOfListPlusOneNode && batchCount  len)
    {
        stackbuf[batchCount] = currentNode->stringPtr;
        currentNode = currentNode->nextNode;
        batchCount++;
    }

    state->state = (unsigned long)currentNode;
    state->itemsPtr = stackbuf;
    state->mutationsPtr = (unsigned long *)self;

    return batchCount;
}

Explanation of this example:

We now use stackbuf to store the data accumulated from the list and we return it in state->itemsPtr.
len is used now because it is the maximum number of objects we can accumulate in stackbuf each time.
When executed the first time (when state->state == 0), we set the currentNode to our object's private _startOfListNode — that we assume we have correctly set to the start of our list.
Every other time we are run, state->state will hold our currentNode, saved from the last iteration.
The fast enumeration will repeatedly invoke this method until we reach a currentNode == _endOfListPlusOneNode at the end of the list — remember that state->state is not allowed to be nil, which is why we use this non-nil end marker node. If you use a list that ends in nil, then you should detect this and set state->state to a special non-nil "end" flag so that you won't get trapped in an infinite loop.

PSIG 118: Thu Oct 2 2008

2008-10-02T05:02:42+00:00

When:

Thursday, October 2nd, 2008 @ 7pm

Where:

Hotel Indigo (pic, directions from the Arlington Park Metra station).

Schedule:

Show & Tell
We'll start out the meeting by going around the table and talking about what we're currently working on or learning about. Handouts are welcome, or bring along your Mac and we'll hook it up to the projector.

Book Reports
Bring along the book you're currently reading, or one of your old favorites. Hopefully the book would have some relevance to programming, but we're fairly open-minded. Just give us an overview the book's topic, and what you liked (or disliked) about it.

Topics
Celebrating the death of the iPhone NDA, Tom Swift will present "iPhone Development: Zero to Sixty". Tom will walk us through all the steps of creating a new app, including the tricky parts of actually getting it loaded on your iPhone/iPod Touch. Brace yourself, it's a bumpy ride.

Dinner
If you want pizza, bring along three dollars and we'll all chip in.

Looking for Presenters:

I'm always on the look-out for folks to want to give a talk for a meeting. The talk doesn't need to be long (10 minutes is fine if your topic is small or you just want to tease the group) and you don't need to be an expert (just tell us why you think your topic is cool or your experiences). Toss me an email and I'll assign you a chunk of time.

Apple removes the NDA!!

2008-10-01T21:37:27+00:00

Apple has just lifted the NDA for released software, so we can now publicly talk about it. Over the last few weeks, I've been writing the iPhone client for byNotes, so I have a good amount of things to write about. Expect some iPhone entries soon ;).

TouchMap Teaser

2008-10-01T20:58:20+00:00

A quick teaser for TouchMap. I’m hoping to release this on TouchCode later today.

TouchMap.mov

Apple Lifts iPhone Developer NDA

2008-10-01T16:50:16+00:00

Apple made the right choice today, in choosing to publicly lift the non-disclosure agreement which has, for the past several months, prevented iPhone developers from discussing specifics of the platform and development process.

I’m sure most of you have already heard the news, it’s being shouted from the rooftops on venues such as Twitter, but I wanted to make my own announcement, as I think many developers should do.

Why? Because as much as we cry and whine in the face of Apple’s misguided actions and policies, we should be prepared to turn around and laud them when they do the right thing. Today, Apple deserves to be lavished with praise from all corners of the iPhone developer world.

You go, Apple.

Apple’s statement, reproduced here in entirety because the page has a temporary look to it:

To Our Developers

We have decided to drop the non-disclosure agreement (NDA) for released iPhone software.

We put the NDA in place because the iPhone OS includes many Apple inventions and innovations that we would like to protect, so that others don’t steal our work. It has happened before. While we have filed for hundreds of patents on iPhone technology, the NDA added yet another level of protection. We put it in place as one more way to help protect the iPhone from being ripped off by others.

However, the NDA has created too much of a burden on developers, authors and others interested in helping further the iPhone’s success, so we are dropping it for released software. Developers will receive a new agreement without an NDA covering released software within a week or so. Please note that unreleased software and features will remain under NDA until they are released.

Thanks to everyone who provided us constructive feedback on this matter.

No longer any need to ask forgiveness, now that we’ve got permission to productively discuss the development process. Thanks again, Apple!

The NDA is dead! long live the ... err...

2008-10-01T16:32:13+00:00

The iPhone NDA has been taken down . Or rather, will be in a bit. At least for released stuff, which approaches normalcy. Thanks, Apple! We love you again. Well, except for that review process, but this is better than nothing.

iPhone NDA to be lifted

2008-10-01T15:44:40+00:00

Apple has today updated its iPhone Developer Program portal with a message indicating that the NDA (non-disclosure agreement) for the iPhone SDK is to be “dropped for released iPhone software” (which presumably means versions of the iPhone SDK which correspond to publicly released versions of the iPhone firmware - at time of writing, this would be the iPhone SDK for firmwares 2.0 and 2.1). I’ve archived the text of the message here.

This change is to take place within a week or so of the date of this post (Wednesday 1st October 2008), when developers will receive an updated agreement with the new terms. This new state of affairs should allow public discussion of iPhone SDK APIs, the publication of books on iPhone development, iPhone SDK development training courses, open source code releases, and more. Unreleased (beta) versions of future iPhone firmwares will remain under NDA until they are released, as is the case with beta version of Mac OS X.

Surely another strong indication that, as I previously asserted, Apple is listening to our concerns.

NDA Day

2008-10-01T15:35:56+00:00

http://developer.apple.com/iphone/program/

Thank you Apple.

Cocoa Touch Tutorial: iPhone Application Example

2008-10-01T15:34:34+00:00

Similar to one of my first blog posts on building a basic application for Mac OS X using xcode 3.0, I am going to explain for beginning iPhone/iPod Touch developers how to build the most basic Cocoa Touch application using Interface Builder and an application delegate in xcode 3.1. This tutorial post is really to provide a quick how-to. I won’t go into any depth explaining why things are done the way they are done, but this should help you get up and running with your first application pretty quickly so that you too can clog the App Store with useless superfluous apps (kidding… just kidding).

If you are a visual learner, it may be helpful to you to instead watch a video presentation of this tutorial. I’ve posted it on the site, but you’ll have to click the link to see my Cocoa Touch Video Tutorial.

Understanding Cocoa programming is much simpler if you learn MVC, Model, View, Controller. You can probably step through code examples and figure some things out without learning MVC, but I wouldn’t recommend it. Go Google it and read up on it.

I will say as an introduction to MVC for those who are not familiar that it should probably be called (Model --> Controller --> View) or (View --> Controller --> Model) as the controller always sits between the other two. Your controller is either telling your model to update its data or it is telling the view to update its display. That’s the crux of the whole paradigm. The details run much deeper, but that’s how I will nutshell it for you.

Create Your Application

Let’s get started. Create a Cocoa Application using the following steps:

Select File > New Project…, under the iPhone OS templates choose Window-Based Application in the ensuing dialog. Click Choose…

Enter ‘Basic iPhone App’ as the project name. Click Save

You should see a project workspace like the following:

The next thing you should do is create a class to act as your controller or delegate.

Delegate == Controller

The words delegate and controller can be used synonymously. You’ll see later that we delegate the work of the different controls we create in Interface Builder to a delegate or controller class. In the iPhone template projects, this application delegate is created for you. Our app delegate has been named Basic_iPhone_AppAppDelegate.

In our app delegate class we need to add what Cocoa developers refer to as outlets and actions. I could spend an entire post explaining these two things in depth, but for the sake of brevity and walking you through the steps to build your first application, the definition will have to suffice.

Outlets represent controls in your user interface that can have some action performed upon them. Action are functions in your code that are connected to controls in your user interface such as a button or a drop down list. When connected to a button for instance, the action code will be run when the user clicks the button.

In xcode, open your app delegate header file Basic_iPhone_AppAppDelegate.h. Add an outlet for the text field and the label below the window outlet as in the following snippet:

@interface Basic_iPhone_AppAppDelegate : NSObject <UIApplicationDelegate> {
    IBOutlet UIWindow *window;
    IBOutlet UITextField *textField;
    IBOutlet UILabel *label;
}

You will also want to add an action that will be performed when our button is clicked. Add that below the property for our window:

@interface Basic_iPhone_AppAppDelegate : NSObject <UIApplicationDelegate> {
    IBOutlet UIWindow *window;
    IBOutlet UITextField *textField;
    IBOutlet UILabel *label;
}
 
@property (nonatomic, retain) UIWindow *window;
 
- (IBAction)click:(id)sender;

Now switch over to the implementation file, Basic_iPhone_AppAppDelegate.m. Add the click: action below our applicationDidFinishLaunching: function:

- (void)applicationDidFinishLaunching:(UIApplication *)application {	
 
    // Override point for customization after app launch	
    [window makeKeyAndVisible];
}
 
- (IBAction)click:(id)sender;
{
 
}

We will actually add some code to do something in the click: action handler, but first we need to hook it up to the user interface in Interface Builder.

Interface Builder And Controller/Delegate Implementation

Now that you’ve specified the outlets–a UITextField and a UILabel and an action called click:, you will see these items available for connecting to the UI in Interface builder. Let’s open Interface Builder and make the connections we need using the following steps:

In your xcode workspace, expand the folder in the tree view called Resources and double click the file called ‘MainMenu.xib’.

Note:: A .xib is a .nib that uses XML for the internal data structure.

This will open the xib file in Interface Builder
Once Interface Builder loads, you will notice that there is an object representation of our app delegate in the MainWindow.xib window. This is the object you will use to create connections for your actions and outlets.

Design The User Interface

Now you simply need to add the controls to the main window in Interface Builder and then we can connect the action and outlet accordingly. To finish the interface, complete the following steps:

Drag a TextField, a Label, and a Button to the main window so that the user interface looks like the screenshot below:
Control-Click and drag from the Button to your app delegate object in the ‘MainWindow.xib’ window.

A pop-up will display. Select click:
Control-Click the app delegate object and drag it to the text field in the main window.

A pop-up will display. Select textField
Control-Click the app delegate object and drag it to the label in the main window.

A pop-up will display. Select label

That’s it for Interface Builder. You can quit interface builder and return to xcode. We have one more piece of code to add and then our application will be finished.

Finishing Up

When the button is clicked, it will simply grab the text from the text field and place it into the label. That’s all the application does. Here’s the code you need. Just make your implementation of the click: action in the Basic_iPhone_AppAppDelegate.m file look like this:

- (IBAction)click:(id)sender;
{
    [label setText:[textField text]];
}

Notice we are grabbing the text from the text field, and setting the text in our label with it. Now all you need to do is click “Build and Go”. When the application runs the iPhone Simulator will be started. You will see the application load. Type some text into the text field and click the Change button. You will see the label update with the text from the text field.

Conclusion

The limit with iPhone development is really just your imagination. It is an extremely fun platform to develop on and the resulting applications are very rewarding. Have fun with it and learn as much as you can. Just do me a favor and don’t clog the App Store with any more flashlight apps or tip calculators… Seriously ;-) . Until next time.

Basic iPhone Application Demo Project

Thank Goodness the F'ing iPhone NDA is being lifted

2008-10-01T13:10:30+00:00

Apple FINALLY did the right thing today and publicly recognized what pretty much all iPhone developers and the public that have been paying attention to the news have known for a long time now, that the iPhone NDA was doing much more harm than good. From their page ( http://developer.apple.com/iphone/program/ ) "To Our Developers We have decided to drop the non-disclosure agreement (NDA) for

Web Inspector Redesign

2008-10-01T00:06:36+00:00

It has been nine months since our last Web Inspector update and we have a lot of cool things to talk about. If you diligently use the Web Inspector in nightly builds, you might have seen some of these improvements, while other subtle changes might have gone unnoticed.

Some of the Web Inspector improvements were contributed by members of the WebKit community. We really want to get the whole community involved with making this the best web development tool available. Remember, most of the Web Inspector is written in HTML, JavaScript, and CSS, so it’s easy to get started making changes and improvements.

Redesigned Interface

First and foremost, the Web Inspector is now sporting a new design that organizes information into task-oriented groups — represented by icons in the toolbar. The toolbar items (Elements, Resources, Scripts, Profiles and Databases) are named after the fundamental items you will work with inside the respective panels.

Console

The Console is now accessible from any panel. Unlike the other panels, the Console is not just used for one task — it might be used while inspecting the DOM, debugging JavaScript or analyzing HTML parse errors. The Console toggle button is found in the status bar, causing it to animate in and out from the bottom of the Web Inspector. The Console can also be toggled by the Escape key.

Error and warning counts are now shown in the bottom right corner of the status bar. Clicking on these will also open the Console.

In addition to the visual changes to the Console, we have also greatly improved usability by adding auto-completion and tab-completion. As you type expressions, property names will automatically be suggested. If there are multiple properties with the same prefix, pressing the Tab key will cycle through them. Pressing the Right arrow key will accept the current suggestion. The current suggestion will also be accepted when pressing the Tab key if there is only one matched property.

Our compatibility with Firebug’s command line and window.console APIs has also been greatly improved by Keishi Hattori (服部慶士), a student at The University of Tokyo (東京大学) who tackled this area as a summer project.

Elements Panel

The Elements panel is largely the same as the previous DOM view — at least visually. Under the hood we have made number of changes and unified everything into one DOM tree.

Descend into sub-documents — expanding a frame or object element will show you the DOM tree for the document inside that element.
Automatic updates — the DOM tree will update when nodes are added to or removed from the inspected page.
Inspect clicked elements — enabling the new inspect mode lets you hover around the page to find a node to inspect. Clicking on a node in the page will focus it in the Elements panel and turn off the inspect mode. This was contributed by Matt Lilek.
Temporarily disable style properties — hovering over an editable style rule will show checkboxes that let you disable individual properties.
Style property editing — double click to edit a style property. Deleting all the text will delete the property. Typing or pasting in multiple properties will add the new properties.
Stepping for numeric style values — while editing a style property value with a number, you can use the Up or Down keys to increment or decrement the number. Holding the Alt/Option key will step by 0.1, while holding the Shift key will step by 10.
DOM attribute editing — double click to edit a DOM element attribute. Typing or pasting in multiple attributes will add the new attributes. Deleting all the text will delete the attribute.
DOM property editing — double click to edit a DOM property in the Properties pane. Deleting all the text will delete the property, if allowed.
Metrics editing — double click to edit a any of the CSS box model metrics.
Position metrics — the Metrics pane now includes position info for absolute, relative and fixed positioned elements.

Resources Panel

The Resources panel is a supercharged version of the previous Network panel. It has a similar looking timeline waterfall, but a lot has been done to make it even more useful.

Graph by size — click Size in the sidebar to quickly see the largest resources downloaded.
Multiple sorting options — there are many sorting methods available for the Time graph, including latency and duration.
Latency bars — the Time graph now shows latency in the bar with a lighter shade. This is the time between making the request and the server’s first response.
Unified resource views — clicking a resource in the sidebar will show you the data pulled from the network (not downloaded again), including the request and response headers.
View XHRs — the time and size graphs also show XMLHttpRequests. Selecting an XHR resource in the sidebar will show the XHR data and headers.

Scripts Panel

The previous standalone Drosera JavaScript debugger has been replaced with a new JavaScript debugger integrated into the Web Inspector. The new integrated JavaScript debugger is much faster than Drosera, and should be much more convenient.

From the Scripts panel you can see all the script resources that are part of the inspected page. Clicking in the line gutter of the script will set a breakpoint for that line of code. There are the standard controls to pause, resume and step through the code. While paused you will see the current call stack and in-scope variables in the right-hand sidebar.

The Web inspector has a unique feature regarding in-scope variables: it shows closures, “with” statements, and event-related scope objects separately. This gives you a clearer picture of where your variables are coming from and why things might be breaking (or even working correctly by accident).

Profiles Panel

The brand new JavaScript Profiler in the Profiles panel helps you identify where execution time is spent in your page’s JavaScript functions. The sidebar on the left lists all the recorded profiles and a tree view on the right shows the information gathered for the selected profile. Profiles that have the same name are grouped as sequential runs under a collapsible item in the sidebar.

There are two ways to view a profile: bottom up (heavy) or top down (tree). Each view has its own advantages. The heavy view allows you to understand which functions have the most performance impact and the calling paths to those functions. The tree view gives you an overall picture of the script’s calling structure, starting at the top of the call-stack.

Below the profile are a couple of data mining controls to facilitate the dissection of profile information. The focus button (Eye symbol) will filter the profile to only show the selected function and its callers. The exclude button (X symbol) will remove the selected function from the entire profile and charge its callers with the excluded function’s total time. While any of these data mining features are active, a reload button is available that will restore the profile to its original state.

WebKit’s JavaScript profiler is fully compatible with Firebug’s console.profile() and console.profileEnd() APIs, but you can also specify a title in console.profileEnd() to stop a specific profile if multiple profiles are being recorded. You can also record a profile using the Start/Stop Profiling button in the Profiles panel.

Databases Panel

The Databases panel lets you interact with HTML 5 Database storage. You can examine the contents of all of the page’s open databases and execute SQL queries against them. Each database is shown in the sidebar. Expanding a database’s disclosure triangle will show the database’s tables. Selecting a database table will show you a data grid containing all the columns and rows for that table.

Selecting a database in the sidebar will show an interactive console for evaluating SQL queries. The input in this console has auto-completion and tab-completion for common SQL words and phrases along with table names for the database.

Search

Accompanying the task-oriented reorganization, the search field in the toolbar now searches the current panel with results being highlighted in the context of the panel. Targeting the search to the current panel allows each panel to support specialized queries that are suited for the type of information being shown. The panels that support specialized queries are Elements and Profiles.

The Elements panel supports XPath and CSS selectors as queries in addition to plain text. Any search you perform will be attempted as a plain text search, a XPath query using document.evaluate() and a CSS selector using document.querySelectorAll(). All the search results will be highlighted in the DOM tree, with the first match being revealed and selected.

The Profiles panel supports plain text searches of the function names and resource URLs. Numeric searches are also supported that match rows in the profile’s Self, Total and Calls columns. To facilitate powerful numeric searching, there are a few operators and units that work to extend or limit your results. For example you can search for “> 2.5ms” to find all the functions that took longer than 2.5 milliseconds to execute. In addition to “ms”, the other supported units are: “s” for time in seconds and “%” for percentage of time. The other supported operators are “ ”, “=”, “>=” and “=”. When no units are specified the Calls column is searched.

In all the panels pressing Enter in the search field or ⌘G (Ctrl+G on Windows and Linux) will reveal the next result. Pressing ⇧⌘G (Ctrl+Shift+G on Windows and Linux) will reveal the previous result. In the Resources, Scripts and Profiles panels the search will be performed on the visible view first and will automatically jump to the first result only if the visible view has a match.

Availability and Contributing

All of these things are available now in the Mac and Windows nightly builds. Give them a try today, and let us know what you like (or don’t like).

If you would like to contribute, there are some really interesting tasks in the list of Web Inspector bugs and enhancements, and other contributors in the #webkit chat room are pretty much always available to provide help and advice.

Docudrama

2008-09-30T19:14:58+00:00

Now that we’ve established how code documentation sucks, let’s start by deducing how code documentation could be made great.

The first thing we do is we kill the idea of documenting the API inline with the code. Yes. I’m serious. I know the allure of this. But I also know how it’s holding back documentation.

Here’s what it means:

You have to make your way around bigger files when editing either code or documentation. The other content is a nuisance. Yes, in competent editors you can “fold” those blocks; not an excuse.
Plain-text formatting doesn’t play well with comments, especially multiline comments, code formatting standards, and indent depths where this plays a role.
Documentation copy editing bloats the file versioning history.
It is work to figure out which methods (every method has code; some have documentation) are documented. With creative header file use, this is less of a problem in some languages.

The second thing we do is we integrate code documentation into our IDE with editor integration but without embedding the documentation into the code. Imagine a button in the breakpoint/line number/warning gutter for creating an entry. This is a shortcut to a new documentation panel with a dedicated editor (maybe even a limited form of rich text) with capabilities to add cross references to other methods or types.

From this panel, you can arrange a bunch of topics in a hierarchy, including on which page the documentation for these types go, with a sensible default of one type per page. And of course you can create conceptual material and relate back and forward between that and code elements. (This is Wiki-like, but you control the hierarchal structure, you get things generated for you in a smart way and code elements are handled in a block-wise fashion.) Everything is stored in a plain format, and can be generated into a HTML web site, zip, maybe PDF or in a form suited for the IDE’s documentation browser. And of course, the documentation is (generation or not) shown in your IntelliSense or your Research Assistant or your generic contextual what-have-you as you browse code.

As relieving as it was, ~~whining~~venting about how the code documentation generators of today, er, yesterday worked is not going to solve anything. Presenting a clear idea of a more bearable way to document is much more like it; perhaps you’ll now see what I’m getting at.

Update Engine

2008-09-29T21:11:54+00:00

Today we announced a new open source project called Update Engine. Update Engine is a framework to help developers keep their software up-to-date. See the Google Mac blog post for a quick overview and a link to some demo movies explaining Update Engine [and yes, I knew I sounded like kermit when I recorded the video—I even told my wife but she didn't think so... oh well ;-)].

Also, we did not build Update Engine to compete with Sparkle. We built Update Engine to solve different problems. If you're interested, here's my reply about this in the Google Group for the project.

Core Intuition 8: For The Good Of The Country

2008-09-29T19:58:35+00:00

Manton and I sat down to record another episode of Core Intuition, speaking as usually on a variety of topics including the C4 conference, Android, and Apple’s “elevated user experience.”

Hope you enjoy the show!

Ceramic Notepad

2008-09-29T19:22:43+00:00

Yoyo Ceramics: "Plain Jotter" ceramic notepad.

Looks neat, not sure how well it would stay clean though. Might as well just use Acorn anyway :)

SousChef

2008-09-29T18:47:02+00:00

Congrats to Ben Lachman for releasing SousChef, "A digital cooking assistant".

'''Most cooking software stops at letting you organize your recipes. SousChef helps you cook, start to finish. Find a recipe, cook it, modify it and share it with friends & family—all in one application.'''

Revving software with Update Engine

2008-09-29T17:40:58+00:00

By Greg Miller, Software Engineer, Update Engine Team

We ship a wide variety of Mac software ranging from simple Cocoa applications that anyone can use to sophisticated ones that require admin privileges. The complicated requirements of each application, combined with the need to occasionally update more than one at a time, made for a tall order. We realized that we were not the only ones facing these issues, so in true Google fashion, we set out to build a solution that we could open-source for everyone to use.

So today, we're announcing Update Engine, a Mac OS X framework that can help developers keep their software up-to-date. Update Engine can update all the usual suspects, like Cocoa apps, preference panes, and screen savers. But it can also update oddballs like arbitrary files, and even things that require root—like kernel extensions. On top of that, it can update multiple products as easily as it can update one.

In most cases, programmers can make use of Update Engine simply by using one of the sample command-line programs called EngineRunner. However, if you need more control over the update process, you can use the Objective-C API directly and link with the provided framework.

A couple of us engineers decided to take a break from the code for a bit and try our hands at movie-making. We came up with two demos for Update Engine: The first one gives an overview of Update Engine, and the second presents an orientation of the source and shows a "Hello Engine" example. We had fun, but I think we'll keep our day jobs.

Update Engine Overview

(http://www.youtube.com/watch?v=9K_W5Af99PU)

Hello Engine

(http://www.youtube.com/watch?v=x2m_poXQYMY)