Building with Rake (Jim Weirich)

I did manage to squeeze in a single slide showing the creating of a GEM file from a GemSpec. This was a teaser from the RubyGem folk that Rich elaborated on later in his talk.

Toward a Refactoring Framework for FreeRide (Hal Fulton)

Hal shared some of his ideas for a Refactoring framework for FreeRide. He has been experimenting with the Scientilla editor widget and has some (very) rudimentary refactoring and code assists running. Truthfully, Hal was limited by the lack of a good Ruby-based parser for Ruby. Without that, a full featured rectoring browser will have to wait.

The discussion that followed Hal’s talk centered on the need for a good Ruby parser. There was some talk about Ripper, which is a port of the original parse.y file from the Ruby source base, but replaces explicit parse actions with a callback/event based mechanism to allow something other than the Ruby interpreter to use it. FreeRide is using this parser and there is some hope that it will be integrated back into the Ruby source tree so there will be only one parser. I can think of serveral projects that would benefit from this.

Ruby and the Java Debug Wire Protocol (Rich Kilmer)

I don’t think Rich could decide what topic he wanted to present at the conference this year. The main thrust of his presentation was about using Ruby to control Java VM via the Java Debug Wire Protocol. Rich uses a ruby based monitoring script to control the execution of over 100 (large) JVMs.

One thing that I found particularly interesting was how Rich generated the code for the low level debug packets. The JDWP is a binary protocol, with around 70 different packet types. There is an HTML writeup from SUM detailing all these different packet types. Rich transformed (by hand) the descriptions of the packets in HTML to more or less isomorphic Ruby code. In other words, He described the packets using Ruby instead of HTML. He then wrote a generated that loaded the Ruby descriptions of the packets and generated code to parse, send and receive the packets. The Ruby description and generator were several hundred lines of code, but the final generated code base was well over 1500 lines. Not a bad trade-off.

I’ve been thinking about Ruby as a declarative language for a bit. See onestepback.org/articles/buildingwithrake/appa.html for some of my thoughts in the area.

When Rich got to the demo portion of his talk, he pulled up a terminal window and tried to run his program which immediately failed because one of the Ruby JDWP libraries were not installed. "Oh look" says Rich in a mock serious voice, "I’ve got a GEM for that library here." Rich runs the GEM which installs the library. He then tries the demo again, but it fails because it is requiring the wrong version of the library. Rich fixes the version problem and the demo runs without a hitch.

What you missed if you blinked was that Rich inserted a mini-demo of the RubyGems project into the middle of his Ruby-JDWP demo. Although sneaky, the next part of the demo should he had even more tricks up his sleeve.

The demo consited of a JVM running some Java-2D demos and a GUI listing the JVM threads and command buttons to start and stop individual threads or the entire JVM. The GUI was implemented by Ruby code, and although I couldn’t place the toolkit used to generate it, I didn’t really think too much about it.

After the demo, Rich revealed that the GUI was done using the Alph project (Rich had been dropping hints about Alph all weekend long). The GUI was drawn in a Flash component and communicated with a controlling Ruby script that specified the components and buttons to appear on the page and then handled the callbacks when those buttons were clicked. The Flash portion of the GUI is a single file that implements all the components, but lets the Ruby script completely control it. You need the proprietary MacroMedia development kit to create that Flash file, but once created it can be used by any Ruby script. In other words, you can develope your GUI completely in Flash without using the proprietary Flash development kit. Cool!

Why is it named Alph? It comes from the poem:

  In Xanadu, did Kubla Khan
  A stately pleasure dome decree
  Where Alph the sacred river, ran
  Through caverns measureless to man
  Down to a sunless sea.

Rich was thinking of a GUI Utopia, and Alph the river runs right through that utopia. One of my favorite quotes from Rich during the talk:

"This is pretty much the fun thing you do in Open Source, is think of names." — Rich Kilmer

Post Conference Activities

The presentation portion of the conference ended around 11:30. Lunch was to be served at noon, so I hustled up to my room to check out of the hotel. After lunch, several of us decided to head to the airport to take advantage of the WIFI network, even though our flights were not scheduled for several hours.

At the airport, Chad and Rich put some final touches on the RubyGems code and checked it into RubyForge CVS tree. I did some cleanup on Rake and as soon as they check RubyGems in, I updated the copy on my laptop and generated a GEM for Rake 0.2.9. I then uploaded the GEM to the file area of RubyForge allowing me to claim the first GEM enabled application on RubyForge (we are ignoring for the moment that I forgot to use a "require_gem" in the source, so the fact that the Rake GEM won’t work out of the box is a small blight on that claim).

Rich and Chad’s flight was about a half an hour before mine, so after they left I hung around the ruby-lang IRC channel and answered some questions on RubyGems. I even started the gem_server on my laptop and allowed a couple people to download the Rake GEM directly through the gem_server before I to pack up to make a plane. What a great way to cap off the whole weekend.

Late Update: Presentation Source

Ryan Davis is hosting all the 2003 RubyConf presentations. You can find them at www.zenspider.com/Languages/Ruby/RubyConf2003.html

Speaking of which, I’ve uploaded the "Building with Rake" presentation I gave this morning at the conference. You can find it here.

