Now a few months down the road, I’ve been playing with a much simpler approach using Lighttpd. It’s not perfect for a couple reasons I will point out…but good enough for me, for now.

# default document-root
  var.baseDir = var.CWD
  server.document-root = var.baseDir + "/"
   index-file.names   = ( "index.php", "index.html", "index.htm", "default.htm" )

  # TCP port
  server.port = 8000

  # selecting modules
  server.modules = ("mod_rewrite", "mod_accesslog", "mod_fastcgi")

  #logs
  accesslog.filename = var.baseDir + "/access.log"
  server.errorlog = var.baseDir + "/error.log"

    server.dir-listing = "enable"
    mimetype.use-xattr = "enable"
    mimetype.assign = (
  ".html" => "text/html",
  ".txt" => "text/plain",
  ".jpg" => "image/jpeg",
  ".png" => "image/png",
  ".js" => "text/javascript"
  )

  static-file.exclude-extensions = ( ".php", ".pl", ".fcgi" )
  fastcgi.server = (
  ".php" =>
  (( "host" => "127.0.0.1",
     "port" => 9000,
      "bin-path" => "/usr/bin/php5-cgi"
  )))

What seems like a lifetime ago, I was the database administrator for a very heavily trafficked web SaaS site. One thing I remembered vividly was that for a poorly configured development instance of MySQL, random logging and utility files would crop up in strange places. Since I was already spending a good portion of my life at that time with MySQL, I spent some extra time to figure out that these files were showing up because my.cnf was configured with relative file paths. Taking that memory alongside my habit of relaying on document relative paths in Apache, I wondered if I could do the same for lighttpd.

Turns out you can actually. So using the above template, I can host arbitrary locations in my /home directory by simply running “lighttpd -f lighttpd.conf -D” which translates out to: Lighttp’y run using this specific configuration file ( -F lighttpd.conf ) in the current PWD and stay resident to the console -D so I can shut you down later”

Problems

Unless you change the local config file to something else, you can’t run two instances of lighttp’y concurrently. First reason is that the second instance would try to listen to the same port for http traffic. This is pretty easy to fix, just change sever.port to some other port #. The second problem is that fastcgi.server also has to have it’s own port to listen for fastcgi traffic.

Also, it might not be to obvious, but if you ran the above config on a non-firewalled, internet homed box, someone could find your development environment and possibly cause havoc.

Solutions

The first problem is a doozy that won’t have an easy fix… and its debatable whether investing time to come up with a fix.

Second problem is stupid easy by adding:

   server.bind = "127.0.0.1"

to tell your instance to home on the loopback address.

I’ve been using SVN for several years now, since late 2005 or early 2006, and its done me well since then. But a new darling has entered my life and its name is Git. I like git for some very specific reasons: It’s stupid easy to work with and as good or better then SVN for reliability. Also it helps that my preferred IDE, Komodo, recognizes and works with Git as well.
That said, I use google code for hosting my public projects and it only supports SVN and HG. So one night I read up on git and noticed that it had a plugin/support for bridging to a SVN managed repo. So began my journey.

!Note – I am using a client side credentials manager, if access to your repo requires authentication credentials you will need to supply them where appropriate.

Initialization

Bridging a new Git Repo to a new directory in SVN
Step 1:

$svn mkdir https://devdave.googlecode.com/svn/trunk/javascript/canvastag/cnvLib

Committed revision 26.

Now I’ve got a fresh/empty svn directory

   $git svn init https://devdave.googlecode.com/svn/trunk/javascript/canvastag/cnvLib
   Initialized empty Git repository in ~/dev/javascript/cnvLib/.git/

Now I’ve got a local git repo that has most of the information I need for the bridge, to verify everything is hunky dory so far:

    $git svn fetch
    #r26 = a47a908ea96bec2d737f6646c47418778ce6ad32 (git-svn)

Final steps, the graft

