GregHeo.com

Custom Keyboards in iOS

2013-03-17T00:00:00Z

So you want to make a custom keyboard in your iOS app? Numeric, different key positions, custom button sizing – the possibilities are endless!

The tl;dr version: check out the sample code on GitHub.

High-level view

When a text field becomes the first responder, iOS will show the keyboard view on screen. If it isn’t already there, it usually slides up from the bottom.

What you want to do is replace the usual keyboard with your own custom view.

A view is a view

Your custom keyboard view is just that, a view. You can construct it using code or from a nib.

Let’s say you want to build the ultimate programmer nerd’s keyboard, something like this:

Here’s what a nib-ified version might look like:

Connecting the keyboard cables

You have your text field, and you have your custom keyboard nib. Connecting them together is easy!

NerdKeyboard *nerdKeyboard = [[NerdKeyboard alloc] initWithNibName:@"NerdKeyboard"
                                                            bundle:nil];
[self.myTextField setInputView:nerdKeyboard.view];

Easy! At this point, things will look pretty good. The keyboard appears as expected, but nothing happens when you tap the buttons. Hey, it’s a custom keyboard, remember? It’s up to you to handle that part.

In the sample project, the nib has an accompanying view controller class to handle the button press actions and update the text in the text field. Check out NerdKeyboard.m for the details.

Keyboard clicks

One more small detail: there are no keyboard click sounds! The magic method call you need looks like this:

[[UIDevice currentDevice] playInputClick];

Unfortunately, it’s not that simple. You can’t call playInputClick anywhere you please; iOS limits its use to very specific places.

Here’s what you need to do:

A view (i.e. your custom keyboard nib) needs to be of a class that implements the UIInputViewAudioFeedback protocol.
The class should implement the enableInputClicksWhenVisible method to return YES.
The class can then call [[UIDevice currentDevice] playInputClick] whenever it likes.

Have a look at NerdKeyboard.xib, NerdKeyboardView.m, and NerdKeyboardView.h for the gory details.

You can always customize the sound playback too but using playInputClick means you don’t have to worry about having an audio file or checking the system volume/mute switch.

In Closing

Of course, real programmers only need zeros…

Restoring In-app Purchases

2012-08-16T00:00:00Z

I’ve noticed a bit of chatter on the Internets about this bit in Apple’s In-App Purchase Programming Guide:

…if your application supports product types that must be restorable, you must include an interface that allows users to restore these purchases

What the heck? Where am I supposed to find room for a “Restore” button in my app, you ask? Luckily, that’s your problem; what I’ll talk about here is how to handle the implementation.

Regular In-app Purchase

Let’s go over the basics of the simplest purchase before talking about the restore procedure:

SKPayment *payment = [SKPayment paymentWithProductIdentifier:@"productId"];
[[SKPaymentQueue defaultQueue] addTransactionObserver:self];
[[SKPaymentQueue defaultQueue] addPayment:payment];

StoreKit will take over and if all is well, your transaction observer (self in this case) will receive a call to this method:

- (void)paymentQueue:(SKPaymentQueue *)queue
 updatedTransactions:(NSArray *)transactions

The transactions array will contain SKPaymentTransaction objects, each with a transactionState property. This will usually be SKPaymentTransactionStatePurchased for a successful purchase.

Anyhow, you already know all this. Let’s talk about the dreaded restore.

The Restoration

The general workflow is pretty similar. Rather than “purchase” a specific product, send the restoreCompletedTransactions message to the queue.

[[SKPaymentQueue defaultQueue] addTransactionObserver:self];
[[SKPaymentQueue defaultQueue] restoreCompletedTransactions];

Again, StoreKit will take over and call paymentQueue:updatedTransactions: for each restored purchase. These will look an awful like regular purchases except the transactionState will be SKPaymentTransactionStateRestored. The original transaction details are available in transaction.originalTransaction.

Once all the paymentQueue:updatedTransactions: calls are made, the transaction observer will receive this callback:

- (void)paymentQueueRestoreCompletedTransactionsFinished:(SKPaymentQueue *)queue

If something goes wrong (StoreKit error, invalid password, user hits “Cancel”, etc.) you’ll receive this callback instead:

- (void)paymentQueue:(SKPaymentQueue *)queue
  restoreCompletedTransactionsFailedWithError:(NSError *)error

Implementation Details

