NOTE:This blog had a good run, but is now in retirement.
If you enjoy the content here, please support Gregory's ongoing work on the Practicing Ruby journal.

The Ruby Best Practices blog is a collaborative effort between Gregory Brown, James Britt, Robert Klemme and Magnus Holm. If you like what we do here, you might also want to subscribe to Gregory's Practicing Ruby Journal.

USP: fcntl: file descriptor flags vs file status flags

Eric explains how to use fcntl system call from Ruby to set various properties of IO objects.

2012-09-23 10:43 by Eric Wong (View Comments)


USP: Handling excessive CPU Usage within a Process

Eric presents an example of a process which monitors itself for excessive CPU usage derived from PulseAudio source code.

2012-03-27 01:11 by Eric Wong (View Comments)


USP: Implementing signal handlers - some caveats

Today Eric talks about how to implement signal handlers properly and what pitfalls to look out for.

2012-03-27 00:25 by Eric Wong (View Comments)


Practicing Ruby's second volume now freely available

I've decided to publicly release 15 more articles from my Practicing Ruby journal. Read on if you want a bunch of links to some of the best Ruby content I've ever written.

2012-03-26 14:00 by Gregory Brown (View Comments)


USP: Unix signals - primitive interprocess communication

Today Eric talks about signal handling basics.

2012-03-20 21:56 by Eric Wong (View Comments)


Kicking ass together: How to improve coding skills as a group

In this article, I provide some advice for folks who want to create local or online communities that help folks get better at programming. While these ideas are based on the values of Mendicant University, they should be relevant to anyone who wants to get a group of programmers together for serious practice.

2012-01-06 18:00 by Gregory Brown (View Comments)


Issue 1.26: Structural Design Patterns

Issue #26 of Practicing Ruby Volume 1, originally published on February 28, 2011. This article is about the various structural design patterns originally laid out by the Gang of Four.

2011-12-27 18:00 by Gregory Brown (View Comments)


Issue 1.25: Creational Design Patterns

Issue #25 of Practicing Ruby Volume 1, originally published on February 22, 2011. This article is about the various creational design patterns originally laid out by the Gang of Four.

2011-12-20 18:00 by Gregory Brown (View Comments)


How Mendicant University Works

Mendicant University is a free online school for software developers that aims to help smart people do amazing things for the world. Many folks often ask me how our program works, so I wrote this post to answer some of those questions.

2011-12-02 22:00 by Gregory Brown (View Comments)


Practicing Ruby Journal: Three months in and still going strong

The Practicing Ruby Journal publishes new Ruby articles by Gregory Brown on a weekly basis. It is the source of many of the articles on this blog, and is how Gregory pays his bills. Read on to find out how things have been going for the last three months. Links to three free articles are included in this post!

2011-11-23 22:00 by Gregory Brown (View Comments)


USP: Unix processes and their attributes

Today Eric presents various bits of information that the kernel manages for a process.

2011-11-11 22:37 by Eric Wong (View Comments)


USP: IO#dup and the dup(2) system call

Eric explains duplicating file descriptors.

2011-10-19 04:59 by Eric Wong (View Comments)


The Death and Rebirth of Practicing Ruby

The Practicing Ruby Journal publishes new Ruby articles by Gregory Brown on a weekly basis. Each article is a well-polished brain dump based on real experiences that will help you become a better software developer. Paying subscribers not only get access to a great learning resource, but also help make it possible for Gregory to spend more and more time working on the completely free Mendicant University. Read on to learn more.

2011-09-27 22:00 by Gregory Brown (View Comments)


USP: Unix time and the Ruby Time class

Eric explains Unix time concepts and how time related functionality is accessed from Ruby.

2011-09-24 02:28 by Eric Wong (View Comments)


USP: An introduction to the Unix pipe

We learn what pipes are and how they are realized in a Unix kernel.

2011-09-23 00:35 by Eric Wong (View Comments)


USP: Directories on the filesystem

This article explains how hierarchical filesystems are organized and what utilities Ruby provides for access to directories and directory entries.

2011-09-23 00:21 by Eric Wong (View Comments)


Issue #24: Connascence as a Software Design Metric

Issue #24 of Practicing Ruby, originally published on February 11, 2011. This article is about how to use the concept of connascence when reasoning about software design problems.

2011-09-20 17:00 by Gregory Brown (View Comments)


