Nov
20
2009

RubyConf Part One: Education and Ideals

This entry is part 1 of 3 in the series RubyConf 2009

Way out in San Francisco, I’m attending RubyConf 2009 from November 19 through November 21, and JRubyConf 2009 on November 22. It was a pretty significant financial investment (many attendees receive corporate travel funds) but I managed to make it out to San Francisco early Wednesday.

For me, the experience actually started just after I switched planes – I discovered that I had actually been sat next to the department head of the computer science department at Michigan Tech. My usual social-anxiety-ridden self, I sat and read for a while, listening to music. Then, in the spirit of RubyConf, I decided I had a duty to be outgoing. She and I talked for the majority of the flight about the structure of their program, difficulties faced in CS education, and the gamut of subjects. She really got me to reconsider whether I’ll be looking at grad school when my undergrad career is over.

Then, of course, I arrived in San Francisco, took the shuttle to the hotel, and discovered that the hotels are quite segregated. After about two hours of walking, I managed to find a little downtown area, bought some Subway, and it was a good day.

RubyConf began with Matz’ keynote – he discussed the idea of a “true” language. Matz (@yukihiro_matz) discussed the idea of creating a language that can solve 80% of the worlds’ problems – naming it ZPET (Zero-Point-Eight True). He argued that Ruby needs to improve on distributed systems, and needs to provide better solutions for functional programming, but that ultimately, Ruby could be the ZPET that the world needs.

There were some fantastic presentations throughout the day:

  • Several Japanese Ruby developers gave talks expressing their concern about the communication gap between US and Japanese Rubyists, noting that the core team of developers working on the Ruby implementation conduct their work in Japanese – making collaboration difficult. They discussed some of the activities the Japanese Ruby community is involved in, and invited everyone to attend RubyKaigi in 2010.
  • Sarah Mei @sarahmei gave a talk about her experience teaching Ruby to high-school girls. Using the Shoes framework as a platform, she was able to give some impressive insight into what students found easy, difficult, or just plain fun. She pointed out the fact that the stereotypes surrounding programming need to be updated, as programming “has more to do with language than with math.”
  • Nathan Talbott @ntalbott spoke out against reliance on TDD/BDD alone to make a project succeed—it’s simply not the case. Nate identified a possible cause—that features requested by clients (or determined by developers) are not always perfect. We’re good at solving problems, but not knowing which problems to solveAs developers, we’ve become very good at solving problems, but not great at determining which problems to solve. He discussed the idea of Experiment Driven Development (EDD) to help address this issue. Using new frameworks like Vanity, which was just released today by @assaf, we can take a baseline product, and test conversion rates on different projected features – this helps direct developers into solving the correct problems, rather than arguing over which features need to be implemented, or have a net effect on the user experience.
  • Oh yes, and there were flying robots!
  • After the regular sessions ended, I meandered on over to Kincaid’s Bayhouse, which featured a fantastic dinner, with some new friends. Truly, this has already been a fantastic experience, and I can’t wait for tomorrow’s sessions!

Nov
20
2009

RubyConf Part Two: Principles and Progress

This entry is part 2 of 3 in the series RubyConf 2009

Day two of RubyConf 2009 was just as exciting as the first. Unfortunately, I slept through a piece of it! I woke up around 9:30AM—just short of making it to Ben Scofield (@bscofield)’s presentation on non-relational databases. Ben gave a really fantastic presentation at Windy City Rails 2009, where he described particular problem domains that don’t lend themselves to standard relational modeling—specifically cross-bred animals like Ligers when trying to model classifications of species, or worse, the incredibly confusing situation regarding comic books. From talking to Ben, the presentation he gave today would have been a great followup to that talk – as he demonstrated some of the non-relational tools that developers are beginning to use for persistence. I’m very sorry I missed his talk, but thankfully, all the presentations are being recorded!

