Ruby and/or Rails

OS X: Built-In Apache Web Server Can Keep The Twitter Monkey Off Your Back

Giles Bowkett — Wed, 11 Nov 2009 15:30:00 -0800

For a long time I've periodically mapped Twitter and other distracting sites to localhost in my /etc/hosts file.

Tonight I decided to get a bit harsher with myself. OS X ships with an Apache web server not only built-in but up and running by default. So I did this:

cd /Library/WebServer/Documents/

git init
vi .gitignore # ignore WebObjects/ and Java/
git add .gitignore *.gif *.html.*

vi index.haml
haml index.haml > index.html.en
vi index.css

git add index.css
git add index.haml
git ci .

And I got this:

It'd be cool to create some kind of nifty app and store it on 127.0.0.1, but I think this will get the job done for now. In practice I've found host-file bans really easy to circumvent - obviously, I always have sudo on my own machines - but it's still a nice reminder, kind of the Web geek equivalent of a really big, bright pink Post-It note.

What seems to actually work, however, is setting daily targets, with associated rewards, for Twitter avoidance. It's too early to blog about that yet; it's earned me maybe one day of clarity and peace, maybe two max. It's also earned me a Puma hat, which is a mixed blessing; that "associated rewards" part could turn expensive.

The Irish bit might seem a bit harsh. A little backstory: I'm Irish on my mother's side. Not Irish the way every person born within 100 miles of either Chicago or Boston is part Irish. Full-blooded Irish. My grandfather, who was born in County Waterford, has faked an English accent his whole life, but give him a few beers and some Irish poetry, and you might get to hear his true voice.

Speaking of a few beers, everybody knows the stereotype of the Irish drunk. The magazine Molecular Psychiatry found evidence that suggests the Irish may be genetically predisposed to alcoholism. Although I have no proof, I think it goes further than that; I think there's something wrong with dopamine receptors among the Irish. Dopamine drives habit-forming behavior. This includes Twitter.

A Twitter habit is nowhere near as damaging as alcoholism, drug addiction, or a gambling problem - all more destructive habits that dopamine can drive - but it's still an annoying habit and usually a waste of time. I say usually because I also get great information and conversations from Twitter now and then. I even got a pretty great job off Twitter once. I've read the fantastic book Everything Bad is Good for You, and I can't help but wonder if there's some hidden upside to Twitter.

Torquebox: An All-In-One Java/JBoss Powered Ruby Webapp Platform

Wed, 11 Nov 2009 15:43:09 -0800

In the past two years we've seen a number of changes in the world of Ruby webapp deployment, but have you heard of Torquebox? Built upon the Red Hat Inc. JBoss middleware, Torquebox is an enterprise-grade application server that provides scale-oriented services to your Ruby webapps, including turn-key clustering. With its latest release, Torquebox supports all Rack-based Ruby frameworks.

Torquebox comes with job scheduling and asynchronous task scheduling out of the box (no extra installs necessary), and while I've grown fond of RabbitMQ, the ease of using the built-in JMS (Java Message Service) messaging is appealing, particularly if you're likely to deploy within a Java dominant environment. If you are having trouble convincing management to let you use Ruby, Torquebox is the most enterprise-oriented platform I've seen to date. Not just that, it's open-source and licensed under the LGPLv3. Their community site boasts that JBoss (upon which Torquebox is built) is "the world's number one Java application server, and it was created by the community."

Torquebox 1.0.0.Beta18 was released within a day's time from the latest JRuby 1.4 release and you can download Torquebox from its download page, or build it yourself from source easily obtained from GitHub. If you are using Mac OS X, the following code sample will get you up and running with a simple cut and paste:

wget http://repository.torquebox.org/maven2/releases/org/torquebox/torquebox-bin/1.0.0.Beta18/torquebox-bin-1.0.0.Beta18.zip
unzip torquebox-bin-1.0.0.Beta18.zip
mv torquebox-1.0.0.Beta18-bin torquebox
export TORQUEBOX_HOME=~/torquebox
export JBOSS_HOME=$TORQUEBOX_HOME/jboss
export JRUBY_HOME=$TORQUEBOX_HOME/jruby
PATH=$JRUBY_HOME/bin:$PATH
sudo gem install jruby-openssl
sudo gem install activerecord-jdbcsqlite3-adapter
cd ~/torquebox/share/rails
rails -m template.rb ~/torquebox_rails_app
cd ~/torquebox_rails_app
rake rails:freeze:gems
emacs config/database.yml # (now prefix sqlite3 with jdbc to become "jdbcsqlite3") jruby -S rake gems:install
jruby -S rake db:migrate
jruby -S rake torquebox:rails:deploy
jruby -S rake torquebox:server:run

While waiting for JBoss to unfurl, you can close your eyes and do a mental walk-through of installing Erlang, a RabbitMQ daemon, cron, HAProxy, etc. – because you won't have to do that with Torquebox – and when you open your eyes approximately two minutes later, you should be able to see the default Rails page at http://localhost:8080. While everything appears the same as if you were running on it on a Mongrel, you're really experiencing Rails as it's presented from within a JBoss AS appserver, more about that in a minute.

Handily, Torquebox contains tried-and-true JDBC drivers for a number of databases, including Derby, H2, HSQLDB, MySQL, PostgreSQL, and of course, SQLite3. Additionally, Torquebox is Capistrano friendly – so you probably won't need to learn any new tricks to deploy – and it also has built-in support for cryptographic key-storage.

With an application appropriately bundled into a WAR file, you can utilize Torquebox's farming to "deploy your app to one node of the cluster, and to have that node farm it out to all of its peers." Torquebox uses httpd+mod_cluster out in front, so it's "intelligently aware" of your JBoss cluster, and thus, if you have a two-node cluster running, and you start two more JBoss instances on the same subdomain, they'll auto-join the cluster and then the existing nodes will auto-farm the app to them. You're app now has twice the resources and didn't need to be restarted, which in and of itself, is pretty huge.

So, where does Torquebox fit in? One can make the argument that it fits "everywhere." The JVM comes pre-installed on Macs, is easy enough to add to Linux or a Windows desktop, and of course deploys to a number of hosts. Scaling the JVM isn't new, and finding the people to do so is probably easier than finding dedicated Ruby programmers. I would be remiss not to point out that JBoss is hungry for RAM, and I realized quickly that Torquebox wanted more cowbell than my Linode 720 could afford. Engine Yard Cloud greatly simplifies deployment to EC2 instances (via Chef), and the smallest instance provides a whopping 1.7GB RAM, so scaling JRuby through the company that houses the JRuby core commiters just makes sense to me. If, however, you feel better qualified to deploy Torquebox yourself, you might look at JBoss Cloud.

I recommend taking 10 minutes to watch the pair (1, 2) of screencasts by Bob McWhirter, which demonstrate all of what I've highlighted here in well under a half an hour.

[ad] Find duplication, code smells, complex code and more in your Ruby code with Caliper! The metrics are free and setup takes just one click. Get started!

Mail: An All New Ruby E-mail Library

Wed, 11 Nov 2009 07:02:04 -0800

To date, the main ways to send e-mails from Ruby have been Net::SMTP, TMail, and Rails' ActionMailer (which uses TMail). Now, however, there's a fourth option, the simply named "mail" by Mikel Lindsaar.

Mail is a new pure Ruby library designed to handle the generation, parsing, and sending of e-mail in a "Rubyesque" manner. Both the sending and receiving e-mails can be handled through the library and, where necessary, Mail proxies methods from libraries like Net::SMTP and Net::POP3. Ruby 1.9 support has been built in from day one so dealing with different text encodings in your e-mails is easier than ever (Mikel claims this is less than straightforward with TMail). Mikel also points out that Mail has 100% spec coverage.

There are lots of code examples on the Mail page but to give you an idea of how it works, here's a code example that sends an e-mail with an attachment:

Mail.defaults do smtp '127.0.0.1' # Port 25 defult
end mail = Mail.new do from 'me@test.lindsaar.net' to 'you@test.lindsaar.net' subject 'Here is the image you wanted' body File.read('body.txt') add_file {:filename => 'somefile.png', :data => File.read('/somefile.png')}
end mail.deliver!

As well as the main GitHub page for the Mail project, there's also a mail-ruby Google Group where questions can be asked, etc.

[ad] Find duplication, code smells, complex code and more in your Ruby code with Caliper! The metrics are free and setup takes just one click. Get started!

Upcoming Webcast: Tokyo Cabinet in One Hour - Meet Experts Online

O'Reilly Media — Tue, 10 Nov 2009 05:57:43 -0800

Config So Simple Your Mama Could Use It

john — Tue, 10 Nov 2009 03:00:00 -0800

In which I clog a bit of code for simple application configuration.

Tonight, Kastner asked me if I had anything to do some simple configuration for something he was working on. I’ve got a simple module and yaml file that I’ve been using so I gist’d it. It then occurred to me that I might as well share it here too.

The Yaml

Below is an example of the yaml file. Basically, I setup some defaults and then customize each environment as needed.

DEFAULTS: &DEFAULTS email: no-reply@harmonyapp.com email_signature: | Regards, The Harmony Team development: domain: harmonyapp.local <<: *DEFAULTS test: domain: harmonyapp.com <<: *DEFAULTS production: domain: harmonyapp.com <<: *DEFAULTS

The Module

The module can read and write to the config and even loads the Yaml file the first time you try to read a configuration key.

module Harmony # Allows accessing config variables from harmony.yml like so: # Harmony[:domain] => harmonyapp.com def self.[](key) unless @config raw_config = File.read(RAILS_ROOT + "/config/harmony.yml") @config = YAML.load(raw_config)[RAILS_ENV].symbolize_keys end @config[key] end def self.[]=(key, value) @config[key.to_sym] = value end
end

If I wanted to get the domain, I would do the following:

Harmony[:domain]

Nothing fancy, but it gets the job done. I just drop the yaml file in config/ and the module in lib/. Obviously, you would rename the module and yaml file to whatever constant you want, such as App or something related to your application’s name. I know there are gems and plugins to do configuration, but when something this simple gets the job done, I figure why bother.

What do you all use for app configuration? What do you like about what you use?

iGhost iRide iThe iWhip

Giles Bowkett — Tue, 10 Nov 2009 02:16:00 -0800

Interesting Ruby Tidbits That Don’t Need Separate Posts #29

Mon, 09 Nov 2009 19:09:03 -0800

Welcome to the latest installment in the series of compilation posts summarizing some of my latest findings in the world of all things Ruby. Let's tackle those links..

Alchemist: Easy Unit Conversion in Ruby

Alchemist is a new Ruby library that aims to take the pain out of performing translation with day to day units, such as miles, kilograms, kelvin, meters, and becquerels. There are a few ways you can perform conversions such as explicitly with a method: 8.meters.to.miles or inline: 10.kilometers + 1.mile. The library's source code is quite something to look at - there are units I've never even heard of before.

The Compleat Rubyist - An All-Star Ruby Training Event

David A Black, of The Well Grounded Rubyist fame, got in touch recently to promote his forthcoming The Compleat Rubyist training event. The instructors are David, Gregory Brown (of Ruby Best Practices fame), and Jeremy McAnally (of, well, lots of fame) and the event takes place on January 22-23, 2010 in Tampa, Florida. I initially wanted to do a series of interviews with the guys to help them spread the word but they'll come later (one word: newborn). Anyway, this is a great chance to learn a thing or two from three Ruby superstars.

You're An Idiot For Not Using Heroku?

In the dramatically titled You're An Idiot For Not Using Heroku, John Nunemaker relays how much fun he's been having with Ruby cloud hosting service Heroku which, you may recall, we covered very recently here on Ruby Inside.

A First Look at Rails 3.0

Dr Nic Williams has put together a walkthrough of Rails 3.0.pre, the embryonic version of the forthcoming Rails 3.0.

JRuby 1.4 Released

The latest significant release of JRuby, 1.4.0, is now available! (linked to a newsgroup announcement as jruby.org is down at the time of writing) The 1.4.0 release brings compatibility with Ruby 1.8.7p174, improved Java integration support, a Windows installer and native launcher, a new embedding framework, RubyGems 1.3.5, and a whole batch of bug fixes.

Hacking Gems With GitHub and GemCutter

