------------------------------------------------------------------------------------------------------------
This blog is looking neglected. I've been spending most of my non-coding writing energy on a new project about beer with some friends. It's a simple wordpress blog, nothing codey at all. Just something fun to keep us motivated and active. I'll be back here soon with some updates.

------------------------------------------------------------------------------------------------------------
This was a great conference. Great setting, professional setup, decent coffee, decent grub, comfortable seating, etc. I took some notes that are not really fit for public consumption, but I have a little bit to say (naturally) about each of the presentations, so I'll outline them below, mostly so I don't forget.

Bryan Helmkamp
Story Driven Development: The Next Generation of Rails Functional Testing

Bryan from WePlay, a social networking site for "Kids, Parents, Coaches, and Teams," stepped up to the plate (ouch) and presented a thorough and insightful presentation on Story Driven development, which was birthed from Behavior Driven Development, which was birthed from Test Driven Development. Bryan described the methods in which SDD , through RSpec, Webrat, and Selenium, could help empower the customer and the programmer both through the process of determining the specifics of Business Value and Logic. The talk was focused on breaking down the Stories into scenarios, and showed how these scenarios could be broken down into Ruby Code. The idea of "executable documentation" was especially resonant, and I look forward to trying these ideas out with new clients. I myself have written stories which I have shared with clients, and this has proven to be effective. The Given/When/Then grammar, accompanied by the As A/I would Like to/ In order to concept, is very powerful. Bryan also maintains Webrat, which I haven't tried out yet, but is linked in my tumblr a few times and seems really great, especially the part where you can describe user interactions through views using a syntax including "clicks_on," "fills_in," etc. for web forms. I still long for a talk which speaks more directly to how you can define good tests, but I guess this was beyond the scope of the talk. I asked a question, which felt good, and the slides, which should be posted online soon, would be helpful to anyone looking to get more involved in SDD. Bravo, Bryan.

Giles Bowkett
Archaeopteryx: A Ruby MIDI Generator

The talk which had me the most intrigued as a music programming nerd, and the least intrigued as a web programming nerd, turned out to be the most inspiring and well executed talk overall, in my humble opinion. Giles is an opinionated, funny, outspoken blogger who brings an amazing sense of experience and insight to the table when he comes up to present. He warned us that he was a Liar, that there would be some code in his talk but not all code, and that he didn't really give a shit about giving in to "Muppet Fucking" VC dorks. Giles presented his Ruby Midi integration system in the context of "having a good idea, sticking to it, and getting shit done." He reiterated some of the concepts which have become more pervasive on the Ruby and Rails blogs lately, championed by DHH at the "Startup School" lecture, and more. Do what you do because you love it, not because you want to become a billionaire. Giles' system might become hugely popular for live music DJs, or it might not. It may become the next big thing, or it might not. He works on it when he can. He loves the music it produces. He's fanatical, funny, and presented his talk in a fashion that had many people paying close attention even though they seemed as well to be initially put off by the topic of the talk. I was truly inspired by Giles' talk and I hope I can see him talk more in the future. His blog is great too, look him up if you haven't read it. Oh, and Archaeopteryx is wicked cool, even if Drum 'n Bass burns my earholes.

Chris Wanstrath
Forbidden Fruit: A Taste of Ruby’s Parse Tree

Chris, of Err, Github, Sake, and more awesome projects you probably use even if you don't realize it, gave a very interesting talk about Ruby2Ruby, the Parse Tree, and showed some of the more gory guts of Ruby in a way I have never seen demonstrated before. Especially cool was seeing how Ruby evaluates something as simple as "1+1", and his continuous references to the Gang of Four book made me reach for it Saturday night and I haven't put it down since. I was most excited for this talk and wasn't let down, and although it was pretty heavily technical, it showed how you can approach the power of Ruby and bend it to your will. CheatSheet and Sake were demonstrated and talked about, and Chris fielded a few interesting questions, including one by Ryan Davis about the specifics of how these ideas would work in the newer Ruby implementations. Chris spoke directly to the power of understanding the inner workings of Ruby, and I was very pleased to get some of his great insight. The Parse tree is something I look forward to playing with when I'm not holding down two jobs, and hopefully I will remember some of what he said so that I can make use of it. He talked quite a bit about Ambition too, which was fascinating.

Ryan Davis
Hurting Code for Fun and Profit

Ryan's talk was another of the inspirational variety, and contained very little code, which turned out to be somewhat of a blessing. Ryan spoke very earnestly about giving a shit. This was a theme of the conference, and Ryan really took it to the next level. You should hurt your code because you love to code. You love clean, understandable, un-clever code. You want to make it work for your customer, and work for yourself. He showed how heckle, flog, and autotest can make your code breathe more strongly in the decrepit stank air of a legacy project. Ryan is truly an inspirational figure in the Ruby world and his talked raised a lot of interesting questions about why we do what we do. I highly recommend that people check this out (and most of the other talks as well) when it is posted by Confreaks. I think I learned the most about coding from the talk that contained the least code. Thanks, Ryan, for all of your contributions. Dude is hard core.

Paul Dix
Collective Intelligence: Leveraging User Data to Create Intelligent Rails Applications