Some tutorials out there say you should run git svn rebase or such, but doing so has gone poorly for me with results like

$ git svn rebase
      fatal: ambiguous argument 'HEAD': unknown revision or path not in the working tree.
      Use '--' to separate paths from revisions
      log --no-color --first-parent --pretty=medium HEAD: command returned error: 128

I believe the problem relates to lining up your local Git repository with the remote SVN repository. Unfortunately I was somewhat stuck in trying to figure out how the hell to fix this problem for a long time. Fortunately Google search is the modern day version of a genie, it can grant you the information you seek, but first you have to know what to ask. Which led me to finding this blog post.

I am not doing things “exactly” like the aforementioned blog, but close enough that I can get a similar result.

$ git show-ref
2a41e85e0dc264cfdb6c04b59547a3093c02f64f refs/heads/master
a47a908ea96bec2d737f6646c47418778ce6ad32 refs/remotes/git-svn
$ git log --pretty=oneline master
2a41e85e0dc264cfdb6c04b59547a3093c02f64f Initial import, copied from ping project
$ echo "2a41e85e0dc264cfdb6c04b59547a3093c02f64f a47a908ea96bec2d737f6646c47418778ce6ad32" >> .git/info/grafts

Since I am doing things a little odd/differently, there is no “trunk” branch available. But the idea is close enough to duplicate. I’ve already made some add/commit’s to my local Git repo but there isn’t a logical way to tell git/git-svn that this local commit also belongs to my remote SVN remote. A more human friendly version of git show-ref is
available via:

$ git branch -a
* master
  remotes/git-svn

So the concatenation of the two internal reference’s into .git/info/graft helps git-svn understand that the two separate repositories belong to each other. Sometimes it’s nice when a configuration structure does what it’s called.

That said, on to the next obvious step, actually pushing changes from a local Git repo to SVN.

$ git svn dcommit
Committing to https://devdave.googlecode.com/svn/trunk/javascript/canvastag/cnvLib ...
        A       app.canvas.js
        A       app.input.js
        A       app.main.js
        A       app.mainloop.js
        A       app.shapes.js
Committed r27
        A       app.canvas.js
        A       app.mainloop.js
        A       app.input.js
        A       app.shapes.js
        A       app.main.js
r27 = ae1cd1055deffe4209ab89d1316c97336c731c39 (git-svn)
No changes between current HEAD and refs/remotes/git-svn
Resetting to the latest refs/remotes/git-svn

What’s going on here?

As I am still learning the finer points of Git, it was important to me to understand what exactly .git/info/grafts does. So turning to my favorite resource for arbitrary questions… I found an answer on Stack overflow: What are git info grafts for? And a more official answer in the Git Wiki http://git.wiki.kernel.org/index.php/GraftPoint

JS Objects

Besides the canvas tag related stuff, I was experimenting with another approach to class construction that for the moment seems to goofy to be viable.

appLib.Point = function (x, y) {
        this.x = x;
        this.y = y;
    };
 
app.w(appLib.Point, function () {
 
    this.dist = function (o) {
        var tX = Math.pow(this.x - o.x, 2);
        var tY = Math.pow(this.y - o.y, 2);
        return Math.sqrt((tX) + (tY));
    };
 
    /**
     *Bad design choice
     *@deprecated */
    this.slope = function (o) {
        return (this.y - o.y) / (this.x - o.x);
    };
});

app.w( scope, anonymous) basically makes this in context of the anonymous function == scope.prototype. Therefore making it easier to add prototypical methods to the final product. My thought was to avoid closure based creation and rely on Function.prototype.method = function to make the objects leaner/faster. I figured that Javascript engines have already been optimized to a degree to build an object from it’s prototype. From my perspective, there didn’t seem to be a noticeable difference.