Dr Nic Williams (who's proving rather popular in this post) asks: "Ever used a rubygem, found a bug, and just wanted to quickly bust out the big guns and fix it quickly? Surely, we all have.. so he's written Hacking someone's gem with github and gemcutter to show us how to easily fork an existing gem, make our changes, and get it deployed on Gemcutter tout de suite.

Building a Twitter Filter with Sinatra, Redis, and TweetStream

Mirko Froehlich (a.k.a. DigitalHobbit) has written an awesomely in-depth tutorial on how to build a "Twitter filter" using Sinatra, Haml, jQuery, and some other funky tools. If you want to see the result, check out http://twatcher.com/

The Official GitHub Command Line Tool

I hadn't heard of it before, but Dr Nic Williams announced the release of version 0.4.0 of "github-gem", an official GitHub "command line helper for simplifying your GitHub experience." If you're a GitHub user, this looks extremely useful. You can quickly deal with patches made on any forks of your project, fetch downstream changes, and so forth.

Peepcode On jQuery Features Snippet Of My Music

Giles Bowkett — Mon, 09 Nov 2009 10:20:00 -0800

Plus it looks awesome.

Rails Envy Podcast – Episode #099

Mon, 09 Nov 2009 11:37:15 -0800

Episode #99 Like a Boss edition. Here’s a YouTube link (NSFW) for those that haven’t heard it and don’t get the joke.

The Rails Envy podcast is brought to you this week by NewRelic. NewRelic provides RPM which is a plugin for rails that allows you to monitor and quickly diagnose problems with your Rails application in real time. Check them out at NewRelic.com.

Show Notes

RailsConf RFP Open

RailsConf 2010 will be held June 7-10, 2010 at the Baltimore Convention Center in Baltimore, MD – and Ruby Central and O’Reilly Media are now accepting proposals for conference sessions and tutorials. Proposals are due at 11:59pm EDT March 17, 2010.
Introducing Resque

Resque is GitHub’s Redis-backed library for creating background jobs, placing those jobs on multiple queues, and processing them later.
BigRecord

BigRecord is an object-data mapping layer for distributed column-oriented data stores (inspired by Google’s BigTable) such as HBase and Cassandra. Adapted from ActiveRecord, BigRecord is designed to work as a drop-in for Rails applications.
Rails Best Practices

Wen-Tien Chang’s slideshare presentation Rails Best Practices from kungfurails.
Alchemist

Alchemist is a fine Ruby unit conversion library designed for readability and convenience.
Limelight GUI Framework

Limelight is a rich client GUI framework.
Ruby Manor 2: Manor Harder

Ruby Manor 2: Manor Harder is taking place December 12th at Parry Hall, London and has the best tag line of any ruby or rails conference ever.
Jsvars

This rails plugin will hide the messiness of passing variables from rails into javascript. It will automatically add the js needed to create a variable you define in rails, or add variables to objects.
Underscore.js

Underscore is a utility-belt library for JavaScript that provides a lot of the functional programming support that you would expect in Prototype.js (or Ruby), but without extending any of the built-in JavaScript objects. It’s the tie to go along with jQuery’s tux.
Twitter gem 0.7.0 out

Twitter gem version 0.7.0 has been released with list support.
Yahoo BOSS and Rails

Vinsol has posted a small tutorial on using Yahoo BOSS with rails.
HTTPing

HTTPing.rb is a utility to measure web service response time. This is a Ruby port of HTTPing (http://www.vanheusden.com/httping/).
http://github.com/jpignata/httping
Win a Motorola DROID Programming Contest: “Worst App Server Technology Ever”

Engine Yard is sponsoring another programming contest. The goal of this contest is to collaborate with your other contestants to build the “worst app server ever” (WASE) , and use it to complete one or more challenge computations.
Refraction

Refraction is a Rack middleware replacement for mod_rewrite.
Continuous Integration with Signal

Signal is a continuous integration server written in Rails.
Nokogiri 1.4.0 Released

"XML is like violence – if it doesn’t solve your problems, you are not using enough of it."

Version 1.4.0 has been released. A big change in this one: Hpricot compatibility layer removed

JavaFX Coding Conventions

Sun, 08 Nov 2009 20:29:29 -0800

I've been writing a lot of JavaFX code over the last year. After some tweaking I've arrived at a style that I like a lot. I notice that even on my team there are some variations in how people format their code, so I thought I would document what I like in case this helps others get started. (I did a quick google search and didn't find any JavaFX coding convention documents anywhere. The closest thing I found was a blog entry, but while it contains a lot of good advice, the style it recommends does not match the practice of the JavaFX team (or the Sun Java style) either). Therefore, I thought I would document what I consider good JavaFX coding conventions.

Rather than post them here in a blog entry, I placed them in a Wiki page such that they can easily be improved and kept up to date as I get feedback and in case I change my mind :)

You can find the coding conventions document here:

http://wikis.sun.com/display/JavaFxCodeConv/Home

P.S. I will be speaking at Devoxx in Antwerp, Belgium next week! Hope to meet some of you there!

You're An Idiot For Not Using Heroku

john — Sun, 08 Nov 2009 09:17:00 -0800

In which I discuss my first experience with Heroku and my second. And how awesome it is.

It is true. You are. Go try it now. That is an order. I can wait for you to come back and finish reading this post. I could end the post now, but I suppose I’ll go on and tell you a bit about my experience with Heroku yesterday.

Formerly a Toy in the Cloud

Wynn and I were talking yesterday about how, back in the day, Heroku seemed like a toy in the cloud. They had a rich code editor and you could magically create and deploy applications that sometimes worked. It was neat, but nothing you would use for anything serious.

A toy they are no more. So what is Heroku? According to their site, Heroku is “fast, frictionless, and maintenance free.” After giving it another look yesterday, I would have to agree.

The App

I have a tiny note application that my wife and I use. I use it to mark things to read later and save plain text notes. She uses it to keep track of recipes, tagged with ingredients and whether or not she has made the recipe before. It is nothing fancy, but it serves a purpose for both of us.

The app formerly ran on Dreamhost (how to deploy rails on DH) and used MySQL. Since I decided not to attend the Notre Dame game yesterday, I had some free time, so I watched football on TV all day and worked on converting this project from MySQL to MongoDB (which is awesome).

Once I finished the conversion, which didn’t take long, I exported the MySQL database as XML using PHPMyAdmin (shutter) and then wrote an import rake task that reconnected the xml in MongoDB (which is awesome).

MongoHQ

I have had a MongoHQ invite for a while now, but hadn’t kicked the tired so I decided now was as good a time as any. Then it occurred to me. Why use Dreamhost when Heroku has a free account and I’m already hosting my database in the sky? Why not go cloud to the max and see how things end up?

Heroku

I logged in with my old Heroku account and did some reading through their amazing docs.

I gem installed heroku.
heroku created my app using the command line tool.
git pushed to heroku remote.

Boom. In less than a minute my app was created and deployed on Heroku. Impressive. Now that isn’t where the story ended. Hosting on Heroku is a bit different.

Config Vars

The first thing I ran into was some config file issues. I found Heroku’s article on config vars and switched my app to work like that. git push and my app was deployed again.

Gems

Now I was missing gems. Back to the docs I went, this time to read about managing gems. I created my .gems manifest and git pushed again. Just like that my app was up and running in the sky.

Conclusion

I made a few more changes to my app over the next few hours and deployed after each one with a simple git push heroku master. Each time, I almost giggled as the normal git messages happened and then out of nowhere, Heroku stepped in and informed me that it was deploying my app and…wait for it…wait for it…that the deploy was finished.

Now that I’ve used it for a tiny app, I’m curious to see what it can do with something larger. I’ll definitely be using Heroku a lot in the future, that much I know for sure. Combined with a hosted MongoDB service, it is absolute glory. MongoDB having their GridFS file store, means that not having write access to a file system on Heroku is no big deal. You don’t even have to setup S3.

I’ll leave you with my tweet from yesterday, summing up my experience.

Created and deployed a MongoDB backed Rails app to Heroku and MongoHQ today. I have witnessed the future.

Anyone else out there using Heroku? What kind of apps have you deployed on it? What have your experiences been? Curious to hear from others.

Time Management: Two Pics, Two Books, One App

Giles Bowkett — Sat, 07 Nov 2009 03:52:00 -0800

Lots of people are into David Allen's Getting Things Done. I discovered it in 1998, about ten years before it became a programmer fad, when it was a mail-order tape course that cost $100 instead of a best-seller on Amazon that cost $10. I liked the ideas, but in practice it was too complicated; there was no way in hell I was going to get from as disorganized as I was, to following a system that complicated, without becoming an organized person first. A system for becoming organized which requires you to already be organized in the first place was no use to me at all.

I've read a few books on time management since then, but they all seem to suck. These two books are the only two I've really liked:

No B.S. Time Management for Entrepreneurs (NO BS)

Time Management for System Administrators

Everything I'm doing now revolves around pen and paper (or felt-tipped marker and calendar). I've tried a lot of different software, including Things and RescueTime, but I only ever found one piece of time management software which was useful for me at all: Streaks.

However, even Streaks didn't really do it for me. I kept creating new calendars for all the new habits I wanted to cultivate - eat healthier food, work out every day, remember to wash the dishes, etc., etc. - and some of these things, I wanted weekly frequencies for, not daily. I couldn't solve the weekly problem with Streaks, and I solved the many habits problem with many calendars. Pretty soon I had more than 20 calendars, which was way more than Streaks was even designed to hold in memory, and performance nose-dived. So I bought a physical calendar and wrote on it.

It worked but it looked like crap. I soon upgraded to color.

Vertical lines represent weekly habits; horizontal lines represent daily habits. It's pretty great because you can see at a glance how you're doing. You can only track about ten daily habits with this, though.

I wanted to buy ten or fifteen calendars and put them all up on a wall, one calendar per habit, to make it much easier to read, but you can really only buy 2009 calendars in 2009 if it's January. The calendar publishing industry is so insane about promoting new releases that they make the car industry, which will have people buying 2011 model cars by June 2010, look reasonable. I realize I'm raising this complaint in November, but I started looking in August.

Anyway, come 2010, I might go for a wall of calendars. I've reserved wall space for at least ten calendars, just in case, but I might go for something simpler instead. I have some other ideas that might work better. I'd like to go into more detail, but I only have nine more minutes budgeted for this, and I have to take an unscheduled leak.

Full disclosure: The Amazon links in this post are affiliate links, which pay small sales commisions.

Coyotes, A Pulitzer, And DHH's Lamborghini

Giles Bowkett — Thu, 05 Nov 2009 08:00:00 -0800

A few months ago, Yehuda Katz came to LA Ruby and gave a presentation on his plans for Rails 3 and Rails 4. The presentation consisted almost entirely of a history of DHH, based on what appeared to have been a detailed (almost obsessive) analysis of everything DHH had ever put on the web in any way shape or form. Yehuda was looking at e-mails from 2003, Subversion commit messages from Rails 0.13, and beyond that to commit messages from Instiki.

Some people who have seen this presentation might have marvelled at Yehuda turning into some kind of web stalker or DHH historian. Personally, I thought it was awesome, because I had already spent a lot of my own time doing the exact same thing. That's how I know what color DHH's Lamborghini is (white), what model it is (Gallardo), and where he races it (Autobahn Country Club).

photo by symmetricalism

If that's creepy, I apologize. But it's also how I found Code Generation in Action by Jack Herrington. I did a whole presentation (at MountainWest RubyConf) about how every programmer needs to read this book, after I found it in an offhand comment on DHH's old blog.

(The sad thing, of course, is that the number of people who told me they loved the presentation is much, much higher than the number of people who told me they went and bought the book.)

I spent time studying DHH because when Rails came along, it was a Post-It Note - something so obvious you had to wonder why nobody had ever created it before. I started on the web before Perl even had database libraries, back when the way you used a database with a web app (which we called a CGI script) didn't involve opening a database handle, but creating a SQL string manually and putting it in backticks. All that SQL generation in ActiveRecord descends very directly from how this thing started, at least as far as I'm concerned. If I had taken that and just made it gradually cleaner day by day over the course of a few years, we could have had Rails in 1997 - and I could have done it. But I didn't. And neither did anybody else.

Why not? What did this guy know that nobody else did? These questions fascinated me.

Not just with technology, either. Only a few years before Rails emerged, I left San Francisco with the goal of never returning and never, ever having a thing to do with technology ever again. I was disillusioned, disappointed, disgusted, and bored out of my mind. I had a pimp 2-bedroom apartment in a pricey San Francisco neighborhood, and I traded it for a camper parked in the forest on my parents' land in the mountains of New Mexico. I stopped writing code and I put all my energy into studying electronic dance music production and writing screenplays instead.

this is an actual pic my dad took looking out his bedroom window

New Mexico is beautiful, but let me tell you something about RVs. If you decide that you're going to live in one, and you go looking to find out what your options are, you're going to find something out about RVs. You're going to find that Lamborghini doesn't make one. It's a different demographic.

not made by Lamborghini

My parents have a nice house on their land now, but they didn't at the time. It's there now because we built it. We got a small construction vehicle called a skidster. I cleared space for their house by driving that vehicle into sandstone boulders to smash them. Let me tell you something about skidsters - Lamborghini doesn't make those, either. Even if you ram it into a boulder at top speed, you won't be going very fast. I know because I've done it.

also not made by Lamborghini

Before the house existed, there were plumbing issues. On top of that, I was broke. But I was happy with this. I considered it a huge improvement. When I wasn't smashing boulders, I was writing and making music. Giving up success as a programmer to struggle as an artist seemed like a good deal, until my high school classmate Sarah Ruhl got nominated for the Pulitzer Prize, and won a MacArthur genius grant.

Sarah's a very successful playwright. I hadn't heard her name in a decade. But this was someone whose writing I knew, someone I worked on a high school arts magazine with and co-founded the first ever high school chapter of the ACLU with, someone who I remembered struggling with math when she was ten years old. There I was, living in a forest like an idiot hillbilly, while she was up for the Pulitzer. I realized it was probably a lot more fun succeeding as an artist than struggling as one. I realized what I was doing was ridiculous, and I wondered how in the hell I had gone so wrong, and what Sarah had gotten so right.

she lost to John Patrick Shanley, but still, holy shit

So when Rails came along, I was already obsessed with the general topic of what makes greatness.

If this question interests you too, I have good news. This book contains the definitive answer.

There are a couple other books that came out recently addressing the same question, but in my opinion, they suck. Malcolm Gladwell's Outliers is, in my opinion, self-indulgent, incoherent, uninspired, and flat-out unworthy of Gladwell - easily his worst book - and Talent Is Overrated looked too shallow to even investigate. Also, it matters to me that a book be well-written. If you're looking at a book wondering if it's well-written, and the book is called Talent Is Overrated, well, honestly, that ought to be a clue. If the clue isn't enough for you, let me give you another one: I read some sample pages, and it ain't Hemingway.

not the author of Talent Is Overrated

There are a couple other books I can recommend - The Inner Game Of Music and The Creative Habit - but they're really just related books. They don't come anywhere near hitting the same target, or even aiming at it. When it comes to the question of what makes greatness, and how to achieve it, The Talent Code is, in my opinion, the best book on this topic, and for many people, the only book about this topic that you need to read at all.

The book builds on some new research in neuroscience, around a substance called myelin, to a general theory of skill before launching what is (to me) infinitely more interesting: a tour of talent hotbeds all over the world. These are schools which produce disproportionate numbers of superstars in various fields - for instance, a Russian tennis school which trained a staggering number of top ten female tennis stars, a Dallas voice coach who trained Jessica Simpson, Beyoncé, and a ton of American Idol contenders, and a tiny island nation which produces an absurd number of baseball stars, despite having only one or two baseball fields on the entire island. (I think it was the Dominican Republic.)

In fact, my own high school might qualify as a talent hotbed. Alumni include Donald Rumsfeld, Rahm Emanuel, Rainn Wilson, Adam Baldwin (star of Firefly and Chuck), Pete Wentz from the band Fall Out Boy, Al Jourgensen from the band Ministry, Rock Hudson, Charlton Heston, notorious Internet fameball Julia Allison, and many others. Others such as Sarah Ruhl. The Pulitzer nomination didn't actually surprise me all that much, to tell you the truth.

Anyway, the author flew all over the world visiting these places and met with a staggering number of coaches and teachers who send their students straight to the top on a regular basis, and The Talent Code combines detailed theory from neuroscience with a long and impressive survey of the people and places consistently producing greatness, and pulls examples from that survey to illustrate that theory.

It's awesome.

The ultimate message is just practice makes perfect, but it matters a great deal what kind of practice, because practice doesn't always make perfect. Some practice does, some doesn't. You can't get good at something by doing it wrong over and over again. The brief, shallow answer is you require slow, deliberate, focused, challenging practice, but if your goal is greatness, you want more than the brief, shallow answer. If you want to find out what kind of practice makes perfect, and what kind of practice is just useless time-wasting bullshit, believe me, you need to read this book. If you want to find out how to be great at something, or how to teach your kids to be great at something, again, get this fucking book. Seriously. Get it.

Sarah Ruhl with Mary-Louise Parker, star of Weeds, who also starred in one of Sarah's plays. at roughly the same time this picture was taken, I was defending my parents' chickens from a hungry pack of coyotes.

yes, goddammit, coyotes. they tried to eat the chickens. and my dog.

Full disclosure: The Amazon links in this post are affiliate links, which pay small sales commissions. This includes the links to books that I told you not to buy, because fuck it, why not. But seriously, forget those books. Read The Talent Code.

New Ads By Ruby Row

Giles Bowkett — Thu, 05 Nov 2009 07:26:00 -0800

My blog's now sporting ads from Ruby Row, an ad network which also sponsors blogs by Thoughtbot, Jamis Buck, Geoffrey Grosenbach, Obie Fernandez, and loads of other great programmers. Cool beans.

Jekyll: A Ruby-Powered Static Site Generator

Thu, 05 Nov 2009 13:34:22 -0800

Jekyll is a simple Ruby-powered static site generator, originally by Tom Preston-Werner (aka mojombo) of Github fame. It's focused around blogging, but it can be configured to generate any kind of static site. (Note: Jekyll has been around for about a year - Tom originally blogged about it in November last year, so apologies if this is old news to some readers, but I've only recently discovered it!)

Because Jekyll outputs a static site structure, it means you can host your blog (or site) from anywhere that you can serve static HTML, simply by using your favourite web server (e.g. Apache). As Tom describes in his blog post, the idea came from wanting to be able to "Blog like a Hacker". Jekyll lets you write from the comfort of your favourite text editor, and publish from the command line. Using familiar tools reduces the cognitive load involved with publishing a blog, and lets you focus on what you're writing. It doesn't hurt that even a pretty weak Web server could stand a pounding if it's just serving static files!

By default, Jekyll uses its own (slightly modified) flavour of Liquid templates, with help from pygments for syntax highlighting, and you can use textile or markdown for the content. Each Jekyll blog article template needs a header containing some metadata about that article, such as what layout to use, the article's title, and any custom information you want to provide (such as tags for that article).

Generating your site is easy: just running the jekyll command turns your directory of templates into a complete website, ready to serve. There's a Jekyll server that you can use for testing (passing --auto as an argument means it will automatically regenerate the site when things are changed).

jekyll --server --auto

Github Pages provides a neat way to publish your Jekyll-generated site. Every Github page is actually run through Jekyll when you push content to your pages repo (this works because a normal static site is also a valid Jekyll site).

The easiest way to get started with Jekyll is by installing the gem (which is available on Gemcutter), and checking out the wiki on Github, where there's some great documentation.

sudo gem install jekyll

As you might expect, Tom Preson-Werner's personal blog runs on Jekyll. Its source is publicly available on Github.

Announcing O'Reilly Answers - Clever Hacks. Creative Ideas. Innovative Solutions.

Allen Noren — Wed, 04 Nov 2009 13:27:33 -0800

Devise: Flexible Authentication for Pragmatic Rails Developers

Wed, 04 Nov 2009 15:57:25 -0800

Devise (GitHub repo) is a new Rails authentication library/engine developed by Brazilian development company Plataforma. It's pitched as a "flexible authentication solution for Rails." Devise builds upon Warden, a general Rack authentication middleware, while offering Rails developers a flexible but easy to use front end.

Plataforma's blog post about Devise says that it's different to the incumbent libraries, Clearance and Authlogic, in that it provides a full stack solution like Clearance (unlike Authlogic) but allows you to use a custom model (not just "User") and gives you customized role support. It also has full i18n (internatiionalization) support out of the box and Plataforma has made available a complete demo app showing off how Devise can work within a small Rails app.

Devise is a full stack authentication system that provides 5 "strategies" out of the box. A strategy for authentication, one for "confirmations" (e-mails, etc), one for "recovering" accounts, one for "remembering" logins over time, and one to "validate" signups. You can, however, add your own strategies depending on what you need to do (they suggest a "invitations" strategy).

Tweet This Post

Training Your Inner Monkey

Giles Bowkett — Wed, 04 Nov 2009 03:29:00 -0800

Training monkeys on a two-choice visual task, researchers found that the animals’ brains kept track of recent successes and failures. A correct answer had impressive effects: it improved neural processing and sent the monkeys’ performance soaring in the next trial. But if a monkey made a mistake in one trial, even after mastering the task, it performed around chance level in the next trial — in other words, it was thrown off by mistakes instead of learning from them.

“Success has a much greater influence on the brain than failure,” says Massachusetts Institute of Technology neuroscientist Earl Miller, who led the research. He believes the findings apply to many aspects of daily life in which failures are left unpunished but achievements are rewarded in one way or another—such as when your teammates cheer your strikes at the bowling lane. The pleasurable feeling that comes with the successes is brought about by a surge in the neurotransmitter dopamine. By telling brain cells when they have struck gold, the chemical apparently signals them to keep doing whatever they did that led to success. As for failures, Miller says, we might do well to pay more attention to them, consciously encouraging our brain to learn a little more from failure than it would by default.

A nice little article, but guess what? The article's conclusion is ridiculous:

Success has a much greater influence on the brain than failure...we might do well to pay more attention to [failures], consciously encouraging our brain to learn a little more from failure than it would by default.

That's some of the worst logic I've ever seen. To find worse logic than that, you have to get a teenager to read Plato. "You learn more from success than failure; therefore, pay more attention to failure." Or to rephrase again, "Your brain is bad at a particular type of activity; invest more of your energy and time in that activity."

Obviously, if you want to learn something, and the brain responds to failure without learning anything, but it responds to success by learning, then focusing on failure is not a good learning strategy.

But what should you do? Does this mean that, if you don't score a home run the first time at bat, then the people who do will learn more than you, and be at a huge advantage the next time you compete with them?

Yes, it does.

So if you don't score a home run your first time at bat, you're doomed?

No.

The reason why not:

To learn, all you have to do is succeed.

Notice what that doesn't say. It doesn't say what you have to succeed at.

Let's say you're a tennis player. Somebody beats you at tennis. You revamp your tennis practice to focus on the tiny details of how you play. Why? Because you might not be able to win the games you want, but if you set yourself a tiny goal to win at serving, or to win at backhand form, or to win at aiming the ball, you can win there, and every time you win, you learn.

There's some powerful neuroscience supporting this and a great book which goes into exquisite detail. I have a blog post coming about that book. I'm aiming for tomorrow. It's a hell of a book, though, and it deserves more writing than I have time to finish at the moment, so for now I'm just going to leave you in suspense about it.

Watch Out For The Torpedoes

Giles Bowkett — Wed, 04 Nov 2009 01:03:00 -0800

Cory Doctorow damns every torpedo. If there's a law he disagrees with, its proponents are insane, or morons, or evil, and usually all three. If there's a book he likes, it's an amazing work of genius, untarnished by a single flaw. It makes buying books off recommendations on BoingBoing an insane crapshoot: every book is a work of staggering genius, yet only one out of three turns out to be any good. I often wish his praise was more specific.

Here's Doctorow damning the torpedoes in another way:

Every writer has a FAQ—Frequently Awkward Question—or two, and for me, it’s this one: “How is it possible to work as a science fiction writer, predicting the future, when everything is changing so quickly? Aren’t you afraid that actual events will overtake the events you’ve described?”

It’s a fresh-scrubbed, earnest kind of question, and the asker pays the compliment of casting you as Wise Prognosticator in the bargain, but I think it’s junk. Science fiction writers don’t predict the future (except accidentally), but if they’re very good, they may manage to predict the present.

Like many science fiction authors working today, Doctorow isn't telling us anything that William Gibson hasn't said before, and better - and if you don't believe me, check out Doctorow's post on Gibson saying this back in 2007. One of the superiorities in Gibson's way of putting it: he doesn't deny that science fiction is also good at predicting the future. Doctorow damned that torpedo, saying it only ever happens by accident.

Doctorow says:

Orwell didn’t worry about a future dominated by the view-screens from 1984, he worried about a present in which technology was changing the balance of power, creating opportunities for the state to enforce its power over individuals at ever-more-granular levels.

Gibson said, two years before:

1984 is a powerful book precisely because Orwell didn't have to make a lot of shit up. He had Nazi Germany and the Soviet Union under Stalin as models for what he was doing. He only had to dress it up a little bit, sort of pile it up in a certain way to say, "this is the future."

But the reason it's powerful is that it resonates of history. It doesn't resonate back from the future, it resonates out of modern history. And the power with which it resonates is directly contingent on the sort of point-for-point mimesis, like sort of point-for-point realism, in terms of what we know happened.

Note the absence of any sweeping generality equating the ability to predict the future with some kind of random luck. To quote the article Doctorow linked to in 2007:

Gibson's elaborate vision of the internet - before it existed - and Reality TV - before it existed - has led many to call his work prophetic.

Since Gibson owes a lot of his success to his prescience, you're not going to see him writing off that vision as luck. It could have been just luck, but when you check out the sheer literary density of Gibson's interview, you'll understand why I opt for a different explanation. I think Gibson thought hard about the future, and came to conclusions which were correct.

Doctorow's assertion that predicting the future is only a matter of luck would come off as a lot more plausible, and a lot more respectful of his peers in science fiction, if he (like Gibson) had an actual track record of successful and accurate predictions. I also find it hard to believe that he ever even hears this alleged Frequently Awkward Question in the first place. His last book, Little Brother, was set only a few years in the future, and his current book, Makers, appears to either follow the same model or to be set in the present.

On top of that, I don't think anybody even thinks of Doctorow as a science fiction author at all. I think of him as a blogger, and most other people I know (who have heard of him) think of him the same way. Long story short, I'm calling shenangians on this nonsense. Doctorow's posted a Cliff's Notes rewrite of a great William Gibson interview. Rewriting Gibson is like rewriting Hemingway or Shakespeare. Don't waste your time. Just read the interview.

Know When to Fold 'Em

john — Tue, 03 Nov 2009 16:22:00 -0800

In which I relinquish the day to day maintenance of a few of my projects.

I have a lot of projects. Each time I feel pain or inspiration, I’ll whip together a new library and release it as a gem. It is fun and I love it. It is even more fun when people come along and use those projects to do cool stuff. This in turn, inspires me to write more code and release more projects. It is a vicious cycle.

A while back, I caught myself making jokes about how I don’t even use my projects. I can barely remember the last time I actually used HTTParty, HappyMapper, or the Twitter gem. Not too long ago, I came across Dr. Nic’s Future Ruby talk on Living with 1000 open source projects.

In the presentation, he says that you should maintain the projects you use everyday and abandon the rest. Good advice. Over the past few months, I have been seeding maintenance and new features to other talented developers for several of my projects.

HTTParty

The first to go was HTTParty. I believe it was the Ruby Hoedown where I ran into Sandro. He mentioned some HTTParty bugs and asked him if he was interested in taking over. He accepted and the last release (0.4.5) was all him.

HappyMapper

Brandon Keepers, a good friend of mine, has a client project that uses HappyMapper, so the fact that he actually uses it made him a logical choice to help with the maintenance of it. He did a bunch of namespace work for the 0.3 release and now has commit rights.

The Twitter Gem

The last gem that was beginning to feel like a burden was the Twitter gem. Wynn Netherland has built several apps that rely on the Twitter gem, so I gave him commit rights and he recently added lists to it.

Conclusion

I can’t say that I am abandoning these projects, as I am sure from time to time I’ll feel inspired and spend some time on them. I just know that I am no good for them if I am not using them. I can’t feel the pain or know what is needed if I am not using the code.

I’m posting about this for two reasons. First and foremost to give some credit to the people who are doing the work now. Second, just setting some expectations that I probably won’t be snappy in responses for these projects as I’m not actively working on them anymore.

Thinking Functionally In Ruby – A Great Presentation by Tom Stuart

Tue, 03 Nov 2009 06:04:51 -0800

Thinking Functionally in Ruby is a talk that British Ruby developer Tom Stuart gave at a recent London Ruby Users Group meeting. In it he covers what functional programming is, why it's a "pretty neat idea," and how to adopt functional programming principles in Ruby. Skills Matter took a video of the entire 47 minute presentation (it's embedded on the right hand side of that page - Flash required.. just been told it might be limited to UK visitors only, if so get the original MP4 file) but there's also a 110 page PDF (1.5MB download) you should have to hand too (with Tom's slides).

