InfoQ

News

MountainWest RubyConf 2008 Videos

Posted by Mirko Stocker on Apr 23, 2008 12:00 PM

Community
Ruby
Topics
Community ,
Language ,
Programming ,
Domain Specific Languages
Tags
Rubinius ,
Merb ,
Conferences ,
Metaprogramming ,
RubyConf
The MountainWest RubyConf took place at Salt Lake City on March the 28 and 29. Thanks to Confreaks and various sponsors, all 15 talks are already available for download  on the Confreak website (the website also allows to watch them online using Flash). We'd like to give you a guide to a few selected talks, providing you with some cues about the content and, if applicable, the time it comes up during the presentation so you can jump right to the part that interests you.

Strengthening the Ruby Ecosystem Part I: Rubinius, by Evan Phoenix

Evan Phoenix is the creator of the Rubinius project, a virtual machine implementation for Ruby. This isn't really a technical talk about Rubinius, but more an update on the current state of the project (it already runs irb and RubyGems (09:12)) and an illustration of its extremely open development process. Evan says that one of the biggest outcomes of the project so far is its giant Spec suite (7:08). He then presents nine points that are vital to the success of the Rubinius community and can also be used as guidelines for other open projects:

  • No task is too small (17:55)
  • Every contributor has worth (20:05)
  • Every contribution has worth (21:22)
  • Asking for forgiveness is better than asking for permission (21:44)
  • Debate is healthy (22:26)
  • You are not your project (24:31)
  • The "Keys to the Castle" is a myth (29:47)
  • Foster experimentation (33:38)
  • Excitement is contagious (Lead by example) (38:00)

Strengthening the Ruby Ecosystem Part II: Merb, by Ezra Zygmuntowicz

Ezra starts with an introduction to the web framework merb, explaining the fundamental principles and key design considerations, like the merb motto "No code is faster than no code". He not only talks about merb, but also gives an introduction to Rack and GitHub.

  • Why he started merb and why Rails isn't always the best solution (07:00).
  • What's new in merb (10:43).
    • Quick introduction to Rack (12:43).
    • Merb::Router (21:16)
  • The components from merb-more (30:46).
  • A few words about merb-plugins (34:48).
  • What's cool about GitHub (36:22).
  • How merb's parameter passing for actions works (46:45).

Code Generation: The Safety Scissors Of Metaprogramming, by Giles Bowkett

Giles starts with the Greek letters pi, lambda and the word meta to lead over to metaprogramming (5:25). He argues that we usually don't really do meta programming but meta-OO. The first live demo is about Ruby2Ruby (6:28) and turns a Rails model class back into ruby code to see the magic Rails worked.

Giles is a very entertaining speaker, and I recommend watching the whole talk. Here are some entry points:

  • Why monkeypatching isn't always appropriate (12:15).
  • How he monkey-patches monkey-patching itself (meta-monkey-patching) to generate a script that visualizes an objectgraph (14:33).
  • Code Generation in Action, a book every programmer should read (26:14).
  • He takes a look at Lisp (29:12) and why he thinks that nobody uses it.
  • Ruby, compared to Lisp and Perl, has a good balance of simplicity and magic (38:20).

In conclusion, his main point is that everyone should read Code Generation in Action!

Deep Ruby, by Jeremy McAnally

Jeremy believes that most programmers don't use Ruby's objects right, so his talk sheds some light onto advanced topics like singleton classes and the instance_eval.

  • What are objects? Definition and comparison to other languages (04:19).
  • Behavior: Ways to change an object's functionality (8:19).
  • Dynamism: The family of *_eval-methods (11:40).
  • Advice: Prefer define_method and instance_variable_set over instance_eval (14:24).
  • Practicalities: DRY'ing up your code and best practices (16:09).

The talk lasts about 20 minutes, the rest of the time is spent on questions.

Domain Specific Languages: Molding Ruby, by Joe O'Brien

Life cycle and maintenance accounts for 85% of software costs (11:55), so software needs to be readable. This can be achieved with DSLs. Joe starts with the classical example of the Starbucks DSL (13:41) and explains why Ruby is so well suited to write DSLs and where its ingredients came from (24:10).

The second half of the presentation is about a tale of 3 DSLs (31:31):

  • Act 1: "oops I created a DSL", about tasks in rake and how Jim Weirich accidentally created rake.
  • Act 2: Consistency, an example of custom asserts in rails models (37:19)
  • Act 3: Business Language, on how to use a DSL to make specifications readable and verifyable for the client (42:53)

Shaving with Ockham, by Jim Weirich

Jim's real keynote is titled "Anything I Want to Talk About", and starts with a very nice (and 5 slides long) quote from Fredrick Brooks' "The Mythical Man Month" about the nature of programming. He continues with the story on how he became a programmer (5:40) and the very first Lisp code he saw (6:56). The next 10 minutes are an introduction to Lisp, explaining the basics of Lisp and why it is so powerful (21:24).

He continues with his first software project, implementing fancy graphics stuff for some generals, using spare hardware nobody else wanted to use. They had to work with two extremely different architectures and assembler languages (26:10). To work in this hostile environment, they ported Forth to both systems, which was relatively easy because only a very small core of Forth is machine specific (34:53).

On a later job, Jim needed to work with a multithreaded system, which brought him to the conclusion that threaded programs are hard (46:39), and so he continues his presentation with a language that excels in this discipline: Erlang (47:25). What follows is a ten minutes introduction to Erlang.

The end of the presentation consists of a few remarks about why we are always tempted to create overly complex software (01:00:20) and a quote from Tony Hoare (01:05:32) about the two ways of constructing a software design. Fortunately for us, there are some promising trends (01:08:05).

Note: InfoQ just published a video interview with Jim Weirich, talking about rake and DSLs.


No comments

Reply

Exclusive Content

Diary of a Fence Sitting SOA Geek

In this presentation, Mark Little explains the history of SOAP/WSDL/WS-*-based web services and RESTful HTTP and highlights how the two approaches might converge into a single solution.

Flex for XML and JSON

Platforms need interoperability. In this article Flex interoperability with JSON and XML is explored including direct mapping to chart and grid components.

Measuring Agile in the Enterprise: 5 Success Factors for Large-Scale Agile Adoption

Michael Mah analyzes the development process in 5 companies: 2 Agile (one of them BMC) and 3 classic. He presents the factors which contributed to the success of BMC's Agile adoption.

Tom Preston-Werner on Powerset, GitHub, Ruby and Erlang

In this interview filmed at RubyFringe 2008, Tom Preston-Werner talks about how both Powerset and GitHub use Ruby and Erlang, as well as tools like Fuzed, god, and more.

David Laribee on Alt.NET and its Mission

David Laribee discusses the purpose of ALT.NET, its mission and future.

Discover RailsKits and Stop Writing Redundant Code

Ruby on Rails has become a popular Ruby framework for creating web applications in recent years. An aspect of creating a web application is the need to repeatedly create the same base functionality.

A Formal Performance Tuning Methodology: Wait-Based Tuning

Steven Haines talks about tackling web application performance tuning by proposing a method called wait-based tuning.

Shaw and Fowler About Forging a New Alliance

Shaw and Fowler talk about the need for a new relationship between the business department and the IT department. Studies have shown that projects mostly fail due to miscommunication between the two.