This session probably had the most relevance to my current project at work and it was pretty exciting to see in action just what ATLAS is going to be able to provide me in the future.

Rick was a great speaker and his demos really did a great job of quickly showing just what ATLAS could do for you. It was particularly nice to see just how easily you can convert an old ASP.NET web application to take advantage of AJAX with ATLAS. It basically consists of putting any controls you want to AJAX-ify into an update panel that you just drag and drop onto your webform. That’s nice. VERY nice.

Basically if you’re not familiar with AJAX, it’s a technology that allows you to do a partial post-back of content on a page so that an entire page doesn’t have to re-render in the browser. This is quite an advancement for UI development for web apps (although it’s not really a new technology, it’s just not been used much) and it takes web applications one step closer to although still not having “state”, at least simulating “state”.

ATLAS is a framework for .NET that makes developing your web applications to utilize AJAX a whole lot easier and watching it in action it looks like Microsoft has a great start on it. While I wouldn’t describe everything as easy, what I did see was a lot easier then trying to implement AJAX in your web pages yourself without the ATLAS framework.

This session, I was reacquainted with my favorite person of annoyance again, and they did indeed proceed to halt the session several times with some questions that just weren’t appropriate for the format. Rick (just like Lucas) showed amazing patience and was quite skillful at putting the session back on track again although it did end up going a bit long because of the side tracking questions. (Please people if you have idle curiosity about something, go home and play with it, don’t force the presenter to play with it during a free session with limited time. Those kind of questions just aren’t appropriate.)

Rick has been quite generous and has his demos and slides up on his site (get them soon, he’s not planning on keeping them there for long), so even if you couldn’t make it to Code Camp, take a look at his demos if you want to get a feel for what ATLAS can do for your ASP.NET web application.

Rory is just flat out one of my favorite technical speakers period. If you haven’t had a chance to hear him speak, well, make the effort. And when Rory is talking on a subject of some interest to you that you know little about, do whatever you can within the confines of the law (or maybe a little outside of the law) to make sure you don’t miss it.

WCF (Windows Communication Foundation) (formerly ‘Indigo’) is part of the .NET framework 3.0 (formerly ‘WinFX’, thanks for confusing the heck out of me Microsoft). Basically, it’s all those old APIs that dealt with communications gathered into one nice easily accessed and elegant API.

Watching Rory throw together a quick demo using 3 different communications methods (TCP, Named Pipe and HTTP) was pretty breathtaking. The first one you were like, ok, so you had to do that this and that and suddenly you can transfer text between two applications. Yeah, neat. But then, you saw him do it using the next communication method and guess what? YOU DO IT THE EXACT SAME WAY! That’s right. If you can setup a communication using HTTP, you can setup a communication using TCP. That just rocked.

I haven’t played with Indigo (I mean WCF) yet, but watching Rory’s sample application quickly come together was enough to make me think I need to start doing some playing.

All in all, some pretty exciting stuff for developers coming from Microsoft. If you’ve ever experienced the headache of remoting, be happy because your relief is coming very soon (just how soon is that Rory?)

Well, this session was the one I was most excited to attend and maybe because of those high expectations was the most disappointed with. First, I’d just like to apologize to anyone that attended this session. I became “that guy” and I’m sorry for that. I disagreed with so much of what was being said by David, that I had a hard time keeping my mouth shut. Especially when I felt it wasn’t even a disagreement of opinion, but just wrong information being given. So for not allowing the presentation to just go on and instead interjecting constantly to disagree I apologize and hope I didn’t ruin that session too much for others.

Coding standards and best practices is a passion of mine and I have some very strong opinions about it. All in all, I’m glad the session was held because I think it’s important, but the delivery for me just wasn’t what I wanted. For me, I think it’s wrong to say “here is the standard you should use, and it should be an underscore to identify class level variable”, but more explain why you need to have standard for something, like why is it important to have some identifier for class level variables. I also felt that the book pimping was a bit out of control, but I guess that’s his right and just to make up for me being such an annoying ass to him, I’ll help him pimp it. Here check it out.

Even though I didn’t agree with all of his content, the general message is one I stand behind wholeheartedly, everyone who is a developer needs to follow some kind of standard. You need to do this at work and in your hobby projects. If you are writing code, you should have a standard and follow it.

So, one of my most disappointing sessions, I couldn’t keep my mouth shut, but overall the message still rings true. Props to David for presenting such a controversial topic, it’s always hard telling developers they need to change how they write their code, maybe next year I’ll have the guts to do one like this myself.

