Doug Daniels Dev Blog ramblings from another game developer

Loading image

Click anywhere to cancel

Image unavailable

View image in its original context

Great news!!

I’m going to be working for NCSoft, in Austin, TX as a 3D game programmer!! I’ll be working with the Java Monkey Engine technology on a super-secret project (You know how it is with video games).

NCSoft is a premiere developer of PC based MMO’s like Tabula Rasa, Guild Wars, City of Heroes, City of Villains.

Now the really interesting thing about finding this job is that I have no direct game development work experience (by day I’m a java programmer for a military contractor, by night a ninja monkey game programmer), but as a personal passion, I’ve been learning, prototyping and extending projects using the jMonkeyEngine technology, and so through the jME community I was able to get in touch with two of the creators of the Java Monkey Engine who work at NCSoft Josh Slack, and Mark Powell. Over the past year or so through discussion with Mark and Josh and vigilantly monitoring the NCSoft jobs site I noticed they had some open positions for 3D client developers with Java Monkey Engine experience!! I immediately sent my resume in, and was lucky enough to get the chance to fly down to Austin and interview with the team!

The interview went great, I met some incredibly creative and interesting people (I absolutely can’t wait to work with the team). I was nervous that because I didn’t have any direct game related experience that I’d lose to a candidate whose been in the industry, but I feel that my passion, plus my unique experience and involvement in the jME community helped tip the decision in my favor.

It’s going to be a little crazy for my personal life, because I quit my current job (gave them my 2 weeks notice friday), and I’m going to be packing all my stuff up and shipping down to Austin, TX in 2 weeks!! I’ll be leaving behind 90% of my family and friends (except for my friend Matt who plans on quitting his job, and joining me on the cross-country adventure by moving down to Austin with me and finding some job down there). I’m at a point in my life where I need the change, I want the adventure, I’m up for the challenge and plus this job is a dream come true for me! Also Austin is supposed to be an incredible place to live and I can’t wait to check out the music scene and apparently there’s a huge technology maker/hacker scene down there, I’m excited!

Once I’m down there I hope to continue writing about my experiences working for a game development company, and also some more ideas I have on how people from the larger “corporate” software industry can break into the game development industry. Especially with the unique technologies like the Java Monkey Engine which is going to require developers to have strong Java and computer graphics experience, which is very different from the traditional C++/OpenGL game technologies.

It’s going to be very interesting to be part of the jMonkeyEngine community as more commercial companies begin to utilize it, I’m hoping that companies will realize that the competitive business edge is not in the core game engine framework but in the unique proprietary gameplay and tools specific to the game built on top of that technology, and that by leveraging and contributing to open source standardized core game technology, they can create a cheaper higher quality end product across the industry. Then the industry won’t be driven by a select number of multi-million dollar blockbuster games, instead it will be driven by a massive selection of games which allows developers more freedom to develop creative and engaging gameplay and stories. (or at least that’s the idealists dream right )

Last week I had a technical phone interview with an engineer from Google’s Mountain View office. He presented me with the problem description for a classic producer consumer concurrent programming problem. This being the 3rd freakin’ time I’ve interviewed with them in the past year, I wasn’t to nervous this time, because I’d basically already given up on them and was just doing this because they contacted me to interview with them again.

Long story short I nailed the producer consumer problem IMHO, possibly because as a side hobby I’ve been reading up on concurrency in Java. The interview lasted exactly 45 minutes, and at the end the interviewer seemed pleased with how it went. I got a call back the next day saying they wanted to setup an on-site interview at the Boston area Google office in Cambridge. I’ll be going there next wednesday 8/22 for a 2 hour on-site interview. I’m pretty pumped about this seeing as it’d be my dream job to work for Google and have a chance to work on and even start some really innovative projects.

The technical momentum and community that Google has created is simply amazing. They’ve been able to create an environment where you get to work on the most interesting and sometimes esoteric computer science problems, and yet those problems have practical applicability in Google’s mission to make all of the worlds information universally accessible.

If you want to read more about the interview I wrote up a detailed article on my wiki:

Google Interview Details

I created a project on Google’s code hosting site, to host common code that I create such as tutorials, little scripts and examples. I feel like I code up stuff and then save it in some obscure project on my hard drive and always have to dig around for it when I want to grab ideas from it.

So instead I’m going to try and organize my code in a subversion repository, and release it to the world under the BSD license.

JDDaniels project @ code.google.com

JDDaniels wiki @ Event Horizon Games Wiki

The first thing I’ll be doing is posting up my Project Euler solution for the first problem I attempted. I’m also going to post up any jMonkey Engine example/tutorial code I come up with.

I think this will be a good place to persist any code tutorials I write up on this blog or on my wiki.

Check it out it’s a good read:

jME: Multithreaded Madness

I posted a comment to his blog, but then I discovered this nifty Trackback feature, so I’ll repost my comment here (I’m kinda using this as an experiment using trackback URI’s):

Here’s my comment to his post:

Mark,

Very interesting post!

I agree with you that the real challenge for the future is not to find a few parralel tasks in your game engine (physics, collision detection, AI) because that limits your concurrent scalability, you need to find tasks that are scalable to n cores.

Another interesting feature of some of the java.util.concurrent collection objects such as the ConcurrentHashMap is that they are not only thread safe but their performance is concurrently scalable. They are scalable because they use a concurrent finer grained locking scheme called lock striping, this allows the ConcurrentHashmap to only lock portions of its bucket so that multiple threads could write to it safely (The book Java Concurrency in Practice has a whole section dedicated to Concurrent Performance and Scalability it’s a very interesting read check out their example of a StripedMap).

Another lock-free idea that provides a high capability for concurrency is Software Transactional Memory. The idea is very similar to atomic transactions in the database world, STM optimistically assumes that any concurrent transaction that is made on shared memory is going to be done without another thread trying to access that shared memory. The key idea is that it makes the concurrent code developer not have to write explicit synchronization to perform actions, but once that threads transaction is submitted then the application will validate that no other thread has accessed that shared memory, and then commit it. If it fails then the transaction is retried, in real practice this transaction retry mechanism has proven more efficient because actual conflicts are rare, rather than having threads explicitly acquire locks per transaction. In the end STM provides a way of creating a highly concurrent application (it will scale to N processors/cores).

Right now I’m just researching a bunch of concurrency topics to get an idea of the whole range of ideas out there, I hope to be involved in the future direction of jME’s concurrent architecture.

I started an article on the jME wiki to summarize any interesting articles about concurrency and multithreading in game design:
* Concurrency and Multithreading in Game Design

It’s a mirror of the one I have on my developer wiki, I’ll try to keep the 2 in synch.

def close(self):
    try:
        self.setVelocity(self.mMoveVelocity)
        self.sleep(self.mCloseMoveTime)
    except CCollition, col:
        print “Oops.. sorry”, col.name

    self.setVelocity(CVector3.ZERO)

void update(t_actor *actor,double timedelta){
    if(actor->state == CLOSING){
        Cvector3 pos = actor->origin;
        pos = pos + actor->velocity * timedelta;
        if(pos == restpos){
            actor->state = CLOSED;
            return;
        }
        actor->origin = pos;
    }
}