For a simple app, say with a single “unlock app” kind of in-app purchase, it would be easy to handle the various use cases:

If the app is already unlocked, we don’t even need to show the “Restore” button. Easy!
If the app hasn’t been unlocked and we receive the paymentQueue:restoreCompletedTransactionsFailedWithError: message, show an error alert to the user.
If the app hasn’t been unlocked, we receive the paymentQueueRestoreCompletedTransactionsFinished: message, and the app still isn’t unlocked, show a “Sorry, no previous purchases could be restored” kind of message.
If the app hasn’t been unlocked, we receive the paymentQueueRestoreCompletedTransactionsFinished: message, and the app is now unlocked, show a “Restore successful!” kind of message.

In Closing

Apps with more complicated IAP usage might need more complicated IAP restore procedures, but I hope this is a good start.

Share your own IAP restore success and failure stories in the comments below!

Simple iOS audio playback

2012-07-05T00:00:00Z

So you want some sound playback in your iOS app? Just something simple, like an alert sound or two…

Note: This post has been slightly tweaked to be ARC-friendly.

Audio Services

The (arguably) simplest way to play a sound is with Audio Services. You can play uncompressed audio files with a maximum of 30 seconds in caf, aif, or wav format. Only one sound can be played at a time.

Here’s the setup code to load the sound file:

// need this include file and the AudioToolbox framework
#import <AudioToolbox/AudioToolbox.h>

// also need an instance variable like so:
// SystemSoundID sound1;

NSURL *soundURL = [[NSBundle mainBundle] URLForResource:@"sample"
                                          withExtension:@"caf"];
AudioServicesCreateSystemSoundID((CFURLRef)soundURL, &sound1);

If you like, you can add a callback function for when the sound starts playing:

AudioServicesAddSystemSoundCompletion(sound1,
                                      NULL,
                                      NULL,
                                      systemAudioCallback,
                                      NULL);

AudioServicesPlaySystemSound will play a specified sound; AudioServicesPlayAlertSound will play the sound and vibrate the device, if applicable:

AudioServicesPlaySystemSound(sound1); // or...
AudioServicesPlayAlertSound(sound1);

Note that these functions will return immediately regardless of how long the sound is. You need to have set up the callback and registered it in advance. Here’s what the callback looks like:

void systemAudioCallback(SystemSoundID soundId, void *clientData)
{
    NSLog(@"System sound finished playing!");
}

Finally, the cleanup:

AudioServicesRemoveSystemSoundCompletion(sound1);    
AudioServicesDisposeSystemSoundID(sound1);

I say Audio Services is arguably simple because it exposes a C API. People who like objects and square brackets may be mystified by the toll-free bridging and Core Foundation use.

Why to use it: It’s simple!

Why not to use it: It’s too simple! And based on C/Core Foundation.

AVAudioPlayer

Next is AVAudioPlayer. AVAudioPlayer offers a friendly Objective-C layer where each sound gets its own AVAudioPlayer instance. Audio files can be a wider variety of types, such as compressed caf or mp3.

// need this include file and the AVFoundation framework
#import <AVFoundation/AVFoundation.h>

// also need an instance variable like so:
// AVAudioPlayer *avSound

NSURL *soundURL = [[NSBundle mainBundle] URLForResource:@"sample"
                                          withExtension:@"caf"];
avSound = [[AVAudioPlayer alloc] 
           initWithContentsOfURL:soundURL error:nil];

[avSound play];

// later...

if ([avSound isPlaying])
    [avSound stop];

The all-important cleanup, if you’re not using ARC:

[avSound release];

With AVAudioPlayer, you can set up multiple instances and have playback control over each sound individually. There’s also much more control over playback settings (volume, panning) and control (play, pause, seek to a point in the audio file).

AVAudioPlayer has a set of delegate methods to notify you when playback has finished or in the case of interruptions. These follow the usual delegate/protocol patterns found elsewhere in Cocoa.

You’ll also get a bit of a delay the first time you play a sound since iOS does a little lazy loading. You can send the prepareToPlay message to an AVAudioPlayer instance to speed up the eventual play call.

Why to use it: It’s a simple yet powerful object-based system.

Why not to use it: Latency.

There’s still some pretty noticeable latency when using AVAudioPlayer; it might be OK for simple sound effects but what if you want more precise and timely playback? Stay tuned for part two, featuring an introduction to OpenAL!

Blocks in Objective-C