Great talks continued throughout the day; some of the highlights included:

  • Jim Weirich (@jimweirich)’s talk on SOLID Ruby covered the idea that as developers, we still have a really hard time discussing what good code design is. The SOLID principles were laid out as objective means of evaluating static languages—but that doesn’t mean there isn’t great use for them as guides for developing Ruby code. SOLID, while written for static languages, is a good guide for RubyMost notably, Jim talked about how Java developers consistently try to “program to the interface”, because the abstraction layer of interfaces allows for increased modularity. With Ruby, this isn’t necessary—objects are objects. However, in order to maintain the modularity, clients who use functions that expect a certain type of object need to know what the input specs are. Therefore, it’s incredibly important to discuss the virtual concept of “protocol” between methods, in documentation.
  • Chris Wanstrath (@defunkt) presented on Python—specifically looking at ideas that the Ruby community could learn from or take away. He gave a brief overview of the language, and a brief description of some of the cool libraries that Ruby doesn’t quite have, or could improve upon. Chris’ ultimate message was that adopting new languages is a practice that should be encouraged, because communities have a lot to learn from each other, and it’s never good to get too comfortable at any one thing for too long.
  • Noah Thorpe (@aquabu) gave a demonstration of various audio libraries in Ruby. He discussed how music could be generated from mathematical constants, using various technologies. However, Ruby does have the limitation of being an interpreted language, so real-time audio is a bit crippled. He did suggest, however, that JRuby might help to fix this problem. Several of the demos were very exciting, and I can’t wait to play around with the code myself.

Day two of the conference ended with a hasty rush to the Startup Crawl—a tour of open-house events hosted by Ruby startups in the San Francisco area. While I decided not to attend, many developers are currently traveling between such wonderful companies as Scribd, Engine Yard, Heroku, Justin.tv, Apture, Yammer, HeyZap, Pivotal Labs, SocialCast, Sauce Labs, ZenDesk, Shop It To Me, Chargify, BigTent, Airbnb, Plato’s Forms, and Dropbox.

Recent Twitter updates suggest some transportation hiccups, but it appears to be a great event!

Nov
21
2009

RubyConf Part Three: This is Why

This entry is part 2 of 3 in the series RubyConf 2009

The final day of RubyConf 2009 was a poignant reminder of _Why: why we love Ruby, why we go to conferences, and why the Ruby community is unlike any collection of developers. This was perhaps embodied best by the Programming with the Stars event which ran during the lunch period of each day of the conference.

Developers passionately watched as pairs competed in a paired-programming event to demonstrate good coding practices and refactor things for the better. Every individual in the room was excited and involved in considering best practices for development in Ruby—in what other community are individuals so excited about not only getting work done, but doing it in the best way possible? A big thanks to Corey Haines (@coreyhaines) for organizing this event!

The day had several great talks as well.

  • Stuart Holloway urged Rubyists to consider what their next language was going to be—specifically, by discussing things he loved about Clojure. Stuart reminded us that we’re passionate developers, and our enthusiasm doesn’t need to be constrained to a specific language domain—get out there and have fun with something new.
  • Aaron Patterson (@tenderlove) and Ryan Davis brought the house down with their Worst. Ideas. Ever presentation. Some of the fantastic topics included optimizing web performance by writing in assembly, “Ruby doesn’t scale…but XML scales like a boss!”using PHP for Rails views, and making Ruby more “enterprise” by converting it to XML (because, as everyone knows, Rails doesn’t scale, but XML does). The mentioned that they actually did encounter a few bugs in Nokogiri and other libraries, just in writing the samples for this project—bugs that likely could have gone unchecked otherwise. The overall message: do stupid stuff; play with fire; having fun with a language is hardly something to be avoided—even if the overall product might not have any real value.

As the _why-esque art from the RubyConf whiteboard—along with all the presentations from the event—remind us, Ruby is fun, Ruby is never finished, and there are always people who look forward to working with you in the community.

Thanks to everyone involved for a truly phenomenal RubyConf 2009.

Search