This post originated from an RSS feed registered with Ruby Buzz
by Jamis Buck.
Original Post: RubyConf: Day 3
Feed Title: the buckblogs here
Feed URL: http://weblog.jamisbuck.org/blog.cgi/programming/index.rss
Feed Description: Jamis Buck's corner of the blogging universe. Mostly about ruby, but includes ramblings on a variety of topics.
Just in time to head home, my body seems to have figured out the time difference. I was actually reasonably refreshed when I awoke this morning, though that could have been because I went to bed earlier than I had the last couple of days.
Morning (Final) Panel
John Knight: Rubyx
John Knight had originally been scheduled to speak on the first day, but was delayed. David Black gave him about 15 minutes this morning to talk quickly about his topic, which is Rubyx.
Rubyx is a Linux distribution that uses Ruby for its various script files, instead of Python, Perl, or shell (like many other distributions do). It sounds interesting, and John was certainly passionate about it, saying that this could be a great way to introduce non-Rubyists to Ruby.
It was too bad he wasn’t able to give his complete presentation.
Daniel Berger: Ruby on Windows
Dan spoke about his Win32Utils project. He spent most of his presentation on creating (and manipulating) windows services from Ruby, and although I am not a Windows user, I have to admit it was interesting. He spoke about some gotchas when using Ruby-based windows services (error reporting, in particular) and also introduced the windows system for logging events. (Ich…the whole logging infrastructure for Windows seems horrendously overcomplex.)
Jamis Buck (me!): Dependency Injection in Ruby
Next was, by far, the best and most anticipated presentation of the entire conference. (Okay, okay, I’m kidding…although I do know there were several people who told me earlier that they were looking forward to it.) I spoke about dependency injection in Ruby—specifically, about Copland.
I must admit, I don’t feel like my presentation was entirely successful. I’m looking forward to reading what other conference bloggers have to say about what I presented, because I felt like there was still a lot of confusion regarding what IoC is and how it can really benefit Ruby.
Rich Kilmer suggested that I might want to add the ability to serialize a loaded registry to Ruby code, to faciliate faster realoading. This is a great idea, and I’ll start investigating this. There are a few difficulties there, though, so it won’t be as trivial a process as I had hoped. In particular, I’ll need to implement a way to (easily, and briefly) define new packages, service points, and configuration points directly from Ruby. This was another requested feature, so I ought to implement it anyway.
Francis Hwang (of Lafcadio) and Patrick May (of Narf), in particular, were both very curious as to what Copland brings regarding dependency injection, and why a simp
1000
ler approach would not be more appropriate. I need to do some more thinking about how to present IoC, since in my mind, if people came away from my presentation still wondering about something so fundamental, then I’m still not communicating the concept adequately.
Gordon James Miller: Code Generation in Ruby
The last speaker was Gordon James Miller. He discusses his professional work on embedded fail-safe network systems. Although they are implementing those systems in C++, he is being very successful at applying Ruby as a code generation framework. He (and his team) define the network protocols they are using in (potentially large) XML documents, and then they generate C++, Java, and Python code from those documents, using Ruby. He is using REXML to parse the XML documents, and ERB to manage the actual generation of the code from templates.
It’s actually a very similar framework to what I’ve got going at work, myself, where we use YAML-based data files and ERB templates to generate Java classes. It’s worked very well for us, too.
Conclusion
And thus the conference concluded. Lunch was served and people began milling about and talking. I spoke with several people afterwards. Austin Ziegler suggested that I might (once I’ve got Ruby-based registry serialization working) consider porting Ruwiki to take advantage of IoC. Hal Fulton wondered if IoC might not be useful in designing a GUI framework abstraction for rapidly designing simple interfaces. Jim Wierich was interested in some of the AOP aspects of Copland.
I was pretty disappointed at having to leave before the “self-organizing activities” got underway—I think there would have been a few people willing to help me prototype a Ruby-based way of defining registry elements for Copland. But, my plane was scheduled to leave at 3 pm, and by the time lunch was over it was nearly 1.
Thus, I bid farewell to RubyConf 2004, boarded the airport shuttle, and headed west.
Previous Topic