2011-07-12T00:00:00Z

I gave a quick introductory talk about blocks in Objective-C for iOS and Mac development tonight, and I thought I would put together some of the slides and my notes here as a post.

The least you need to know

Blocks are like closures. Or function pointers. Or lambdas. They’re available starting in OS X 10.6 Snow Leopard and iOS 4.

The symbol for blocks is this: ^ That’s a reasonable ASCII approximation of the real Greek lambda (upper case Λ, lower case λ).

Here’s a really simple block, the requisite “Hello world”:

^{ NSLog(@"Hello, world!"); };

Of course, that won’t actually do anything; it’s like declaring a function and not calling it. So here’s the revised version:

void (^myBlock)() = ^{
    NSLog(@"Hello, world!");
};
myBlock();

Block declarations look very much like function pointers, if you have dealt with those in C. In our example here:

void is the return type
^ indicates it’s a block
myBlock is the name of the variable
the () means it doesn’t take any arguments; we could also write (void)
note that blocks are C statements, so the closing brace is followed by a semicolon.

Blocks for enumeration

Here’s our case study, a classic map (as in map/reduce): we have an array of a million objects. We need to iterate through the array and do some work for each array element.

We could use a for loop or NSEnumerator. In the more recent runtime, we might use fast enumeration like so:

NSArray *collection = [[NSArray alloc] ...];
for (id object in collection) {
    // do something here
}

Here’s the block way of doing it. We put the block code directly inline, although you can set up a block variable in advance if you like:

[myArray enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
    // do something
 }];

For the block function’s arguments:

obj is the value from the array
idx is the array index
*stop is used if you need to exit early; set *stop to YES to break out of the loop/iteration

Concurrency

Blocks are a natural gateway to Grand Central Dispatch (GCD) and being able to take advantage of parallelism, whether through multi-cores, multi-processors, or multi-threads. If it’s OK to iterate through the collection in parallel and out of order:

[myArray enumerateObjectsWithOptions:NSEnumerationConcurrent
  usingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
    // do something
 }];

So there’s nothing about blocks themselves that speeds up your code. What they offer is a very easy way to segment bits of hard-working code and then lean on GCD to handle the dispatching.

Foreign keys - an introduction

2011-02-22T00:00:00Z

Someone recently asked me why I had all these foreign keys defined in the database schema even though “MySQL doesn’t support foreign keys.” After I finished laughing, the statement changed to “foreign keys aren’t needed in real database design anyway.”

I laughed again. Then I cried a little. Then I revoked this person’s license to work in any technical field.

A scenario

Let’s start with the problem that is solved by foreign keys.

You have a database keeping track of employees. There’s a table listing all employees, a table with a list of skills, and another table establishing a many-to-many relationship between employees and skills. So Bob knows C++ and Java while James knows C and C++.

These are all keyed by ID of course, so Bob’s employee ID is 15 and C++ is actually skill ID 75. That means the employee skills table is filled with numbers since it relates an employee ID to a skill ID.

Now there’s a bug in the front-end interface that mangles these IDs. The system tries to insert a new record to relate employee 15 to skill 99; the problem is there is no skill 99. What happens now?

Or, someone goes right into the database and decides that Java is worthless. She deletes Java from the skills table, but what happens to all those records in the skills-to-employees table that are referencing Java?

Foreign keys are constraints

You may have already heard about unique keys, like primary keys. That means values must be unique. The constraint on the field means there can only be one record with a certain value at a time. With a unique key, the database system checks the table when a new record is inserted to enforce the rule.

A foreign key is another kind of constraint. It’s called “foreign” because it depends on some other table. In our skills and employees example, the skills-to-employees table would have a foreign key constraint linking back to the employee table and the skills table:

The result

With foreign keys in place, the system maintains data consistency. If 5 employees have Java listed as a skill, the system will not allow Java to be deleted from the skills table. If there is no skill #99 or there is no employee #101, the system will return an error if you try to insert it into the skills-to-employees table. The insert/delete/update statement is stopped right at the database level.

The code

Here’s how it looks when you’re creating a new table. Like other kinds of keys, you can specify the foreign key with the field itself (as with employee_id) or as its own declaration (as with skill_id):

CREATE TABLE employee_skills (
    employee_id INTEGER REFERENCES employees(employee_id),
    skill_id INTEGER,
    FOREIGN KEY (skill_id) REFERENCES skills(skill_id),
);

