sorted by: recent | see : popular

Content Tagged with cool + Ruby

(Photo credit: Kieran Huggins)

RubyFringe - described as a "pricey, limited-attendance smoozefest" by Ruby documentation co-ordinator James Britt or as "an avant-garde conference for developers that are excited about emerging technologies outside of the Ruby on Rails monoculture" by the organizers - went ahead last week and appears to have been a significant hit. A small conference with a reasonably high ticket price (though far less than RailsConf Europe!), RubyFringe was set to be a very unique sort of conference with parties, drinks and out-of-hours entertainment laid on, and a limited number of tickets made available to ensure a more intimate gathering. The gamble appears to have paid off.

Praise

I'm not quite sure exactly what went down (I had to pull out of attending) but all references I've seen have been almost over-the-top with excitement and praise:

Soleone says: "Rubyfringe was amazing! So many good talks and great people. Best talk: Giles' presentation on computer generated music. Laughed my ass off!"

Rob Sanheim says: "rubyfringe was a blast, and now i can't sleep."

Lennon Day-Reynolds says: "RubyFringe after-party unsurprisingly turned out to be awesome."

Josh Merchant described it as "an amazing - inspirational - creative- experience."

Heck, there are far too many positive mentions to read on Twitter.

Mark McGranaghan of TechCrunch wrote directly to Ruby Inside:

RubyFringe was a huge win. Unspace set out to raise the bar for software conferences, and I think that they succeeded. I hope that RubyFringe does for web conferences what Rails did for web development; show others that there is a better way, that it does not require corporate sponsorship, and that it can fun, artistic, and productive all at the same time.

Content

There are over 1000 photos from the event on Flickr.

Joey deVilla has put together some handy notes for most of the presentations.

Rowan Hick has put together a list of his RubyFringe highlights.

InfoQ attended the event and, I am told, will be putting up videos of several presentations on their site soon. Until then, the content of the talks is summarized here.

The next RubyFringe?

With such success, it's inevitable another RubyFringe conference will take place within the next year. If you're interested, Pete Forde suggests joining the Google group, and keeping an eye on RubyFringe.com for more info (although it'll be here at Ruby Inside too). It remains to be seen if the success of RubyFringe will encourage "avant garde" conferences elsewhere in the world or for non Ruby communities generally, but Ruby Inside wants to hear about them if so.

Autumn is a framework by Tim Morgan that makes it easy to develop powerful IRC (Internet Relay Chat) bots with Ruby. Version 3, a significant update, was launched just a week ago. The code is available on Github, so it's ready to fork, tweak and work on to your heart's content.

An instance of an "Autumn app" is laid out in a similar way to a Rails app. There are config, doc, script, libs, tmp, and log folders, containing much what you'd expect, as well as a leaves folder (Autumn refers to "bots" as "leaves") that contains any number of folders each containing data, helpers, models, tasks, and "views" for individual bots. A default Autumn app comes with two bots pre-installed called insulter and scorekeeper that you can use to learn from.

Autumn is a pretty significant piece of work and Tim has done an excellent job at documenting it, leaving almost no stone unturned in demonstrating how to create bots / leaves of your own with the framework.

I’ve been working with what I used to call “utility computing” tools for about 6-9 months. However, for about the past 2 months, I’ve been seeing the term “cloud computing” all over the place, and there is so much buzz surrounding it that it’s reaching that magical point best described using Alan Greenspan’s words: “Irrational Exuberance”.

When Alan Greenspan used those words to describe the attitudes of investors toward the markets, what he was basically saying was that there were people who didn’t really know what they were doing, putting more money than they ought, into things they knew relatively little about. Further, he was saying that the decisions people were making with regards to where to put their money were a) bad, or at least b) not based on sound reasoning, or the ‘facts on the ground’.

This, I think, is where we are at with “cloud computing”. The blog post that put me over the edge is this one, for the record. I read Sean’s writings often enough, but this one strikes me as being a little off, a little sensationalistic, not based in reality, and a little misleading.

