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.

I must preface this by saying that I’ve never really watched Stargate before… short of the original film (on that DVD that you had to flip over to get the second half…) and a handful of episodes of SG-1, whenever my father happened to be watching the show.  For some reason, I never got into it – it seemed very “original series” in that every planet was “pick a time-period” earth.

However, Netflix didn’t have the original Stargate movie; and the first show I found was Stargate: Atlantis.  So I figure, why not, it would be like watching some DS9 before I watched the Original Series.  And this method worked all through the first season of Atlantis.  And then I got to the end of Season 1.

Spoilers… Kinda…

So Season 1 of Atlantis (and the first episode of Season 2) come on – and up to this point it has all seemed like fairly standard SciFi.  Within the rules of the universe, as I understood them, you could travel via Stargate to other planets, and some races were technologically more advanced, some less, etc etc.  But then Earth has a space vessel (ala the Defiant) – capable of FTL travel, and I was sooooooo confused.  Not having watched SG-1 (as I said before).. I had no idea where this came from.  So I wikied it – and apparently… somewhere in the course of SG-1, Stargate stops being Stargate, and becomes a kind of space SciFi epic… complete with Star Trek-esque technology…and yea.  I stopped watching Atlantis immediately, did some research into the proper (chronological) order to watch the Stargate shows, and started at the beginning by torrenting the original movie (which by the way, the quality sucks on – someone get on uploading a better quality version ASAP) – and starting SG-1 at the beginning.

I had heard that many people said the start of SG-1 is total crap (and in fact, the show isn’t all that great until season 6+) – and I’m here to say:  I agree.  A lot of the show is useless original-series-esque drivel – but the few episodes that stand out, really do.  And thats the point of this entry – as I go through Stargate, I’ll update this entry with the episodes that are worth watching – in hopes that if I want to see them again, I’ll remember what was decent.

Worth Watching-

Stargate (the movie) – ummm. Duh.

SG-1 Season 1

01 Children of the Gods – Plot points established.  Not a great episode – but it is ep1, so you have to watch it.

06 Brief Candle – Reminds me of the “The Inner Light” episode on TNG (The Ressikan Flute episode)

09 The Torment of Tantalus – Revisits information from the original movie, and expands on the history of the stargate.

12 The Nox – Armin Shimerman!  Need I say more?  Also some cool effects, and development on the US government’s attitude towards the SG project.

13 Hathor – An entertaining episode, mostly because the concept reminisces to the original movie storyline and gives a bit more info about the Goa’uld

16 Enigma – Some good moments

17 Tin Man – Can’t miss episode, great twist, and the inspiration for writing this crap down.

18 Solitudes – Long-term plot development.  Episode sucks, just watch the last 20 minutes.

As I progress through the series, I’ll update this post (or create more).  For reference, this is the viewing order I’m using:

http://www.gateworld.net/news/2009/05/stargate-recommended-viewing-order/

I’m assuming that “30% of score” means a “maximum of 30% of the final score.”  As in, if the band gets perfect scores from all the judges in all the categories, the boost to their final score will be equal to 30% of their final score.

There is only one way to make this mathematically valid:

We need:  Final Score = Bandscore + Judges_Score

Thus each single point of a judges score should be equal to:

((Bandscore *30)/70)

——————————————————————————–