The first session of the day and I was instantly blown away. Lucas Carlson presented an amazing introduction to developing with Ruby on Rails and I almost got physically sick in the classroom. What the Rails framework provides is the EXACT functionality I have been developing for a current project of mine for the LAST TWO YEARS!

Watching just how quickly a CRUD (create, read, update and delete) web page could be developed for a database table was just sickening to watch. I’m talking just a few lines of code in Ruby and you are done. The language itself is developed with “The Principle of Least Surprise” and after watching this session, it was easy to see how well that principle was achieved. At no point during the presentation was I “surprised” at how a function worked or where something was found in one of the libraries. It is just such an elegant language.

Lucas himself was a great speaker. Soft spoken and extremely intelligent. Watching his fingers fly as he would enter command line commands and switch back to the development environment to type a single line of code to make a web page was just phreaking impressive.

The only downside of the whole session came from the attenders themselves and it’s a problem I’ve been experiencing a lot lately when I attend presentations. People really seem to believe that saying “there are no stupid questions”. Stop it people, that’s a lie, so quit believing in it. I really find myself frustrated with people that halt a presentation with these questions that just aren’t appropriate. I don’t want to spend my whole time talking about this issue right now, I think since it bothers me so much I’m just going to have to do a post in the future about learning to ask the right questions at presentations.

So for now let’s just say there were a few individuals asking certain types of questions that made parts of this session particularly grating, hat’s off to Lucas though for his patience in dealing with the questions and moving the session along.

All in all, this was one of my favorite sessions of the day and had me so excited about Ruby on Rails that I got the environment setup on my computer to play with the next day (although one of the other 4Guys was even MORE excited than I was….). If you haven’t taken a look at Ruby on Rails and are involved in web development in any way, I would highly recommend you read up on it. It never hurts to be familiar with other web technologies and you’ll get over that sick feeling in your stomach when you realized you could have spent 3 months learning Ruby and 3 days making your entire project instead of 2 years eventually…or at least I hope you do.

This year I decided to try to catch some of the Ruby sessions, and see what all the hype was about. Apparently I have been missing a lot. Fortunately Lucas Carlson was around to show me the light.

As it turns out, Ruby (or Rails, really) is just awesome. Actually, I’m not sure awesome is quite enough to really describe my thoughts, but I can’t think of a better word…. (if only I had a way with words like Rory maybe I could come up with something. (But I’m not. (So I can’t. (But (Maybe (I ( Can (Get (More (Parentheses (Into (One (Sentence))))))))))))).

OK, so back to Rails. If you haven’t tried it, you should. I’m pretty sure you can re-create the internet in about 4 lines of code. Yeah, its that good.

I have found a really good bit of aggregated info about Rails on this site, so check it out.

Honestly, I had a terrible headache during the afternoon, so I don’t remember a lot of the afternoon sessions very well. I remember thinking “Atlas is cool” and “That guy isnt wearing any shoes”, but most of it is kind of a blur.

P.S. It was somewhat difficult to get setup on Windows, but its probably because I was falling asleep. I have it down pretty good now, so if you need help, leave a comment and I will e-mail you back and help you through it.

Portland Code Camp v2.0 was held this past Saturday (7/22) on the WSU campus in Vancouver and man, what an event! If you didn’t have room in your schedule to attend it this year, start writing “Portland Code Camp” in your day planner for every day of next year just to make sure you don’t make that stupid mistake again.

I just want to say to all the people involved in making it happen, awesome job guys. You really pulled it off and code camp was a total success in my opinion. The code camp was cut back to just one day this year (due to lack of presenters, not lack of attenders), but what a day it was. Coffee in the morning, an quick opening session, 2 awesome sessions, a great box lunch outside near the WSU fountain, followed by 3 more awesome sessions, a nice catered dinner with good conversations with fellow technology enthusiasts in the community, live music, Frisbee golf, geek karaoke and croquet on the lawn. Quite a day.

The sessions were varied and covered a wide range of topics from ASP.NET to Ruby to AJAX to Use Cases to.. well, let’s just say you could get a LOT of information about many technologies in just a single day.

While the sessions were awesome, the true power of the code camp is in meeting other members of the technology community. If you didn’t take the time to introduce yourself to at least one new person, you really missed out on some serious networking opportunities.