Final thoughts
Ping functions as expected on Chrome but otherwise if not for my quad-core environment, I imagine it would be a rather abysmal user experience. According to top and Chrome’s built in task manager, its devouring near 100% cpu time and has a semi-stable memory leak ( drifting up and down around 1,500 KB ever 30 seconds ) when in a resting state.

This will be the third time I’ve implemented a Lunar lander simulation game; the first was in C++ using inline ASM and mode 13H as my graphics interface. Fun stuff. The second was in Java in the late 90’s and not so fun ( My last line of Java was 2000 for a reason). Now comes the third iteration, implemeneted in Javascript using the Canvas tag. Overall the experience wasn’t so bad, I was initially frustrated annoyed at the lack of a simple putPixel like mechanism, but canvasContext2d.arc or rect with a size/width of 1 pixel is a relatively good substitute.

I decided to go with a run loop pattern instead of a tickless/event driven mechanism. Sure, a tickless system is more efficient ( avoiding unecessary redraws ) but it’s also a tad more complicated and prone to error. Also, I am relying HEAVILY on JIT javascript interpreters to make the MainLoop class efficient. Normally you want to minimize as much as possible unnecessary function calls but MainLoop’s logic handler has a stack and list mechanism that it iterates over, every tick.
The list is a constant actions function, every tick the logic handler calls each element which is an anonymous function. In Lunar lander I used this to split off the status board in two, key state’s being handled by an anonymous function, while the other stats are handled by the Game logic class itself.
The stack on the other hand will be used for staggered events, one anonymous function being popped off and executed per tick. Some in-efficient idea’s for using it would be for animation effects. Push 10 actions onto the stack, each action drawing say an explosion image frame in progressing fashion.

LunarLander’s logic add’s a hook onto MainLoop’s constant action list and from there its pretty straight forward. Every tick, add a gravity value amount to the Y delta velocity, then add this to the current Y position. If Y is > then the height of the screen, then the lander has crashed/landed.

My resume shows 5 years of contract work and I’ve got half a dozen references ranging from developer peer’s to team managers and c-letter people…but from what I’ve seen none of that matters. Out of respect for all involved, I won’t be mentioning names, employer, or anything specific. Last thing I want is to kill someone’s career or tarnish a client’s reputation. That said, I’ve seen some pretty terrible “Senior” developers. What I mean by terrible has little to do with how they solve problems, but the fact that they don’t solve problems.

One recent case, I worked with a “Sr.” developer that proclaimed themselves “Team lead”, “Chief Architect”, and “Dev. manager” which was surprising because I finished three different projects on time and tested for production use in the time that this individual struggled with one project. Speaking to the CTO of the company I got to look at the person’s resume and it all made sense. They had been in the industry for 4-5 years as well, but 3 and a half of those years was as a “junior” developer in a fairly large team. Then they jumped or got booted and fell into my client’s company and became the defacto “Senior” developer because there was no one else. I think two things fed this person’s loose grip on their reality. In very large company’s, I’ve noticed that junior developers are not to be seen or heard and instead are programmers. They aren’t given opportunities to grow through mistakes and failures because that’s not what they are there for. Then the other side is that without peer review from competent peers… its easy to imagine your poop smells like roses.

Another case was a peer that got signed to the same company as me, both as contract to hire. One unique thing about this situation was that I knew NOTHING about the language or technology being used. The only saving grace is that the team leads had re-implemented a better/saner version of a framework pattern I had designed a few years ago. So of course I struggled in the first week and somewhat into the second week, but fortunately the language in use was imperative object oriented so everything eventually clicked for me. I won’t lie and say I was a super star, but I did my best to pull the line and help the team meet its goals. Meanwhile the other contract made a lot of mistakes: it’s generally a bad thing to hit on the female staff at work, if the product lead takes the time out to give you advice… its probably cause your fucking up, and lastly do not alienate your peers. Healthy dev. teams are like Survivor… if you become the weakest link and cause others to work harder to cover your ass, you will find yourself out of a job.