Maybe he just didn’t put enough qualifiers in there. His post might make more sense if he limited its scope and provided more facts, but I guess it’s just an opinion piece so he decided not to go that route, and that’s his prerogative I guess.

By limiting the scope, I mean he should’ve realized that there are millions of web sites currently scaling quite nicely without the use of cloud computing. In addition, some of the new ones that are having issues are also not using cloud computing, and when they hit bumps in the road, they make it through, and the great thing is that they also share their stories, and those stories indicate that a cloud (or, the current cloud offerings) wouldn’t have helped much (there’s lots of other evidence of that too). What would’ve helped is if they had paid more attention to:

• monitoring
• initial infrastructure design
• their own app code and app design

Note: This item has also been posted on Rails Inside. I don't tend to make it a habit of crossposting items, but as Rails Inside is still very new, I am sure many Ruby Inside readers will want to know about it. Beware, however, you will need to subscribe to Rails Inside to get the skinny on new Rails events in the long term :)

Following on from the outstanding success of the "Rails Camp" events that have taken place in Australia, comes Rails Camp UK, the equivalent for Brits (and brave travellers). The first is from Friday, August 15th to Monday, August 18th and takes place just a 30 minute train ride away from London, in Orpington, Kent (my teenage stomping grounds, as it happens).

The organizers say that they want to get together a "posse of like-minded Ruby hackers" to hack and have fun together in an open environment. The whole weekend costs £45 (and includes food and basic accommodation) with a day pass available for £20. Places are limited. You can sign up on EventWax and a Google group has been put together for attendees to discuss the event.

Post supported by Brightbox: Brightbox is a specialist European Rails hosting company. Each Brightbox server includes an optimised Ruby on Rails stack, SAN storage and access to a managed MySQL database cluster. They also manage dedicated clusters for large scale Rails deployments. Click here to learn more...

I’ve had word from Apress that they’re doing a one-off 24 hour $10 sale on the e-book version of Beginning Ruby as part of their “daily deal” series. The 24 hours is up - sorry! - but the e-book is still available from Apress at the usual rate of $27.99. It comes as a password protected PDF - no crazy DRM.

Beginning Ruby (Amazon link to the print version) is the ideal book for those new to Ruby, whether fresh to programming or coming from other languages. As well as covering Ruby in a general sense, it also covers the community, a handful of interesting RubyGems, database programming & SQL, object orientation (from the ground up), Rails (though very briefly), and network programming. Not convinced yet? The foreword was drawn by Why The Lucky Stiff, and of the 21 reviews of the book on Amazon.com, 18 give it five stars, and 3 give it four stars (the reviews are well worth reading to see if it’s the sort of book for you).

At $10, even if you’re a bit beyond the level of Beginning Ruby, it might make a good purchase for a co-worker, family member, or anyone else who’s hassling you about Ruby. Feel free to buy a copy and share it around the office. You’re probably not meant to, but I don’t care because if you really wanted to steal, you can just get it off of BitTorrent anyway :)

Finally, while on the Beginning Ruby theme, Amazon has Beginning Ruby available for the Kindle. It’s $23.75, and appears to be the best selling Ruby book on the Kindle so far (which isn’t saying a lot, I appreciate).

Ruby on Rails 2.1: What’s New? (PDF, 2MB) is a free e-book written by Carlos Brando (with help from Marcos Tapajos and Daniel Lopes). It was initially written in Brazilian Portuguese (find the original version here), but this version is an English translation by several community members.

As far as community written books goes, it’s pretty good! It comes in at 124 pages, and while 30 of these are just the Rails 2.1 CHANGELOGs (formatted in a nice way, none the less), the rest definitely does a good job of presenting some of the new features of Rails 2.1 (such as named scopes, dirty objects, numerous ActiveRecord changes and time related functions) in a very easy to digest manner.