Well, that’s my little blurb about the Portland Code Camp v 2.0 in general, I’ll try and get some of my session specific observations up in just a little bit. Throughout the day it was possible to attend five sessions, but I only went to four of them. During the third session, I took a little Code Camp break and went home to give my wife a little break with the boys (we have 3 of them), but I’ll make sure to post my coverage of the sessions that I did attend.

If you didn’t get the pleasure of attending this fun networking and learning experience last year, do everything in your power to make sure you can make it to this year’s Portland Code Camp 2.0.

You can register for the event here. It really sounds like they are going all out this year including having evening activities and catered meals. If you do attend, make sure to look us up and say hi. It’s always fun to meet the other Portland/Vancouver area nerds.

Those of us from 4Guys who attended last year had a great time and really picked up a lot of new information and skills. The topics covered are varied and it looks like they are getting a ton of new speakers this year (there’s a slim chance some of us might work up the courage and motivation to be a presenter, but looking at past motivational history, the chances are slim…very slim), so I’m expecting a similar and most likely better experience than last year.

Hope to see you there!

To wrap up the day, the 5 “presenters” sat at the front of the room and allowed us to ask some questions (both stupid and not as stupid) to which they would have to try to provide answers to without looking stupid.

Rory graced us with his presence, and then proceeded to interrupt the introductions with his question. Once his question was answered, he promptly packed his bags and walked out. All the pressure of being famous I guess.

Most of the questions seemed to revolve around how to make money from game development, and most of the answers seemed to be “good luck, loser”. The panel did a good job of explaining that the game-dev market is very hard to break in to, and its quite difficult to publish your own games these days without a substantial chunk of cash. It was mentioned that the shareware model is still quite viable though, and can bring in a little bit of cash now and then.

The best thing is that there is one other person that seems to play Guild Wars. I think he may in fact be the only person that I have met face to face that plays this game. What a shame.

This session was a fun way to end the day.

Andy is a very interesting individual. He recently quit his job at Microsoft, and has decided to live on savings for a year while he tries to break into the gaming industry. Furthermore, if this doesn’t work out, he seems fairly confident that he can get re-hired by Microsoft. He must be good.

I was late to the after-lunch session yet again, due to the a bit of slow restaurant service. When I walked in Andy was knee deep in some stuff that was clearly over my head, and I was barely grasping at some of the concepts. I was relieved only by the fact that when he asked questions, everyone else was silent too.

Most of the presentation was getting down and dirty with HLSL. It was indeed impressive how little HLSL code could be written to insert lights, textures, etc into shader that could then be used to affect a scene. Andy stepped through re-creating the fixed function pipeline functionality of the graphics card (at least I think so, he kept saying things and then appending “…of course” onto the statement, making me feel a bit ignorant). In the end, he made it look rather simple, though I don’t think I could go and do it again on my own.

While the subject was a bit over my head, the presentation was excellent and enjoyable. Off to the Game Dev Panel.

This talk was one I was really looking forward to, as I find AI in games really fascinating. Chris certainly did not disappoint in another concept-based talk.

Much of the presentation focused on the different components of AI (Fear, Hunger, Morale, Loyalty, Greed, etc) and how they are created in reaction to stimuli around the creature. He explained how many more components may be thrown into AI to make it more interesting, such as contention between races, and how to calculate certain reactions based on different AI characteristics.

Chris has authored his own ASCII based RPG, Heroic Adventure using VB.NET. After some bad luck with his intended demo (which he warned us was not working as intended before unleashing it on us), he demonstrated some AI that was worked into his own game (after dying several times without leaving the first room).

This talk led to lunch and made for a very informative and fun morning.

I arrived promptly at 8:55 for this first Sunday session. There were now 3 of us in the room, and one of us was the presenter. Well, that’s what you get for being the first speaker after the “Nerd Crawl” that surely kept people out way later than the “I want to be up for Jason’s talk at 9:00 tomorrow” time. By the time we started the talk 5 minutes late, there were probably half a dozen people in the room. Lucky for me, I was one of the 2 that didn’t have David Weller’s book “Beginning .NET game programming in VB.NET”, so I received one of the 2 copies that were to be given away for that session.

This was probably my favorite talk. Jason has taken a unique approach to keeping separate components of his game informed of what other components are doing by using a central message processor. It was revealed that he hates using .NET events, and prefers his self-rolled message processing approach.

This approach allows each component to send messages to the message processor, which will in turn send them to all components that have subscribed to that particular type of message. By using this de-coupled architecture, it would be very easy to add additional components into the game, and allow them to hear the messages of the other components, without touching a single line of code in any of the other components. None of the components need to know what other components may be listening to its messages.

