Al Hoang

Lightning talks are one of the more interesting parts of a conference in my opinion since 5 minutes really forces the speaker to get to the point and it becomes painfully obvious if the presentation has no focus or if there has been real work to get across the main message in the shortest amount of time.

So here are some highlights

Kuwata on Java to Ruby

• No, not the book Java to Ruby
• Going from Java to Ruby requires a change in mindset. Not a change of code
• Some historical example: COBOL in Java (ed. That sounds frightening) is like Java in Ruby
• Don’t hold back experts and too many things spend too much time on beginners
• Do not keep beginners as beginners (teach them!)
• Bragging about the largeness of a project size is the wrong type of bragging (suggested large code + many devs == lack of ability

dRuby & Security by Nishiyama

• druby is not built by default to handle the wild Internet
• There is a feature called insecure method list that will help prevent certain methods from being invocated remotely
• Use $SAFE however it won’t save against a DoS. Also don’t forget about rlimit

Ruby + ODE by Sasaki

• Showed a very nice 3D demo walkthrough world controlled with a Wii-mote and looked like the Pitagora Switch world
• Can summon objects pressing one of the buttons
• Can stop time
• The project should be on Code Repos
• (ed. Seeing this in action was far more interesting than reading these notes)

• Conclusion first: Sorry they don’t
• Showed some very nice examples of using the Enumerator library for many bad cases (each_slice)
• Beginning Ruby programmers really love each to the point of going overboard

Folk programming with Ruby by mootoh

• Folk Programming was introduced at YAPC Asia 2008 (See my notes)
• Show examples outside of building web applications such as Rich UI exploration
• Showed examples of Plugins to other programs since it’s easier than writing a big app (although with Ruby the apps should be nice and small)
• Some examples: Safari + Hatena bookmark, Quicksilver + Twitter (looks dangerous), Quartz Composer + Gainer, Vim + Refe
• Ruby is a very good glue

Again as a Rubyist… toRuby by Ikezawa

• (ed. I liked this talk a lot since it wasn’t by some uber-Ruby hacker)
• Didn’t use Ruby until 2000
• Background was as a consultant since 1984. Helped found a Wapro Kissaten!
• Moving to Ruby hit the OOP barrier. Was not used to OOP methodologies at all
• Stopped however after a long time in June 2007, found a local Ruby guru to help him out and that got the ball rolling again
• Invites others to join in

Ruby 1.9 with Rails 2.1 by matsuda

• Went through the history of web programming (or his version of it)
• Ancient History – PHP
• Recent History – DB Framework with ORM (in Java… lots of these frameworks)
• Current – Rails
• However DB access is a Rails weakness
• Introduced named_scope feature (Is this a Rails 2.1 specific feature? Need to review this myself
• More info on this at blog.dio.jp

Read code with Testing by Endoh

• Rookie Ruby Committed
• His suggestion on learning is by reading real code
• Use TBCR (Test Based Code Reading)
• Run make test-all
• Find code paths that are never executed
• Add tests (requires more code reading)
• Using this method have increased Ruby’s test coverage to 85%
• In contrast Python is 80%, Perl 63%, PHP is 51% (plans to target PHP next)

Okay this is my notes from Matz’s Keynote. I was 5 minutes late since finding lunch took a really long time to find anything around the area unfortunately. Unfortunately, most of the visiting Rubyists decided to do KFC however Charles Nutter decided to stick it through and we finally found a nice Yakiniku restaurant to eat at but that ended up being the reason I was 5 minutes late… okay anyways here are my notes from in the middle of the talk…

Matz was talking about sanctuaries and how some technologies have built their sanctuaries over time. Here are some sanctuaries he mentioned and some of their defining characteristics:

• UNIX
• The filter (wahoo!)
• “Worse is better” aka the New Jersey School of Design (I always ask myself just how much worse though..)
• Convenience over perfection
• Smalltalk
• OOP, deep OOP
• Targeted at children (funny how only greybeards really use this language now discounting eToys)
• Bytecode VM but not the first to have one but one of the more prominent ones
• A dynamic language implementation with decades of hard-earned experience, wisdom and knowledge around it
• java
• Well Java seems to fulfill business and ‘enterprise needs’ (for now)
• Java was originally slow however time has changed that perception. Java’s speed complaints have mostly faded away (But I still complain about a 30 second startup time for the VM)
• Absorbed many other ideas from other languages (VM, Garbage Collection, Exception Handling)
• Java has one of the fastest Garbage Collected VMs now (with the amount of engineering effort thrown at it I’d hope so)

Matz then describes that Sanctuaries tend to go through the following phases

• Hackers gathered
• New technology is born
• The world changed (because of the technology? Missed this…)

Don’t forget about centripetal forces during these stages. The community matters quite a bit. According to Matz, 50% of the types of OSes out there in this world are some type of UNIX.

Finally, he goes on to describe the Ruby Sanctuary and its defining characteristics

• For Rubyists, feeling matters. Focus on the human and the joys programming
• It inherited many things from the past. Lisp metaprogramming, Smalltalk OOP, UNIX text processing
• Productivity matters. Machines are faster but people’s time is much more expensive
• Agility matters. Environments change and embracing the changes is the right thing

At this point a person from Rakuten comes up on stage and talks about some projects that Matz has been collaborating with.

One is called ROMA which is some sort of distributed memory data storage (think memcached with some more ability for data integrity in case of failures)

The other one is called fairy which is supposed to be a lightweight distributed programming framework.

Unfortunately it seems that both projects are rather delayed and it doesn’t seem apparent if these projects will be Open Sourced or not. That is rather disappointing to me but can’t have everything for free now can we?

Evan Phoenix on Rubinius

Evan started off with a quick intro on Rubinius and proceeded to talk about some of the big pieces of Rubinius from a 10,000 feet high view.

• The kernel of the system
• The C Compatibility Layer
• It’s a big project and Evan wants to have a conversation with anyone who wants to have one on it

For the VM nerds here are some feature highlights…

• Accurate generational Garbage Collector
• Bytecode based VM
• Capable of bootstrapping itself

Evan suggested we should think of Rubinius sort of like an OS.

Then he started diving right into a tour of some of the cool internals of Rubinius and explaining some of the internal objects that really are the heart of Rubinius (above the VM layer)

BTW what is the <<? Evan coins it the left chevron.

With MethodContext and CompiledMethod it’s possible to implement eval in Ruby and follow the principle of Code as Data. Taking advantage of Ryan Davis’s ParseTree (included in Rubinius) one can take something like

"1 + 1".to_sexp

Which will take 1 + 1 and change it into an s-expression, convert it into an AST, and a User Visitor Pattern implementation can walk through this and spit out bytecode. (I might have recollected this wrong.. if so, sorry.. Not a VM implementor)

Some other big features that Evan mentioned were

• Extensions
• Getting close to running Ruby C-extensions
• However they are still 2nd-class citizens (they will take a performance hit but working is better than fast and broken)
• MRI in this case is still faster
• Multi-VM implementation
• stdin and stdout are implemented as pipes
• Functional but still highly experimental (can try calculating Pi across a multi-core machine)
• args = ["-e", "puts", "hello"]
  vm = Rubinius::Vm.spawn args
  puts vm.stdout.gets
• Channels
• One of the main internal communication channels used in Rubinius
• I/O events use channels for example