USP: Regular files and metadata

This article presents the various types of meta data of a file which can be obtained from the kernel. We also learn how to access this information from Ruby.

2011-09-20 04:13 by Eric Wong (View Comments)


USP: basic IO methods

This article introduces basic methods used for doing IO and how they map to system calls.

2011-09-19 21:28 by Eric Wong (View Comments)


USP: The Ruby IO Class

Class IO is at the core of Ruby's IO functionality. We also look at what types of buffers are active in an application and whether and how they are shared.

2011-09-17 03:33 by Eric Wong (View Comments)


USP: The Unix object model (as seen in procfs)

This is an introduction to places where information about processes in a running Unix system can be found.

2011-09-17 03:32 by Eric Wong (View Comments)


Issue #23: SOLID Design Principles

Issue #23 of Practicing Ruby, originally published on February 5, 2011. This article is about apply the SOLID design principles to Ruby programs.

2011-09-15 20:00 by Gregory Brown (View Comments)


USP: System calls in Unix

Explanation of the different functional layers involved in eventually getting the kernel to do something for us.

2011-09-15 00:34 by Eric Wong (View Comments)


USP: Avoiding system calls

Eric describes common strategies to reduce the number of system calls done. This does make sense since they come with an overhead.

2011-09-15 00:34 by Eric Wong (View Comments)


USP: Traditional Unix filesystem behavior

POSIX filesystems are byte oriented and the abstraction is difficult to adhere for certain use cases.

2011-09-14 23:55 by Eric Wong (View Comments)


USP: An overview of the Unix filesystem

In this installment Eric explains basic features of the Unix hierarchical filesystem including virtual filesystems.

2011-09-14 23:30 by Eric Wong (View Comments)


USP: The Unix object model (as seen from user space)

Eric introduces fundamental concepts of the runtime architecture of a Unix system: processes and file descriptors.

2011-09-13 04:24 by Eric Wong (View Comments)


USP: Prerequisite Knowledge

This is the first article in the series of our guest author Eric Wong about Unix systems programming (USP).

2011-09-13 01:29 by Eric Wong (View Comments)


Issue #22: How to practice (2 of 2)

Issue #22 of Practicing Ruby, originally published on January 28, 2011. This article is the second half of a two part series about my way of practicing software development.

2011-09-09 16:00 by Gregory Brown (View Comments)


Issue #21: How to practice (1 of 2)

Issue #21 of Practicing Ruby, originally published on January 26, 2011. This article is the first half of a two part series about my way of practicing software development.

2011-09-06 16:00 by Gregory Brown (View Comments)


Issue #20: Thoughts on Mocking (2 of 2)

Issue #20 of Practicing Ruby, originally published on January 22, 2011. This article is the second half of a two part series about using mocks in testing.

2011-08-15 20:00 by Gregory Brown (View Comments)


Issue #19: Thoughts on Mocking (1 of 2)

Issue #19 of Practicing Ruby, originally published on January 19, 2011. This article is the first in a two part series about using mocks in testing.

2011-07-29 14:00 by Gregory Brown (View Comments)


Issue #18: Dirty Little Secrets about Testing

Issue #18 of Practicing Ruby, originally published on January 14, 2011. This article is a small rant about TDD practices.

2011-07-25 14:00 by Gregory Brown (View Comments)


Issue #17: Interesting Ruby Hacker-Writers

Issue #17 of Practicing Ruby, originally published on January 7, 2011. This article highlights some Ruby developers I find particularly interesting.

2011-07-21 13:00 by Gregory Brown (View Comments)


Issue #16: Interesting Ruby Hackers

Issue #16 of Practicing Ruby, originally published on January 3, 2011. This article highlights some Ruby developers I find particularly interesting.

2011-07-20 13:00 by Gregory Brown (View Comments)


Issue #15: Duck Typing in Practice (2 of 2)

Issue #15 of Practicing Ruby, originally published on December 31, 2010. This article is the second half of a two part series about duck typing.

2011-07-19 13:00 by Gregory Brown (View Comments)


Issue #14: Duck Typing in Practice (1 of 2)

Issue #14 of Practicing Ruby, originally published on December 28, 2010. This article is the first in a two part series about duck typing.

2011-07-17 13:00 by Gregory Brown (View Comments)


Issue #13: Obfuscations of Christmas Past

