This is really a question, it seems, of enabling ones brain to context-switch between procedural and event based programming with minimal effort. The reason, I feel, I am able to do this, is primarily due to playing a lot of trading card/board games growing up.

In these games, sometimes things happen in order (the steps of the turn are: untap, upkeep, draw…), or sometimes you may be able to respond and deal with situations as they come up (if they attack, I can block, if I block, combat occurs). This context-switching is easy for humans to do – go between resolving things in order to responding to events – but computers don’t have it quite as easy. Fortunately, a large subset of server-side web development problems are event-based problems and not procedural problems. Here is an example:

This is a server-side example, written with the PHP coder in mind – anyone familiar with node.js will understand the oversimplification, but it proves the point.

PHP
$result = mysql_query("SELECT * FROM table");
print_r($result);

JAVASCRIPT (in a node.js-ish way)
mysql_query("SELECT * FROM table", function(result) {
    print_r(result);
});

So what is the fundamental difference here? Unfortunately, it isn’t apparent – you have to understand what is occurring at a lower level, and it isn’t perfectly clear what the difference is within the language’s syntax.

In PHP, when you ask a database application to retrieve the result of a query

$result = mysql_query("SELECT * FROM table");


You are asking your application to sit idly until the database process returns the information. Classic, DO THIS, then DO THAT (knowing that THIS has already happened).

If you want to do a lot of computations in order, depending on the result of previous operations, this makes perfect sense. However, if you have a state that is independent of previous computation, you don’t need the inherent “security” that procedural programming provides. Surprisingly, a metric-shit-ton of modern programming has to do with shifting data from POINT A to POINT B. This is not a procedural problem; it is an event based problem.

Javascript, particularly node.js on the server, is incredibly well-suited to solve this. For years, web programmers have been writing code that (humanly) reads such:

When the user clicks "this button"
  Send a form to the server
    When the data comes back
        Tell the user the response

When the user does something else
  do something immediately

This is a series of event callbacks. It is assumed, that if the user does something else — After they have clicked “this button”, but before the result has come back from the server – the other event will still “do something immediately”. When the server responds, the implications of that response will occur – but the other even has already been handled. This is how asynchronous ajax requests work (if that wasn’t clear). To understand why this is beneficial on the server side, take a look at the following:

When I get a request for this url:  example.com/example.html
   I need to get the contents of example.html
       Once I have the file, I need to send it back to the client
When I get a request for how long this server has been running, I send back the time

Makes sense. However, in PHP (or any non event-driven environment), your application sits around doing nothing for the time it takes to get the contents of the file before it can send the contents back to the client. In event-driven server-side environments (node.js), your application can get a request for a file, and make the file system call to retrieve the file, declaring an event (function) to occur when the file system is done (usually sending back the data). However, in the time between receiving the request for the file, and sending it back, your application is free to do other things (like send how long the server has been running). You are effectively allowed to not care about the blocking calls you make until those calls return. (After the file-system has finally figured out WTF example.html actually contains).

If you need the result of a request to be dependent on the result of previous calculations made within that request, or you need to collect a lot of data from different sources to respond to a request, go ahead – write some PHP or write in any other procedural language of your choice.

However, if you are just asking the OS to serve files (a static http server), or waiting for another application to return the result of some task (A DATABASE QUERY), your program shouldn’t wait around until that other process finally gets around to finishing that task. You should be able to still “do stuff,” within your application, and handle the response from the OS/other app whenever that response come back.

Syntactically – event-driven programming is an effort in indentation. I am a visual thinker, so my coding style is as follow:

inProceduralProgramming();
if thisEventOccurs();
  thenThisEventHappens();
    $variable = anotherFunction();
if thisOtherEventOccured();
  doSomethingElse

inEventProgramming-ThisHappens(
  thenThisEventOccurs(
    whenThatEventIsDoneThisHappens(
      var = anotherFunction
ifSomethingElseHappens(
  wellThenDoThisInstead(

Simply redefining the meaning of indention provides clarity to an otherwise complex paradigm – visualize the multiple routes, and you will quickly see your code as a nested structure of event paths instead of a list of boring instructions and conditional statements. (A choose your own adventure book! instead of those damn Ikea directions.)

I guess the end point for explaining these contexts in such a verbose way is this: choose the right tool for the right job – and adjust your interpretation of syntax between differently constructed languages, because thinking visually helps communicate the structure and architecture of your code.

Event-based server-side code (node.js) is amazing for games, static web servers, and a host of other concurrent-user problems. PHP/Java/Ruby/etc are great for systems that depend on a 100% verifiable state (CRUD applications, etc). You just need to be able to determine which methodology is best applicable to the task at hand – and chose the technology that makes the actual writing of code as easy as possible.

If this example interests you, please take a look at node.js: http://www.nodejs.org

PS: I hope to do a write-up about my node+socket.io game framework in the near future. You can find it on github.com/Tidwell and see my current WIP state.

Dude is a bit stuttery..but the info is right at least

Tag your look and feel on a separate stylesheet, yo.

1. Go to Trakzor and click on profile code at the top. Copy that code into a text editor (or just into your myspace about me section) then add the following around it:

THE CODE FROM TRAKZOR GOES HERE

After, you should have something that looks like this (you will see numbers instead of XXXX in the code, and there will be a space between the ‘a’ and ‘href’):

I’m 99% sure this works in safari, firefox 1.5+, ie7, and ie6. I like the service, I just hate giving them advertising and cluttering my myspace with more ads than what myspace forces on ya…

If anyone hasn’t registered for trakzor before and you do register and want to get around the “you have to send out a bulletin” thing when you first login, then leave a comment – its a slightly more complicated method of viewing the source and modifying some variables in the URL header info, but I could lead ya through