I decided to take a different approach for Day 2 and write a single post instead of writing an entry for every talk. Last year when I had power in the room it was much easier to write the post during the talk, but this year without power I have to try and save my batter power for those boring talks where I want to work on something else.
Aristotle and the art of software development - Jonathan Dahl
This was the first talk of the day and it was very enjoyable. Jonathan obviously comes from a philosophy background and drew on that to make some interesting observations about being a developer. The one that stuck with me is the comparison to morals. When kids are young they follow a very strict rule set which is eventually internalized into morals. Development is very similar, for instance DRY (Don't Repeat Yourself) could be considered a rule of development. But it is very much a judgement call on how far to take DRY, taking it too far can produce overly complicated and obfuscated code. Overall it was a great talk, you can see the slides up already on Jon's blog.
This talk was something I am very familiar with. I used to be very afraid of giving presentations, but one time I gave a presentation for some material I wasn't very familiar with. It was a canned talk from MS for one of their events and was a complete disaster. The next talk I gave was infinitely better though because I had gotten over my fear of completely bombing on a talk. I realized that while it wasn't fun to flop a talk, it didn't cause me that much harm and I was much more willing to take chances and throw myself into a talk after I saw that it couldn't really be that bad. This talk was about the same thing but with writing code and working on side projects. It was a very open talk with no slides and lots of audience participation, it was almost like an open space.
What Every Rubyist Should Know About Threads - Jim Weirich
I love seeing Jim Weirich talk. I have seen him talk more about Ruby more than any other person and his enthusiasm is infectious. For this talk Jim walked through the basics of threading then covered how to deal with the various race conditions that you can encounter and how to tackle them. Jim then went on to cover some of the various other languages that are better built for concurrency including Erlang and Clojure.
Effective and Creative Coding: Help from Cognitive Psychology in Caring For the Rubyist's Mind - Evan Ivancich
This was a very interesting talk that covered how our minds work while we are programming. It covered the differences between fascination and direct attention and the affects of the mental fatigue that long periods of direct attention can have on you. One interesting study showed how people who took a vacation in a wilderness setting vs. an urban setting
had less fatigue and could better focus after the vacation. This talk didn't include alot of actionable items, but it was fascinating to learn a little bit more about how our brains work
Writing Code That Doesn't Suck: Interface Oriented Design - Yehuda Katz
This was a great talk that consisted on one main point. Unit tests are not regression tests. We should be writing regression tests that make sure that the API we are exposing to the world doesn't change or break while we work on our application. So much of unit testing is now focused on testing the actual implementation of that functionality instead of testing the actual interface and functionality. The example he had from Merb was where they used to test lots of the internals of the Render method, but they didn't have a simple test to call the Render method and make sure that the response type is HTTP. How that happens doesn't matter to the outside world, what matters is that the external interface doesn't break. I agree with Yehuda that this is something that is sorely missing in most Ruby programs, because Ruby is so open people tend to forget that they should still care about the public interface of their application.
OS X Application Development with HotCocoa - Rich Kilmer
This talk was freaking awesome. Rich has written a ruby wrapper over Cocoa that along with MacRuby makes writing Cocoa applications in Ruby extremely easy. Rich walked through creating a simple app and showed off controlling iTunes from Ruby code, all very cool stuff. The only downside is that there is still alot of work left to wrap Cocoa and make this a viable solution to writing Cocoa apps.
After dinner we came back for the Dave Thomas keynote. Before the talk they gave away books and I was lucky enough to win Programming Erlang from Joe Armstrong which was perfect since I am looking to use Erlang for a number of things. Dave did an excellent keynote where he started by encouraging people to fork the ruby language. Not to try and replace the existing ruby, but to encourage experimentation in Ruby. Dave went through four different possible forks, but the one that connected with me was RubyLite. I would love to see less methods and features in core Ruby and more moved out to gems, especially things in the standard library. This is a tough line to walk though, one of the benefits of Ruby is that by downloading Ruby you get so much functionality. I can see where it might be frustrating to have to install 10-15 gems to get a reasonably complex application up and working, but I think there is definitely some room to move things to gems without taking it to far. I am sure a number of RubyLites will popup on github and I look forward to seeing what they accomplish.
After the keynote I grabbed a couple beers and hacked on some code then went to bed way too late.
-James