Another talk which covered a topic that I have some first hand experience with. Paul Dix presented the idea of "collective intelligence" in a way which speaks to how Netflix, Amazon, and other sites use recommendation systems. This talk, unfortunately, was way too focused on the mathematical aspects of the ideas, and not focused enough on code and implementation. Fascinating concepts, like Nearest Neighbor and other statistical analysis methods were bogged down in Graduate School speak which I think left a lot of the attendees wanting more. Even as someone who is very interested in Math and has studied some of these ideas before, I was a little bit bored. To Paul's credit, he clearly has a very strong grasp on the concepts and bravo to him for being able to play with the Netflix data set, and to leverage CI to his own advantage on his sites. To be more effective, he should take cues from the other speakers of the day, who leaned more toward implementation than theory, while making sure that the theory was clear. Taking a very simple data set, plugging it into Ruby, and showing the way it could really be used in Rails would have been ace. Regardless, I learned quite a bit, took down the names of some libraries I could use for my own purposes in the future, and re-geared my brain's Stats-Fu for a bit. Enjoyable overall.

Ezra Zygmuntowicz
Merb, All you need, None you don’t

Everyone was pretty buzzed up on coffee and stoked for Ezra's talk, and he gave the crowd what they wanted. He walked through the basics of Merb, discussed its motivations, and then focused on how he was going to kick Rails' ass, mostly in the ActionPack and ActionView areas, and de-cruft a lot of stuff that hasn't been touched for months. I truly commend Ezra for focusing so much of his energy back into the community that birthed his success. His partner defended Engine Yard against Giles' "MF" status, and I concur -- they do it the right way. Engine Yard didn't need VC, VC needed Engine Yard. Regardless, Ezra is a true Ruby luminary and it was great to see him present his project up close. Merb is going to kick some serious ass in 2008 and I'm sure there will be more Merb related talks at GoRuCo next year.

GoRuCo was a great time, and the Engine Yard party at the Tribeca Grand was a fun time. I was unfortunately a little too burnt to talk to anyone or do anything interesting except drink beer and eat Lamb, but I enjoyed myself nonetheless. Cheers to all of the presenters, organizers, and attendees. Oh, except one thing -- ASK MORE QUESTIONS, NYC! Geez!

------------------------------------------------------------------------------------------------------------
The 2008 Gotham Ruby Conference is this weekend. I'll be there, along with my man from Quirkey and some other hoodlumns. I'd say "I'll be the one with the beard," but this is a Ruby Conference, so, you know. Regardless, the agenda looks exciting and I'm looking forward to my first programming conference.

------------------------------------------------------------------------------------------------------------
JRuby is a pure Java implementation of the Ruby interpreter, which I have recently installed and started playing with on my nnew development machine. In the midst of playing, I came across a link to the Ruby Processing project on github which I had found out about through why?'s blog a while back via Quirkey Aaron.

I have taught with Processing for several years now after having met one of the principal creators when I was in Golan Levin's class at Parsons doing my Graduate Work. It is a simplified version of Java, employing a somewhat weak Java syntax in order to give students and visually minded people access to the wonderful world that is graphical based programming. Basically, it takes you out of the command line, into a cushy IDE where the errors are nicer and you get yelled at a lot less.

Needless to say, as a recent Ruby convert, I'm excited that all the power of Processing's amazing graphical engine and ability to export applications both in applet and desktop format will be available to Rubyists. If I was to stay at my school another year instead of going to chase the green with my boys at Clinic, I would definitely switch over to teaching programming with Ruby and Processing. Sure, some things would be harder (hashes? instance variables? symbols?), but some things would be a lot easier (ranges! loops! blocks!) and plus, it would be a party. You know, because it's Ruby.

Big cheers to everyone involved in both the JRuby and Ruby-Processing projects. In case you're wondering the kind of power that Processing has, here's 1,000 random ellipses per frame, in Ruby!

   1  require 'ruby-processing'
   2  
   3  class Sketch < Processing::App
   4    
   5    def setup
   6      color_mode RGB, 1
   7      background 0
   8      smooth
   9    end
  10  
  11    def draw
  12      fill 1
  13      1000.times do |t|
  14        w = random width
  15        h = random height
  16        ellipse w, h, 20, 20
  17      end
  18    end
  19  
  20  end
  21  
  22  Sketch.new(:width => 200, :height => 200, :title => "1,000 Ellipses")

------------------------------------------------------------------------------------------------------------
Sometimes, you need to see your database schema. Not stare at your schema.rb, not wonder what's going on, but see. There are a few tools to do this, but the tried and true method, for now, is Railroad.

When I first started making rails applications, I wondered about the dearth of posts about making ERDs before you make Rails applications, the lack of talk about database specifics. Spending more time in #rubyonrails, and reading more into it, it seemed to make sense that some of this was implicit knowledge. If you're making database based apps, you should know your stuff when it comes to database design.

Regardless, visualization provides an amazing tool to help see how you're doing. You can now perform a sort of schema test where you compare an initial diagram, sketch, or ERD to the outcome, as generated by graphviz through Railroad. And it's dead simple to do.

First, install graphviz - http://www.graphviz.org/Download..php -- it is available for multiple platforms and is easy to install.

Secondly, run a:

   1  gem install railroad

And Railroad and its dependencies are installed. Railroad is capable of visualizing model relationships, controllers, and more. Check the railroad site at http://railroad.rubyforge.org/ for great examples such as Typo visualized and other sick visualizations. Once you have these installed,

   1  railroad -M -a | neato -Tpng > models.png

is all you need to produce a png of your models in a nice clean ERD style format.

I would be remiss to not mention Tom ten Thij's Schema Browser Plugin which is brand new but very promising, producing XML output and an interactive method for viewing schema. For me, the simplicity of RailRoad will keep me using it for a while, but Schema Browser is very cool as well.