I get to see a lot of Ruby code while writing for Ruby Inside. Most is very good, but sometimes we forget some of Ruby's shortcuts and tricks and instead reinvent the wheel. In this post I present 21 different Ruby tricks, from those that most experienced developers already use every day to those that are more obscure. Before writing this piece, for example, I had no idea about trick number 2! Whatever your level, a refresh may help you the next time you encounter similar scenarios.

Note to beginners: If you are still learning Ruby, check out my Beginning Ruby book (18 5-star reviews so far). It’s only $26.39 on Amazon in print or Kindle format or available from the publisher in PDF format.

1 - Extract regular expression matches quickly

A typical way to extract data from text using a regular expression is to use the match method. There is a shortcut, however, that can take the pain out of the process:

email = "Fred Bloggs <fred@bloggs.com>"
email.match(/<(.*?)>/)[1]            # => “fred@bloggs.com”
email[/<(.*?)>/, 1]                  # => “fred@bloggs.com”
email.match(/(x)/)[1]                # => NoMethodError [:(]
email[/(x)/, 1]                      # => nil
email[/([bcd]).*?([fgh])/, 2]        # => “g”

2 - Shortcut for Array#join

It's reasonably common knowledge that Array#*, when supplied with a number, multiplies the size of the array by duplicate elements, but it's a lot lesser known that when supplied with a string Array#* instead does a join!