I don't like to link to individual presentations on Ruby Inside too often, but in spite of poor audio quality on the video, Tom's presentation is top notch (the slides are particularly good) and Tom covers some interesting topics that I think Ruby developers could do with revising. If you've wanted to stay on the functional bandwagon but have found yourself slipping into imperative ways where you shouldn't, this presentation is well worth a watch.

[ad] Find duplication, code smells, complex code and more in your Ruby code with Caliper! The metrics are free and setup takes just one click. Get started!

Pivotal Tracker Screencasts

Giles Bowkett — Mon, 02 Nov 2009 15:04:00 -0800

Matt Taibbi: Research, Writing, And Wrath

Giles Bowkett — Mon, 02 Nov 2009 05:41:00 -0800

The world's most powerful investment bank is a great vampire squid wrapped around the face of humanity, relentlessly jamming its blood funnel into anything that smells like money.

Blog Ads: Experiment On GitHub

Giles Bowkett — Sun, 01 Nov 2009 02:00:00 -0800

http://github.com/gilesbowkett/blog_ads

From the Readme:

I wrote this to generate ads on my blog. It's a lazy Sunday morning hack, finished before 10am, and that includes all the time I spent tweaking the ad text and choosing the sites to link to.

The way to use it is simple: choose affiliate programs to promote, write an ad, and hard-code all the data in the generator script. (Obviously there are more elegant ways to do that part, but this is still less than 50 lines of code.) Run the generator script, and then copy/paste the output into a widget in the sidebar on your blog. Boom, you have ads.

Now instead of Google paying you three cents every time somebody clicks a link, you have some independent business paying you $20 or $50 every time somebody buys something. The win here isn't just the money, it's also the ethics. You were supporting a corporation; now you're supporting independent business. You were selling meaningless clicks; now you're bringing someone actual customers. It doesn't hurt that the earnings potential is orders of magnitude better, but the win is pure ethics win.