I’ll get my notes from the conference upload once I have a chance to review them and polish the words a bit. Watch this space.

I’ve always liked Fowlers "UML Distilled" book because it drilled down to the really important parts of UML without getting caught up in a lot of the superfluous annotations. I definitely fall into the UML-as-sketch category. Now I wonder where UML is going.

If anyone has a heartache over losing Sys, I’ll provide an optional Sys module in a contrib directory. But for now, Sys is being deprecated.

I just love it when I can delete code!

The project is moving slowly. It is very difficult to come in once a month and work a few hours on a project, and then leave it for another month. We spend a good portion of the meeting remembering what we did last month, and just as we get up to speed, the meeting is almost over. It’s a good thing that the goal of the group is more to learn XP practices than to actually finish this project.

Tonight we concentrated on continuous integration. As soon as we had a new JUnit test working, we were to get the integration token and commit to our CVS repository.

If you are in the Cincinnati area and want to join us, feel free. We meet on the first Tuesday of the month. You can find more information here.

I’ll be talking about Rake at the upcoming Ruby Conference. I’m in the process of cleaning up the code, writing more docs and getting my presentation ready. So if there is any feedback you would like to provide, now would be a good time.

What Is UML?

User Mode Linux is a version of Linux that sits on top of a running linux system and runs entirely in the users unprotected process space. At first glance, this seems like a really useless idea. Why run a virtual Linux when you have a "real" version already running on your hardware. It turns out there are a number of useful things

So why would you want to run a User Mode Linux? Here’s some ideas…

• Kernel Development. Running your test kernels in user space makes it much easier to debug your kernels. And crashing a kernel just brings down your local copy, nothing else.
• Experimenting with New Kernels or Distributions. Again, because the UML is isolated from the real system, you can try out new kernels or even whole distributions that you would not normally want to deal with.
• Secure Sandbox. Since the UML has no access (not explicitly granted) to the host Linux system, a UML is a great place to run potentially malicious applications.
• Experimentation. Ever wonder what would happen if you typed "rm -f /" as root. Do it in a UML without fear of breaking anything else.
• Networking. UMLs each act as their own host, so you can setup a network of UMLs on a single box to experiment with networking solutions.
• UML Farm. Put a bunch of UMLs on a single server and let individual users have an entire (virtual) linux system to themselves. We’ll come back to this idea in a moment.

You get the idea. So why is this blog hosted on a UML? First, we need some history.

The UML Coop

Over the years, the local ISP that I use went from being a great ISP to being a very mediocre company. Changing hands several times, it was finally bought by Nuvox who offered to "upgrade" our 100 Mbs of web storage to a generous 5 Mb. Several members of CLUG began looking for alternative web hosting solutions.

In January of this year (2003), David Coulson from the Cleveland Linux User Group came to give a presentation on UML. David has done extensive work with UML and mentioned that he was interested in starting a COOP that would purchase a server on the internet. Each member of the COOP would get their own UML instance to do whatever they wanted.

It took several months before the COOP came together, but by May we had purchased a server and hosted it at N2Net in Cleveland. The system is currently supporting around 20 UML instances with little problem (except for the one day we got slashdotted).

Using UMLs

How CLUG members are using their UMLs?

• Kip
  • Web hosting for shafferhouse.org, a family picture galary.
  • Web hosting for exams4pilots.org, a practice exam site for pilots.
  • TMDA Mail Filtering (TMDA is worth a posting in its own right).
• Jim
  • Web hosting for onestepback.org, this blog site.
  • Mail filtering (someday)
• Jeff
  • Jeff has applied to join the UML COOP, but hasn’t got his UML instance setup yet.
• Monty
  • Shell access from an internet host
• Ryan
  • Mirroring for picture galleries. Ryan hosts a web site on his home system, dlugosz.net. To avoid high bandwidth on his home box, he redirects graphic requests to his UML box.

Some UML Links

• user-mode-linux.sourceforge.net/
• usermodelinux.org/

The scary part is that I have seen some of these in practice.

• Efficiency
• Correctness
• Maintainability
• Understandability
• Personal Expression
• Adherence to Standards
• Scalability
• Reusability
• Testability
• Portability

I’ll give our results here in a minute, but go ahead and pick your top five before reading on.

My personal picks were: Correctness, Maintainability, Understandability, Reusability and Testability.

Once everyone had picked their top five, we got together in groups of four and determine the top three items within our group of four. The top two was easy: Correctness and Maintainability. We had a tie for third place between Understandability and Reusability, and broke the tie in favor of Reusability because we felt that Understandability was intimately tied to Maintainability anyways.

Finally we surveyed the entire group and totalled the votes from each of the subgroups. Heres the results:

• 8: Correctness
• 8: Maintainability
• 3: Reusability
• 2: Efficiency
• 2: Scalability
• 1: Adherence to Standards

We see two strong winners here: Correctness and Maintainability. Every group voted for them. Beyond that, there is no clear winner. One thing I do find interesting is that Testability didn’t make the final cut in any of our groups. Even though our team is developing a strong test driven design culture, it hasn’t (yet) spread to the rest of the department. It seems we have our work cut out for us.