Issue #13 of Practicing Ruby, originally published on December 23, 2010. This issue is a fun diversion that digs into one of the more notable obfuscated programs produced in the Ruby community.

2011-05-11 16:00 by Gregory Brown (View Comments)


Issue #12: Rapid Prototyping

Issue #12 of Practicing Ruby, originally published on December 21, 2010. This issue discusses how to use Ruby for coding up quick proof-of-concept prototypes.

2011-05-05 20:00 by Gregory Brown (View Comments)


Issue #11: Uses for Modules (4 of 4)

Issue #11 of Practicing Ruby, originally published on December 21, 2010. This article was the third in a four part series on modules, and what you can use them for.

2011-05-03 13:00 by Gregory Brown (View Comments)


Supporting the Ruby Mendicant experiment

Want an extremely easy way to help make a huge impact on the software development community? I have an idea!

2011-04-29 09:00 by Gregory Brown (View Comments)


Issue #10.5: Addendum to Uses For Modules, Part 3

Issue #10.5 of Practicing Ruby, originally published on December 15, 2010. This issue adds a bit more context to what was discussed in Issue #10.

2011-04-21 20:00 by Gregory Brown (View Comments)


Issue #10: Uses for Modules (3 of 4)

Issue #10 of Practicing Ruby, originally published on December 14, 2010. This article was the third in a four part series on modules, and what you can use them for.

2011-04-19 09:00 by Gregory Brown (View Comments)


What have the RBP bloggers been up to?

While we've seen a small resurgence in activity on this blog due to the gradual release of the Practicing Ruby newsletter, it's been quite a while since we've seen any posts that were specifically written for this blog. I went ahead and caught up with the RBP bloggers to see what they've been up to.

2011-04-18 16:00 by Gregory Brown (View Comments)


Issue #9: Uses for Modules (2 of 4)

Issue #9 of Practicing Ruby, originally published on December 10, 2010. This article was the second in a four part series on modules, and what you can use them for.

2011-04-14 16:00 by Gregory Brown (View Comments)


Issue #8: Uses for Modules (1 of 4)

Issue #8 of Practicing Ruby, originally published on December 8, 2010. This article was the start of a four part series on modules, and what you can use them for.

2011-04-13 18:00 by Gregory Brown (View Comments)


Issue #7: Meditations on Bad and Good Code (2 of 2)

Issue #7 of Practicing Ruby, originally published on December 3, 2010. This article describes a learning technique I use frequently to help me reflect on my software design and development practices.

2011-04-06 04:00 by Gregory Brown (View Comments)


Issue #6: Meditations on Bad and Good Code (1 of 2)

Issue #6 of Practicing Ruby, originally published on December 1, 2010. This article describes a learning technique I use frequently to help me reflect on my software design and development practices.

2011-03-24 12:00 by Gregory Brown (View Comments)


Issue #5: Testing Anti-patterns; Testing Private Methods

Issue #5 of Practicing Ruby, originally published on November 25, 2010. This article covers various alternatives to testing private methods explicitly in your unit tests.

2011-03-22 12:00 by Gregory Brown (View Comments)


Issue #4: Writing Configurable Applications (2 of 2)

Issue #4 of Practicing Ruby, originally published on November 18, 2010. The focus is on how to build configurable applications that don't suck.

2011-03-17 19:33 by Gregory Brown (View Comments)


Issue #3: Writing Configurable Applications (1 of 2)

Issue #3 of Practicing Ruby, originally published on November 16, 2010. The focus is on how to build configurable applications that don't suck.

2011-03-10 19:33 by Gregory Brown (View Comments)


Issue #2: Ruby's method lookup path (2 of 2)

Issue #2 of Practicing Ruby, originally published on November 11, 2010. The focus is on one of the most fundamental bits of Ruby knowledge one must master: the method lookup path.

2011-03-08 17:33 by Gregory Brown (View Comments)


Issue #1: Ruby's method lookup path (1 of 2)

The very first issue of Practicing Ruby, originally published on November 9, 2010. The focus is on one of the most fundamental bits of Ruby knowledge one must master: the method lookup path.

2011-03-03 13:52 by Gregory Brown (View Comments)


The Gradual Practicing Ruby Giveaway, Phase II

Now that my paid newsletter is wrapping up, I've decided to bring this blog back to life by gradually releasing back issues for the enjoyment of RBP blog readers. We also decided to do a small rebranding in the process.