Epic Graffiti Artist DAIM On Skinizi

Giles Bowkett — Sun, 01 Nov 2009 01:37:00 -0700

I can't tell you how thrilled I am about this.

The German graffiti artist DAIM is known for pieces with three-dimensional styles so realistic, people driving by in their cars have thought the shapes coming out of the walls were real.

He's one of a growing number of graffiti artists receiving recognition in the formal art world.

His new skins on Skinizi fit on iPods, iPhones, MacBooks, MacBook Pros, non-Apple hardware, netbooks, PSPs, and all kinds of nifty gadgets.

Riot: for fast, expressive and focused unit tests

Sat, 31 Oct 2009 09:57:28 -0700

Riot is a new Ruby test framework by Justin Knowlden that focuses on faster testing. Justin was frustrated with his slow running test suites, despite employing techniques such as using factories, mocks and avoiding database access. He realized that a slow-running suite makes one reluctant to run it or expand it - not good.

With Riot, each test consists of a block which forms a single assertion on the topic of the test, keeping the tests focused. Tests run in a specific context, and the setup code is only run once per context, further contributing to the speed of your test suite, and unlike some Ruby test frameworks, such as Shoulda, that rely on or are based on Test::Unit, Riot has taken a new approach for speed purposes. In Justin's own comparisons, Riot comes out about twice as fast as Test::Unit.

Here's an example Riot test (from the README):

context "a new user" do setup { User.new(:email => 'foo@bar.com') } asserts("email address") { topic.email }.equals('foo@bar.com')
end

Riot's comprehensive README also includes lots of examples and details on how to modify your Rakefile to run your Riot test suite in different frameworks. The full documentation is available online here.

You can install Riot as a gem from Gemcutter:

sudo gem sources -a http://gemcutter.org
sudo gem install riot

Justin also has a spin-off project called Riot Rails, which includes some Rails-related macros for testing your Ruby On Rails code, and Alex Young has written a Javascript port of Riot which is worth checking out too. He also has his own look at Riot and demonstrates how Riot can reduce redundancy in tests.

[ad] Codebase is a fast & reliable git, mercurial & subversion hosting service with complete project management built-in - ticketing, milestones, wikis & time tracking - all under one roof. Click here to try it - free.

Draft of O'Reilly's "Rails In A Nutshell" Free To Read Online

Thu, 29 Oct 2009 12:36:02 -0700

Rails In A Nutshell is a forthcoming book, to be published by O'Reilly, by Cody Fauser, James MacAulay, Edward Ocampo-Gooding and John Guenin. Like other titles in O'Reilly's "Nutshell" series, the book is designed to be a concise introduction to the topic with an overview of commands and configurations, and a look at parts of Rails you'd use every day as a Rails developer.

The print version of Rails In A Nutshell isn't due out till early 2010 but a focus on targeting Rails 3.0 is almost certainly to blame here. On the plus side, the book should be one of the most up to date Rails tomes once 3.0 eventually hits the streets in the next few months. Luckily, O'Reilly are doing "the right thing" and have wisely licensed the text with the Creative Commons Attribution-Noncommercial license and released the work as it is so far through their O'Reilly Open Feedback Publishing System. What this means for you is that you can read it now - here!

As an intriguing aside, it looks like O'Reilly have had the book on the burner for some time now as three years ago they signed up Jeremy Voorhis to write it.

Tweet This Post

Want To Speak At RailsConf 2010? Submit Your Proposals Now

Wed, 28 Oct 2009 12:41:25 -0700

Want to impress your fellow Rails developers? Want to get a free pass to the world's definitive Rails conference to see great keynote speakers of the caliber of Tim Ferriss? Submit a proposal to speak at RailsConf 2010 - taking place June 7-10, 2010 in Baltimore, Maryland, USA. Yep, the call for participation opened today!

Speaking at RailsConf is a great addition to your CV and a lot of RailsConf's speakers have been first timers. From what I've seen over the years, there doesn't seem to be a pattern to who gets in and who doesn't (though bigger names do, certainly, seem to pop up more - but perhaps they submit the most proposals..) and as long as you can come up with a solid Rails-related talk proposal, you're in with a good chance.

The official call for proposals outlines some areas that would be preferred:

Time-saving developer productivity tips, tricks, and tools
Patterns and best practices for developing maintainable Rails applications
Rails Internals
Complex domain modeling
Rails development case studies, including application rewrites and organizational bootstrapping
Making Rails
Heterogeneous systems integration
Real-world deployment and scaling
Making the most out of new Rails features
Gem and Plugin highlights
Extending Rails

Proposals are due by 11:59pm Eastern on March 17, 2010 and successful speakers will be notified in April. Good luck!

Tweet This Post

Rails Envy Podcast – Episode #098

Wed, 28 Oct 2009 12:10:53 -0700

Episode #98- “I leave my syntax out when company comes over.”

Important inaccuracy in this week’s show: We have misrepresented Bryan Liles as having written the dm-is-schemaless plugin when, in fact, it’s actually Bryan Smith. Sorry guys!

Show Notes

Gemcutter will become default host for gems

Gemcutter will become the default for Ruby gems. They hope to complete the transition by Rubyconf. The new address will be http://rubygems.org and migration paths are being worked out.
Rails in a nutshell

Rails in a Nutshell is a concise introduction to Rails, an overview of commands and configurations, and a guide to the parts of Rails you’ll be using every day. It’s written by Cody Fauser, James MacAulay, Edward Ocampo-Gooding, and John Guenin. It’s a beta book and you can comment on every paragraph.
Devise is a new authentication gem for Rails

Devise is a flexible authentication solution for Rails based on Warden. It’s Rack based, is a complete MVC solution based on Rails engines, allows you to have multiple roles (or models/scopes) signed in at the same time, and is based on a modularity concept: use just what you really need. There’s also an example app available.

http://github.com/plataformatec/devise/
http://github.com/plataformatec/devise_example/
Ancestry 1.1.0 Released

Ancestry allows the records of a ActiveRecord model to be organised as a tree structure, using a single, intuitively formatted database column, using a variation on the materialised path pattern. It exposes all the standard tree structure relations (ancestors, parent, root, children, siblings, descendants) and all of them can be fetched in a single sql query. Additional features are named_scopes, integrity checking, integrity restoration, arrangement of (sub)tree into hashes and different strategies for dealing with orphaned records.

Version 1.1.0 Notable new features:
* Depth caching and selecting records on depth
* Easy migration from parent_id based plugins like nested_set and acts_as_tree
Dm-is-schemaless

Brian Lyles of TATFT fame has written dm-is-schemaless which is a DataMapper plugin to accomplish schemaless storage in a relational database by storing it in JSON with a primary key.

http://github.com/BrianTheCoder/dm-is-schemaless
http://bret.appspot.com/entry/how-friendfeed-uses-mysql
Trusted Params

Rails plugin which adds a convenient way to override attr_accessible protection.
Riot

Riot is a new, concise, and fast testing mini-framework.
GeoMereLaal

GeoMereLaal is a plugin that includes all you need to create Location-Aware rails application based on W3C Geolocaton API.
The Complete Class

Robert Klemme posts a thorough walk through of writing a Ruby class on the Ruby Best Practices blog.
acts_as_pingable

Acts as pingable is a Rails plug-in for simply opening your Rails app to HTTP pings. It can produce pingdom.com XML.
Sinatra_more

Sinatra_more strives to be a central-hub for useful sinatra extensions such as tag helpers, form_builders, partials, and a whole lot more.
Installing Varnish with nginx, Passenger, and Monit on Ubuntu 8.10 intrepid

Trever posted a tutorial about getting nginx, passenger, varnish, and monit installed on the Almost Effortless blog.
Loofah

Loofah is an HTML sanitizer. It will always fix broken markup, but can also sanitize unsafe tags in a few different ways, and transform the markup for storage or display. It’s built on top of Nokogiri and libxml2, so it’s fast.
Rails 2.3.4 and SWFUpload

Brian Racer posted a walk through of how to get SWFUpload working with Rails 2.3.4 for gracefully degrading flash and javascript uploads.
Curbit

CurbIt makes it easy to add application level rate limiting to your Rails app by using a controller macro.
Amazon RDS

Amazon Web Services (AWS) delivers a set of services that together form a reliable, scalable, and inexpensive computing platform ‘in the cloud’.

Heroku Gets Add-Ons: Serious Ruby Webapp Hosting Made Easy

Wed, 28 Oct 2009 08:33:10 -0700

Heroku is a Ruby webapp hosting service that we first mentioned about two years ago. It started off as an online IDE of sorts, but is now a complete cloud platform for running Ruby webapps. You can develop locally and then, with a single command, deploy your app to their metered service. Well, Heroku got in touch with me last week to talk about their new "Add-Ons" feature and they've really kicked things up a notch for people wanting to quickly roll out webapps online.

Till now, Heroku has provided basic functionality on a semi-metered basis. You pay a monthly fee for a basic rate of service and then pay an hourly rate for more concurrency. Now, you can also add on a bunch of other features which Heroku are calling "Add-ons." Here are just a few of the more interesting ones:

Amazon RDS (Relational Database Service) - This add-on is free from Heroku's point of view but you'll be paying Amazon.
Bundles - A "snapshot" type backup system. You get a single bundle for free or can pay $20 for unlimited bundles.
Cron - Daily and hourly crons can be set up with a couple of clicks.
Memcached - You can boost your app's performance with in-memory caching provided by Memcached. The key here is that Heroku totally manages the Memcached instance - no server setup needed, etc. Currently this feature is only in private beta though..
New Relic - Most readers should be familiar with New Relic's application performance tools by now and Heroku makes it easy to get them running directly on your Heroku-hosted apps. (As an aside, New Relic rolled out a significant update last week - version 2 of their flagship RPM system.)
SSL - Get https:// URLs on your Heroku app with a choice between piggyback SSL (free), SNI SSL ($5 per month) or full-blown custom SSL ($100 per month).
Websolr - A no-setup-needed Solr instance so you can get quick and easy full text indexing and search functionality in your apps.

Note: You can learn more about all the different Add-ons at Heroku's dedicated Add-ons page.

Impressive but Expensive?

As impressive as Heroku's one-command-deploy and add-ons features are, though, I can't quite put my finger on Heroku's market - they're kinda pricey. Perhaps it'd be good for professional developers who want to do a test deployment of an app on a live server without getting mired in server configuration?

For full time use, Heroku doesn't strike me as very competitive. For example, for the "Crane" 500MB storage option (billed as "perfect for a small biz app") with the recommended 4 "Dynos" the fee comes to an estimated $158 per month, and that's without any add-ons. For the entry level "dedicated" option with the recommended 8 dynos, the cost goes to $452.

Despite the cost, though, what Heroku offers is a very simple "no hassles" hosting service that, crucially, can handle significant workloads. You could rig up something similar with VPSes, dedicated boxes elsewhere, or even Amazon EC2, but you're going to be spending time doing server configuration. If playing sysadmin isn't tricky for you (I enjoy it, personally), Heroku might not be for you and you should be looking at companies like Webbynode or Linode. But if you're just a 100% developer who wants to get something up and running and doesn't want to worry about scalability too much, Heroku could be worth the extra expense.

Update: Oren Teich of Heroku got in touch with some notes regarding Heroku's value proposition versus the comparisons I made above. I quote verbatim:

I wanted to point out that we have many users running huge sites on the free version, serving up hundreds of thousands of hits per month, and that they pricing is deceptive - for that $150 you get an AMAZINGLY high powered service, capable of serving >10 millions requests per day.

We don't do a great job right now of making it clear just how powerful a single dyno is, or what you get with the platform. We're working on improving the pricing to be clearer. In the meantime, getting the right message out on this is really important to us.

Also keep in mind, that the DB pricing is for DB usage only - it doesn't include your code, files on disk, etc. That said, we know we need to right size the DB pricing, but it's amazing how far 500, or even 50 MB of pure DB usage will take you.

Heroku has many users running huge sites on the free version, serving up hundreds of thousands of hits per month. The pricing can be deceptive, for that $150 you get an AMAZINGLY high powered service, capable of serving >10 millions requests per day.

He also noted that there's no charge for bandwidth, although there are some soft limits that haven't been hit by any users yet.

Disclaimer: Webbynode and Linode are currently Ruby Inside sponsors. Heroku, however, has no financial connection with Ruby Inside and vice versa.

[ad] Find duplication, code smells, complex code and more in your Ruby code with Caliper! The metrics are free and setup takes just one click. Get started!

TinyMCE: Nothing In Textarea

Giles Bowkett — Tue, 27 Oct 2009 11:37:00 -0700

If you want to get the value of the <textarea> through some method other than just hitting "Submit", you're dealing with some kind of <iframe> jiggery-pokery. A good old-fashioned Prototype $(editor_id).value won't get the job done; in this instance, you need tinyMCE.get(editor_id).getContent().

How To Use Bundler With Rails

Giles Bowkett — Mon, 26 Oct 2009 14:07:00 -0700

gem rails, :only => :bundler

via @carllerche and @patmaddox

Gemcutter Is The New Official Default RubyGem Host

Mon, 26 Oct 2009 16:48:01 -0700

Just two months ago we posted about Gemcutter, a new RubyGem hosting repository that, we said, was "taking aim at RubyForge and GitHub." It only took six weeks for GitHub to give up on building gems and to start recommending Gemcutter instead. Today, RubyForge is toppled also. Gemcutter developer Nick Quaranto has announced that Ruby Central has given the thumbs up to replacing http://gems.rubyforge.org/ with http://rubygems.org/ (the new Gemcutter URL) as the default gem host in RubyGems.

The transition from RubyForge to Gemcutter/RubyGems.org isn't an overnight deal and gem publishing from RubyForge will continue to work for the time being, but within the next couple of months, RubyForge accounts will be merged with Gemcutter and an update will be made to change the canonical gem source (though, of course, you can use Gemcutter already if you like by following their instructions).

What all of this means for you as a Ruby developer is that if you want to release your own RubyGems (or "gems") in future, things will become a lot easier. Gemcutter, if you haven't checked it out, is definitely a refined evolution in terms of gem hosting - you can "push" a built gem to their server with a single command. If you want to learn how, check out Ryan Bates' awesome Gemcutter & Jeweler screencast that demonstrates how to create a gem and deploy it with Gemcutter.