What I am getting at is that, in both cases it would be tough to figure out if someone can actually do the work needed for an employer. Their resume might look amazing or their credentials impeccable, but neither really mean much. The subject of vetting out good candidates has been covered over and over across the web and print…so I will keep my advice simple. If you have a small team or no team, go with established recruiting firms that will incur penalties to themselves if they recommend a dud ( generally 5-10 business days covered ) or if you do have a team, get them involved in the last stage interviews and see if this person fits in. I am sorry, I know this would seem to eliminate anyone who has text anxiety or social disorders… but time after time Geeks & Nerds recognize their own.

Its not really so bad to do this and in a lot of ways, it makes sense. All the information and constructs to accomplish the task is there, but it would need to be immediately refactor’d out at the first opportunity for one single reason: scalability. If Pymetheus suddenly starts taking on more and more trivial tasks, one day I am going to wake up and have this monolithic super process that does everything and has a memory profile similar to a swamp.

The ideal solution in my mind is:
User A & B connects and should be granted Chat privileges, accounts are created or activated on a xmmp server alongside pymetheus which returns connection credentials to Pymetheus which passes this back to each User. A & B now connect to the xmpp server and can chat away to their hearts content. Alongside some of the weirder xmmp sub-protocols this solves a whole slew of things that must be implemented ( presence, offline messaging, event notification, etc ).

Given the following

        <table border="1" style="height:100%; width:100%" >
            <tr class="x0">
                <td class="y0">&nbsp;</td>
                <td class="y1">&nbsp;</td>
                <td class="y2">&nbsp;</td>
            </tr>
            <tr class="x1">
                <td class="y0">&nbsp;</td>
                <td class="y1">&nbsp;</td>
                <td class="y2">&nbsp;</td>
            </tr>
            <tr class="x2">
                <td class="y0">&nbsp;</td>
                <td class="y1">&nbsp;</td>
                <td class="y2">&nbsp;</td>
            </tr>
        </table>

I used the following logic to determine the coordinates from a user click

var clickHandler = function(e){
//Recieves a plan/jQuery managed event object                    
       var element = e.target;
       var parent  = element.parentNode;                    
       var x,y;
       //Below is fine for 0-9 scenario's but will need to be refactored for more
       //advanced/larger grids.
       try{
            y = element.classNames().detect(function(cls) { if( /y\d/.match(cls)){ return true; }})[1];
            x = parent.classNames().detect(function(cls) { if( /x\d/.match(cls)){ return true;}})[1];
        }catch(e){
            console.debug(e);
            return;
        }
 
         console.log("Coordinate " + x + "," + y);
};