2011-03-03 13:08 by Gregory Brown (View Comments)


Practicing Ruby, The Newsletter

My work with students at Ruby Mendicant University over the last several months has taught me a ton about what topics are stumbling points for intermediate Ruby developers. In an effort to help support the ongoing operations of RMU while simultaneously helping others learn, I'm launching an inexpensive bi-weekly newsletter.

2010-11-08 16:43 by Gregory Brown (View Comments)


The Ruby Mendicant University Core Skills Course

Ruby Mendicant University is an experiment in alternative technical education that got its start through some brainstorming done here on the RBP blog back in June, 2010. This series of posts will bring the community up to date on what we've been up to, and what lies on the horizon.

2010-10-21 17:35 by Gregory Brown (View Comments)


Complexity

For a while I have been pondering how to write about complexity. I believe this term is a crucial one for our profession and we should understand it in order to be able to make a good job. Today I will explore the first dimension of complexity: complexity to avoid redundancy.

2010-06-06 16:37 by Robert Klemme (View Comments)


Ruby Mendicant University is a Go!

Details on how to get involved with my new Ruby Mendicant University idea.

2010-06-04 14:50 by Gregory Brown (View Comments)


IDEA: Ruby Mendicant University

It's time for another one of my crazy ideas: This time, a free online Ruby training program. Please read about it and let me know what you think.

2010-06-03 14:50 by Gregory Brown (View Comments)


If you want to see the wizard, go to Oz.

The story of how I got involved in Ruby, and made one of the best friends anyone could ask for. And also, why you should be registering for Red Dirt RubyConf right now.

2010-04-21 14:50 by Gregory Brown (View Comments)


rubyproblems.com is now live!

I'm pleased to announce the launch of rubyproblems.com, a new Ruby learning resource that readers of RBP are sure to enjoy.

2010-04-07 14:50 by Gregory Brown (View Comments)


Full Book Now Available For Free!

As of today, you can download the full PDF copy of my book "Ruby Best Practices". I have also put the manuscript and production sources out there, so contributors can start to play with things as they see fit. Click through for details.

2010-03-17 16:50 by Gregory Brown (View Comments)


Ruby Tuesdays: RBP Chapter 7

This week, we have the Reducing Cultural Barriers chapter of Ruby Best Practices available for reading and discussion. In it, you'll learn about some multilingualization and localization techniques, including a bit about how encodings work in Ruby 1.9.

2010-03-09 14:00 by Gregory Brown (View Comments)


Ruby Tuesdays: RBP Chapter 6

This week, we have the When Things Go Wrong chapter of Ruby Best Practices available for reading and discussion. In it, you'll find practical tips that will make troubleshooting your Ruby code a whole lot easier.

2010-03-02 07:00 by Gregory Brown (View Comments)


Code Massage

Playing around with code can be fun and even provide new insights into the language or coding techniques.

2010-02-28 08:32 by Robert Klemme (View Comments)


Ruby Tuesdays: RBP Chapter 5

This week, we have the Functional Programming Techniques chapter of Ruby Best Practices available for reading and discussion.

2010-02-23 15:00 by Gregory Brown (View Comments)


The Complete Numeric Class

If you want to create a class to do math with (more precisely, a class with that employs operator overloading) additional aspects come into play compared to the class I presented in "The Complete Class".

2010-02-20 09:25 by Robert Klemme (View Comments)


Ruby Tuesdays: RBP Chapter 4

After a short delay, the Text Processing and File Management chapter of Ruby Best Practices is now available for you to read and discuss.

2010-02-16 15:00 by Gregory Brown (View Comments)


RBP is useless without you

If you were expecting to see Chapter 4 released today, unfortunately, it's not going to happen this week. See the main post for details.

2010-02-12 05:24 by Gregory Brown (View Comments)


Weekend Reading: RBP Chapters 2-3

Releasing Chapter 2 and 3 of my book, "Ruby Best Practices". Last week's comments on Chapter 1 were great, so hopefully we can keep that up this week.

2010-02-05 14:00 by Gregory Brown (View Comments)


Sexp for Rubyists

Sorry to interrupt you, but you've totally lost me. What is this "Sexp" you're speaking of? I've heard it before, but never quite understood it...

2010-02-04 16:00 by Magnus Holm (View Comments)


Weekend Reading: RBP Chapter 1