Rails 2.3.4 + SWFUpload: Gracefully Degrading Rails File Uploads

Sun, 25 Oct 2009 18:23:44 -0700

Over on the Jetpack Flight Log, Brian Racer demonstrates how to use SWFUpload with Rails 2.3.4 to implement slick, yet gracefully degrading, Rails file uploads powered by Flash. It's an impressive walkthrough post.

If you've uploaded photos or videos to Flickr or YouTube, you should be familiar with Flash-powered uploading. Instead of selecting a file and then waiting on a precarious HTTP request to send all of the data, Flash based uploading results in a Flash widget doing all of the hard work on screen - you even get upload progress "out of the box."

While you can use Brian's techniques in your own app, he's also put together swfupload_demo, a complete demo app that shows SWFUpload in action to power a MP3 repository of sorts. It not only processes the upload of MP3s but it also uses an embedded MP3 player to let you play the tracks you upload into the app right on the page.

Tweet This Post

Alternate Programming Business Model: Driving Affiliate Traffic With Shareware

Giles Bowkett — Sat, 24 Oct 2009 12:43:00 -0700

I've written recently about how I think consulting is a terrible business model. Given that it's basically the business I've always been in, I started to look into other business models and find out what my alternatives might be. Out of curiousity, I bought an ebook on affiliate marketing.

Since Ruby programmers love meta crap, I'll introduce affiliate marketing the meta way: if you click this link and buy the PDF, I'll get a commission. That's affiliate marketing - basically, driving traffic, selling stuff, and getting a commission. (I'm not actually expecting to see a lot of people buy this thing, but a) if I'm going to link, I might as well use an affiliate link, and b) the FTC set up some new rules about that, so I'm mentioning it out of legal paranoia.)

Anyway, most of these things are pretty cheesy. This one was written by some kind of surfer guy, so I thought what the hell. I know a woman who does Internet marketing full-time - she gets paid to blog about yoga - and another who offers an affiliate program for her business, where she teaches actors how to be financially self-sufficient. So I've seen a little bit of this affiliate marketing world, and by its standards, this surfer guy seems unusually chill. He also gives away a lot of detailed information, which I took to be a "good karma" type thing. Anyway if I get into explaining it I'll want to do a whole review, and I'm too tired for that right now. Maybe later.

What surprised me, and why I'm blogging this: a chapter on the guy's "secret weapon" for generating lots of traffic (traffic is a big deal to affiliate marketers). Basically, the secret weapon is downloadable applications. This includes shareware, freeware, and Web apps repurposed to run within dedicated browsers and thereby become equivalent, as far as a nontechnical user is concerned, to downloadable desktop apps.

On the one hand, this struck me as a weird potentially-revolutionary business model for programmers: building stuff for people to give away to drive traffic to their affiliate marketing programs. On the other hand, there's nothing that revolutionary about it. It's essentially what many of us already do for a living. We build stuff for entrepreneurs to give away to drive traffic to their "hey Mr. VC, buy me out" programs. But it's scaled down much, much smaller than is usually the case.

It matches the thing I said in my Archaeopteryx presentations: that Internet startups can be not only too cheap to fund - from the traditional VC perspective, where any business launch requires millions upfront - but also too small to see. If I make some shareware, license it to somebody in exchange for a portion of their affiliate marketing earnings, I have in a sense successfully launched an Internet startup, even though it's not at all what people mean when they use the term. This is an "Internet startup" that you could in theory launch with one programmer in his or her spare time, although I have no idea if there's any real money there.

When you look at the fiction people have generated about robots, a lot of it revolves around the idea of giant robots. What's the reality? The reality is that tiny robots can do a lot, and robot price gets out of control quickly if you make the robot big. A robot the size of a computer mouse costs about as much; a Lego Mindstorms NXT kit costs around $300; a Lynxmotion hexapod costs around $700, not counting brains or sensors; and anything bigger than a hexapod gets you into crazy money really fast. Technology tends toward miniaturization.

Lynxmotion hexapod

A corporation is kind of like a robot, although that's a huge separate topic. Point is, a lot of people think the Internet is here to make our corporate overlords more powerful than ever before, and give them even more gigantic empires. (And by "a lot of people" I mean those corporate overlords themselves, and their minions.) But I think long-term, it's going to have the opposite effect, and that (among other things) the Internet may make software businesses much, much smaller than they are (and they're already smaller than they've been in the past).

This is the other reason I find affiliate marketing interesting. Every indication is that these businesses are extremely small. But that's another rant, and I'm tired. Anyway, if you're curious, here's the ebook link again. It's an interesting read, even if it isn't free (assuming you find these sort of micro-entrepreneurial phenomena interesting).

The Complete Class

shortcutter@googlemail.com (Robert Klemme) — Sat, 24 Oct 2009 11:05:00 -0700

A remark: we enabled comment moderation because the blog was recently target of spam. You probably have not seen much of it because we were pretty quick in removing it manually. So if your comment does not show up please be patient.

There are some basic concepts (often called “aspects”) that need to be implemented for many classes although not all classes need all (or even any) of them:

initialization
conversion to a printable string
equivalence
hash code calculation
comparability
cloning (clone and dup)
freezing
customized persistence (Marshal and Yaml)
matching
math and operator overloading

Which of these is needed for a particular class depends of course completely on the circumstances. Classes which are never written to disk or used in a DRb context will not need customized persistence handling. For other classes there might not be a reasoable ordering.

We will look at these concepts individually in subsequent sections. For the sake of this presentation I will create a slightly artificial class which will have particular properties in order to be able to show all the concepts:

mutable fields
redundant fields, i.e. fields which carry cached values that can be derived from other fields
at least two fields for ordering priorities

Class Album implements a music album with a title, interpret, sequence of tracks and a fixed pause duration between tracks. I picked a slightly different approach than Eric in his article in two ways:

Eric has a stronger focus on collaboration with standard library classes while my guiding question was “what does a class need to be complete and consistent?”,
I present all the features in a single class to show how aspects play together.

You will likely never implement all these aspects in a single class. Even for those aspects you do use, you might not use the same implementations I will present. That’s OK. The implementations presented in this article are intended to cover aspects thoroughly even though you will not always have to do that in practice. For example, certain code is there in order to make the class work properly as part of an inheritance hierarchy. If you write a one off class for a script which is never intended for inheritance you can simplify many of the presented methods.

I left out the topic of math and operator overloading since that does not mix well with the concept of music album. Instead I will cover that in the next article in the blog which will present a class that shows how to override operators in Ruby and that plays well with Ruby’s built in numeric classes.

Initialization

Implementing method initialize is typically one of the first things I do when implementing a new class unless I can use the default implementation of Struct. There are a few things though that are worth considering.

First of all, who owns arguments to initialize? It is important to make clear what happens to arguments that are provided to the call to new. There are three cases

the value is immutable (like Fixnum) or
the caller retains ownership or
ownership is transferred to the new instance.

Case 1 is the simple one: basically you do not need care thinking about who owns the object as there are no bad effects which can be caused by aliasing. If the instance is mutable these effects can show up. If you want to make your code as robuts as possible you must ensure you got your own copy of the instance (typically via copying it, for example by using dup). The downside of this is of course that this costs performance as you’ll likely copy too many objects. In practice you will probably most of the time do nothing special and keep the code as simple as an assignment.

class Album def initialize(title, interpret, pause = 0) super() # main properties self.title = title self.interpret = interpret @tracks = [] # additional properties self.pause = pause # redundant properties # left out end def title=(t) @title = t.dup.freeze end def interpret=(i) @interpret = i.dup.freeze end def pause=(time) @pause = time @duration = nil end end

The other important aspect is inheritance. Most classes that are written probably do not have a super in their initialize method. If there are chances that you reopen the class and add mixin modules you should include super() right from the start because even if you only implicitly inherit Object and initialize in Object does nothing you may later reopen the class and add a mixin module which has an initialize method itself. If you inherit another class than Object you should explicitly mention arguments with super and not rely on having the same argument list as the super class initializer. That way you are making the call more explicit and are robust against changes in your initialize method.

class CdAlbum < Album attr_accessor :bar_code def initialize(t, i, code) super(t, i, 2) self.bar_code = code end
end

While we’re at it: if you write a module which is intended as mixin and needs initialization itself the initializer should simply pass on all arguments in order to be compatible with arbitrary inheritance chains:

module AnotherMixin # Prepare internal state and pass on all # arguments to the super class def initialize(*a, &b) super @list = [] end
end

Conversion to a printable String

Often it is desirable to be able to convert an instance to a human readable string. Which representation is most appropriate depends on the uses of the class. One policy is to create a string representation so the instance can be later reconstructed given this string as is the case for all the numeric types from the standard library. In the case of our sample class we will provide all interesting information:

 def to_s "Album '#{title}' by '#{interpret}' (#{tracks.size} tracks)" end

If you want to reuse a string field as external representation you could copy it in order to avoid bad effects from aliasing. However, since typically to_s is invoked for printing and no references are held I would say most of the time it is safe to not explicitly copy the field in these cases.

Equivalence

There are two methods that deal with object equivalence eql? and ==. (Method equal? tests for object identity and should not be overridden.) Some core classes do have different equivalence relations implemented:

irb(main):003:0> 2 == 2.0
=> true
irb(main):004:0> 2.eql? 2.0
=> false

But most of the time both methods will implement the same equivalence relation. This also helps avoid confusion. Note that eql? is special because it is used by Hash and Set to test for instance equivalence. We will come to that in a minute when we look at hash code calculation.

Equivalence of instances must be tested against significant fields and should ignore redundant fields. Looking at derived field values does not add anything to equivalence and makes the process slower at best.

 def eql?(album) self.class.equal?(album.class) && title == album.title && interpret == album.interpret && tracks == album.tracks end alias == eql?

Now here you see a test for class identity which you likely have not seen in other classes. Why is it there? Mathematical equivalence is a symmetric relation which means that if a.eql? b returns true so should b.eql? a. Implementing eql? and == that way also helps prevent strange effects when working with Hash instances. So if you are going to compare two instances of a class and a subclass then you might get true when called on the super class instance and false on the subclass instance. The same happens for two completely unrelated classes where the set of fields of one instance is a subset of those of the other instance. You may actually be tricked into thinking they are equivalent because the common fields are equivalent while the two instances represent completely different concepts. The only way to remedy this is to check for identity of the class.

The reason that omitting the class identity check does not cause issues most of the time is simple: usually you stuff uniform instances into a Hash or Set and even if you mix different classes most of the time they will have different fields and different field values. Still it is good to remember the point in case you experience unexpected effects with Hash keys.

Note that I omitted the test for self identity which you might be used to from Java classes. I believe this is a premature optimization because most of the time you are going to test different instances for equivalence so most of the time you pay the penalty of the failing identity check and win only in rare circumstances.

Hash Code Calculation

This topic is closely related to instance equivalence: classes Hash, Array, Set and other core classes rely on the fact that equivalent instances also return the same hash code. Note that this is not symmetric: instances wich have the same hash code may actually not be equivalent. But if the hash code differs they must not be equivalent.

An instance’s hash code should be based on the same fields that are used for determining equivalence. Our class Album has more fields and it is advisable to do some bit operations (often involving XOR) to combine all member hash codes into a single value in order to ensure better diversity of these values. If you base the hash code only on a single field you increase the likelyhood that non equivalent instances fall into the same bucket of the Hash which makes additional equivalence checks via eql? necessary. You can find more about how hash tables work on Wikipedia.

 def hash title.hash ^ interpret.hash ^ tracks.hash end

Comparability

Many classes have a natural ordering such as integers which are ordered by their numeric value. If your class does also have a natural order you can implement operator <=> and include module Comparable to get implementations of <, <= etc. for free.

 include Comparable def <=>(o) self.class == o.class ? (interpret <=> o.interpret).nonzero? || (title <=> o.title).nonzero? || (tracks <=> o.tracks).nonzero? || (pause <=> o.pause) || 0 : nil end

Cloning

When cloning or duping an instance the default mechanism sets all fields of the new instance to refer to the same objects as the cloned instance. While this is not an issue with immutable instances (e.g. Fixnum or instances which are frozen) bad things can happen if you have a mutable instance (for example Array or String) which is suddenly referenced by two instances which both believe they are the sole owner of it. All bad effects can happen including violation of class invariants and the instance state likely becomes inconsistent. Do deal with such cases even for shallow copies such as #clone and #dup you need to copy a bit more. Fortunately Ruby provides a hook (#initialize_copy) which is invoked after the instance has been copied and which can make appropriate adjustments. In our case we only need top copy the Array of Track instances because all other fields are immutable:

 def initialize_copy(source) super @tracks = @tracks.dup end

There is a recent discussion on comp.lang.ruby that started out with the subject of deep cloning but uncovered some general aspects of cloning.

Freezing

For freezing similar reasoning applies as for cloning: immutable fields need no additional attention as you cannot change those objects anyway. For others you need to decide how deep you want the freeze to go. In case of class Album we certainly want to prevent addition of more tracks after an album has been frozen. We also explicitly trigger calculation of duration so to avoid errors when accessing the duration on the frozen instance; the value cannot change any more anyway. This also makes it important to invoke super as last method.

 def freeze # unless frozen? @tracks.freeze duration # end super end

Note that the code is robust against multiple invocations of #freeze because duration is calculated only once (on first transition from unfrozen to frozen). If you have more complex calculations going on that involve state changes of the instance you should place unless frozen? and end around the custom freeze code.

Custom Persistence

If you want to serialize the complete state of your instance there is nothing more to do: you can simply use Marshal and YAML from scratch. However, if you have redundant data (such as field duration in our case) which you want to omit from the serialization you have to adjust the process yourself.

For Marshal the proper approach is to use the newer approach which invoves writing methods marshal_dump and marshal_load. The former is supposed to return something which is serialized instead of the current instance and the latter is invoked on a new empty object and handed the deserialized object so fields can be initialized properly.

 def marshal_dump a = (super rescue []) a.push(@title, @interpret, @pause, @tracks) end def marshal_load(dumped) super rescue nil @title, @interpret, @pause, @tracks = *dumped.shift(4) end

For YAML it is even simpler: you basically just need to ensure to_yaml_properties returns a list of symbols containing only those members that you want serialized.

 def to_yaml_properties a = super a.delete :@duration a end

Both approaches do have their own strengths: with Marshal it is easier to completely replace an object with something else. While that can be done with YAML as well it is not as simple and elegant as in the case of Marshal. YAML on the other hand shines because you need to override only a single method.