And here’s how it looks when you’re modifying an existing table:

ALTER TABLE employee_skills 
    ADD FOREIGN KEY (skill_id) REFERENCES skills(skill_id);

Schwartzian transform in PHP

2010-05-03T00:00:00Z

Ah, the Schwartzian transform. Is there some way to do this in PHP, that is “speak PHP with a Lisp”?

Use the Schwartz, Luke

Let’s say we have an array of thousands of things, numbers in this case:

$array = array();
for ($i=0; $i < 100000; $i++) {
  $array[] = $i;
}

For some reason, we want to sort this array by each array element’s MD5 hash. Here’s the naïve PHP sort:

function custom_sort($a, $b) {
  return strcmp(md5($a), md5($b));
}
usort($array, 'custom_sort');

In PHP 5.3 and above, we could use a closure. Otherwise, create_function() does almost the same thing very succinctly:

usort($array, create_function('$a,$b', 'return strcmp(md5($a), md5($b));'));

Now that I know how to benchmark PHP, I wanted some timings to compare. Here on my traveling laptop (a trusty old Powerbook G4 1.5GHz) the sort takes about 33 seconds.

Decorate-sort-undecorate

The point of the Schwartzian transform is to perform the expensive operation (the MD5 hash) just once per object. Here’s how it looks in PHP:

// decorate
array_walk($array, create_function('&$v, $k', '$v = array($v, md5($v));'));
// sort
usort($array, create_function('$a,$b', 'return strcmp($a[1], $b[1]);'));
// undecorate
array_walk($array, create_function('&$v, $k', '$v = $v[0];'));

It doesn’t look all nicely chained together as it does in Perl, but it works.

How’s the timing? 15 seconds, a more than 50% reduction!

How it works

PHP’s little-used array_walk() takes the place of Perl’s map: it performs some action on every element in an array. If you pass in an array reference (&$v rather than plain old $v) you can also edit the array elements in-place.

Have a look at the array_walk() documentation for more details.

Useful? Got a better way to do it? Share!

Benchmarking PHP

2010-04-22T00:00:00Z

I recently needed some quick code timing information so I wrapped some function calls with $current = time() and then subtracted the results. Then I tried it with microtime() instead. Then I decided to browse PEAR for some kind of benchmarking tool.

Here are some notes on what PEAR’s Benchmark has to offer.

Iterate

Benchmark_Iterate is the classic “run something n number of times” kind of benchmark. It returns the time each execution took as well as the mean.

require_once 'Benchmark/Iterate.php';

function doSomething($arg)
{  
    return $arg += 100;
}

$benchmark = new Benchmark_Iterate;
$benchmark->run(100000, 'doSomething', 100);
$results = $benchmark->get();

$results['iterations'] returns the number of iterations (100000 in this case)
$results['mean'] returns the mean iteration time
In this case, there will also be $results[1] through to $results[100000] with each individual iteration time. Note the indexes go from 1 to n, not 0 to n-1

Timer

Benchmark_Timer allows you to set markers at various points in your code. It keeps track of the time elapsed between markers as my original time() and microtime() example did.

require_once 'Benchmark/Timer.php';

$timer = new Benchmark_Timer();

$timer->setMarker('start work');
for ($i=0; $i < 100000; $i++) {
  $a = sprintf("%.2f", $i);
}
$timer->setMarker('end word');

$results = $timer->getProfiling();
$timer->display();

The display() method will print out a table with your results. Or, you can access the raw results with getProfiling().

Profiler

Benchmark_Profiler is similar to Benchmark_Timer except it’s meant to be enclosed in function and methods. You can also nest various things.

require_once 'Benchmark/Profiler.php';
$profiler = new Benchmark_Profiler();

$profiler->start();
doSomething();
doSomethingElse();

$profiler->stop();
$profiler->output();

Not as simple as that though; doSomething() and doSomethingElse() look like this:

function doSomething() {
    global $profiler;
    
    $profiler->enterSection('doSomething');
    // do lots of work
    $profiler->leaveSection('doSomething');
}

function doSomethingElse() {
    global $profiler;
    
    $profiler->enterSection('doSomethingElse');
    doSomething();
    // do even more work
    $profiler->leaveSection('doSomethingElse');
}

Note the nested call in doSomethingElse(). Benchmark_Profiler will handle this correctly and show the profile results as expected.

