// example 1
if (isset($_SESSION['var1'])) {
  $var1 = mysql_real_escape_string($_SESSION['var1']);
} else {
  $var1 = "";
}

// example 2
$var1 = mysql_real_escape_string(@$_SESSION['var1']);

Example 1 is much more verbose than example 2. Based on syntax alone I would always choose example 2. However, up until now I've never considered whether there are performance problems with using @. Although the notice does not interfere with the program, it is possible that it has a bad influence on performance.

Test Setup

I had to run the following tests 1-million times to even reach an order of magnitude that matters -- that alone says that this isn't a BIG issue, but let's continue. Here are the two tests I wrote, each run 1,000,000 times.

// test 1: using a condition to avoid array-out-of-bounds notice
if (isset($_SESSION['something_that_doesnt_exist']) )
  $a = $_SESSION['something_that_doesnt_exist'];

// test 2: hiding error message and acting cool.
$a = @$_SESSION['something_that_doesnt_exist'];

Results

Test 1: Total time: 0.12 seconds
Test 2: Total time: 1.04 seconds

Hiding error messages is 11 times slower than using an if-statement to avoid the error-prone code. There it is. If you have an loop that runs 99% of your application and ALL IT DOES is use @ then you may want to write that if-statement, but for the rest of us humans, we don't really bat an eye at the handful of places where 0.0000014 seconds are added to a page-load.

Still, I'm glad to know the impact!

Warning: Division by zero in /Users/garrett/.../test.php on line 32

You can regard these error messages as garbage (to be hidden at the first opportunity), or you can view them as meaningful scenarios that expose a need for code changes. The latter being the better solution, the former being one that is easily supported by just hiding all errors. Luckily, capturing these errors is not out of the question.

PHP provides a mechanism to hook into the error handler (quaintly named set_error_handler()), which can allow us to kick off an exception. We'll discuss whether this is a good idea in a moment, but for now let's consider the execution. The following will give use some basic error translation.

function translate_error_to_exception($errno, $msg, $file, $line) {
  throw new ErrorException( $msg, 0, $errno, $file, $line);
  return false;
}
set_error_handler( "translate_error_to_exception", E_ALL^E_NOTICE );

This is good, but we also need something to handle some of the more unusual errors too.

function translate_shutdown_error_to_exception() {
  $error = error_get_last();
  switch($error['type']) {
    case E_ERROR:
    case E_CORE_ERROR:
    case E_COMPILE_ERROR:
    case E_USER_ERROR:
      throw new ErrorException( $error['message'], 0, $error['type'],
                                $error['file'], $error['line']);
  }
}
register_shutdown_function( "translate_shutdown_error_to_exception");

That's it, that's ALL we need to capture all meaningful errors as exceptions. And, here's an obligatory example of what I mean!

try {
    $value = 10/0;
} catch (ErrorException $e) {
    // ...
}

Now, when do you use it? THAT's the tricky question.

I decided to do some benchmarks to see, not only what is possible, but what is ADVISABLE. I ran three tests, in two environments, with 20,000 iterations (times shown in seconds). The three tests were the following.