%w{this is a test} * ", "                 # => “this, is, a, test”
h = { :name => "Fred“, :age => 77 }
h.map { |i| i * "=" } * "\n"              # => “age=77\nname=Fred”

3 - Format decimal amounts quickly

Formatting floating point numbers into a form used for prices can be done with sprintf or, alternatively, with a formatting interpolation:

money = 9.5
"%.2f" % money                       # => “9.50″

4 - Surround text quickly

The formatting interpolation technique from #3 comes out again, this time to insert a string inside another:

"[%s]" % "same old drag"             # => “[same old drag]“

You can use an array of elements to substitute in too:

x = %w{p hello p}
"<%s>%s</%s>" % x                    # => “<p>hello</p>"

5 - Delete trees of files

Don't resort to using the shell. Ruby comes with a handy file utilities library that can do your bidding:

require 'fileutils'
FileUtils.rm_r 'somedir'

Be careful how you use this one!

6 - Exploding enumerables

* can be used to “explode” enumerables (arrays and hashes). We'll let the examples do the talking:

a = %w{a b}
b = %w{c d}
[a + b]                              # => [["a", "b", "c", "d"]]
[*a + b]                             # => ["a", "b", "c", "d"]

a = { :name => "Fred“, :age => 93 }
[a]                                  # => [{:name => "Fred", :age =>93}]
[*a]                                 # => [[:name, "Fred"], [:age, 93]]

a = %w{a b c d e f g h}
b = [0, 5, 6]
a.values_at(*b).inspect              # => ["a", "f", "g"]

7 - Cut down on local variable definitions

Instead of defining a local variable with some initial content (often just an empty hash or array), you can instead define it “on the go” so you can perform operations on it at the same time:

(z ||= []) << 'test'

8 - Using non-strings or symbols as hash keys

It's very rare you see anyone use non-strings or symbols as hash keys. It's totally possible though, and sometimes handy (and, no, this isn't necessarily a great example!):

does = is = { true => 'Yes', false => 'No' }
does[10 == 50]                       # => “No”
is[10 > 5]                           # => “Yes”

9 - Use 'and' and 'or' to group operations for single liners

This is a trick that more confident Ruby developers use to tighten up their code and remove short multi-line if and unless statements:

queue = []
%w{hello x world}.each do |word|
  queue << word and puts "Added to queue" unless word.length  2
end
puts queue.inspect

# Output:
#   Added to queue
#   Added to queue
#   ["hello", "world"]

10 - Do something only if the code is being implicitly run, not required

This is a very common pattern amongst experienced Ruby developers. If you're writing a Ruby script that could be used either as a library OR directly from the command line, you can use this trick to determine whether you're running the script directly or not:

if __FILE__ == $0
  # Do something.. run tests, call a method, etc. We're direct.
end

11 - Quick mass assignments

Mass assignment is something most Ruby developers learn early on, but it's amazing how little it's used relative to its terseness:

a, b, c, d = 1, 2, 3, 4

It can come in particularly useful for slurping method arguments that have been bundled into an array with *:

def my_method(*args)
  a, b, c, d = args
end

If you want to get really smart (although this is more 'clever' than truly wise):

def initialize(args)
  args.keys.each { |name| instance_variable_set "@" + name.to_s, args[name] }
end

12 - Use ranges instead of complex comparisons for numbers

No more if x > 1000 && x nonsense. Instead:

year = 1972
puts  case year
        when 1970..1979: "Seventies"
        when 1980..1989: "Eighties"
        when 1990..1999: "Nineties"
      end

13 - Use enumerations to cut down repetitive code

%w{rubygems daemons eventmachine}.each { |x| require x }

14 - The Ternary Operator

Another trick that's usually learned early on by Ruby developers, but again something I see quite rarely in less experienced developers' code. The ternary operator is not a fix-all, but it can sometimes make things tighter.

puts x == 10 ? "x is ten" : "x is not ten"

# Or.. an assignment based on the results of a ternary operation:
LOG.sev_threshold = ENVIRONMENT == :development ? Logger::DEBUG : Logger::INFO

15 - Nested Ternary Operators

It may be asking for trouble but ternary operators can be nested within each other (after all, they only return objects, like everything else):

qty = 1
qty == 0 ? 'none' : qty == 1 ? 'one' : 'many'
# Just to illustrate, in case of confusion:
(qty == 0 ? 'none' : (qty == 1 ? 'one' : 'many'))

16 - Fight redundancy with Ruby's logical provisions

I commonly see methods using this sort of pattern:

def is_odd(x)
  # Wayyyy too long..
  if x % 2 == 0
    return false
  else
    return true
  end
end

Perhaps we can use a ternary operator to improve things?

def is_odd(x)
  # Don't EVER put false and true in a ternary operator!!
  x % 2 == 0 ? false : true
end

It's shorter, and I see that pattern a lot but really you should go one step further and just rely on the true / false responses Ruby's comparison operators already give!

def is_odd(x)
  # Use the logical results provided to you by Ruby already..
  x % 2 != 0
end

17 - See the whole of an exception's backtrace

def do_division_by_zero; 5 / 0; end
begin
  do_division_by_zero
rescue => exception
  puts exception.backtrace
end

18 - Allow both single items AND arrays to be enumerated against

# [*items] converts a single object into an array with that single object
# of converts an array back into, well, an array again
[*items].each do |item|
  # …
end

19 - Rescue blocks don't need to be tied to a 'begin'

def x
  begin
    # …
  rescue
    # …
  end
end

def x
  # …
rescue
  # …
end

20 - Block comments

I tend to see this in more 'old-school' Ruby code. It's surprisingly under-used though, but looks a lot better than a giant row of pound signs in many cases:

puts "x"
=begin
  this is a block comment
  You can put anything you like here!

  puts “y”
=end
puts "z"

21 - Rescue to the rescue

You can use rescue in its single line form to return a value when other things on the line go awry:

h = { :age => 10 }
h[:name].downcase                         # ERROR
h[:name].downcase rescue "No name"        # => “No name”

If you want to post your own list of Ruby tricks to your blog, send trackback here or leave a comment, and I'll link to all of them in a future post. Alternatively, feel free to post your own Ruby tricks as comments here, or critique or improve on those above.

As an aside, Ruby Inside is exactly two years old today. Thanks for your support! Intriguingly, the first post was another Ruby trick that I forgot to include above, so check that out too.

Evan Phoenix has announced that the Rubinius project has hit a major milestone: Rubinius can run Rails! This makes it implementation #3 (after MRI and JRuby) to join the Rails club and will help cement its reputation as a strong, key implementation to watch in the future. Chad Fowler goes as far as to assert that in a year’s time, Rubinius will be used in production deployments and quickly become the defacto standard Ruby implementation shortly thereafter.

Eyes are now on Microsoft’s implementation, IronRuby, that may also be joining the Rails club soon.

This post is sponsored by 16bugs — You know how cumbersome most bug trackers are. We know it, too! If you believe bug tracking should be an easy and unobtrusive task, you should try 16bugs right now. Use coupon code “RUBYINSIDE” and get 50% off when you upgrade your account.

Insoshi is a new, open-source social networking platform developed in Ruby on Rails. It’s on GitHub, so you can fork it to your heart’s content, and it can act as a base for developing your own social Web application. Features include activity feeds, profiles, photo sharing, comment walls, blogs, forums, user messaging, and an admin panel.

Insoshi was developed by Michael Hartl, author of RailsSpace, an Addison-Wesley published book about developing a social networking site in Rails. Hartl certainly practices what he preaches! It is important to note, however, that Insoshi is licensed under the Affero General Public License, so making the source code available for your derivative sites is necessary.

Lovd By Less is a similar system previously mentioned here on Ruby Inside that’s also open source and free to use. From what I can make out, both systems are very similar in terms of features (profiles, messaging, blogs, admin system, etc. but Lovd By Less has the edge by being MIT-licensed, making it easier to use in your own commercial applications.

Ezra Zygmuntowicz (of Merb and Engine Yard fame) has been spending quite a bit time playing with Rails®, both by cleaning up parts of ActionPack but, more significantly, porting Merb’s Rack mechanics to Rails. He has a personal fork of Rails on Github where he’s doing all the work.

It might not sound particularly impressive work from this description, but Ezra appears to be doing some good work in bringing the Rails dispatch system up to modern standards, and that can only help with Rails’ performance and stability in future. Ezra has also made the mutex locks more granular which provides a “speed boost with standard Mongrel under concurrent load” although more thread-safety testing is, he readily admits, required.

Perhaps more developments on this front will lead to a much needed mod_rack to make deploying Ruby applications on the Web easier without workaround techniques like SwitchPipe or mod_rails. So, let’s give Ezra some applause, and hope he (and maybe others) will keep up this great work :)

It’s been the programming world’s worst kept secret, but the covers are finally off as GitHub officially launched today. No more beta invites needed - hurrah!

GitHub is, officially, a Git repository hosting service (where Git is a source code control system - think decentralized, distributed SVN) built by Chris Wanstrath (Err the Blog), Tom Preston-Werner (creator of Chronic and God), and PJ Hyett. GitHub’s early users are calling it a “social programming network,” a “FaceBook for coders,” and all sorts of wonderful things. This is because Git’s decentralized nature makes it easy to fork, branch and merge code, and so does GitHub, which makes GitHub an ideal platform for collectively working on software, especially open source.

As of Rails 2.1 (coming very soon), GitHub will be the new official home of the Rails source repository, and the Merb, RSpec, Capistrano, Prototype and Scriptaculous projects are also on board, along with hundreds of other Git repositories created by beta users.

GitHub is a commercial offering (though from two open source devotees), but with an incredibly generous free level, meaning that the service is free for most reasonably sized open source projects (that is, the free level covers that sort of open use). There are, of course, a wide range of plans available for the whole gamut of users.

If you haven’t yet given Git a go, don’t fear, as a round up of Git tutorials, tips and tricks (with a Ruby slant, naturally) is coming next here on Ruby Inside. That said, I’ve just noticed InfoQ has already posted something similar, so read that if you’re feeling impatient.

If you couldn’t get to the popular MountainWest RubyConf two weeks ago, don’t fear. In conjunction with Confreaks, videos of all of the presentations are available to watch online. 14 videos are available, including the following:

It seems MountainWest had a really high quality level of talks, so give it a thought when choosing which Ruby events to attend next year.

(On another level, I’m kinda surprised by how many Rubyists seem to have ended up working in groups - whether ThoughtBot, ENTP, or Engine Yard.)