One word about the implementations: while these methods could look simpler I picked an approach which also works when inheritance comes into play. You can repeat the pattern of marshal_dump, marshal_load and to_yaml_properties throughout a class hierarchy and still have each method only deal with fields of the class in which it is defined. That makes it easier to deal with later additions or removals of fields in some class in the hierarchy. This is even more so important when dealing with mixin modules, which can happen on a per instance basis (via #extend).

Matching

I use the term “matching” for the functionality of the three equals operator (===) and for the matching operator (=~). The first is used in case statements and with Array#grep while the latter is usually used only explicitly.

The semantic is completely up to the class at hand and there are no general guidelines that could be given. Implement it when it is reasonable for your class. If you want to elegantly use instances of your class in case expressions you have to implement === doing something meaningful.

 # Check whether we have that track or track title by title. def ===(track_or_title) t = (track_or_title.title rescue track_or_title) tracks.find {|tr| t == tr.title} end # Match title against regular expression. def =~(rx) rx =~ title end

Summary

Today we looked at a class which implements various common aspects that you will meet over and over again when coding Ruby. Many of these are in fact present in other programming languages as well: Java has serialization, equals and hash code calculation. C++ also has an equivalence operator and other operators that can be overloaded to implement ordering etc. You can find the full code of the class at github.

Doctor McNinja

Giles Bowkett — Thu, 22 Oct 2009 18:15:00 -0700

In the glorious tradition of Scud The Disposable Assassin and Rex Mantooth, Kung-Fu Gorilla.

Community Highlights

Gregg Pollack — Thu, 22 Oct 2009 07:43:00 -0700

I’m always impressed by the continuous flow of innovation from the Rails community. Below are just a few of the highlights from the past month. These stories all came from the Ruby5 Podcast, which covers all the news from the Ruby and Rails community twice weekly.

Authentication

The talented Brazilian guys over at Plataformatec released the Devise gem this week, a new authentication option for your Rails app. Devise is a Rails Engine which sits on top of Warden, a Rack authentication framework. This makes Devise a little more flexible then other Rails authentication libraries, and is definitely worth a look.

On the otherhand if your application needs something more simple, check out Terry Heath’s OpenID Rails Engine. It should take you about 10 minutes to have an authentication system up and running, and you won’t have to worry about storing your users’ passwords.

Helpful Libraries

Thanks to Twitter’s new Streaming API we no longer have to poll every 5 seconds to discover new tweets. To start using it today check out the TweetStream Gem by Intridea.

With Rails 2.3 we gained the ability to utilize Rack Middleware in our Rails apps. If you don’t know what Rack middleware is yet go watch this screencast. Also, if you’d like some idea on how to use it, check out the CodeRack Middleware Contest, a competition to develop more useful and top quality Rack middleware.

A few weeks ago I heard about a javascript library called Validatious, which provides unobtrusive javascript for doing client side form validations. I know what you’re thinking though, “if I do both client side and server side validations I’ll have code which duplicates validation logic, and that makes me want to hurl.” Don’t hurl quite yet, first check out Jonas Grimfelt’s Validatious on Rails plugin which will auto-generate client-side validations using your existing model validations.

Optimization & Performance

If your Rails app needs to be able to handle many users uploading files at the same time (think Flickr), then you may want to look at ModPorter, an Apache module and Rails plugin created by Pratik Naik and Michael Koziarski. ModPorter parses incoming multipart requests storing the file to disk before it reaches your Rails app, so your Rails processes don’t get held up. We hear there is also support for nginx through a 3rd party module.

When you’re dealing with a database abstraction like ActiveRecord, it’s very important to ensure you’re writing optimal database queries. If you’re worried that your app may be doing more queries then it should or isn’t using eager loading properly, you may want to checkout the Bullet plugin by Richard Huang. Bullet can actually give you growl notifications when you’re missing an :include or should be using a counter cache.

Do you have mongrels that are consuming more then 150 Megs of RAM and you don’t know why? Do you suspect that it might be Ruby leaking all over the place? Then you’d probably be wrong, and Sudara Williams will tell you That’s not a Memory Leak, It’s Bloat. It’s more likely that you’re instantiating thousands of ActiveRecord objects, and Sudara gives you a few suggestions on how to find them.

Cleaning up code

The presenter pattern is very useful for encapsulating code that may be making your controller look fat, code that may not belong in your model. Dmyto Shteflyuk wrote up a great introduction to using presenters that’s worth a read if you’re not using them already.

Sending complex data-sets between Ruby and Javascript isn’t always easy. Don’t you wish there was a way to take that Ruby hash and just have it automatically transform into a javascript Map? If yes, then you may want to look at jsvars by Erick Schmitt, that’s what it does.

Deployment

You may already know about Chef (the system integration framework) but did you know that you can also deploy your Ruby app from chef using chef-deploy? Ezra Zygmuntovich created this gem which allows you to run your chef recipes and then if they pass (and only if they pass) deploy your code in a capistrano like fashion.

If you’re deploying a Rails cluster to Amazon EC2, then another solution aside from using Chef is a gem called rubber by Matthew Conway. Rubber keeps deployment a first class citizen, storing all your server configuration files inside your Rails app where they can quickly be tweaked under version control. It comes with many deployment best practices out of the box and can scale up or down at a moments notice.

Media

Have you ever wanted to run a Rails tutorial in your city, but you’re discouraged by the thought of writing all the course material? Then you need to checkout the Rails Bridge Open Workshop project where they have all the course material you’re going to need, for free! You have no excuse not to spread the word of Rails anymore.

Lastly, if you’re looking for additional Rails screencasts, you may want to checkout Teach Me To Code, and if you’re looking for additional Rails reading, then check out the past few issues of the Rails Magazine by Olimpiu Metiu.

Thanks for reading, and if you have any Ruby or Rails news you’d like to spread the word about, please send it into the Ruby5 podcast by emailing ruby5@envylabs.com.

Image Credit: Blue Sky on Rails by ecstaticist, Analog Solutions 606 Mod by Formication, Rainbow by One Good Bumblebee. Orange County Security by henning, Broom by fatman , remember by tochis, Darwin Was Right About Media Players! by Neeku.

Rails Envy Podcast – Episode #097

Thu, 22 Oct 2009 14:32:46 -0700

Episode #97 Lieutenant Commander Boson reporting for duty. Get the ring tone.

Show Notes

RPM For Java

RPM 2 Now supports Java and Ruby 1.9.
nginx push module

Nginx HTTP push module – Turn nginx into a long-polling message queuing
HTTP push server.
Railscast episode on Formtastic

Ryan Bates shows how to use Formtastic in your views.
The Art of the Library

Wesley Beary posts on the Engine Yard blog about what makes a good library.
TDD in Objective-C with MacRuby

Joshua Ballanco walks through creating a pig latin translator in objective c using MacRuby to TDD.
Sunspot

Sunspot exposes all of Solr’s most powerful search features using an API of elegant DSLs. That means robust, flexible fulltext search with no boolean queries and no string programming.
Inploy

Inploy is another way of doing deployments with different opinions than Capistrano.
Full Text Search on Heroku using Texticle

Aaron Patterson posts on the Tender Lovemaking blog about using Texticle to do full text searching using Postgres
Boson

Gabriel Horner put up a tutorial on using Boson to create commands for watching GitHub repos on your shell.
DeVIL

DevIL is a fast and lightweight image library that supports the loading and saving of images in almost any graphics format. It also provides some basic image manipulation functionality.
How to Start Sub-processes part 3

Avdi posts on the Devver blog part 3 of starting sub-processes in Ruby.
rails_on_pg

This is timesaver for middle/large Rails application which used PostgreSQL as database. Create/drop Views, Functions, Triggers, Foreign keys in your migrations using ruby syntax.
Mappoint/VE

Using the new handsoap gem, Jeff wraps all the nastiness of the VE and Mappoint web SDK SOAP into two very easy to use gems.

http://github.com/jmhodges/mappoint
http://github.com/jmhodges/virtualearth

Boson: A Next Generation Task Framework for Ruby

Thu, 22 Oct 2009 14:02:17 -0700

Boson is a new command/task framework for Ruby by Gabriel Horner (of Hirb fame). Gabriel seems to be trying to supersede Rake, the Ruby "make" equivalent, and from first glance Boson seems to provide many benefits from the "reinvent the wheel" philosophy.

Anyone who's built a Rakefile knows it's not the most straightforward syntax, so Boson's approach of using regular Ruby code in the shape of methods added to a module is refreshing. Tasks are methods, methods are tasks - simple. Within these methods, you can use the options helper method and passed arguments to access command line options and other data. Another feature is that while, like with Rake (or Thor), Boson can execute commands from the command line, you can also do so from IRB (the Ruby "console").

It's always a bit of a crapshoot when new tools come out in the Ruby world. Some catch on, some don't. Gabriel has clearly put a lot of thought into Boson, though, so if enough people are fed up with using Rake for command launching, I think it could catch on. Gabriel's blog post outlines what Boson does perfectly. For those ready to shoot down Rake, though, don't forget to read John Barnette's awesome, recent On Rake post. Rake's not just about launching tasks - it's a killer dependency resolution engine at heart, and that can result in less code if you approach your problems the right way.

(Aside: Sorry for the slow week at Ruby Inside. Six days ago my wife gave birth to our daughter and since she had a C-section, I'm playing housewife. I have quickly discovered if you're a housewife - or husband! - you have about zero hours left at the end of the day to do any other work.. I shall try my best!)

[ad] Mobile Orchard's from Rubyist to iPhone programmer in 2 days class is coming to Portland/OR Nov 12-13 and Los Angeles/CA Nov 19-20. ~~$1200~~ $799 with early reg and "inside" discount code. Note that the early registration price ends tomorrow - 10/23!

ignoring attempt to close foo with bar

Giles Bowkett — Fri, 16 Oct 2009 10:54:00 -0700

Given:

When:

Then:

It's pretty easy, when running a ton of specs or tests, to see giant strings of dots interrupted by bizarre, enigmatic shit like this:

.........................................................................
...............................................................................
.........................................................................ignori
ng attempt to close form with br
 opened at byte 12093, line 245
 closed at byte 13454, line 282
 attributes at open: {"class"=>"new_piece", "action"=>"/p", "method"=>"post", "id"=>"new_piece"}
 text around open: "loader'></iframe>\n <form action=\"/p\" cl"
 text around close: "x\" value=\"1\" />\n </br>\n <input nam"
...

It never tells you where it came from and never interferes with a spec completing. For years I thought it came from Hpricot. Nope. It comes from here:

/Library/Ruby/Gems/1.8/gems/actionpack-2.3.3/lib/action_controller/vendor/html-scanner/html/document.rb

In this arcane back alley there lurks a parser from the dark days before Treetop, just waiting for the day when a lazy blogger will quit talking shit and write some fucking code. (Or, alternatively, waiting for the day when an inspiring blogger will motivate one of his heroic readers to learn Treetop (which is awesome) and replace the old Rails HTML parser with a better one.) Until that day, you have to deal with its idiosyncrasies, one of which is overzealous warnings about HTML (indeed I think even XHTML) correctness.

It's easy to kill those warnings. Either use the verbosity special variable $-v as in this example, or run your test like this:

ruby -W0 test/whatever_test.rb

Obviously however this breaks with rake test:whatevers, and I have no idea if it works in any sense at all with RSpec. So the short-term hack: $-v reassignment FTW.

(Update: of course, the smart thing is to couch these hacks in before(:each) blocks, for RSpec, or setup and shutdown methods, for test/unit.)

Rails Envy Podcast – Episode #096

Fri, 16 Oct 2009 13:39:07 -0700

Episode #096. Dan Benjamin (Playgrounder, Hivelogic) is back this week. We each had some background noise and an awkward moment. But it’s funny.

Subscribe via iTunes – iTunes only link.
Download the podcast ~14:30 mins MP3.
Subscribe to feed via RSS by copying the link to your RSS Reader

Show Notes

GitHub Discontinues Publishing Gems

Following the move to Rackspace, Github has decided to stop building gems and instead recommends people move to Jeweler or Gemcutter. Old gems will be served for a year.
Gem Bundler is the Future

Nick Quaranto walks through how Gem Bundler is going to work on the Litany Against Fear blog. Gem Bundler is going to be the default gem dependency resolver in Rails 3.
Ruby Daemons and Angels

David Palm has posted a tutorial for working with daemon-kit by Kenneth Kalmer. He walks through created a simple daemon with three worker processes and explains what daemon kit is doing each step of the way.
Completely False: Rails site serving 10 million page views per day

The High Scalability blog has an article up covering Ravelry, a Rails site serving 10 million requests per day from Rails.
Advanced Messaging and Routing With AMQP

Ilya Grigorik posts a walk through of using AMQP for messaging and its benefits.
CodeRack Competition

The CodeRack competition is a competition to develop the most useful and top quality Rack middlewares.

http://coderack.org/
http://www.rubyinside.com/21-rack-middlewares-2649.html
Hosted Mongo

Fred Wilson (AVC) posts about a new hosted Mongo DB service.
Warp Drive

Mark Bates, over on the Meta Bates blog, introduces Warp Drive which he describes as “what Rails Engines wish they could be, and more!” A Warp Drive is a standard, full featured, Rails application that you can easily bundle up into a Ruby Gem, and include into another Rails app.
Cap-recipes

Nathan Esquenazi has posted some common cap recipes on his GitHub account. There are recipes for Ruby, Passenger, Memcache, DelayedJob and more.
iPhone app development with Ruby web services

Justin Leitgeib walks through the architecture for his iPhone app SubwayDelay and outlines how he uses Sinatra and Tokyo Cabinet.
Web Hooks in Ruby on Rails

Travis Dunn takes a look at one way of doing Web Hooks in your Rails app.
What’s New in Edge Rails – 10/12/2009

Nathan Bibler’s post about what’s new in edge rails.

Marketing Music: Wired Video on Topspin Media

Giles Bowkett — Wed, 14 Oct 2009 14:27:00 -0700

21 Rack Middlewares To Turbocharge Your Ruby Webapps

Wed, 14 Oct 2009 10:28:43 -0700

If you've worked with Web apps using Ruby, you might know of Rack, an interface that sits between Ruby applications and HTTP-speaking Web servers. All of the major Ruby frameworks and server setups use it now, including Rails. Middleware (in Rack) is code that manipulates data going back and forth between your Ruby apps and the HTTP server. You can use middleware to intercept requests, change data in mid-flow, etc. Ryan Bates has a great screencast tutorial if you're new to the concept and want to build your own.

P.S. I know the term "middlewares" sounds borderline insane, but.. it works, you know what it means - yada, yada ;-)