From the time I began writing the "Ruby Best Practices" book, I knew I'd eventually release it under a Creative Commons license. It's now time to start that process. This post releases the book's first chapter, "Driving Code Through Tests".

2010-01-29 14:32 by Gregory Brown (View Comments)


Reflections from "The Compleat Rubyist"

Reflections on our recent training event The Compleat Rubyist, held January 22-23 in Tampa, FL. Everybody learned a ton, including us instructors.

2010-01-25 15:36 by Gregory Brown (View Comments)


Learning From Bad Ideas

A common way of studying the game of Go is to work backwards from a bad position to discover what a better move would have been. In this article, I'll show you how to do that with Ruby code as well.

2009-11-22 22:57 by Gregory Brown (View Comments)


The Complete Class

There are a few concepts you have to implement for many classes such as equivalence, hash code calculation etc. Today I will discuss these and provide a sample class implementation with all of them.

2009-10-24 14:05 by Robert Klemme (View Comments)


Structs inside out

I will try to expose the utility of class Struct which is part of the standard library. And it does not even need a require! Read on for full story.

2009-09-21 17:48 by Robert Klemme (View Comments)


Muppet Labs closing for now

Now that the code has reached a final version and interest in the blog series has died away Muppet Laboratories will close the door for now.

2009-09-07 15:03 by Robert Klemme (View Comments)


James will be right back after these interruptions

Keeping your focus and flow while still making notes of bugs and quirks can be challenging. Luckily, as Ruby hackers, we can build tools to reduce the friction of mundane tasks

2009-08-30 09:00 by James Britt (View Comments)


Completing the Animal

We are coming close to the end to the Laboratory series: finally the animal is complete and munches away on your logfiles.

2009-08-24 17:09 by Robert Klemme (View Comments)


Be Nice and Have Fun

In the wake of yet another Ruby drama scene, there is one community Best Practice that always works.

2009-08-21 11:25 by Gregory Brown (View Comments)


A bit of Optimization

The dramatic decrease of performance bugged me. Today I show, how I managed to remedy that - and even get a faster version than before.

2009-08-09 16:47 by Robert Klemme (View Comments)


Should I Tap that Hash? (Ruby 1.9 Style)

Ruby 1.9 gives us Object#tap, which is immediately useful for some benign purposes. But lately I've been getting more creative and can use some peer review to tell me if what I'm doing is elegant or ugly.

2009-08-05 12:00 by Gregory Brown (View Comments)


LRU Integration explained

Today I'll add a bit more explanation to the last article and provide the reasoning behind the implementation.

2009-07-31 12:33 by Robert Klemme (View Comments)


LRU Integration

I could not find a LRU class which fits nicely with our requirements so I wrote it myself. This is just a short article showing the integration of it.

2009-07-10 17:07 by Robert Klemme (View Comments)


25th Post!

This is the 25th post since RBP blog started up. Let us know what you think of how things have gone so far.

2009-07-07 05:00 by Gregory Brown (View Comments)


Code Blocks: Ruby's Swiss Army Knife

A complete section excerpted from the "Designing Beautiful APIs" chapter of my O'Reilly book, Ruby Best Practices.

2009-07-07 04:00 by Gregory Brown (View Comments)


Animal Interaction Processing

The InteractionProcessor is one of the core components of our Animal. We will look at how it is built - and why it's done that way.

2009-06-30 12:30 by Robert Klemme (View Comments)


The Decorator Delegator Disco

In response to Aaron Patterson's "Double Dispatch Dance", we'll take a look at another way to get funky with design patterns. Go read his post first if you haven't already.

2009-06-27 16:00 by Gregory Brown (View Comments)


The Animal raises its head

I hacked together a first draft illustrating the intended architecture.

2009-06-22 18:36 by Robert Klemme (View Comments)


Shadow of the Animal

Today I will go into more detail with regard to the application structure and the thought process that led to it.

2009-06-21 15:36 by Robert Klemme (View Comments)


The Double Dispatch Dance

Let's take a quick tour of how to convert anything to anything using the Double Dispatch and Visitor patterns.

2009-06-19 20:30 by Aaron Patterson (View Comments)


First Design Considerations

Today we will go into medias res. I will start by outlining application design and collect some useful facts derived from requirements. You'll even see small snippets of Ruby code!

2009-06-12 16:36 by Robert Klemme (View Comments)


