Dan Yoder is the Director of Development at ATTi R&D, and will be talking about Waves, a Ruby architectural framework for developing RESTful apps.

A Brief History

Ruby web development came of age with MVC and Rails. Later, people who didn’t need a full MVC invented Sinatra and other frameworkes. Which brings us to today, and …

Waves Introduction

Waves can do simple apps in just a few lines of code. And by using “foundations”, developers can build more advanced apps with MVC-like functionality. You can build your own foundation for whatever web framework you envision (there are several for MVC and REST).

Waves supports rack::cache and JRuby. It’s Actually In Production(tm)!

Web as Services

As more rich browser apps use AJAX and COMET, server-side APIs are becoming more important. This is where REST shines.

“HTTP isn’t MVC, but our frameworks think in MVC.”

REST and ROA

“REST” shouldn’t be applied to things that are “REST-influenced” (just ask Roy). Dan likes to use “Resource-Oriented” for these situations.

HTTP-based ROA uses the existing infrastructure, and has proven scalability. HTTP defines a protocol for a distributed hash table:

• put(key, value)
• get(key)
• delete(key)

Q: “What about post?” A: “Post is for ‘everything else’.” Some things aren’t clearly RESTful, and post is the catch-all for other operations.

What’s in the hash? Resources, and keys are the URIs.

What’s the point? Platform-neutral distributed objects! RDF can be used to describe discoverable resources.

ROA in action: rss/atom. It’s one link to a resource describing your blog. “Boom! Podcasts for free.” Dan describes this as the law of “unintended consequences,” in a good way.

Edge caching is another big win for HTTP-based ROA.

How Does Waves Help?

Waves makes it easier to write resourceful applications like this today. New foundations will make it even easier going forward.

You can check out Waves at http://rubywaves.com, and on their Google Group.

Eleanor McHugh, a physicist by training, will be talking about how to make *nix systems work naturally within the Ruby environment.

The Unix Way

Eleanor actually hates Unix, but recognizes that it’s a very effective operating system for getting things done. It’s DRY: build little things, build them well, don’t build them twice. There’s a natural marriage between agile Ruby and the Unix philosophy.

Unix provides basic services which make it a very useful OS to “muck about with”:

• virtual memory
• process management
• hierarchical file system
• user permissions
• interprocess communication

Ruby provides some “really lovely” utilities:

• Kernel.system
• Kernel.spawn
• IO.popen
• Open3.popen3

However, if you’re doing a lot of IO, you end up doing a lot of select()s and keeping a lot of file descriptors open.

System Calls with Ruby DL

DL, which Ruby delivers out of the box, is a way to wrap a C library with a Ruby call. This is a nice way to access the underlying kernel system calls without relying on the Ruby IO implementations.

This is superior to Ruby’s syscall, in that you can actually get results back from the function call.

Using mmap allows you to do much faster memory reads, rather than do slower file reads.

Using kqueue/epoll/inotify allows you to build evented ruby (like EventMachine, but without EventMachine).

Using pipes allows you to build efficient IPC.

The drawback is that using DL means more verbose code, and more error prone code. (Pointer math FTL!) So, for things like sockets, use the Ruby API unless you specifically need kernel-level eventing.

Multicore

The lack of real thread support in Ruby can be addressed by using multiple processes, held together with IPC (sockets, pipes, memory mapped files). This is the traditional “Unix way” for handling multiple processes.

Gregory Brown is the creator of Ruport and Prawn, and the author of the upcoming Ruby Best Practices. He’ll be talking about the various-and-sundry Ruby implementations.

Moving to 1.9

On Ruby 1.8, strings are sequences of bytes. On Ruby 1.9, strings are proper characters (not bytes!). Even if your app only speaks “American”, you still need to be aware of this to handle data properly. Plus, some of the new syntax in 1.9 is not backwards compatible with 1.8.

Recommended steps for upgrading from 1.8 to 1.9:

1. make sure you have good test coverage!
2. make sure your test are checking the output (some end-result validation)
3. run on 1.9
4. hammer on your code until the tests pass
5. decide whether to continue to support 1.8

Prawn only officially supports 1.8.6 and 1.9.1 to make life easier, but if support more versions is necessary for your project, check out ZenTest’s multiruby features.

Greg recommends using conditional-execution blocks to make version-dependent code look nicer:

if RUBY_VERSION < "1.9"
 def ruby18
   yield
 end
else
 def ruby18
 end
end

Greg opines that moving to Ruby 1.9 is not a magic bullet, but has lots of advantages, so try it out!

Ruby 1.8.7

Ruby 1.8.6 is a workhorse (insert image of beat-up pickup truck). Ruby 1.9 is a Lamborghini (we think). “What the hell is 1.8.7?”

Answer: 1.8.7′s patch set is largely 1.9 backports. It’s a platypus!

However, this doesn’t mean that code written for 1.9 will magically work on 1.8.7. Or that code written for 1.8.7 will work on 1.8.6.

What should authors be doing? Should we release for 1.8.6 or 1.8.7? Greg recommends releasing for 1.9, especially if you’re writing a Ruby book (wink wink).

Peanut Gallery

Eric Hodel (maintainer of Rubygems), is planning on dropping 1.8.6 support within the next year, but continuing support for 1.8.7 and 1.9.

Writing Extensions

FFI (Foreign Function Interface) is supported “all over the place”, and is an alternative to writing a C extension. FFI works across implementations (JRuby, Rubinius, and MRI).

On Windows, Greg proclaims that JRuby is the easiest way to wrap a C library. “WTF?”

Oversimplified Explanations of Ruby Variations

According to Greg. (Not all of the nuance may be captured here, since Greg was moving pretty quickly. Blame me, not him.)

• 1.8.6 is ubiquitous, and may be slowing adoption of other, better interpreters.
• YARV (1.9) is faster than Matz’s implementation and is the only complete m17n implementation of Ruby.
• Ruby Enterprise has a great installer!
• JRuby is great and new, but requires C extensions to be rewritten
• Rubinius is what created the RubySpec project and FFI, and is very innovative.
• MacRuby is, um, Ruby for Macs.

Good morning! Today Ben Woosley and I will be live-blogging what’s going on during Goruco at Pace University.

You can check out some photos of the conference.

One day only… We’re giving away one ticket to GoRuCo, the Gotham Ruby Conference happening here in New York tomorrow, Saturday, May 30th.

Rules: Submit your Pivotal Tracker-related Haiku to tracker-haiku-contest@pivotallabs.com by 5pm ET tonight, May 29th.

We’ll pick one winner, at our sole discretion, to be announced here. All submissions are licensed to Pivotal Labs to use however we see fit, and you retain the ability to use them as you see fit, under the Creative Commons commercial attribution share alike license. The winner will be granted one ticket to GoRuCo, to be used tomorrow.

Valid entries must include name, telephone, and email. Name will be used in attribution, but neither the telephone number or email will be made public.

So have at it! Give us your Tracker haikus. Don’t know Tracker yet? Check it out!