Jason concluded by showing us his own creation, tanks 0.0.3 very beta. He also talked briefly about hooking into a 3rd party physics engine to provide the physics for his project, and about using baretail for logging.

I think this was my favorite talk due to my general noobishness with DirectX, and the focus on concepts rather than specific examples. A great way to start the morning.

I of course didn’t know what to expect in this talk, since there was absolutely no description given for the session, but I knew there would always be good times when Rory is presenting.

Inform is a tool that was made to do one thing, and one thing only. It’s a language to make text adventure games. If you have ever played one of these games, then you know how ridiculous they can sound at times, and that is when the developer is trying to be serious. We, of course, weren’t.

We created a simple text adventure game that consisted of having to retrieve a golden fish without being attacked by the “magical living golden lute monster”. We needed this fish, of course, to give to Rory gave out his “swag” in the form of autographed Tazo Tea Kits which he hurled across the room as a reward for asking good questions.

Well. Hmm…

It appears to be very easy to script actions in tribes.

Yep. This is one of those “If you don’t have anything nice to say…” times…

Maybe you can ask George…

We were a few minutes late coming back from lunch, so I missed the first few minutes of this talk. Naturally I didn’t know what to expect here. As we ate lunch, there was quite a lot of speculation as to what type of talk this may be, and in fact what color the balls may be.

Jason’s talk mostly focused on physics and collision detection. His application consisted of a surface with some pool/striped balls that would drop from the sky at the whim of the user, and as they collided, cause a chain reaction which would send balls in all directions. Jason pointed out some of the roadblocks he had run into when trying to do collision detection in 3 dimensions, and how using a single axis partitioning scheme would reduce the collision detection load exponentially.

At one point, Jason started playing with the window with his mouse (as probably most geeks do…. we must have some sort of interaction with the computer at all times.) , and they noticed that the balls seems to react to window movements. Very, very cool. Well, it turns out this is a bug. the longer you hold down the mouse, the more the balls gain downward force (due to gravity) and the more they “bounce” upward when you let go. I blame Windows, for not processing messages while dragging a window.

All in all this was a very cool talk. The demo was very flashy, and demonstrated the point well.

So, a bit bewildered from the first session, I make my way back to the lecture hall for Chris’s talk. I’m not really sure what to expect here, 2D gaming is pretty broad.

He starts out showing a demo of exactly what he has done, which is the main focus of his talk. Chris, it turns out, has written a program called Warplanner that allows multiple people to play this game with each other over the net.

Chris had a demo of some basic 2D DirectX work using DirectDraw. As Jason pointed out, this is a deprecated namespace, but the demo was still worthwhile. The next item on his agenda was how his network play worked. He made the mistake of asking Jason about some terminology for a “lounge” in DirectPlay to which he got a “I don’t know, I don’t use deprecated namespaces” answer. Ouch, heckled again.

Throughout the presentation Chris showed a really slick replay feature that would allow you to go back to any point in the game, and replay some or all of the moves. I have to say watching it was pretty impressive.

All in all this was a good talk, and made even better by Chris’ enthusiasm for his project.

OK, so here we are in our first session of code camp. Fresh from *not* winning the X-Box (if they could have told me I wouldn’t win before I got there, I could have slept another few minutes…), I knew we were surely not going to hear a standard Microsoft marketing presentation, because they told us specifically in the “Welcome to Code Camp” that we would not be hearing any of this at this Non-Microsoft-sponsored-but-payed-for-by-Microsoft-non-Microsoft-code-camp event.

Hmm, it seems that our friend David here missed that part. A good part of his talk was very marketingy (if that’s not a word, then it should be, because there is not a good word to describe “something that is marketing like”). One of the “students” had to call him on it, and get him rolling through his slides.

The major gem in this talk was his demo of PIX. If you don’t know what it is, use Google. I’m too lazy to do the search for you and provide a link to some useful material. I will, however, explain it in my own words. PIX is kind of like a DirectX debugger. You can record all of the DirectX information about an entire length of a scene, a single frame, etc. The really cool part is what you can do with that information. For each frame, you can step through each of the DirectX API calls, and see what is happening on the screen. You can watch as it draws the background, textures it, and then proceeds to draw each layer on top of it. Essentially you get to step through the minute steps of rendering a single frame and see whats going on in the guts of DirectX. Man, it’s like PIX just oozes geekiness…

The next best thing about this talk was that he told us that he wrote a book……45 times….