In this post, we're going to highlight various Rack middlewares from CodeRack, an on-going Rack middleware competition:

Karma Chameleon - Focused at Rails developers, Karma Chameleon makes it easy to automatically have file extensions added to all of your app's links and URLs. The humorous motivation for this is so that you can have all your pages use ".aspx" or ".php" extensions to look better in corporate environments. Joking aside, though, this is a cute, well written middleware that's worth looking at.

Rack::Rewrite - This middleware is a clever attempt at implementing some of Apache's mod_rewrite functionality in Rack. So far it has support for doing basic rewrites (where URLs are changed mid-request before they hit the backend) and HTTP 301 and 302 redirects.

Canonical Host - This middleware lets you specify a "canonical hostname" for your application so that any requests to other hostnames are redirected to the same URL on the canonical hostname.

Rack::Tidy - Rack::Tidy cleans up HTML markup by automatically indenting and reformatting content. If you want the output from your Web apps to look clean (especially if you used ERb!), this is worth a try, although it expects valid markup in order to perform its cleaning..

Zombie Shotgun - The Zombie Shotgun provides protection against Microsoft Windows zombie attacks! It rejects requests from known "evil" user agents and to known nefarious URL paths. I dare say this is a useful middleware to throw in front of almost anything.

ImageSizer - This middleware adds an HTTP header to the HTTP response when serving images that provides the image's dimensions. It works with both static and dynamically generated images as it get used after your code has provided the image.

Firebug Logger - Adds logging to your Rack-powered app for use in the Firebug Firefox extension or Webkit/Safari's Inspector.

EnforceSSL - EnforceSSL lets you ensure that certain paths are only reached securely over HTTP/SSL. If a path denoted as sensitive is requested over regular HTTP, an HTTP 307 redirect will be issued (as an aside, I didn't know about HTTP 307 till now - it's worth reading about).

InlineUploader - This middleware sells itself! "Need inline uploads for files like the way GMail handles email attachements? InlineUploader makes it easy! InlineUploader provides a generic file upload endpoint and a way to attach uploaded files to subsequently submitted form data."

RefererControl - A middleware that restricts access to certain paths based on the Referer header. Rather than blocking people who have no referrer, however, this middleware is intended to enforce certain referrers so that users follow the intended flow of a site.