The cool thing about this, is that with jQuery I can do jQuery(“#myTable tr.x2 td.y0″) and get the exact cell I am looking for… or even crazier stuff like:
“#myTable td.y0″ to select vertically down a row
OR
“#myTable tr.x0″ to select horizontally.

My initial solution to loading in dependencies depended on a switchboard style approach, if browser support onready or similar events then bind an anonymous function to make the appropriate notice.  Else spin up a interval based checker anonymous function that looked every few seconds for the script for about a minute.    This solution kind of worked, but not reliably because it depended on browser detection vs. capabilities detection.

Instead of reworking things to attempt to ferret out what capabilities a foreign browser supports, I went with a brute force approach that will eventually be a foundation for a much more advanced system.

So the prototype works like such.

wm.loader.load(“someModule”) which becomes the path “/mods/someModule.js” and that is applied to a new script tag as it’s src attribute.  This is then appended to the head tag.  All pretty standard stuff actually.  What’s different is the notification process.

someModule.js contains a simple line “wm.loader.notify(“someModule”) ” which hits an internal dictionary and if this is the first notification, fire’s of a notice to the server.

Simple and guaranteed to work reliably.   Plus it gives me room to grow for later.

Like adding a call like “wm.loader.multi(“lib1″,”lib2″,”lib3″, 10,  function(){   doSomethingWhen Dependancies met });

arguments[0-2] can be detected and pushed to a callstack array, any integer can be assumed to be a time out period, and the last argument as an anonymous function can be assumed to be a onSuccess callback.   A dependency failure mechanism could be incorporated into the actual loader lib as either an observable emitter or just a cry for help back to the service.

More involved:

wm.loader.multi( ){
 
          var dependancies = [],  timeOut = -1,  callBack = None;
 
          loop through arguments:
                    if( current instanceof string ){
                           append to dependancies
                    } 
                    else if( current instanceof integer){
                             append to timeOut
                    } 
                    else if( current instanceof function ){
                                assign to callBack
                     }
 
              var dependancyCheck = function(loadedLib){
                                          pop loadLib from dependancies;
                                         if dependancies.length <= 0 then
                                                     cancel timeOut 
                                                     call  callback;
                                 }
             dependancies.map( wm.loader.load, dependancyCheck );
}

I would be lying if I said I knew this construct would work perfectly once I implement it, but I think the general idea is something to work with.

Origins:

I started Pymetheus originally to create a platform for a near real time web based multi-user dungeon… but I wasn’t satisfied with what was available as far as feature complete frameworks and toolsets.  I wanted to create a VERY rich web application that used as much of the newer possibilities being rolled out by HTML 5.  Specifically web sockets, local & session storage, and then branch out to using the Canvas tag and whatever else I could pull off.  So a normal bread & butter html

Change of plans:

I’ve had more rewarding of an experience making the platform then I have making the game.  Of course I can’t make the game until the platform is stable, but with few exceptions, when is a platform ever completely stable when it involves the internet?

Brief outline:

Client side is a rich web application that relies completely on dynamically injected/loaded content and logic to function.   On the initial load, there is nothing but a blank blue page and about half a dozen scripts src’d in.

From authentication, modules,  mini-app like bundles, are bootstrapped into the client by means of dynamically injecting new script tag’s with src links to corresponding logic.  If any of the modules depends on external content like images or extensive HTML markup, that logic is dynamically loaded in as well.

While all of this is happening, the service side is merely instantiating classes called handlers to provide the business logic and hold some of the more important parts of the module’s state.   One trick about these handlers is that they don’t have to belong to the platform but instead can come from any package available on the Python import path.    The closest comparable design to this would be a WSGI based application, where a WSGI app can include other WSGI apps according to the URL path.

Anyway, I have the platform up and running and the three parts I feel need to be hammered out some more are

1. Working example of a Model system
2. Cleanup the user management system, it’s functional but has some weak points in it’s design
3. Implement a multiplexing message system that won’t encumber the platform, specifically for passing non-control messages between users.

Otherwise, about me.  I began my trials with computers somewhere around the late 80’s with a Apple ||e personnel computer.  I wish I still had a copy of the first few scripts I wrote, but the more advanced of them was a simple alternating game loop structure.  In the initial state, the computer would randomly pick a number from 1-10 and the user had to guess it.  After 3 tries, the person would then pick a number in their head and the computer would pick 3 random numbers.   So input could be summarized in a regex like ( [0-9]{1}| [YyNn]{1}) and the whole deal was something I could do in a minute.  It’s kind of funny to think about because It took me a few days to get that working right.

After that, I didn’t do much programming but I did spend a considerable amount of time of trial and error time with computers, at one time landing myself a part time job at age 14-15 doing computer repair & support.   What got me back into the programming game was when i first played Quake’s demo and then later learned that you could modify the game logic api for free… you just had to learn c/c++.    So began a lovely adventure into the world of compiled strictly typed langues and pointers.   I actually miss that environment but its pretty rare for me to fire up gcc and build up binary exectuables

After that the rest of my life got kind of weird, i knew i wanted to be a professional programmer but a lot of things got in the way, the biggest one being the economy and the death of the web for a time.