The two environments were: WITHOUT the above error handlers active (in case they might interact negatively with other code), and then WITH them. And the 20,000 iterations are obviously how many times I looped over the test code. (1,000 was enough to see these trends but I figured 20-times that was sufficient for a blog post. Don't tell me I never did anything for you!)

Here are the code tests

// Error-free, no-mod
for($i=0; $i<MAX; $i++) {
  $a = 10/10;
}

// Error-full, no mod
for($i=0; $i<MAX; $i++) {
  $a = 10/0;
}

// avoiding the problem code via a conditional, no mod
for($i=0; $i<MAX; $i++) {
  if (0 > 0) {
    $a = 10/0;
  }
}

// Error-free, with mod (same code as first example)
for($i=0; $i<MAX; $i++) {
  $a = 10/10;
}

// Error-full, with exceptions (THIS IS THE INTERESTING ONE!)
for($i=0; $i<MAX; $i++) {
  try {
    $a = 10/0;
  } catch (ErrorException $e) {}
}

// avoiding the problem code via a conditional, with mod
for($i=0; $i<MAX; $i++) {
  if (0 > 0) {
    $a = 10/0;
  }
}

Okay, got that out of the way. Now the results.

Error-free, no-mod: 0.0132961273193
Error-full, no-mod: 21.1321649551
Conditional, no-mod: 0.0135869979858

Error-free, with-mod: 0.0151519775391
Error-full, with-mod: 1.63587808609
Conditional, with-mod: 0.013237953186

Let's discuss the mundane first. Error-free code runs about the same with-or-without the modifications. Since these don't even interact that's not surprising. Conditional code also has the same performance -- it seems correct code is better than incorrect code! Wow, the things you learn...

Anyway, on to the buggy code. Error-full (that's the one where we were kicking out 'Divide By Zero' errors) actually took a long time (21 seconds). This is REALLY expensive because PHP feels compelled to output all of the errors to the browser (or in my case the command prompt). I actually used ob_start()/ob_end_clean() to avoid that (it was 44 seconds without). Interestingly we also see that the code using exceptions only took 1.6 seconds. From this we can determine that exceptions are cheaper than errors.

Exceptions seem to be about 20x faster than errors (in my situation, at least) but using proper avoidance is another 100x faster.

Yes, for all you nay-sayers, we *should* still avoid using exceptions when we can otherwise detect a faulty state. But if the choice is between exception or error, choose exception -- not only that, but having a consistent system for handling bugs is AMAZING!

In Mac OS X you often interact with wireless networks via the top-menu, but you also have access via command-line.

In this above view you can see the signal strength and that it only gives you 5 different values. This is good enough for a casual observation, but for other purposes we may need something better — enter the command line!

1. Scanning the network

$ export PATH=$PATH:/System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources

$ airport -s

    SSID BSSID             RSSI CHANNEL HT CC SECURITY (auth/unicast/group)
2WIRE442 3c:ea:4f:cb:a9:a9 -86  6       N  US WEP
      gb 00:25:4b:07:3f:8d -65  2       Y  US WPA2(PSK/AES/AES)

2. Viewing Current Connection Strength

$ airport -I

     agrCtlRSSI: -71
     agrExtRSSI: 0
    agrCtlNoise: -94
    agrExtNoise: 0
          state: running
        op mode: station
     lastTxRate: 104
        maxRate: 130
lastAssocStatus: 0
    802.11 auth: open
      link auth: wpa2-psk
          BSSID: 0:25:4b:7:3f:8d
           SSID: gb
            MCS: 13
        channel: 2

3. Watching the current connection strength in real-time

Updates twice a second with the details above output. I find this very useful when I'm curious about how

$ watch -n 0.5 airport -I

• The service I want to monitor has a firewall that only allows access from a single host.
• And on that host, I didn't have permission to install new software. (It's temporary anyway)
• But, I do have access to SSH & Bash.

Therefore, here is my solution!

The only dependencies that are needed are common commands like curl, watch, mail, and the script I'll show you about.

1. Download and install this timeout script

curl -L http://www.bashcookbook.com/bashinfo/source/bash-4.0/examples/scripts/timeout3 > timeout3
chmod +x ./timeout3

2. Craft your one-liner.

Actual code (You can call this in your terminal or save it to a file):

watch -n 300 \
  ./timeout3 -t 15 \
    curl -q -X GET http://url \
      || { echo "Cannot access PAGE_NAME. Waited 15 seconds on `date`" \
           | mail -s "Web Site Not Responding" \
             garrett.bluma@gmail.com; }

3. Done!

Oh, what's that? One-liners are complex and frustrating? I totally agree -- let's break it down!

watch -n 300 \

Watch is a program for monitoring command line applications output different information between calls. It calls the same command on a given interval and displays the results. This is handy for watching processes, but here we are using it solely for it's ability to kick off an application at some time interval. For a more elegant solution feel free to remove this and actually cron the thing.

  ./timeout3 -t 15 \

timeout3 is the script we downloaded earlier. Passing in -t 15 means that want the command (that is about to be defined) will be allowed to run for 15 seconds -- but once it reaches that limit, timeout3 will kill it.

    curl -q -X GET http://url \

With curl we are simply sending a GET request to a server (over HTTP). If we receive a response, we do nothing and fall back to the watch command and wait until the next iteration. However, if this request takes too long however, the process will be interrupted by timeout3 and exit with an error -- this signals our script to send an email.

      || { echo "Cannot access PAGE_NAME. Waited 15 seconds on `date`" \
           | mail -s "Web Site Not Responding" \
             garrett.bluma@gmail.com; }

If the timeout process triggers an error (which we assume means the request took more than 15 seconds), then we send an email. We do this via the mail command, which we assign some options to and pass data in via stdin. You could also read it as follows;

      || { echo "message" \
           | mail -s "title" \
             "recipient"; }

Quake 2 Source Code Review -- Fabien Sanglard

Fabien Sanglard has written an amazing review on the insight that the game company id had when developing Quake 2 -- not from the perspective of a gamer but down to the nuts and bolts of program design. It is especially interesting for me because I used to hear about many of these features when the game first came out, before I knew anything about programming.

In fact, games like Quake 2 were the stimulus that got me interested in programming in the first place. Hearing about the cryptic-but-astonishing news that John Carmack had broken some previous limit that everyone thought was the ceiling of what games could be. Actually, even the basics of matrix transformations floored me at the beginning.

Ah, those where the good days.

Mozilla Research:

Contracts.coffee is a dialect of CoffeeScript with built-in support for contracts. It is inspired by the contract system found in Racket.

Contracts let you clearly—even beautifully—express how your code behaves, and free you from writing tons of boilerplate, defensive code.

Personally, I think that this update to coffeescript is actually more significant that coffeescript itself. The ability to define invariants (static constraints on data) is something badly needed for new projects.

The likeness to Coffeescript contracts and Haskell types is significant and likely to draw a lot of comparison. Haskell folks might argue that it's still not static typed -- and they'd be right -- but I think they would be missing the bigger picture that this is a huge leap forward for usage of invariants in a (somewhat) common language.

Martin A. Schwartz:

"... it hit me. Science makes me feel stupid too. It's just that I've gotten used to it. So used to it, in fact, that I actively seek out new opportunities to feel stupid. I wouldn't know what to do without that feeling. I even think it's supposed to be this way. " 

I read this today and realized that this is the exact same conclusion that I've reached over the last couple years.

Unknowns are good, and we ought to pursue them harder than we currently do — especially in the sciences.  Yes, it's a little bewildering to be set in the midst of so much that could go wrong, but even if you uncover one grain of truth, that's something that perhaps no-one has even seen before.

 Neo4j is a high-performance graph engine with all the features of a mature and robust database.

There are a number of reasons to consider graph databases important — In this webinar Emil Eifrém gives a great presentation on the benefits that graph databases can provide for complex data.

I've been researching Graph Theory over the past couple months and Neo4j appears to have hit a sweet spot for operating on graphs.  Specifically, there are a class of problems that are exceedingly difficult to compute in a timely fashion on a relational database.

(hint: look for the PDF file or you'll miss the wealth of it — all 46 pages!)

Normally I'm cautious about performance metrics — they have a tendency to compare dissimilar technologies and often avoid important details (like standard deviations) — but with this article, by Ian Ozsvald, I am quite thrilled with the completeness of his results.

He goes through a number of different scenarios implementing an algorithm in python and the available ways to tune the code using traditional methods (numpy and pypy) and non-traditional methods (pyCUDA, cython, shedskin, and ParallelPython), all the while comparing the relative performance and difficulty of implementing the code.

I wouldn't mind seeing more articles like this!

With all the benefits that CSS transforms and animations can offer -- namely better performance & lower power consuption -- it would make sense to wrap it in an API similar to what we've seen with other javascript APIs.

The animation of transform properties can be hardware accelerated because modifying them doesn’t force a reflow of the page; 

-- Extralogical.net