((#judges)*(#categories)*(max rating per judge per category))

So for example:

A band plays “White Wedding” and scores 1,400,200 points

Assuming we have 3 judges, and 2 categories (costume and performance) and a 10-point scale to judge each on, we plug the band’s score into the equation and figure out that each point the judge gives in each category is worth:

((1400200 *30)/70)/ 3*2*10

600085.714… / 60

= 10001.429 points.

If all 3 judges give a perfect 10 for both categories, the band racks up:  600085.714 points from the judges

Add this to the band score and you get 2000285.7143 total points.

Lets check our math.  30% of 2000285.7143 = 600 085.714 (which is exactly what the judges gave – woot! The math works!).

Whats wrong with this, though?  It hugely depends on the actual in-game score (because we just want to add a “judges score” to the “band score”)  A band with an amazing stage presence that scores very terribly on the song will get crap for points from the judges just to mathematically ensure that the score from the judges doesn’t exceed 30% of their final score.  Then again, this ensures that the band that wins will both score very highly and have a relatively decent stage presence (two bands that score close to equal (within say, 10000k) will come down to the judges scores).

Lets break it down with an extreme example, and you decide if the “correct band” wins using this method.

We will use 3 judges, 2 categories, and a 10-point scale for each category.

Our 4 bands and their scores are:

Band A – Scores 1,500,000 points but doesn’t do much for costumes and performance.  The judges give them a combined total of 20points (I guess we’re talkin’ that they just showed up in jeans and tshirts and maybe walked around a bit).  Their total score would be: 1714285.714

Band B – Scores 1,200,000 points and does some for costumes and performances The judges give them a combined total of 30 points (so, they maybe have a couple of wigs on, generic rock t-shirts, and they moved around and interacted with each other a bit).  Their total score would be:  1457142.857

Band C – Scores 900,000 points and does a fair amount of costume and performance work.  The judges give them a combined total of 45 points (costume and moving really damaged the game score a bit).  Their total would be: 1189285.714

Band D – Scores 500,000 and does a TON of costume and performance work (to the detriment of their score).  Judges give them a combined total of 57 points.  Their total would be:  703571.429

Band E – Scores  1,350,000 points (second place score overall) – but did a bunch of costume and performance work (not as much as D, but definitely more than any other band) – and the judges give them 50 points.  Their total:  1832142.857

We see that what this (really) means, is that it ends up being a score competition with bonus points for costumes/performance that really don’t effect much unless the point totals between bands are fairly close (in this case, E wins by having the 2nd highest score and the 2nd highest performance/costume total).  But that’s the way that anything is, especially when you have such a wide range in possible scores.

For reference, If a band can score over 2.5 million points odds are, they really don’t even need to bother dressing up – if they do, they can just stand there and get the score.   Want to push it towards having the performance scores effect things more? We would have to do something like cutting the in-game score (to like ¾ of the in game counts towards the final score) and still basing the costume/performance off of the uncut in game score.

A discussion came up on twitter over what method will be used to score.  Here’s my opinion on it… First, I took a look at the  rundown of the known information about the way they want to score:

• Percentage of notes hit
• Level of difficulty of song (as determined by highest score recorded on Scorehero.com)
• Longest run of notes hit

Yea.. it made no sense to me either… but then I found out this tidbit:

• Since all qualifiers will be within a full band during normal events, we’re going to take your % and weight it to how hard song is

Ahh ha!  Okay, so I asked:

So MyScore would be My% of the Top on SH? Or just higher score songs = harder than lower score (visions doesnt break top10?)

They asked for an opinion after that, so I commented:

Would prefer @cybercircuit scores using My% of Top Score w/NS tiebreaker

and linked to this post to explain why this would be the most fair given the circumstances… Heres why:

If a ranking has to be formed based on % and Note Streak alone, there needs to be some way to mathematically evaluate the differences between two performances.  Score exists for a reason, and is generally what all competitions are based on.  This makes sense.  So how would I do the math?  Take the % that the player receives, and calculate that percentage of the top score from scorehero.  Then use Note streak as a tiebreaker.  This works great if you assume that everyone will FC every song (as Note Streak would differentiate who got the squeezes under the activations, because they aren’t counted in %).

Whats the disadvantage here?  Well if you assume that all the top players will be able to 90% or higher each of the songs, the only ones worth playing are Panic Attack, Painkiller, Teen Age Riot, Ramblin’ Man, Battery, Bodhisattva, Let There Be Rock, Lazy Eye (everything else would give you a score of less than 300k even if you FC the song).  Also, this scoring completely ignores OD usage (the scores on SH are top scores with perfect paths, and often also have the under-OD squeezes also) – but that is really the price that has to be paid to take scores from BQP.

But, if we want to even out the competition a bit, there could be a wonky way of giving extra points based on Note Streak.  Still calculate the %, but then, for each note in the the players NS, add 25 points to that score.  How would this work out in practice?  Lets look at some examples (note that the difficulty of each song is increasing with each player):

Player A plays “Eye of the Tiger” and scores a 100% with a 1331NS
they score 158375+33275 = 191650

Player B plays “Shooting Star” and scores a 98% with a 50NS
they score 209279 + 1250 = 210529

Player C plays “Carry On Wayward Son” and scores a 98% with a 640NS
they score 210675 + 16000 = 226675

Player D plays “Let There Be Rock” and scores a 99% with a 2500NS
they score 378037 + 62500 = 440537

Player E plays “E-Pro” and scores 100% with a 1449NS
they score 181775 + 72450 = 254225

Player F plays “Spoonman” and scores 99% with a 500NS
they score 192233 + 12500 = 204733

Player G plays “Panic Attack” and scores 95% with a 200NS
they score 416741 + 5000 = 421741

What do we see here?  Player D wins.  Why?  Because while player E may have FC-ed a song within the same approximate difficulty range, “e-pro” has no-where near as many notes to hit.  Similarly, player G went for broke and played a rediculous song, but because he couldn’t hold a combo (despite doing very well) – he comes up short.

This system rewards players for playing at/slightly above their skill level, on complex songs that have large volumes of notes.  A player who can 98-100% any of the aforementioned top scoring songs will still probably win, but a player who can 96-97 a fairly challenging song within his skill level will still have a chance if an “elite” player doesn’t show up…

Just my thoughts… take em for what you will..

Back In Black        ACDC
Hells Bells        ACDC
You Shook Me All Night Long        ACDC
Im Eighteen        Alice Cooper
Almost Easy        Avenged Sevenfold
Sorry        Buckcherry
Stupid Girl        Cold
Believe        Disturbed
Prayer        Disturbed
Stupify        Disturbed
Down With the Sickness        Disturbed
Inside the Fire        Disturbed
Panic Attack        Dream Theater
Bad Religion        Godsmack
Voodoo        Godsmack
Vampires        Godsmack
Crawling In The Dark        Hoobastank
Coming Undone        Korn
Inja        KoRn
Kottonmouth Kings – Round & Round        Kottonmouth Kings
Break Stuff        Limp Bizkit
My Way        Limp Bizkit
Nookie        Limp Bizkit
Rollin        Limp Bizkit
One Step Closer        Linkin Park
Antichrist Superstar        Marilyn Manson
mOBSCENE        Marilyn Manson
Cruci-fiction In Space/Album Version        Marilyn Manson
This Is The New Shit        Marilyn Manson
Disposable Teens        Marilyn Manson
The Beautiful People        Marilyn Manson
The Dope Show/Album Version (Explicit)        Marilyn Manson
I Don’t Like The Drugs        Marilyn Manson
Bat Out of Hell/Album Version        Meat Loaf
The Monster Is Loose        Meat Loaf
In the Land of the Pig, The Butcher Is King        Meat Loaf
Battery        Metallica
Enter Sandman        Metallica
Teenagers        My Chemical Romance
Closer        Nine Inch Nails
Crazy Train        Ozzy Osbourne
Youth Of The Nation        P.O.D
Satellite        P.O.D
Walk        Pantera
Last Resort        Papa Roach
Boom        POD
Smack My Bitch Up        Prodigy
Blurry        Puddle of Mudd
She Hates Me        Puddle of Mudd
Testify        Rage Against the Machine
Give It All        Rise Against
Dragula        Rob Zombie
Bleed For Me        Saliva
Your Disease        Saliva
I Can’t Drive 55         Sammy Hagar
Remedy        Seether
Today        Smashing Pumpkins
Bullet With Butterfly Wings        Smashing Pumpkins
Spoonman        Soundgarden
Black Betty        Spiderbait
Outside        Staind
Fever Dog        Stillwater
Violent Pornography        System of a Down
Aenima        Tool
Headstrong        Trapt
11 Slither        Velvet Revolver

spoiler warning?

I recently started going back and reading books that I had read when I was in primary school… I’m not really sure why – maybe trying to recapture some of that innocence, or hoping that I would gain some kind of insight. I’m probably just bored on the hour-long subway commute. Either way – Its got me thinking…and has generated at least one realization – that while, perhaps, obvious – is important enough for me to write about

A few months ago, I started re-reading the Homecoming Saga – and Orson Scott Card book about a group of people on a colonized planet after the destruction of Earth, sent back to Earth by the planet’s god-like computer. As I read through the series – my reading pace swaying between boredom and fanboy-like jubilation – I realized that my enjoyment of Card’s work has little to do with the story; (though sci-fi has always been my niche of choice) Instead – it is the profound realizations and insight that his characters have about both their own lives, and the story they were taking a part in that draws me in. I have often dreamed that I could have even half the insight that his characters show in their weakest moments.

After Homecoming I began again on Ender’s Game. This was my introduction to Card – first viewed at school when I was young enough to be content with the escape that it provided. The plot spoke to me – genius kid sent to military space camp and becomes a hero! Of course! I loved it – and I still do. But this time, I focused on the characters – the way the world was shaped around them, and bent by their actions – the connections between characters became important – and creating my own understanding of the cast’s relationships sparked my creativity. It was a different experience – enough so that I desired to read more…

So I started Ender’s Shadow. There isn’t really much I gained from the experience – the book is an exceptional story – but it seemed distant – and almost emotionally and insightfuly simplistic compared to Ender’s Game. Bean – the character defined by his genius yet Dexter-like inability to contemplate emotion – it struck me as unreal (the very point, I think). And while I loved the story, I wanted back into a world where inner-monologue became pages upon pages of exposition. So I grabbed Speaker for the Dead

I have a chapter left in Speaker – one that I know belongs in Xenocide far more than this book – but I have already been overcome with a great sense of realization. I originally couldn’t wrap my head around Speaker – the tale was certainly compelling, and the characters were amazing – but the book itself left me…

naive…

The first time I read Speaker – I never knew what it meant to make the sacrifices that the characters made. Never understood what it meant to value a community – an ideal – higher than myself. I was never in a position to be part of much that was larger than myself – it was a glorious safety blanket. But now, I understand – even empathize with the thoughts and emotions Card’s characters expressed… its enlightening and humbling.

Perhaps all great books have this ability – to reinvigorate a childlike desire to understand the world – please your friends and family – and vanquish your demons – and the rereading marks a lightning-strike of understanding. Or maybe they’re just great books, with a great plot, and great characters. I don’t know. But I cant wait to start Xenocide… to see what memories and insights it dredges up.

Hell..it even make me want to write again

Starry Eyed Surprise – Paul Oakenfold
Everything Falls Apart – Dogs Eye View
Get Stoned – Hinder
Drowning – Dashboard Confessionals
Break Stuff - Limp Bizkit
The Fight Song – Marilyn Manson
Disposable Teens – Marilyn Manson
My Own Worst Enemy – Lit
Misery - Soul Asylum
Boom – POD
Coming Undone – Korn
One Step Closer – Linkin Park
Miserable – Lit
In the Land of the Pig, The Butcher Is King – Meat Loaf
Symphony Of Destruction – Megadeth
Disenchanted – My Chemical Romance
I Write Sins Not Tragedies – PANIC! At The Disco
Dragula – Rob Zombie
Your Disease – Saliva
What Hurts The Most – Rascal Flatts
We Be Burnin – Sean Paul
Fake – Shinedown
Black Betty – Spiderbait
Violent Pornography – System of a Down
The Bitch of Living – Spring Awakening Soundtrack
Totally Fucked - Spring Awakening Soundtrack
Life Is A Highway – Tom Cochrane
Changes – Tupac

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

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