Rack::GoogleAnalytics - Rack::GoogleAnalytics automatically adds the Google Analytics tracking code into the HTML pages of your applications. A very simple middleware with code to match (so it's worth looking at if you want to try writing a basic middleware of your own), though I'm not sure whether this sort of thing should be in middleware to start with..

Rack::NoIE - This middleware is self described as "the coolest Rack middleware ever created." I'm not so sure about that but it does redirect Internet Explorer 6 users away from your Web site. Supposedly the CodeRack site itself uses this middleware!

BanHammer - A very simple middleware app that restricts access to specified IPv4/v6 addresses and ranges.

Rack::Codehighlighter - This middleware automatically applies a code highlighter (of your choice out of CodeRay, Syntax, and Ultraviolet) to any source code embedded within PRE tags in your HTML pages. This could be particularly handy if you're using a Ruby blogging tool that doesn't provide this feature.

Response Time Injector - Want the full app response time in the body of your served HTML someplace? This middleware substitutes any reference to "$responsetime" in your response body with the amount of time the response took. Could be handy for debugging. It even lets you specify a format to show the time in.

Probably Versioned - A middleware by Dr Nic Williams! Probably Versioned provides the ability to add a version reference into the URLs/routes for your application without affecting your app.. e.g. www.example.com/v1/some/path.json - As Nic explains, however, this is a precautionary tactic to ensure your users use future-proof URLs rather than a permanent fix as you're on your own when version 2 comes along ;-)

Rack::Proxy - Provides proxying abilities. For example, you could pass remote API calls through your own app/URL scheme. This is one of the middlewares that could probably go on to be a bigger deal with some serious extensions.

Server Proxy - From the name, Server Proxy sounds similar to Rack::Proxy, but Server Proxy is specifically for bypassing cross-domain access restrictions (from AJAX, say). It provides a simple way to proxy requests to remote APIs through your existing site, e.g. http://localhost:3000/server_proxy?service_url=twitter.com&service_path=statuses/public_timeline.xml - you'd need to beware of the security issues with this though!

Casrack the Authentication - A middleware that provides CAS (Central Authentication Service) support. CAS is a centralized authentication system initially developed by Yale. I'm not aware of CAS but it looks like a well put together middleware to solve a specific problem. Note: You'll need to be up to speed with Gemcutter to install it as a gem but the code is on GitHub too.

Rack::ChromeFrame - Recently Google released a plugin for Internet Explorer that provides its own Chrome browser's functionality within existing IE windows. This middleware makes the pages served demand the use of Google Chrome Frame on supported browsers.

Rakismet - Rakismet can pipe the comments your site received through the Akismet comment spam checker. There's no documentation here yet, but the code provides a nice example of interacting with Akismet that could be useful even if you don't use the middleware.

What's New in Edge Rails

Nathaniel Bibler — Mon, 12 Oct 2009 14:40:00 -0700

So, Edge Rails is still chugging right along. There are new and interesting fixes, changes, and refactors going on all of the time. So, lets take a look at just a few that've gone in since the last post (it's been a while, I know, I'm sorry!).

ActionView and Helpers

XSS escaping is now enabled by default. This means that if you want to explicitly output HTML to your views, you'll probably have to mark it as html_safe! before sending it through.

<%= 'my <a href="http://www.rubyonrails.org">safe</a> string'.html_safe! %>

Many of the built-in helpers have been updated for this change and if you see an issues with the Rails helpers being incorrectly sanitized, you should create a new ticket.

distance_of_time_in_words has gained 'over', 'about', and 'almost' keywords, thanks to Jay Pignata and John Trupiano. This provides you with an improved level of granularity when approximating the amount time passed. So, instead of just "2 years ago", it can now also report "almost 2 years ago," "about 2 years ago," and "over 2 years ago," depending on the proximity to being exactly 2 years old.

assert_equal "almost 2 years", distance_of_time_in_words(from, to + 2.years - 3.months + 1.day)
assert_equal "about 2 years", distance_of_time_in_words(from, to + 2.years + 3.months - 1.day)
assert_equal "over 2 years", distance_of_time_in_words(from, to + 2.years + 3.months + 1.day)
assert_equal "over 2 years", distance_of_time_in_words(from, to + 2.years + 9.months - 1.day)
assert_equal "almost 3 years", distance_of_time_in_words(from, to + 2.years + 9.months + 1.day)

The HTML form helper, fields_for - generally used for nesting additional model forms - now allows for explicit collections to be used, thanks to Andrew France. So, instead of just including all of your blog.posts, you should have it only display your published blog.posts, for example. Or:

<% form_for @person, :url => { :action => "update" } do |person_form| %> ... <% person_form.fields_for :projects, @active_projects do |project_fields| %> Name: <%= project_fields.text_field :name %> <% end %>
<% end %>

API Change for content_tag_for: The third argument - being the optional CSS prefix - will now also affect the generated CSS class. This prefix will now be appended to the generated element's CLASS attribute.

<%= content_tag_for(:li, @post, :published) %>
# => <li id="published_post_123" class="published_post">...</li>

ActiveResource and ActiveRecord

Taryn East has added update_attribute(s) methods to ActiveResource. These methods act very similarly to the ActiveRecord methods we already know and love.

Building or creating an object through a has_one association that contains conditionals will now automatically append those conditions to the newly created object, thanks to Luciano Panaro.

class Blog has_author :commit_author, :class_name => 'Author', :conditions => {:name => "Luciano Panaro"}
end @blog.build_commit_author
# => #<Author name: "Luciano Panaro" ... >

Pratik Naik added a new option to ActiveRecord's accepts_nested_attributes_for to :limit the number of records that are allowed to be processed. Also, while we're covering accepts_nested_attributes_for, José Valim as renamed the _delete option to _destroy to better follow what is actually occurring. A deprecation warning has been added to _delete, for the time being.

Jacob Burkhart updated the new autosave option in Rails 2.3 to allow for an :autosave => false, which will disallow saving of associated objects, even when they are new_record?s.

Some Internals

Previously, CDATA elements could be ignored when converting from XML to a Hash, so now, thanks to John Pignata, Hash#from_xml will now properly parse and include CDATA elements values.

Josh Peek has relocated global exception handling into ActionDispatch::Rescue. So, this is now being handled at the Rack middleware level.

And finally, Yehuda Katz and Carl Lerche began work on a Rails::Application object to better encapsulate some of the application start up and configuration details. Also, a good bit of initialization has now gone on to move into this new object.

Remember, if you prefer to have a shorter audio summary of some of this content and more, you should check out the Ruby5 podcast over at Envy Labs; it's released every Tuesday and Friday with the latest news in the Ruby and Rails community.

Photo: Clock Tower by Brian Taylor

Spree: Open Source E-commerce for Rails Apps Gets Even Better

Mon, 12 Oct 2009 09:50:00 -0700

Back in September 2008, we posted about Spree, an open source Rails e-commerce platform that was then in its infancy. Now, however, Spree is truly flying. New versions are coming out frequently and there are more and more established sites using it to provide e-commerce functionality. Spree also just made it into GitHub's top 10 forked projects this week.

So why post about it again here? Well, our readership has grown a lot in the last year and Spree is a strong open source project that's both incredibly useful and worth knowing about in case you have a need for it in the future.

For those who are totally new to Spree, there's a live demo at http://demo.spreecommerce.com/ and an extensive list of features here. Spree has come a long way in the last year - give it a look!

Tweet This Post

There is no magic, there is only awesome (Part 3)

Jamis — Fri, 09 Oct 2009 09:48:00 -0700

This is the third article in a series titled “There is no magic, there is only awesome.” The first article introduced the “four cardinal rules of awesomeness”. The second article discussed knowing your tools.

Opening A.—Pass index finger of right hand distal to the little-finger loop, and passing round the ulnar side of that loop, bring it up from the proximal side into the thumb loop, and with the index finger pointing downard, take up with the back of the index finger the radial thumb string and return.

Even to string figure adepts, it can be challenging to parse those instructions. That paragraph is an extract from the instructions for an Eskimo Caribou string figure, written in 1903 by Dr. A. C. Haddon and published in American Anthropologist (you can read the whole thing on Google Books if you’re really feeling sleepless).

The original string figure notation described by Drs. Rivers and Haddon in 1902 used very technical anatomical terms to identify each finger, and the location of the string on each finger. As in that paragraph, you’ll see terms such as proximal (closer to the base of the finger), distal (closer to the finger tip), radial (closer to the thumb), and ulnar (closer to the little finger). These and other terms are used to describe locations relative to the fingers, as well as to name specific strings (“radial thumb string”) on the hand.

The strength of this notation is that it is very precise, and can be used with little need of external illustration. However, it is also fairly verbose, making it hard to parse without very focused attention and (potentially) multiple read-throughs. Also, the use of the technical anatomical terms makes the descriptions hard for novices to pick up.

To make her book more accessible to a larger audience, Caroline Furness Jayne (or “CFJ”) modified this notation so that “proximal” and “distal” were replaced with “lower” and “upper”, and “radial” and “ulnar” were replaced with “near” and “far”. (She left dorsal/palmar alone, for the most part, although in some figures she referred to the “front” or “back” of a hand or finger.) Her modifications introduced ambiguity, though, and required even more verbosity and copious illustrations to counter.

For example, she described the same movements (from the Eskimo Caribou figure) as follows:

First: Opening A. (The left palmar string must be taken up first). Second: Bend the right index away from you over the right far index string and over both strings of the right little finger loop and down on the far side of the right far little finger string; then draw toward you on the near side of the right index both right little finger strings and the right far index string, allowing the right near index string to slip over the knuckle of the index and to the far side of the finger. Now put the right index (still bent and holding the strings on its near side) from below into the thumb loop, by pressing the near side of the bent index toward you against the right far thumb string, and putting the tip down toward you over and on the near side of the right near thumb string. Pick up, on the far side of the bent right index, this right near thumb string, and lift it and the former near index string up by turning the index away from you and up to its usual position.

(I ommitted the illustrations for brevity’s sake, but if you want to see them, you can view the complete instructions here.)

The lack of technical terms is definitely an improvement, but the (significantly!) greater quantity of text means that the instructions require even more effort to parse. To combat this, the ISFA (International String Figure Association), in its publications, uses an abbreviated notation, numbering the fingers 1 (thumb) through 5 (little finger), and using other one-letter abbreviations for right (R), left (L), near (n), and far (f). They retain the use of proximal/distal in some cases, but also use “below”/”above” and “lower”/”upper” where it isn’t too ambiguous. The ISFA notation reduces the above text to this:

Opening A. R2 rotates away from you, over all strings, around 5f, then back under the strings, and proximally enters R1 loop. R2 hooks up R1n and retraces its path. (from http://www.isfa.org/arctic/30.htm)

This is much more concise, and is easier to scan. It settles on standard meanings of terms like “rotate away”, “hook up”, and “release”, which reduces verbosity, but also requires the reader to know how those words are defined in this context. Also, it is concise at the cost of specificity; there is often ambiguity that must either be resolved at “runtime”, or be countered with more verbose descriptions.

Two other notable attempts at describing string figures are SFN (String Figure Notation) by Eric Lee, and Mizz Code by Kyoichi Miyazaki (“Mizz”). The former is a variation on ISFA notation, employing various abbreviations to reduce verbosity, while the latter is an entirely new take on describing string figures that simply denotes how the string needs to move, without specifying finger movements at all. Both of these are much more concise than any of the others described above, but are also quite specialized and require some study before you can really make heads or tails of them.

So, that gives five different ways of describing string figure construction! How do you choose which one to use? Ultimately, the ISFA notation is the most widly used, as well as the verbose prose of CFJ (thanks to the popularity of her book). But a string figurist will benefit from knowing as many ways to describe a figure as possible, because each notation’s strategies reveal different insights into the techniques, and has different strengths in different situations. CFJ’s prose (if accompanied by a modicum of illustration) is good for beginners, because it does not require any specialized knowledge. The ISFA notation is a good general tool that allows people to quickly learn figures, with only a little training. And notations like SFN are great for quickly jotting down a figure as you learn it from someone else, or as you invent it yourself.

Really, as a string figurist, the more string figure languages you know, the more power you have.

Computer Languages

Thus, the second rule of awesomeness: know thy languages.

As a computer programmer, you’re faced with an even greater flood of languages than string figurists are. Even if you use primarily a single language, you might be surprised at how many incidental languages you use on a regular basis. Are you a web developer? Odds are that you dabble in both HTML and CSS, and probably Javascript, too. SQL is almost mandatory for most interactive systems. Furthermore, if you do anything at all in a text console, you probably know a little bit of shell script. Building your application and deploying it to production probably require a specialized DSL or two as well. And regular expressions are practically everywhere these days.

Despite there being more computer languages than string figure languages, the advice is the same: the more you know, the more power you have. And “knowing” is not merely “knowing about”. Look back at the four “knowledge gauge” questions from Part 2:

What does this do best?
What does this do worst?
Why should I use this in particular?
When was the last time I learned something new about this?

Take a minute and try to list all the languages you use on a regular basis. This includes even languages you use only tangentially, like SQL, regular expressions, Javascript, HTML, XML, CSS, and so forth. Try to answer each of the four gauge questions for every language in your list. If you struggle to answer any of them, consider that a jumping off point for further investigation.

If you aren’t really sure what a particular language is best or worst at, it may be because you aren’t familiar with enough programming languages to compare it with. You’ve probably heard the old saying, “to a man with a hammer, everything looks like a nail,” and that surely applies here. You may be at the pinnacle of guruship in your chosen programming language, but if that’s all you know, then you can’t give worthwhile advice on when that language should be used. You’re living in a house with no windows, and no matter how well you know that house, and no matter how big it is, you can never tell callers what’s just outside.

It’s been suggested by people much smarter than me that you should learn a new programming language every year. I can’t recommend this enough. I won’t deny that there have been years where I haven’t followed this advice, but every time I’ve spent a few months tinkering with a new programming language I’ve come away with my eyes open that much wider. It’s like having a lever, and finally discovering a fulcrum to use it with.

Learning a new language

Now, it’s all well and good to say “learn a new programming language”. It’s also remarkably easy to download the development kit for Ruby, Python, Java, Erlang, Haskell, or just about any other language you want to learn. And once you’ve started learning a language, the learning effect tends to snowball, so that’s not really a challenge either.

What’s hardest (for me, at least) is discovering a good “entry vector” into the language.

Here’s what works for me:

Find the documentation for the language. Look for a page or two that give you a glimpse into the syntax. Not every language provides an introduction like this, but when you can find one, it’s a great way to get a “feel” for how the language expresses things.
Next, look for a “hello world” example, or tutorial. Generally, these things are useless, but as an introduction to the language, it’s a good way to see what’s involved in a fully functional program. How much boilerplate does a program need? How is a program compiled or interpreted, and run? The “hello world” example is also a good place to start experimenting. As trivial as it sounds, try changing the string that gets printed. Try displaying an additional string. Hold on to this file; you can use it to play with as you progress through the next steps.
Now, look deeper. Try and find a more advanced tutorial. Look for examples that demonstrate writing procedures, objects, conditional branching, and so forth. They will almost certainly include concepts unique to the language, which will be new to you, but that’s the point! Work through those tutorials. Find additional documentation to clarify concepts that are unfamiliar to you. Go beyond the tutorials and experiment with these concepts, to solidify their meaning in your mind.
Once you’ve finished some tutorials, look for actual production code written in that language. GitHub is a fantastic resource for this kind of exploration, as are similar sites like SourceForge. Individual languages may have their own project “forges”, like RubyForge. Just find a project that looks interesting and read the code. This kind of “code spelunking” in a new language will give you valuable experience with the practical, day-to-day idioms used by experienced programmers, and will also give you solid examples of the concepts you read about and played with in the tutorials. (I intend to talk a lot more about “code spelunking” in the fourth article in this series.)
Lastly, think of a program or library you’d like to write, and write it in this new language. Nothing else you do will teach you the language as well as this step. You’re going to run into road blocks, but don’t get discouraged. If you need to do something that wasn’t covered in any of the tutorials, consider it an opportunity to read more documentation! Look at other projects and see how they accomplished similar tasks. Your first couple of programs in the new language will be very “unidiomatic”, but that’s how you start. Find someone experienced in the language and ask them to review your program, and point out better ways to do it.

By the end of the process, you won’t necessarily be an expert in the language, but you’ll know enough to compare it to other languages you know. You’ll also know whether you enjoyed the language enough to keep playing with it. Who knows? Maybe you’ll discover your new favorite language this way! I certainly wasn’t expecting to fall in love with Ruby when I started tinkering with it, but here I am, eight years later, and still tinkering.

Learning more

If you are already familiar with a language, the steps described above are not going to be as effective for increasing your knowledge. You’re probably in a rut, comfortable with what you know and able to accomplish almost everything you need to with it. That’s no excuse to stop learning, though; if you push yourself and learn even just a little more, you’ll almost certainly be surprised how useful that extra knowledge can be, even on a daily basis.

But how do you push yourself out of your comfort zone? This is probably harder than learning a new language, in many ways, because when you’re in the rut, it’s hard to see what the benefit of more knowledge would be.

One way is to find a good reference for the language, electronic or otherwise. Spend a little time each day (even just 15 minutes!) skimming that reference, looking for something you didn’t know before, or weren’t as familiar with as you would like to be. Once you find something, spend a little time playing with it. Find a way to add it to a project you’re working on. Blog about it. Tweet it. Just do something with it! Then, try to do something with it on a regular basis, so it stays in your memory.

Another technique is to find a library or program that uses concepts that are new to you. Unfamiliar with socket programming? Look for a networking library to read through. Want to be more familiar with threading techniques? Look for something that does a lot of parallel processing. Even if you have no specific learning goal, a good starting point is to select a programmer you admire, and find projects that they’ve worked on. You’re sure to find idioms, tips, tricks, and language features you’ve not seen before.

Ultimately, though, the game is not about “who can learn the most programming languages”. No one is keeping score. There is no tally scratched into the bedpost of your career, here. The goal is to educate your opinions. Awesome people have opinions born by experience. You want to be awesome? Then you need to be willing to keep pushing the envelope of your knowledge. Never settle for what you already have, even if you’re otherwise content. Keep looking. Lift the curtain on the unknown. If you want to be awesome, you need to explore.

Know thy languages.

More MongoMapper Awesomeness

john — Fri, 09 Oct 2009 06:46:00 -0700

In which I dish on the latest MongoMapper features like dirty attributes, time zone support, custom data types and dynamic finders.

September was a month of craziness and for the first month in quite a while I did not post here. I promise it hurt me as much as it hurt you. In an effort to get back in the rhythm, I am going to start with an easy article. MongoMapper has been getting a lot of love lately and I thought I would mention some of the awesomeness.

Dynamic Finders

Dynamic finders are so darn handy in ActiveRecord. How many times have you used User.find_by_email and the like? Thankfully David Cuadrado took a stab at it. I took what he started, tested it a bit harder and added it onto document associations as well. This means when you have a document with a many documents association, you can now use dynamic finders that are scoped to that association.

class User include MongoMapper::Document many :posts
end class Post include MongoMapper::Document key :user_id, String key :title, String
end user = User.create
user.posts.create(:title => 'Foo') # would return post we just created
user.posts.find_by_title('Foo')

Document associations now also have all the normal Rails association methods such as build, create, find, etc.

Logging

The mongo ruby driver added logging support so a few days ago, I added some basic support for accessing and using that logger from within MongoMapper. When you pass a logger instance to the ruby driver, you can access that connections logger instance from MongoMapper.logger like so:

logger = Logger.new('test.log')
MongoMapper.connection = Mongo::Connection.new('127.0.0.1', 27017, :logger => logger)
MongoMapper.logger # would be equal to logger

Tailing the log would give you output like the following:

MONGODB db.$cmd.find({"count"=>"statuses", "query"=>{"project_id"=>"4aceaabed072c4745f0003ca"}, "fields"=>nil})
MONGODB db.$cmd.find({"count"=>"statuses", "query"=>{"project_id"=>"4aceaabed072c4745f0003ce"}, "fields"=>nil})

The nifty part about this is you can setup your Mongo::Connection to use Rails.logger and then all your mongo queries show up in your Rails logs if you have your log level set low enough. This has been very handy for me working on MongoMapper because I can see exactly what MM is sending to Mongo behind the scenes.

Because of this addition, I noticed that every find(:first) was using :order => ’$natural’ which doesn’t allow using indexes and leads to slow queries. I removed the default order so instead it is just a find with a limit of 1, which should help make a few parts perform better.

Dirty Attributes

ActiveRecord’s dirty attributes is such a cool feature that yesterday, I spent a few hours porting it to MongoMapper::Document. Now you can do things like:

class Foo include MongoMapper::Document key :phrase, String
end foo = Foo.new
foo.changed? # false
foo.phrase_changed? # false foo.phrase = 'Dirty!' foo.changed? # true
foo.phrase_changed? # true
foo.phrase_change # [nil, 'Dirty!']

I’m sure there will be edge cases, but as we find them we can fortify the tests and go from there.

Custom Data Types

With the 0.4 release came the transition from typecasting to custom data types. Now, instead of natively defining typecasting for “allowed” data types, you can have any data type that you like. You just have to do the conversion to and from mongo yourself. Making your own data types is as simple as:

class Foo def self.to_mongo(value) # convert value to a mongo safe data type end def self.from_mongo(value) # convert value from a mongo safe data type to your custom data type end
end class Thing include MongoMapper::Document key :name, Foo
end

This means each time the name of Thing is saved to mongo or pulled out of mongo it will be ran through the Foo#to_mongo and Foo#from_mongo to make sure it is exactly what you want it to be.

Out of the box, MongoMapper supports Array, Binary, Boolean, Date, Float, Hash, Integer, String, and Time. You can check out the support file and tests to see how this works.

Time Zones

One not on times, since I mentioned it above is that all times are stored in the datbase as utc now. Also, if you have Time.zone set, all times are converted to the current time zone going to and from the database. This actually turned out to be really easy. We’ll see if I did it all correctly once people start pounding on it I guess. :)

Lazy Loading

One thing that I’ve been working on in between other features is making MongoMapper more lazy. I have already made connection, database and collection lazy so MM doesn’t actually create the connection or connection to the database until needed which makes MM work a lot better with Rails.

I still need to make indexes lazy, so that is the next thing to tackle. I’m thinking once that is in, I’ll have something like MongoMapper.ensure_indexes!, similar to DataMapper.auto_migrate!, which actually ensures the indexes exist rather than doing that the second a class loads.

Internal Improvements

Along with all the public features, I have been working on the internals of MM whenever I get a chance. They still need cleaning up, but things are getting better. Along with some refactoring, I did some work to speed the tests up.

The tests were starting to creep up to around 40 seconds which was driving me nuts. I did a bit of work and realized that clearing every collection before every test was causing most of the slowdown so I pruned the functional tests to only clear the collections that were actually used in that test. This cut the time from around 40 seconds to 10. Yep, huge!

Conclusion

There are still rough parts and I would recommend MongoMapper for beginners, but if you can troubleshoot not only your own code but others, MM is in a good place for you. Up until now, I’ve been working on adding features that I needed similar to ActiveRecord, but I am almost to a place where I am going to start adding features to MM that can literally only exist because of MongoDB.

The next month is going to see some really cool things like upserts, modifiers ($set, $inc, $dec, $push, $pull, etc.) and the like make their way into MM. I also have some plans for an identity map implementation. Oooohs and aaaaaahs abound!

Scout Improves App Monitoring for Rails Developers

Fri, 09 Oct 2009 13:19:49 -0700

Back in early 2008 I wrote about Scout on Ruby Inside, announcing it as a new "Ruby powered Web monitoring and reporting service." This is still true, except for the "new" bit! I've stayed in touch with the Scout team and they've not slowed down in their work on the system. They've improved the service and added some cool new features for Rails app developers in particular - even going as far as ripping out three months of development work to make the system better!

Scout has matured a lot since last year and now pitches itself as a general server and application monitoring service, though there's a sidefocus on Rails app monitoring. It's a commercial service but the entry plan is only $19 a month and there's a thirty day trial available.

Compared to other services, Scout is interesting because no Rails plugin installation is required and all analysis is separate from the request cycle. Redeployment isn't even necessary. Scout takes a more passive background role while still collecting all of the data it needs.

One of Scout's new features is the incorporation of the Request Log Analyzer by Willem van Bergen and Bart ten Brinke. This tool analyzes Rails log files and produces performance reports based around several metrics: request times, mean request time, process blockers, database and rendering times, HTTP methods used, HTTP statuses, Rails action cache stats, and similar. You can couple this with Scout's regular graphs and e-mail alert systems to get notified about "interesting" occurrences with your applications right as they happen.

Lastly, Scout has a strong plugin ethos, so it's not like it's just a Rails service - though that's what I'm focusing on here. You can write your own plugins to monitor whatever you like.. so even if you do monitor a Rails app, if you want to monitor another service "on the side" and you're willing to write a plugin, you'll be good to go, all on the same account.

Disclaimer: Scout has no relationship with Ruby/Rails Inside, other than having run a job ad on our jobs board a little while back. I promised to write about them while talking with them at RailsConf 2009, however, and genuinely think it's a service worth checking out :-)

Tweet This Post

How a 1-Engineer Rails Site Scaled to 10 Million Requests Per Day

Fri, 09 Oct 2009 10:31:21 -0700

Ravelry is an online knitting and crochet community run by husband and wife team Casey and Jessica Forbes. A few weeks ago they did an interview with Tim Bray where they revealed that their site has over 400,000 registered users and does 3.6 million pageviews per day - though ultimately 10 million requests a day hit Rails (they have significant API, RSS and AJAX usage).

Todd Hoff of HighScalability.com then collected together all of the details he could find about Ravelry and put it together into "How Ravelry Scales to 10 Million Requests Using Rails." It's well worth reading through Ravelry's stack info, but if you want the Cliff Notes version they're using:

Xen virtualization
HAProxy
Nginx
Tokyo Cabinet (for large object storage)
Nagios
New Relic
Amazon S3
Amazon Cloudfront (for CDN)
Sphinx
Memcached

Also worth a visit, if you care to know about Ravelry's history, is this 30 minute interview with Y KNIT - a popular knitting podcast.

Tweet This Post