Extelligent Cocoa

A friend of mine commented that points[pointCount++ % 4] = click qualifies for ‘obfuscated C’ (as in the obfuscated C contest), and they have a good point: the code may be very clever, but it’s also rather dense; and especially in a learning resource, not appropriate. (Others may comment on how much difference it makes to actual applications and compilation times – apparently very little.)

The next example from the same resource – David Chisnall’s “Cocoa Programming Fundamentals” contained

for (unsigned y=0 ; y<2 ; y++);

. This does not compile in my older XCode version, but at least I was able to unravel what he was doing and dissolved it into
int y;
for (y=0 ; y<2 ; y++)
which did.
(I'm assuming that he's using 'unsigned' because the counter cannot be negative in this context and there's a slightly lower memory overhead?)

The main problem I see with this is that the code seems to be immensely optimised for _this_ application, _this_ function. This is a loop for writing data in a grid: two rows, seven columns - and was hardcoded, which for an example is acceptable, but I nonetheless want to turn it into

int y;
int noOfRows = 2;
for (y=0 ; y<noOfRows ; y++)

because a hard-coded unexplained number somewhere in the middle of your sample code does not sound like a good idea to me. And sure, this is a *very* brief sample - but people like me are not unlikely to save it to a file somewhere with the note 'this works to do x' and then drag it out again because we know it works and contains no typos, and I can see that when you look at it in a year's time you might need to spent a little more effort to work out where that '2' came from and how you arrived at it, and of course you need to go and find every instance of the right '2' in your code to change - whereas if you'd just used a variable, you only need to change it once.

This strikes me as one of the principles of good programming practice, actually: if you start with a simple function and expand it later - get it working, then tweak it, or get it working, then save it somewhere accessible and reuse it across a number of projects (because why should you work out the same thing over and over again?), keeping the code expandable, using variables with speaking names instead of hard-coded values, and commenting your code whenever you do something unusual (or just to document your logic) seem to me good habits to get into, because one day I will leave the realm of doing Very Simple Things and enter that of doing simple things that interact with each other in clever ways.

I'm coming to wonder whether super-optimised code - that shaves off a fraction of a second here, a line there - doesn't turn into a disadvantage for the kind of thing I'm doing right now - because it seems less flexible, less easy to adapt.

I've got a good mind to go back to points[pointCount++ % 4] = click and pull it apart.