As with Benchmark_Timer, the output() method will print out a table with your results. You can get at the data for a particular section by passing the section name to getSectionInformations() or data for all sections with getAllSectionsInformations().

That’s it

Remember, profile before optimizing.

SQL JOINs, part 2

2010-02-19T00:00:00Z

Last time, we started our discussion of SQL joins and covered the common cases: LEFT, INNER, and RIGHT. Today, we’ll cover the lesser-used CROSS and OUTER joins.

The OUTER limits

Here’s a sample data set:

Product ID	Product name
Products
100	Pencil
101	Pen
103	Paperclips

Product ID	Product price
Prices
100	0.25
101	0.40
102	0.75

Let’s review some things from last week. The directional joins (LEFT and RIGHT) mark one table as the primary one. INNER join is like a conjunction of left and right where the record and join have to exist in both tables.

SELECT * FROM products
INNER JOIN prices ON (products.product_id=prices.product_id)

Product ID	Product name	Product ID	Product Price
100	Pencil	100	0.25
101	Pen	101	0.40

OUTER join is like saying “either LEFT or RIGHT” (a “disjunction” in tech-speak). The result set will contain data from either just the left table, just the right, or both:

SELECT * FROM products
OUTER JOIN prices ON (products.product_id=prices.product_id)

Product ID	Product name	Product ID	Product Price
100	Pencil	100	0.25
101	Pen	101	0.40
NULL	NULL	102	0.75
103	Paperclips	NULL	NULL

Notice we get a full set of four records. For products 100 and 101 we have a full set of information: ID, name, price. Product 102 looks like a RIGHT join with just a price and NULL for the name. Product 103 looks like a LEFT join with a name and no price.

CROSS Combinations

We’re back at the beginning in a way: a cross join is really the mother of all joins. Let’s look at an example:

SELECT * FROM products CROSS JOIN prices;

Product ID	Product name	Product ID	Product Price
100	Pencil	100	0.25
100	Pencil	101	0.40
100	Pencil	102	0.75
101	Pen	100	0.25
101	Pen	101	0.40
101	Pen	102	0.75
. . .

That’s just a snippet from the results. Note that every record in the left table will be joined to every record in the right table.

Why is this useful? It’s the first step to the other joins. To turn these results into an inner join, for example, we just need to match up the two product IDs and discard the rows where the IDs don’t match.

That sounds useful for the SQL engine itself, but what about useful to humans? Let’s say you have one table listing every entree available at a restaurant and another table listing all the wines. Wouldn’t it be nice to pull out a list of every entree + wine combination? Yes it would!

SELECT * FROM entrees CROSS JOIN wines;

In Closing

That concludes our discussion of SQL JOINs. Let’s hear your own JOIN tips and horror stories!

SQL JOINs, part 1

2010-02-16T00:00:00Z

SQL JOIN is right up there in the list of most useful inventions along with sliced bread, the iPhone, and the chemical toilet. Why are there so many different kinds? Left? Right? Outer? Let’s review.

The INNER track

Here’s our example data set:

Item	Owner
Equipment
iPhone	Jim
Stapler	Dwight
Calculator	Jim
Printer	Pam
Microwave	Everyone

Name	Extension
People
Jim	255
Dwight	132
Michael	329
Pam	0

That’s some pretty crappy schema design. Anyway, we want a list of equipment along with its owner and that person’s telephone extension:

SELECT * FROM equipment JOIN people ON (people.name=equipment.owner)

The result set will look something like this:

iPhone	Jim	Jim	255
Stapler	Dwight	Dwight	132
Calculator	Jim	Jim	255
Printer	Pam	Pam	0

Hey, what happened to the microwave? The SELECT picks it up since it’s in the equipment table, but there’s no matching record in the people table (there’s no person called “Everyone”).

When you say JOIN, that actually means INNER JOIN, which means “if you cannot find a matching record to join, discard it”. And there goes the microwave.

In this case, that might not be what we’re interested in. Maybe we want to know about all the equipment we have, and the owners are just nice to know.

Enter stage LEFT

LEFT JOIN is what we want in this case:

SELECT * FROM equipment LEFT JOIN people ON (people.name=equipment.owner)

Notice that our main table equipment is on the left side of the statement, and our joined table people is toward the right. A left join means “return every record available from the table on the left, even if there’s nothing to join to”. Here are the results:

iPhone	Jim	Jim	255
Stapler	Dwight	Dwight	132
Calculator	Jim	Jim	255
Printer	Pam	Pam	0
Microwave	Everyone	NULL	NULL

Much better. We get to see every piece of equipment and the fields that couldn’t be joined are filled with NULLs.

Exit stage RIGHT

A right join is essentially the same thing except everything from the table on the right is returned. That means these two queries will return the same thing (although the fields may show up in a different order):

SELECT * FROM equipment LEFT JOIN people ON (people.name=equipment.owner)

SELECT * FROM people RIGHT JOIN equipment ON (people.name=equipment.owner)

Generally though, you put the main table as the SELECT and the secondary one as the join. Right joins don’t get a lot of use and I would even argue that they’re bad form. Just stick to left joins and your future self and other code maintainers will thank you.

In closing

The default inner join is really a “left and right” or “both” join, since a record must be returned in both tables. Most JOINs in the world are either INNER or LEFT so those are the ones to know.

In part 2, we’ll look at the oddballs: OUTER and CROSS joins.

Benchmarking Perl

2009-09-14T00:00:00Z

After browsing through the Perl documentation and reading perlperf, I had a sudden urge to profile some code. I’ve been guilty on many occasions of optimizing before profiling so think of this post as a kind of restitution.

Here’s a trivial piece of code I wrote long ago:

my $height = sprintf("%d'%d\"", $inches / 12, $inches % 12);

Given an inches value of 64, this will make a feet and height string like 5’4”.

The sprintf() call is probably unnecessary and needlessly gives away my C background. I could “optimize” the line to this:

my $height = int($inches / 12) . "'" . $inches % 12 . '"';

That makes the same two calculations (one divide, one modulus) but eliminates the function call. It must be more efficient too, right?

Finally, here’s a snippet of code I found online that does the same thing in what I’m pretty certain is a horrible waste of cycles:

my $feet_dec = $inches / 12;
my @parts = split(/\./, $feet_dec);

my $feet = $parts[0];
my $fraction = int((('0.'.$parts[1])*12) + 0.5);

my $height = $feet."\'".$fraction."\"";

Wow. If that doesn’t inspire you to fire up the profiler, I don’t know what will.

Benchmark

Here’s the code to run things through the Benchmark module:

use Benchmark;

timethese(1000, {
  'sprintf' => sub 
    { for (my $i = 0; $i < 1000; $i++) { inches1($i); } },
  'calc'    => sub
    { for (my $i = 0; $i < 1000; $i++) { inches2($i); } },
  'long'    => sub
    { for (my $i = 0; $i < 1000; $i++) { inches3($i); } },
});

inches1, inches2, and inches3 contain the code snippets above. The results:

Benchmark: timing 1000 iterations of calc, long, sprintf...
      calc:  4 wallclock secs ( 3.69 usr +  0.03 sys =  3.72 CPU)
             @ 268.82/s (n=1000)
      long: 19 wallclock secs (16.89 usr +  0.13 sys = 17.02 CPU)
             @ 58.75/s (n=1000)
   sprintf:  4 wallclock secs ( 3.76 usr +  0.02 sys =  3.78 CPU)
             @ 264.55/s (n=1000)

For some reason, I thought the sprintf() call would be much more expensive than it really is. I can continue with my C coding habits after all!

What’s so horrible about the ‘long’ way of doing things? My guess is the call to split() that’s taking so much time. I sure wish there were some way to do a line-by-line analysis…

GregHeo.com

Custom Keyboards in iOS

High-level view

A view is a view

Connecting the keyboard cables

Keyboard clicks

In Closing

Restoring In-app Purchases

Regular In-app Purchase

The Restoration

Implementation Details

In Closing

Simple iOS audio playback

Audio Services

AVAudioPlayer

Next

Blocks in Objective-C

The least you need to know

Blocks for enumeration

Concurrency

Further reading

Foreign keys - an introduction

A scenario

Foreign keys are constraints

The result

The code

Further reading

Schwartzian transform in PHP

Use the Schwartz, Luke

Decorate-sort-undecorate

How it works

Benchmarking PHP

Iterate

Timer

Profiler

That’s it

SQL JOINs, part 2

The OUTER limits

CROSS Combinations

In Closing

SQL JOINs, part 1

The INNER track

Enter stage LEFT

Exit stage RIGHT

In closing

Benchmarking Perl

Benchmark