"And your Mom, too." Ruby-talk best practices.

Part of being a good Ruby hacker is being part of a community. Let's look at some best practices for posting to mailing lists, ruby-talk in particular

2009-06-10 17:59 by James Britt (View Comments)


Quack Attack: Making Your Code More Rubyish

Often times, when a newbie tries to make their code more "Rubyish", it means using some cute meta-programming hack that experienced hackers would never use due to its obscurity or fragility. However, the Ruby Way isn't just an urban myth, nor is it some dark secret held tightly by its masters. In this article, we'll look at a simple but powerful API design technique that will make your code more "Rubyish" without invoking any deep voodoo.

2009-06-09 13:00 by Gregory Brown (View Comments)


Requirements Summary of the Laboratory Project

Now it's time to collect all the requirements from the discussion threads and put them into some groups.

2009-06-08 17:59 by Robert Klemme (View Comments)


Name that method: Symmetry

Naming your methods properly is an important task when it comes to writing readable and reusable code. Today, let's explore one useful concept: Symmetry.

2009-06-05 15:39 by Magnus Holm (View Comments)


RubySpec as a Community Resource (Interview w. Brian Ford)

I caught up with Brian Ford to ask a few questions about RubySpec, the effort to describe Ruby through BDD style specs. With any luck, after reading his responses, you'll be as excited about this awesome effort as I am.

2009-06-04 07:52 by Gregory Brown (View Comments)


The Laboratory Project

Today we will start the announced project. You will find a description of the problem I will attempt to solve in the course of the project. Please read on.

2009-06-03 17:56 by Robert Klemme (View Comments)


Enter the Muppet Laboratories

Often we present finished code which includes all the decisions that have been made during its construction. I will try show the process that led to the final code like we are looking at a test tube.

2009-05-29 13:54 by Robert Klemme (View Comments)


Reading Ruby's Standard Library for Fun and Profit

The more code we read, the more we learn about our craft. No self-respecting Rubyist should go without reading at least bits and pieces of Ruby's standard library, so I'd like to get you started on that journey today.

2009-05-24 18:25 by Gregory Brown (View Comments)


Control flow features and readability

When we program we routinely pick different control flow freatures. Often we do not think much about our choice and in fact in many situations it is obvious what we should do. I got curious about the nature of control flow features with respect to their effects on readability when I realized that catch ... throw is an extreme rare thing to see. Let's look a bit closer at this.

2009-05-19 20:46 by Robert Klemme (View Comments)


Hello World (Literally)

A quick look at of a map of where in the world our traffic has come from in the last few days, along with a few questions for our readers.

2009-05-05 06:42 by Gregory Brown (View Comments)


The Universe between begin and end

The article was inspired by last article's comments. Much has been said in the comments already and today I'll mostly try to combine and organize it to give an overview from begin to end.

2009-05-01 10:05 by Robert Klemme (View Comments)


Fun with Class.new

Building anonymous classes may sound a bit esoteric, but they can actually come in handy in a number of ways. I've collected three and a half of my favorite tricks for your enjoyment.

2009-04-30 17:55 by Gregory Brown (View Comments)


Writing Block Methods with automatic Resource Cleanup

Last time I demonstrated how using library methods with blocks can improve robustness of a program. This time I will show how such methods are implemented.

2009-04-20 19:47 by Robert Klemme (View Comments)


Rails Modularity for Lazy Bastards

If given the choice, would you rather maintain one gigantic Rails application, or a handful of smaller ones? Using some simple organizational techniques along with ActiveResource, you can still tackle the big problems without the big headaches that come along with monolithic systems.

2009-04-16 04:31 by Gregory Brown (View Comments)


Solve the problem, not just a problem

Geeks are prone to build complex tools to solve problems, but the real goal is to solve the right problems. The Korma blogging tool hits that sweet spot.

2009-04-13 20:11 by James Britt (View Comments)


Using Blocks for Robustness

One way to look at Ruby's blocks is as anonymous functions and one of the uses of them is to make your code more robust.

2009-04-09 14:25 by Robert Klemme (View Comments)


Welcome to the RBP blog

This blog will hopefully be a great community resource for Ruby developers who are constantly in search of better coding practices and techniques. Although it'll be a few days before things get rolling, I'm happy to announce the project and the great group of collaborators we've put together.

2009-04-07 17:02 by Gregory Brown (View Comments)