Many crowd based ideas somehow relate to this algorithm, but they are much more complicated than needed. The hope is that if we as humans apply our intelligence to imagine a possibly optimal result we’ll save time, also collectively. What bothers me is that ants do not need this individual intelligence to find a solution that collectively is optimal. So I’m wondering if we are not really losing time paying attention to unneeded details.

• ESP Game, Human Computation, Google Image Labeler
• Energy Transition Model
• Lucrative Algorithms, Kaggle, Innocentive
• Crowd Sourcing, Kick Starter
• Serious Game

I’ve been to both Speed Dating meetups as a tech guy. The last time I had the chance to listen to more interesting projects. That’s good.

At the last meetup, I think we were like 20 techies and 60 entrepreneurs. This is 20 x 60 x 3 minutes each = 3600 minutes of 2 people chats. Those 60 hours could be run with a parallelism of 20 at a time, so they could boil down to a 3 hours meetup at least. In reality, it lasted less than two hours, still enough to meet (theoretically) around 40 different entrepreneurs, but I only met 7 ! (it’s 10%)

This is not a complain, just a surprise. I know how difficult it is to have people come, so if this group was not successful, there wouldn’t be such an issue. However it looks like there is space for improvement.

If I went to a speed dating to find a partner to ask out (http://www.youtube.com/watch?v=pYBo5eS5pW8),
1: men and women are the same number
2: age is a big factor which is taken care of beforehand
3: before actually speaking to anyone, I can see how they look like
4: when we meet at last, we have limited time to understand if we match

In our meetups,

1: parallelism. We should be the same number for each role; if we are not, either (a) move extra people to the next meetup or (b) make them play another role.

2: age. IMO, this is the size of the idea (and maturity of the business, if any). It’s not the same to meet someone who needs a web presence to brand themselves; someone who wants to reach millions of people around the globe; someone who got an idea while having a shower; and someone who is growing the proven business they are expert in.
NOTE that we do not have to filter out members based on this factor, but we should know beforehand the size of their startup effort.

3: likability. This is mostly some details about the idea/team. Who is the leader, who are the other members, what do they do, what are they expert in, what is the idea about, is it selling a product, a service, a software, is there a website to look at, … And finally, it’s not the same to be looking for an associate or an employee.

4: matching. If we get here after knowing all of the above, it’s clear that a lot of time is already saved. This step is not for pitching ! Here we just need to say hello, get a gut feeling about the other and fix any misunderstandings.

Let’s see how a login would work in the real world. If the blog was a house, the login page would be the door and the login button the doorbell. A guest comes to the door, slides their business card below, and rings the doorbell. The gatekeeper wakes up, collects the business card, checks guest’s credentials against the list of people allowed to get in. If there is a match, the gatekeeper opens the door, otherwise goes back to sleep.

In a brute force attack, a guest is trying to get in by submitting ever changing business cards to the gatekeeper, hoping to find a match by mere chance. When such an attack takes place, the gatekeeper is doing a lot of “useless” work, and soon they’ll ask for a raise.

To prevent that, the master provides the gatekeeper with a scanner for business cards that reveals the factory (IP) that made them. Automatically, the scanner rejects any guest whose credentials are written on a business card made by the same factory of the business card of a guest whose credentials were not on the list. This is Limit Login Attempts.

It’s a nice mechanism that in general will work very well because many guests make their business cards themselves. Additionally there are so many commercial factories around that the risk of a rightful guest to be using the same factory of a gatecrasher is very small.

Limit Login Attempts has been doing quite a nice job since I installed it, but lately non desirable people have started sliding below the door business cards made by many different factories, thus reducing a bit the effectiveness of the scanner. Along time, I went through all these levels of annoyance.

1. Just ignore them.
2. Write a sarcastic post about them.
3. Tweak the scanner to block more and faster.
4. Destroy the doorbell.

Step 1 of 2 – Edit the wp-login.php file

In your WordPress blog directory there is a file called wp-login.php. It’s the file that shows the login page. At the very beginning, after the statement that reads

require( dirname(__FILE__) . '/wp-load.php' );

//noteslog.com 2012-02-06 start
$challenge = 'doit'; $answer = 'now';
if (! ('POST' != $_SERVER['REQUEST_METHOD'] || isset($_POST[$challenge]) && $answer == $_POST[$challenge]))
{
	wp_redirect('http://' . $_SERVER['HTTP_HOST']);
	exit();
}
unset( $challenge, $answer );
//noteslog.com 2012-02-06 end

What these lines do is to check if the user has submitted a login form with a given challenge/answer pair. In this example they are doit/now. If the pair is there, then the login form is processed as usual, otherwise the user is redirected to the home page.

Of course you MUST NOT use doit/now, but feel free to choose any other pair of words that you can easily remember, possibly unrelated, like spoon/pig. (sorry, now you cannot use that pair either) Use only letters a through z. (this is not a password !)

That pair is your secret. Do not tell anyone, unless you want them to be able to get through the login page.

Step 2 of 2 – Add a bookmarklet to your browser

Edit the following code such that the challenge/answer pair matches the one used in Step1. Then make a bookmarklet out of it, copy the result in a new bookmark and call it My login.

(function(){
var action = jQuery('#loginform').attr('action') || '';
if (action.search(/^(http|https):\/\/noteslog\.com\//i) == -1) return alert('No login form or not targeting your blog.');
var challenge = 'doit'; var answer = prompt(challenge, '');
jQuery('#loginform')
  .append('<input type="hidden" name="' + challenge + '" value="' + answer + '">')
  .submit();
})();

What these lines do is to add a challenge/answer pair to the login form and submit it.

When you want to login, go to the login form and enter your username and password as usual, but remember to hit the bookmarklet instead of the standard button. (If you used the standard button you’d be redirected to the home page, without logging in.)

A Login Dongle Plugin

I’ve already made a Login Dongle plugin for WordPress with all that code. I’m going to upload it this week. Stay tuned.

EDIT (2012-02-09): http://wordpress.org/extend/plugins/login-dongle/

There are many different scenarios that I didn’t take into account, but almost all of them were related to How to count expected matches of a PHP regular expression. The rest were essentially the same: I thought that the preg_match bug was affecting just the last optional match. Later I found instead that it affects really all the matches at the end, any number of them, be they optional or not. Due to this little misunderstanding I had to rewrite a big portion of the function.

/**
 * Searches $subject for a match to the regular expression given in $pattern.
 * 
 * @see http://bugs.php.net/bug.php?id=50887 This is a fix for that bug
 * 
 * @param string  $pattern 
 *        The pattern to search for, as a string.
 * @param string  $subject 
 *        The input string.
 * @param array   $matches 
 *        If matches is provided, then it is filled with the results of search. 
 *        $matches[0] will contain the text that matched the full pattern, 
 *        $matches[1] will have the text that matched the first captured parenthesized 
 *        subpattern, and so on.
 * @param boolean $flags   
 *        flags can be the following flag: PREG_OFFSET_CAPTURE
 *        If this flag is passed, for every occurring match the appendant string offset 
 *        will also be returned. Note that this changes the value of matches into an 
 *        array where every element is an array consisting of the matched string at 
 *        offset 0 and its string offset into subject at offset 1.
 * @param integer $offset
 *        Normally, the search starts from the beginning of the subject string. The 
 *        optional parameter offset can be used to specify the alternate place from 
 *        which to start the search (in bytes).
 * 
 * @return integer
 *         preg_match() returns the number of times pattern matches. That will be either 
 *         0 times (no match) or 1 time because preg_match() will stop searching after 
 *         the first match. preg_match_all() on the contrary will continue until it 
 *         reaches the end of subject. preg_match() returns FALSE if an error occurred.
 */
function ando_preg_match( $pattern, $subject, array &$matches = NULL, $flags = NULL, $offset = NULL ) 
{ 
    $result = preg_match($pattern, $subject, $matches, $flags, $offset); 
    if (! $result) 
    {
        return $result; 
    }
    $missing = $flags == PREG_OFFSET_CAPTURE ? array('', -1) : '';
    $groups_count = ando_preg_count_groups($pattern, $named_groups, $numbered_groups);
    $matches_count = count($matches);
    $missing_matches = array();
    while ($groups_count != $matches_count - 1 + count($missing_matches))
    { 
        $last_group_offset['named'] = -1;
        $named_groups_count = count($named_groups);
        if ($named_groups_count) 
        { 
            $last_named_group = $named_groups[$named_groups_count - 1];
            $last_group_offset['named'] = $last_named_group[0][1];
            $last_group_name            = $last_named_group[1][0];
        } 
        $last_group_offset['numbered'] = -1; 
        $numbered_groups_count = count($numbered_groups);
        if ($numbered_groups_count) 
        { 
            $last_numbered_group = $numbered_groups[$numbered_groups_count - 1];
            $last_group_offset['numbered'] = $last_numbered_group[0][1]; 
        } 
        $last_group_type = array_search(max($last_group_offset), $last_group_offset);
        $missing_entries = array();
        if ('named' == $last_group_type) 
        { 
            if (! isset($matches[$last_group_name]))  //takes care of dupnames
            {
                $missing_entries[$last_group_name] = $missing;
            }
            $missing_entries[] = $missing;
            array_pop($named_groups);
        }
        else //numbered
        {
            $missing_entries[] = $missing;
            array_pop($numbered_groups);
        }
        $missing_matches = array_merge($missing_entries, $missing_matches);
    }
    $matches = array_merge($matches, $missing_matches);
    return $result; 
}

For the function ando_preg_count_groups(…) see the post How to count expected matches of a PHP regular expression.

Minimal Tests

The following tests are based on $regex = '(?J:(?Mon|Fri|Sun)(?:day)?|(?Tue)(?:sday)?|(?Wed)(?:nesday)?|(?Thu)(?:rsday)?|(?Sat)(?:urday)?)'; .

Test 1a

echo "\n\nIn the next comparison we see the same result, and it really is, because
the count of expected matches equals the count of returned matches.\n";

preg_match("@$regex@", 'This matches on Saturday', $matches);
print_r($matches);

ando_preg_match("@$regex@", 'This matches on Saturday', $matches);
print_r($matches);

In the next comparison we see the same result, and it really is, because
the count of expected matches equals the count of returned matches.
Array
(
    [0] => Saturday
    [DN] => Sat
    [1] => 
    [2] => 
    [3] => 
    [4] => 
    [5] => Sat
)
Array
(
    [0] => Saturday
    [DN] => Sat
    [1] => 
    [2] => 
    [3] => 
    [4] => 
    [5] => Sat
)

Test 1b

echo "\n\nIn the next comparison we see above that the bug applies to all the matches at the end,
and below that my fix correctly returns all expected matches, including the empty ones.\n";

preg_match("@$regex@", 'This matches on Tuesday', $matches);
print_r($matches);

ando_preg_match("@$regex@", 'This matches on Tuesday', $matches);
print_r($matches);

In the next comparison we see above that the bug applies to all the matches at the end,
and below that my fix correctly returns all expected matches, including the empty ones.
Array
(
    [0] => Tuesday
    [DN] => Tue
    [1] => 
    [2] => Tue
)
Array
(
    [0] => Tuesday
    [DN] => Tue
    [1] => 
    [2] => Tue
    [3] => 
    [4] => 
    [5] => 
)

Test 1c

echo "\n\nIn the next comparison we see above the bug at its extreme,
and below that my fix works as well as in the other cases.\n";

preg_match("@$regex?@", 'This doesn\'t match on any day but still matches.', $matches);
print_r($matches);

ando_preg_match("@$regex?@", 'This doesn\'t match on any day but still matches.', $matches);
print_r($matches);

In the next comparison we see above the bug at its extreme,
and below that my fix works as well as in the other cases.
Array
(
    [0] => 
)
Array
(
    [0] => 
    [DN] => 
    [1] => 
    [2] => 
    [3] => 
    [4] => 
    [5] => 
)

The following tests are based on $regex = '(?|Saturday|Sun(day)?)';.

Test 2a

preg_match("@$regex@", 'Sun', $matches);
print_r($matches);

ando_preg_match("@$regex@", 'Sun', $matches);
print_r($matches);

Array
(
    [0] => Sun
)
Array
(
    [0] => Sun
    [1] => 
)

Test 2b

preg_match("@$regex@", 'Sunday', $matches);
print_r($matches);

ando_preg_match("@$regex@", 'Sunday', $matches);
print_r($matches);

Array
(
    [0] => Sunday
    [1] => day
)
Array
(
    [0] => Sunday
    [1] => day
)

Test 2c

preg_match("@$regex@", 'Saturday', $matches);
print_r($matches);

ando_preg_match("@$regex@", 'Saturday', $matches);
print_r($matches);

Array
(
    [0] => Saturday
)
Array
(
    [0] => Saturday
    [1] => 
)

The following tests are based on $regex = '(?|(Sat)ur(day)|Sun(day)?)';.

Test 3a

preg_match("@$regex@", 'Sun', $matches);
print_r($matches);

ando_preg_match("@$regex@", 'Sun', $matches);
print_r($matches);

Array
(
    [0] => Sun
)
Array
(
    [0] => Sun
    [1] => 
    [2] => 
)

Test 3b

preg_match("@$regex@", 'Sunday', $matches);
print_r($matches);

ando_preg_match("@$regex@", 'Sunday', $matches);
print_r($matches);

Array
(
    [0] => Sunday
    [1] => day
)
Array
(
    [0] => Sunday
    [1] => day
    [2] => 
)

Test 3c

preg_match("@$regex@", 'Saturday', $matches);
print_r($matches);

ando_preg_match("@$regex@", 'Saturday', $matches);
print_r($matches);

Array
(
    [0] => Saturday
    [1] => Sat
    [2] => day
)
Array
(
    [0] => Saturday
    [1] => Sat
    [2] => day
)

$pattern = '@(?:([^.]+)\.)*[^.]+\.[^.]+@';

Let’s test the general case with http://www.dnr.state.oh.us/ 

preg_match($pattern, parse_url('http://www.dnr.state.oh.us/', PHP_URL_HOST), $matches);
var_dump($matches);

array(2) {
  [0]=>
  string(19) "www.dnr.state.oh.us"
  [1]=>
  string(5) "state"
}

Pretty good. And now let’s test the edge case with http://google.com/ 

preg_match($pattern, parse_url('http://google.com/', PHP_URL_HOST), $matches);
var_dump($matches);

array(1) {
  [0]=>
  string(10) "google.com"
}

WTF, where is my empty submatch? Since when an optional submatch is not a submatch if it’s empty?

I googled it and found that there is already a filed bug. The chosen resolution has been won’t fix!! They say for backward compatibility, but I cannot imagine how fixing it would break anything older.

• If I expect 3 submatches from my pattern, but I get 2, then I know (for the bug) that the missing submatch is the last one and it’s an empty string. So I add it myself to the submatches array. Would a programmer do anything different to fix this bug?
• If the bug is globally fixed, it means that my old code will always get 3 submatches from that pattern. So my individual fix won’t get triggered, and having the last submatch the same value (empty string) as the one my fix would have added, I won’t have any issue, except a bit of (stale) unused code.

To cleanly fix it myself once and for all, I’ve written a wrapper ando_preg_match that has the same signature and the expected results.

EDIT: There were some bugs in my own fix to the preg_match bug. For the code, please see the new post.

In the edge case I get now

array(2) {
  [0]=>
  string(10) "google.com"
  [1]=>
  string(0) ""
}

Unfortunately the wrapper is more complex than I like, but PHP allows regular expressions with named groups and they require a lot of additional code. Anyway I’ve been able to do it all in a single function that can be easily dropped in any project.

Here is a test with a pattern with named groups, just in case you were wondering what it looks like

$pattern = '@(?:(?<subdomain>[^.]+)\.)*[^.]+\.[^.]+@';
ando_preg_match($pattern, parse_url('http://google.com/', PHP_URL_HOST), $matches);
var_dump($matches);

array(3) {
  [0]=>
  string(10) "google.com"
  ["subdomain"]=>
  string(0) ""
  [1]=>
  string(0) ""
}

Actually, this last example allows me to show that my wrapper is really returning the expected result. In fact, just by adding a last non-empty group to the previous pattern, the original and buggy preg_match will work just fine 

$pattern = '@(?:(?<subdomain>[^.]+)\.)*([^.]+\.[^.]+)@';
preg_match($pattern, parse_url('http://google.com/', PHP_URL_HOST), $matches);
var_dump($matches);

array(4) {
  [0]=>
  string(10) "google.com"
  ["subdomain"]=>
  string(0) ""
  [1]=>
  string(0) ""
  [2]=>
  string(10) "google.com"
}

Of course you’ll get the same result using the wrapper.

This WordPress defect is “caused by” MySQL 5, which only supports UTF-8 characters in the BMP. Apparently, MySQL 6 will be full UTF-8 compliant.

This morning, with the help of the UTF-8 class I recently developed, I made up a new WordPress plugin that adds full UTF-8 support to WordPress.

And this is the same sentence by Douglas Crockford, from the RFC4627 I cited in the previous post:

a string containing only the G clef character [𝄞] may be represented as “\uD834\uDD1E”

Windows users see a rectangle: it’s a Windows feature, but they should see the following thing

You should note that the G clef above (not the one in the picture ;-) appears in the HTML not as an entity but as a common UTF-8 character, entered as is in the WordPress editor. You can see it for yourself by comparing the source code of this post (1) with that of the previous one (2).

1. .

   <blockquote><p>a string containing only the G clef character [<a href="http://www.fileformat.info/info/unicode/char/1d11e/index.htm" target="_blank"><span style="font-size: 2em;">𝄞</span></a>] may be represented as “\uD834\uDD1E”</p></blockquote>

2. .

   <blockquote><p>a string containing only the G clef character [<a href="http://www.fileformat.info/info/unicode/char/1d11e/index.htm" target="_blank"><span style="font-size: 2em;">&#119070;</span></a>] may be represented as &#8220;\uD834\uDD1E&#8221;</p></blockquote>

Note that my plugin works for post and page content, title, excerpt, and also for searches, but it doesn’t cover custom fields. For this reason, I’ve just opened a ticket about this issue in the WordPress Trac: please drop by and comment :-)

What follows is the code of my Zend_Utf8 class, which I included in the plugin, after de-Zend-ifying all of it, for safe distribution in the wild.

<?php
/*
Copyright (c) 2011, Andrea Ercolino (http://noteslog.com)
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
    * Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.
    * Neither the name of the <organization> nor the
      names of its contributors may be used to endorse or promote products
      derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/



/**
 * @package    Ando_Utf8
 */
class Ando_Utf8_Exception extends Exception
{}



/**
 * Basic UTF-8 support
 * 
 * @link http://noteslog.com/
 * @link http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
 * 
 * @package    Ando_Utf8
 */
class Ando_Utf8
{
    /**
     * Escape UTF-8 characters using the given options
     * 
     * About the write.callback option
     * -- it receives 
     * -- -- the given write.arguments 
     * -- -- the unicode of the current UTF-8 character
     * -- -- the current (unescaped) UTF-8 character
     * -- it must return the current escaped UTF-8 character
     * 
     * @link http://noteslog.com/post/escaping-and-unescaping-utf-8-characters-in-php/
     * 
     * @param  string $value
     * @param  array $options
     *   'escapeControlChars'   => boolean (default: TRUE),
     *   'escapePrintableASCII' => boolean (default: FALSE),
     *   'write'                => array(
     *       'callback'  => callable (default: 'sprintf'),
     *       'arguments' => array    (default: array('\u%04x')),
     *   ),
     *   'extendedUseSurrogate' => boolean (default: true),
     * 
     * @throws Ando_Utf8_Exception If the code point of any char in $value is 
     *                             not unicode
     * @return string
     */
    public static function escape($value, array $options = array())
    {
        $options = array_merge(array(
            'escapeControlChars'   => true,
            'escapePrintableASCII' => false,
            'write'                => array(
                'callback'  => 'sprintf',
                'arguments' => array('\u%04x'),
            ),
            'extendedUseSurrogate' => true,
        ), $options);
        if (! self::isCallable($options['write']))
        {
            throw new Ando_Utf8_Exception('Expected a valid write handler (callable, array).');
        }
        if (self::validateFilters($options) && isset($options['filters']['before-write']))
        {
            $value = self::call($options['filters']['before-write'], $value);
        }
        
        $result = "";
        $length = strlen($value);
        for($i = 0; $i < $length; $i++) {
            $ord_var_c = ord($value[$i]);
            
            switch (true) {
                case ($ord_var_c < 0x20):
                    // code points 0x00000000..0x0000001F, mask 0xxxxxxx
                    $utf8Char = $value[$i];
                    $result .= $options['escapeControlChars']
                        ? self::call($options['write'], array($ord_var_c, $utf8Char))
                        : $value[$i];
                break;

                case ($ord_var_c < 0x80):
                    // code points 0x00000020..0x0000007F, mask 0xxxxxxx
                    $utf8Char = $value[$i];
                    $result .= $options['escapePrintableASCII'] 
                        ? self::call($options['write'], array($ord_var_c, $utf8Char))
                        : $value[$i];
                break;

                case (($ord_var_c & 0xE0) == 0xC0):
                    // code points 0x00000080..0x000007FF, mask 110yyyyy 10xxxxxx
                    $utf8Char = substr($value, $i, 2); $i += 1;
                    $code = self::utf8CharToCodePoint($utf8Char);
                    $result .= self::call($options['write'], array($code, $utf8Char));
                break;

                case (($ord_var_c & 0xF0) == 0xE0):
                    // code points 0x00000800..0x0000FFFF, mask 1110zzzz 10yyyyyy 10xxxxxx
                    $utf8Char = substr($value, $i, 3); $i += 2;
                    $code = self::utf8CharToCodePoint($utf8Char);
                    $result .= self::call($options['write'], array($code, $utf8Char));
                break;

                case (($ord_var_c & 0xF8) == 0xF0):
                    // code points 0x00010000..0x0010FFFF, mask 11110www 10zzzzzz 10yyyyyy 10xxxxxx
                    $utf8Char = substr($value, $i, 4); $i += 3;
                    if ($options['extendedUseSurrogate'])
                    {
                        list($upper, $lower) = self::utf8CharToSurrogatePair($utf8Char);
                        $result .= self::call($options['write'], array($upper, $utf8Char));
                        $result .= self::call($options['write'], array($lower, $utf8Char));
                    }
                    else 
                    {
                        $code = self::utf8CharToCodePoint($utf8Char);
                        $result .= self::call($options['write'], array($code, $utf8Char));
                    }
                break;

                default:
                    //no more cases in unicode, whose range is 0x00000000..0x0010FFFF
                    throw new Ando_Utf8_Exception('Expected a valid UTF-8 character.');
                break;
            }
        }

        return $result;
     }
     
    /**
     * Compute the code point of a given UTF-8 character
     *
     * If available, use the multibye string function mb_convert_encoding
     * TODO reject overlong sequences in $utf8Char
     *
     * @link http://noteslog.com/post/escaping-and-unescaping-utf-8-characters-in-php/
     * 
     * @param  string $utf8Char
     * @throws Ando_Utf8_Exception If the code point of $utf8Char is not unicode
     * @return integer
     */
    public static function utf8CharToCodePoint($utf8Char)
    {
        if (function_exists('mb_convert_encoding')) 
        {
            $utf32Char = mb_convert_encoding($utf8Char, 'UTF-32', 'UTF-8');
        } 
        else 
        {
            $bytes = array('C*');
            list(, $utf8Int) = unpack('N', str_repeat(chr(0), 4 - strlen($utf8Char)) . $utf8Char);
            switch (strlen($utf8Char)) 
            {
                case 1:
                    //Code points U+0000..U+007F
                    //mask   0xxxxxxx (7 bits)
                    //map to 00000000 00000000 00000000 0xxxxxxx
                    $bytes[] = 0;
                    $bytes[] = 0;
                    $bytes[] = 0;
                    $bytes[] = $utf8Int;
                break;
    
                case 2:
                    //Code points U+0080..U+07FF
                    //mask   110yyyyy 10xxxxxx (5 + 6 = 11 bits)
                    //map to 00000000 00000000 00000yyy yyxxxxxx
                    $bytes[] = 0;
                    $bytes[] = 0;
                    $bytes[] = $utf8Int >> 10 & 0x07;
                    $bytes[] = $utf8Int >>  2 & 0xC0 | $utf8Int       & 0x3F;
                break;
    
                case 3:
                    //Code points U+0800..U+D7FF and U+E000..U+FFFF
                    //mask   1110zzzz 10yyyyyy 10xxxxxx (4 + 6 + 6 = 16 bits)
                    //map to 00000000 00000000 zzzzyyyy yyxxxxxx
                    $bytes[] = 0;
                    $bytes[] = 0;
                    $bytes[] = $utf8Int >> 12 & 0xF0 | $utf8Int >> 10 & 0x0F;
                    $bytes[] = $utf8Int >>  2 & 0xC0 | $utf8Int       & 0x3F;
                break;
                             
                case 4:
                    //Code points U+10000..U+10FFFF
                    //mask   11110www 10zzzzzz 10yyyyyy 10xxxxxx (3 + 6 + 6 + 6 = 21 bits)
                    //map to 00000000 000wwwzz zzzzyyyy yyxxxxxx
                    $bytes[] = 0;
                    $bytes[] = $utf8Int >> 22 & 0x1C | $utf8Int >> 20 & 0x03;
                    $bytes[] = $utf8Int >> 12 & 0xF0 | $utf8Int >> 10 & 0x0F;
                    $bytes[] = $utf8Int >>  2 & 0xC0 | $utf8Int       & 0x3F;
                break;
                
                default:
                    //no more cases in unicode, whose range is 0x00000000 - 0x0010FFFF
                    throw new Ando_Utf8_Exception('Expected a valid UTF-8 character.');
                break;
            }
            $utf32Char = call_user_func_array('pack', $bytes);
        }
        list(, $result) = unpack('N', $utf32Char); //unpack returns an array with base 1
        if (0xD800 <= $result && $result <= 0xDFFF) 
        {
            //reserved for UTF-16 surrogates
            throw new Ando_Utf8_Exception('Expected a valid UTF-8 character.');
        }
        if (0xFFFE == $result || 0xFFFF == $result) 
        {
            //reserved
            throw new Ando_Utf8_Exception('Expected a valid UTF-8 character.');
        }
        
        return $result;
    }
    
    /**
     * Compute the surrogate pair of a given extended UTF-8 character
     * 
     * @link http://noteslog.com/post/escaping-and-unescaping-utf-8-characters-in-php/
     * @link http://en.wikipedia.org/wiki/UTF-16/UCS-2
     * 
     * @param  string $utf8Char
     * @throws Ando_Utf8_Exception If the code point of $utf8Char is not extended unicode
     * @return array
     */
    public static function utf8CharToSurrogatePair($utf8Char) 
    {
        $codePoint = self::utf8CharToCodePoint($utf8Char);
        if ($codePoint < 0x10000) 
        {
            throw new Ando_Utf8_Exception('Expected an extended UTF-8 character.');
        }
        $codePoint -= 0x10000;
        $upperSurrogate = 0xD800 + ($codePoint >> 10);
        $lowerSurrogate = 0xDC00 + ($codePoint & 0x03FF);
        $result = array($upperSurrogate, $lowerSurrogate);
        
        return $result;
    }
    
	/**
     * Unescape UTF-8 characters from a given escape format
     * 
     * About the read.pattern option
     * -- no delimiters and no modifiers allowed
     * -- for back references, your groups start at 3.
     * About the read.callback option
     * -- it receives 
     * -- -- the given read.arguments 
     * -- -- the current match of the pattern with all submatches
     * -- it must return the current unicode integer
     * 
     * @link http://noteslog.com/post/escaping-and-unescaping-utf-8-characters-in-php/
     * 
     * @param  string $value
     * @param  array $options
     *   'read'                 => array(
     *   	 'pattern'   => preg     (default: '\\\\u([0-9A-Fa-f]{4})'),
     *       'callback'  => callable (default: create_function('$all, $code', 'return hexdec($code);')),
     *       'arguments' => array    (deafult: array()),
     *   ),
     *   'extendedUseSurrogate' => boolean (default: TRUE),
     * 
     * @throws Ando_Utf8_Exception If the code point of any char in $value is 
     *                             not unicode
     * 
     * @return string
     */
    public static function unescape($value, array $options = array())
    {
        $options = array_merge(array(
        	'read'                 => array(
            	'pattern'   => '\\\\u([0-9A-Fa-f]{4})',
                'callback'  => create_function('$all, $code', 'return hexdec($code);'),
                'arguments' => array(),
            ),
            'extendedUseSurrogate' => true,
        ), $options);
        if (! self::isCallable($options['read']))
        {
            throw new Ando_Utf8_Exception('Expected a valid read handler (callable, array).');
        }
        $thereAreFilters = self::validateFilters($options);
        
        $result = "";
        $length = strlen($value);
        $pattern = '@([\w\W]*?)(' . $options['read']['pattern'] . ')|([\w\W]+)@';
        $offset = 0;
        while (preg_match($pattern, $value, $matches, 0, $offset))
        {
            if (! $matches[2])
            {
                //no more escape patterns
                $result .= $matches[0];
                $offset += strlen($matches[0]);
            }
            else 
            {
                //one more escape pattern
                $result .= $matches[1];
                $offset += strlen($matches[0]);
                $args = array_splice($matches, 2, count($matches) - 1);
                $unicode = self::call($options['read'], $args);//                call_user_func($options['integer'], $matches[2]);
                if ($options['extendedUseSurrogate'] && (0xD800 <= $unicode && $unicode < 0xDC00))
                {
                    $upperSurrogate = $unicode;
                    preg_match($pattern, $value, $matches, 0, $offset);
                    if (! $matches[2])
                    {
                        throw new Ando_Utf8_Exception('Expected an extended UTF-8 character.');
                    }
                    $offset += strlen($matches[0]);
                    $args = array_splice($matches, 2, count($matches) - 1);
                    $unicode = self::call($options['read'], $args);//$lowerSurrogate = call_user_func($options['integer'], $matches[2]);
                    $utf8Char = self::utf8CharFromSurrogatePair(array($upperSurrogate, $unicode));
                }
                else 
                {
                    $utf8Char = self::utf8CharFromCodePoint($unicode);
                }
                $result .= $utf8Char;
            }
        }
        if ($thereAreFilters && isset($options['filters']['after-read']))
        {
            $result = self::call($options['filters']['after-read'], $result);
        }
        
        return $result;
     }
     
    /**
     * Compute the UTF-8 character of a given code point
     *
     * If available, use the multibye string function mb_convert_encoding
     *
     * @link http://noteslog.com/post/escaping-and-unescaping-utf-8-characters-in-php/
     * 
     * @param  integer $codePoint
     * @throws Ando_Utf8_Exception if the code point is not unicode
     * @return string
     */
    public static function utf8CharFromCodePoint($codePoint)
    {
        if (0xD800 <= $codePoint && $codePoint <= 0xDFFF) 
        {
            //reserved for UTF-16 surrogates
            throw new Ando_Utf8_Exception('Expected a valid code point.');
        }
        if (0xFFFE == $codePoint || 0xFFFF == $codePoint) 
        {
            //reserved
            throw new Ando_Utf8_Exception('Expected a valid code point.');
        }
        
        if (function_exists('mb_convert_encoding')) 
        {
            $utf32Char = pack('N', $codePoint);
            $result = mb_convert_encoding($utf32Char, 'UTF-8', 'UTF-32');
        } 
        else 
        {
            $bytes = array('C*');
            switch (true)
            {
                case ($codePoint < 0x80):
                    //Code points U+0000..U+007F
                    //mask     0xxxxxxx (7 bits)
                    //map from xxxxxxx
                    $bytes[] = $codePoint;
                break;
                
                case ($codePoint < 0x800):
                    //Code points U+0080..U+07FF
                    //mask     110yyyyy 10xxxxxx (5 + 6 = 11 bits)
                    //map from yyy yyxxxxxx
                    $bytes[] = 0xC0 | $codePoint >> 6;
                    $bytes[] = 0x80 | $codePoint       & 0x3F;
                break;
                
                case ($codePoint < 0x10000):
                    //Code points U+0800..U+D7FF and U+E000..U+FFFF
                    //mask     1110zzzz 10yyyyyy 10xxxxxx (4 + 6 + 6 = 16 bits)
                    //map from zzzzyyyy yyxxxxxx
                    $bytes[] = 0xE0 | $codePoint >> 12;
                    $bytes[] = 0x80 | $codePoint >> 6  & 0x3F;
                    $bytes[] = 0x80 | $codePoint       & 0x3F;
                break;
                
                case ($codePoint < 0x110000):
                    //Code points U+10000..U+10FFFF
                    //mask     11110www 10zzzzzz 10yyyyyy 10xxxxxx (3 + 6 + 6 + 6 = 21 bits)
                    //map from wwwzz zzzzyyyy yyxxxxxx
                    $bytes[] = 0xF0 | $codePoint >> 18;
                    $bytes[] = 0x80 | $codePoint >> 12 & 0x3F;
                    $bytes[] = 0x80 | $codePoint >> 6  & 0x3F;
                    $bytes[] = 0x80 | $codePoint       & 0x3F;
                break;
                
                default:
                    throw new Ando_Utf8_Exception('Expected a valid code point.');
                break;
            }
            $result = call_user_func_array('pack', $bytes);
        }
        return $result;
    }
    
    /**
     * Compute the extended UTF-8 character of a given surrogate pair
     * 
     * @link   http://noteslog.com/post/escaping-and-unescaping-utf-8-characters-in-php/
     * @link http://en.wikipedia.org/wiki/UTF-16/UCS-2
     * 
     * @param array $surrogatePair
     * @throws Ando_Utf8_Exception If the surrogate pair is not extended unicode
     * @return string
     */
    public static function utf8CharFromSurrogatePair($surrogatePair) 
    {
        list($upperSurrogate, $lowerSurrogate) = $surrogatePair;
        if (! (0xD800 <= $upperSurrogate && $upperSurrogate < 0xDC00))
        {
            throw new Ando_Utf8_Exception('Expected an extended UTF-8 character.');
        }
        if (! (0xDC00 <= $lowerSurrogate && $lowerSurrogate < 0xE000))
        {
            throw new Ando_Utf8_Exception('Expected an extended UTF-8 character.');
        }
        $codePoint = ($upperSurrogate & 0x03FF) << 10 | ($lowerSurrogate & 0x03FF);
        $codePoint += 0x10000;
        $result = self::utf8CharFromCodePoint($codePoint);
        
        return $result;
    }
    
    /**
     * A little calling interface: validation
     * 
     * @param  array  $handler
     * @return boolean
     */
    private static function isCallable($handler)
    {
        $result = is_callable($handler['callback']) && is_array($handler['arguments']);
        return $result;
    }
    
    /**
     * A little calling interface: call
     * 
     * @param  array  $handler
     * @param  mixed  $args
     * @return mixed
     */
    private static function call($handler, $args)
    {
        $args = array_merge($handler['arguments'], is_array($args) ? $args : array($args));
        $result = call_user_func_array($handler['callback'], $args);
        return $result;
    }
    
    /**
     * Validate filters. If there are filters return true, else false
     * 
     * @param array $options
     * @throws Ando_Utf8_Exception If there are malformed filters
     * @return boolean
     */
    protected static function validateFilters($options)
    {
        if (isset($options['filters']))
        {
            if (! is_array($options['filters']))
            {
                throw new Ando_Utf8_Exception('Expected valid filters.');
            }
            foreach ($options['filters'] as $key => $value)
            {
                if (! self::isCallable($value))
                {
                    throw new Ando_Utf8_Exception("Expected a valid $key handler.");
                }
            }
            return true;
        }
        return false;
    }
    
}

Not an easy task.

The best I could do is

1. open a Finder window and press [Shift + Command + G]
2. in the text box enter the file path
3. remove the file portion
4. hit Go
5. drag and drop the file from the Finder window to the Zend Studio window

The class EventManager defines a singleton, which you access with the EventManager::getInstance() expression.

Here is the logic:

1. bind a handler to an event: EventManager::getInstance()->bind( ‘event’, ‘handler’ )
   An event can be a string or a PHP regular expression. A handler must be a PHP callable expression.
2. trigger an event: EventManager::getInstance()->trigger( ‘event’ )
   A triggered event should be  a string. That string is going to be matched against all the bound events. Whenever a match is found, all the handlers bound to the matching events will be called. All the arguments passed to trigger will be passed along to the handlers. If a handler returns a false value, all other handlers won’t be called.

class EventManager {
    
    /**
     * Singleton setup
     */
	static protected $_instance = null;
	protected function __construct() {}
	protected function __clone() {}
	static public function getInstance() {
		if (is_null( self::$_instance )) {
		    $class = __CLASS__;
			self::$_instance = new $class();
		}
		return self::$_instance;
	}
	
	
	/**
	 * Stores bindings between events and their handlers
	 *
	 * @var array
	 */
	protected $_bindings = array();
	
	
	/**
	 * Returns the id of the given $handler
	 *
	 * @param $handler a callable expression
	 * @return string
	 */
	protected function getId( $handler ) {
	    if (! is_callable( $handler )) {
	        throw new Exception('Expected a callable expression');
	    }
	    if (is_string( $handler )) {
	        $id = "function: $handler";
	    } else {
	        $container = $hadler[0];
	        $method = $handler[1];
	        if (is_string( $container )) {
	            $class = $container;
	            $id = "class: $class, method: $method";
	        } else {
	            $class = get_class( $container );
	            $object = spl_object_hash( $container );
	            $id = "class: $class, object: $object, method: $method";
	        }
	    }
	    return $id;
	}
	
	
	/**
	 * Returns TRUE if the given $expression is a regular expression in PHP
	 * TODO improve EventManager::isRegExp by allowing matching delimiters (), [], {}, <>
	 *
	 * @param $regex
	 * @return boolean
	 */
	protected function isRegExp( $expression ) {
	    if (is_string( $expression ) && preg_match( '/([^\w \\])[^\1\\\r\n]*(?:\\.[^\1\\\r\n]*)*\1/', $expression )) {
	        return true;
	    }
	    return false;
	}
	
	
	/**
	 * Binds a $handler to an $event
	 *
	 * @param string $event
	 * @param callable $handler
	 * @return EventManager
	 */
	public function bind( $event, $handler ) {
	    $id = $this->getId( $handler );
	    $this->_bindings[ $event ][ $id ] = $handler;
		return $this;
	}
	
	
	/**
	 * Unbinds a $handler from an $event
	 *
	 * @param string $event
	 * @param callable $handler
	 * @return EventManager
	 */
	public function unbind( $event, $handler = null ) {
		if (is_null( $handler )) {
			unset( $this->_bindings[ $event ] );
		} else {
		    $id = $this->getId( $handler );
    	    unset( $this->_bindings[ $event ][ $id ] );
		}
		return $this;
	}
	
	
	/**
	 * Dispatches a $triggered event to all its matching handlers
	 *
	 * @param string $triggered
	 * @return EventManager
	 */
	public function trigger( $triggered ) {
	    $result = true;
	    $args = func_get_args();
	    foreach ($this->_bindings as $event => $handlers) {
	        if ($this->isRegExp( $event )) {
    	        if (! preg_match( $event, $triggered )) {
    	            continue;
    	        }
	        } else {
	            if ($event != $triggered) {
	                continue;
	            }
	        }
    	    if (is_array( $handlers )) {
    			foreach ($handlers as $handler) {
    			    if (is_callable( $handler )) {
    			        $result = call_user_func_array( $handler, $args );
        				if (false === $result) {
        					break;
        				}
    			    }
    			}
    		}
    		if (false === $result) {
				break;
			}
	    }
		return $this;
	}
	
}

Shouldn’t it be null is null and is not an object ?