So I created gabriel. gabriel helps you communicate with god by offering completions for subcommands, options, tasks, and group names for your bash shell. Installing it is pretty simple:

$ gem install gabriel
$ gabriel-install
(From there, follow the on-screen instructions)

To ensure you get completions in every session, confirm that your .bashrc is sourced in your .bash_profile (or .profile, if you’re a bit more old-school).

This is my first foray into shell scripting and into publishing a ruby gem, so check out the source and if you can make gabriel even better, please do contribute your patches.

May god watch kindly over all of your processes.

One of these parallels between humans and computers is the way that we multitask. Computers only seem to multitask by switching between tasks rapidly, with the exception of new multi-core and multi-processor systems, which can run as many tasks in parallel as there are cores or processors. So it was interesting to read recently that the prevailing theory is that humans multitask in precisely the same way!

Analogous to a multitasking CPU, current experimental psychology research shows that interference occurs when we attempt to perform even simple tasks simultaneously. There are certain exceptions to this, particularly when one of the two tasks is stored in “muscle memory”, but this is because we can perform such tasks without even thinking about them. In many other cases, the effectiveness with which we perform the tasks is diminished when we are doing more than one task at the same time.

It is also common wisdom in IT that when somebody is deep in his/her work (commonly referred to as flow), an interruption of even a few seconds can result in 15 minutes of lost productivity. While I’ve never verified the actual number, I have often had trouble putting myself back on a task after being jolted out of it by a short interruption.

When a CPU switches tasks, it must perform a context switch. The current state of the program that is running on the computer, including the values stored in the registers, a reference to the next instruction to execute, and other housekeeping information are stored in memory (RAM). When the program comes back, the stored information is put back into its proper places so that the CPU can pick up where it left off. This is a fairly costly operation as the CPU cannot access RAM even a fraction as fast as it can access its registers. Of course, this means that when a CPU runs two programs simultaneously, it is less efficient at each than if it were concentrating entirely on one program or the other. Determining when to switch to a different program is therefore an incredibly important concern in the design of modern operating systems.

I’ve witnessed human “context switching” in a co-worker of mine. When I knock on her door to ask her a quick question about work that I’m doing for her, she asks me to give her a moment and looks to be deep in thought. She then asks me to repeat my question and answers it with surprising conciseness and accuracy. She has told me that she needs to switch from the mindset of what she’s currently working on to the mindset of what I’m asking her or she can’t answer properly.

This isn’t to say that multitasking is bad, but I am acutely aware that when I do multitask, I am not going to be able to perform each task as effectively as if I were focused entirely on one. Also, there are certain points at which it is easier or more natural to switch from doing one thing to doing another, particularly where I’ve accomplished a sub-goal in the task or where I’ve written down detailed notes on the current state of what I’m doing, which makes it easier to switch back to it later.

What do you think?

Self-esteem expressed in Ruby

It’s a valuable life lesson made incredibly concise in my favourite programming language, Ruby. I leave the interpretation to the reader. It relates to some themes that I’ve already written about before and will probably write more about in the future.

As with the first tutorial, I’ve pushed a branch based on authlogic_example that you can use as a concrete example.

First, let’s bring in the declarative_authorization gem:

# My example code was written before GitHub decided that they don't want to
# build gems anymore but this line should do the trick.
config.gem "declarative_authorization", :source => 'http://gemcutter.org'

Now, we need to make an ActiveLdap model class like LdapUser but for groups. We’ll call this LdapGroup:

class LdapGroup < ActiveLdap::Base
  ldap_mapping :dn_attribute => "cn",
    :scope => :sub,
    :prefix => "ou=groups,o=users"
 
  has_many :members, :class_name => "LdapUser", :wrap => "member",
    :primary_key => "dn", :foreign_key => "dn"
end

The ldap_mapping part is very similar to the previous one for LdapUser, but the has_many is where the real ActiveLdap magic starts!

We are letting ActiveLdap know that an LdapGroup has LdapUser members, which are defined in the multi-valued attribute member, where each of the values is the DN of an LdapUser. If you’re looking for a bit more detail, refer to the ActiveLdap documentation. Keep in mind that the code above is for the specific schema used by my example application and you may have to change it to match yours.

With that, we should be able to list all of our LDAP groups and find the members of any particular one in the console:

>> LdapGroup.all.collect { |g| g.cn }
=> ["super_admin"]
>> LdapGroup.find("super_admin").members.collect { |m| m.dn }
=> ["uid=ebianco,o=users,dc=example,dc=com"]

Now we’ll create an association between LdapUser and LdapGroup so that given a user, we can figure out which groups he/she is a member of. We’re going to tell ActiveLdap that a user’s groups are those groups in which the user’s DN appears in the group’s member attribute:

belongs_to :groups, :class_name => "LdapGroup", :many => "member",
  :foreign_key => "dn"

Let’s check our handiwork in the console:

>> LdapUser.find("ebianco").groups.collect { |g| g.cn }
=> ["super_admin"]

Now why did we go through all of this effort? declarative_authorization allows us to provide an instance method for User, #role_symbols, that returns an array of symbols representing the list of roles that the user has. With our ActiveLdap setup, mapping a user’s roles to LDAP groups becomes a one-liner:

def role_symbols
  ldap_entry.groups.collect { |g| g.cn.to_sym }
end

From here, we can define the authorization rules for our LDAP-based roles. declarative_authorization reads these from config/authorization_rules.rb:

authorization do
  role :super_admin do
    has_permission_on :users, :to => :manage
  end
  role :guest do
    has_permission_on :users, :to => :read
    has_permission_on :users, :to => [:create, :update, :destroy] do
      if_attribute :id => is {user.id}
    end
  end
 
end
 
privileges do
  privilege :manage do
    includes :create, :read, :update, :destroy
  end
end

Now we can use declarative_authorization as usual. I won’t go through all the details but if you want a primer on using declarative_authorization, you can start here and browse the commits on my authlogic_example branch.

class WebTransaction
 
  # Base URL for transaction web service
  SERVICE_URL = "http://accountingservice.com/"
 
  def transaction_url
    url = SERVICE_URL
    url << "VAL1=foo"
    url << "&VAL2=bar"
    url
  end
 
end

The class is meant to represent a transaction being posted against a rather odd web service that actually uses GET rather than POST for posting transactions (bad web service!). In my actual code, the URL parameters appended to the SERVICE_URL base would be determined on a per-object basis but I’ve simplified it here.

Here’s the punchline: SERVICE_URL was changing! Calls to transaction_url would keep on appending more variables to it. If you’re particularly clever with Ruby, you’ve already figured out exactly why. But if you’re scratching your head like I was, here are some hints:

• In Ruby, constants aren’t. In fact, they’re really no different from variables except for the fact that Ruby detects that variable names in all-caps are probably supposed to stay constant and warns if you try to assign to them.
• <<, for strings, will append to the end of the string.
• Ruby strings are mutable. That is, operations on a string variable will usually be done in place, rather than returning a new string. (Method calls, on the other hand, are a different story!)
• Assigning a String variable to another String variable will assign the reference. That is, the two variables will be pointing at the same object.

Hit the jump to see the solution to this little mystery…

SERVICE_URL is only directly assigned to when it is declared. But what happens when I assign SERVICE_URL to the local variable in transaction_url, url. They’re pointing to the same object!

Then I go ahead and I start appending things to the end of the string. Ruby has no complaints because I’m not assigning to SERVICE_URL but the object that it is pointing to is being changed! The operation is causing the URL parameters to be appended in place.

And that, friends, is what happens when constants aren’t. Let’s fix this little error:

class WebTransaction
 
  # Base URL for transaction web service
  SERVICE_URL = "http://accountingservice.com/"
 
  def transaction_url
    url = SERVICE_URL.clone
    url << "VAL1=foo"
    url << "&VAL2=bar"
    url
  end
 
end

Now, instead of appending to the string object referenced by SERVICE_URL directly, I’m creating a copy of the object and then appending URL parameters to that.

About a week ago there was a discussion about this on programming Reddit. The original poster, a programmer, feels a sense of inferiority because while others can succinctly explain the “awesome” in what they’re doing, he cannot. I sympathize with this sentiment. I love what I do but how do I transfer that passion without drowning the other person in the technical details? It feels like without the finer, technical details, my job description becomes distilled to “I make websites.”

Really? That’s it? That’s what I do for a living?

But is the problem really that what we’re doing isn’t interesting to the layperson? Web developers built Google, Facebook, MySpace, Wikipedia, and many more technologies that people use every day. We are building cool web applications that, while they might not gain the same degree of popularity or critical mass, can potentially provide just as much value. If we didn’t think that web development was an awesome career, a lot of us probably wouldn’t be doing it.

(And by the way, if you’re making money doing something you have absolutely no passion for, you might want to try and fix that.  Just sayin’.)

So why do we have difficulty getting people to identify with this?  Perhaps this comment from the Programming Reddit discussion might shed some light on the topic (emphasis mine):

Obnoxious braying girl: (To me and a friend) Oh, i bet i can guess what you do! go on, let me! (Obnoxious braying girl makes a few guesses about my friend’s job, eventually works out he does some sort of admin thing in publishing, polite words exchanged about this field) Obnoxious braying girl: (to me) Hmm.. you’re… a graphic designer? Me: hah! god no OBG: A journalist? Me: Well, that does sound like fun, but no (back and forth for a bit until she eventually asks me what i do Me: (in jokey, self deprecating tone) – I’m a massive nerd, basically – I program computers and make websites for people OBG: oh, right… (she stares down into her drink) Me: (trying to salvage this conversation) – so, and what do you do? OBG: Oh, i work at a corporate events company! it’s really exciting, basically we…. Cue 15 minutes of skull-numbingly boring monologue about basically being a travel-agent for corporations. It puzzles me though – why is anyone who doesn’t work with computers given licence to go on and on about their job (Despite the fact that asking people about work is basically a social nicety and not interesting at all to anyone socially), wheras anyone whose interests (whether work based or not) include anything technology or science-based are automatically percieved as boring socially-inept people who can’t talk about anything else? Fuck that shit – next time i’m introduced to someone I’m going straight into explaining recursion.

There are a few things that one could criticize here but the point I’ve decided to focus on here is the blatant self-deprecation. If you read the rest of the comments in the discussion, you might notice, like I have, that this is actually surprisingly common — it’s like many of us have been conditioned to believe that what we do is simply not interesting to a vast majority of people, so we might as well just say “I do computer stuff” and get it over with.

Alun Anderson, Editor-in-Chief of New Scientist magazine, would beg to differ (emphasis mine again):

Science writing used to be slightly apologetic: [puts on whiny voice] “this is all going to be terribly difficult, but I’ll try and make it easy for you”. Like they’ve sugar coated something you don’t really want to take. Our goal was to really change that – change the people and the ideas – to be self-confident. Science often suffers from this sort of cringe factor – “I’m a boring scientist, you probably don’t want to talk to me”. My policy was if you’re talking to someone else the approach is: “what’s happening in science is the most interesting thing in the world, and if you don’t agree with me just fuck off, because I’m not interested in talking to you”. You had to have that kind of attitude. That tended to be the kind of attitude of people in the arts: [in snooty voice - think Brian Sewell] “Of course I am doing something interesting”, so I took the same attitude. If you’re not interested, I don’t want to explain to you – you’re just a fucking idiot, so get out of my way! And it worked, because if you write like, “I’m really interested in this, it’s not only interesting its really important. If you can’t see this, you’re probably a moron!” It works. It has to be true to a degree. Otherwise it’s just piped bullshit, or triumphalism or something. The thing is, it is really interesting and important. People from the sciences do often have massive inferiority complexes.

I believe that what I do is interesting, important, and valuable. If I didn’t, I’d be doing something else. And so, I will endeavour to find a way to convey that value and importance and when someone asks me what I do, that is how I will answer.

Anyone who absolutely can’t identify with my passion for what I do is probably somebody I really wouldn’t like anyway.

This branch shows a way of implementing pass-through authentication to an LDAP server using ActiveLdap and Authlogic, with just some small changes to the User and UserSession models.

First, we’ll need to bring in the net-ldap and activeldap gems. We edit config/environment.rb to include the following two lines:

config.gem "net-ldap", :lib => false, :version => '>=0.0.5'
config.gem "activeldap", :lib => "active_ldap", :version => '1.0.9'

If you use sudo gem install net-ldap, you’ll get 0.0.4. Here, I’ve built the 0.0.5 gem from the GitHub repo. This is because there are some bug fixes in the GitHub master that aren’t in the RubyForge gem. In the with-activeldap branch, the two gems are vendored.

Now, we create config/ldap.yml to configure ActiveLdap’s connection to our LDAP server. Here’s mine:

development:
  host: 127.0.0.1
  base: dc=dev,dc=Asuka,dc=local
  bind_dn: cn=Manager,dc=dev,dc=Asuka,dc=local
  password: secret
 
test:
  host: 127.0.0.1
  base: dc=test,dc=Asuka,dc=local
  bind_dn: cn=Manager,dc=Asuka,dc=local
  password: secret
 
production:
  host: 127.0.0.1
  base: dc=prod,dc=Asuka,dc=local
  bind_dn: cn=Manager,dc=Asuka,dc=local
  password: secret

This tells ActiveLdap the server/port to connect to, what the base entry for our LDAP objects is, and what user to bind as for operations on the server. Now, we create a LdapUser class to represent user entries in the LDAP:

class LdapUser < ActiveLdap::Base
  ldap_mapping :dn_attribute => "uid",
    :scope => :sub,
    :prefix => "o=users"
end

This defines an LDAP user as being an entry from the o=users organization, where all of the entries are distinguished by the uid attribute. Now, we should be able to use the console to list all of our LDAP users like so:

 >> LdapUser.all

Now, we’ll add some methods to the User model that allow us to look up users by login in the LDAP and create entries in the database if they don’t already exist. We’ll also need a method for forwarding the credentials provided on the login form to the LDAP and see if they are valid:

class User < ActiveRecord::Base
  acts_as_authentic do |c|
    # Don't validate password, since that will be held in the LDAP
    c.validate_password_field = false
  end
 
  def ldap_entry
    LdapUser.find(self.login)
  end
 
  # Tries to find a User first by looking into the database and then by
  # creating a User if there's an LDAP entry for the given login
  def self.find_or_create_from_ldap(login)
    find_by_login(login) || create_from_ldap_if_valid(login)
  end
 
  # Creates a User record in the database if there is an entry in the LDAP
  # with the given login
  def self.create_from_ldap_if_valid(login)
    begin
      User.create(:login => login) if LdapUser.find(login)
    rescue ActiveLdap::EntryNotFound
      nil # Don't do anything since we can't find an entry
    end
  end
 
  protected
    # Authenticates the user against the LDAP.
    def valid_ldap_credentials?(password_plaintext)
      ldap_entry.bind(password_plaintext)
      ldap_entry.remove_connection
      true
    rescue ActiveLdap::AuthenticationError, ActiveLdap::LdapError::UnwillingToPerform
      false
    end
end

With this, there is no longer a need for the crypted_password and password_salt columns in the users table, so if those columns exist, you’ll have to write a migration to remove them (or at least allow NULL values for them). Now, we modify the UserSession to use our custom methods for looking up users and validating their credentials:

class UserSession < Authlogic::Session::Base
  find_by_login_method :find_or_create_from_ldap
  verify_password_method :valid_ldap_credentials?
end

With that, we should now be able to log in as a user by providing her uid as the login and the password. LDAP pass-through authentication achieved! There is a downside though: ActiveLdap is not particularly efficient with its queries but this can be mitigated by storing the user’s LDAP entry (the LdapUser object) in the User instance when it is first looked up.

def ldap_entry
  @ldap_entry ||= LdapUser.find(self.login)
end

In a future post, I will extend this further by modeling LDAP groups and bringing in declarative_authorization to implement role-based access control based on LDAP group membership.

Why The Lucky Stiff’s contributions to the Ruby community include “Why’s Poignant Guide to Ruby”, a book which many state was the reason they got into Ruby, Shoes, an easy-to-use cross-platform GUI toolkit with innovative online distribution features, and Hpricot, a very slick HTML parser that is also a joy to use.

Some believe that he has decided to move on from software development because his last tweet reads “programming is rather thankless. u see your works become replaced by superior ones in a year. unable to run at all in a few more.” Some believe that his accounts were all hacked. A few others believe that his anonymity has been compromised and that he has decided the destroy the pseudonym.

Wherever Why The Lucky Stiff goes from here, I hope he knows that there are so many of us who looked up to him and have him to thank for knowing the joy that is programming in Ruby. He will be sorely missed.

Robert Fischer wrote a post titled “Dear User of My Open Source Project” and many of the proggit comments were quite vicious. I noticed that some of these commentators seemed to have the same understanding of “open source”: that an open source project is a product, like any other product, that is simply distributed with its source code. Therefore, Robert is clearly creating and releasing “inferior” products and this behaviour should be punished. Being open source is not an excuse.

If this is your understanding of open source, you have missed the point. Entirely.

Yes, there are open source projects out there that are very well-documented, quite reliable, and have attracted large communities of contributors that tirelessly work to improve every aspect of the software. But by my count, that seems to be the exception rather than the rule. Most open source projects out there are maintained by just one person who scratched an itch and thought the solution might be useful to others. Some of these projects might be lucky enough to have a few passionate contributors. These projects may have some rough edges in their code or their documentation, and perhaps the contributors might be too busy to put on the appropriate polish.

You might think that irresponsible, or even reprehensible. How dare this person release this garbage and pollute the open source community!

News flash: it is these people who drive open source software. Those large, reliable open source projects with all of the sparkle and polish? They became that way because large groups of people found them useful enough that they decided to invest their time in making the project even better. But in all cases, for open source software to progress, people have to be willing to give up their time and energy for free and with no expectation of reward. Open source is driven by pure altruism.

And yes, as a programmer using open source software, you may sometimes have to roll up your sleeves, get into the code, and make the changes that you need. Or perhaps you can find other ways to contribute. But complaining like a petulant child that it doesn’t serve your particular purpose is, frankly, incredibly rude considering that you were given this software entirely for free and given the power to inspect its source code and change it to suit your needs. If that is the way that you’re going to approach these projects, go use something else.

Like Christmas, the true spirit of open source is giving.

Edit: Some one on proggit rightly pointed out that I’ve made a common mistake of grouping “open source” software with “free” software, a subtle distinction that this pagefrom the FSF makes very clear. However, I believe that Robert Fischer’s post and his complaints also referred more to “free” software than “open source” software. Consider, for example, that he prefers to use the WTFPL for his projects, the spirit of which is “I’ve decided to put this out here, and you guys can do whatever you’d like with it.”

This is not to say that all “open source” software doesn’t adhere to the values of “free” software or that all “open source” software necessarily follows the values of “free” software.

It turns out that ActiveScaffold and YARD don’t play nice together. In particular, if YARD has previously been loaded (say, to define a Rake task for it), ActiveScaffold initialization will fail with the following error:

uninitialized constant Helpers::ControllerHelpers

Using --trace and following the source code, I find out that this is happening during ActiveScaffold’s initialization, particularly at this statement:

ActionController::Base.send(:include, ActiveScaffold::Helpers::ControllerHelpers)

Debugging the ActiveScaffold initialization code yields this baffling result:

>> ActiveScaffold::Helpers
=> Helpers
>> ActiveScaffold::Helpers::ControllerHelpers
NameError: uninitialized constant ActiveScaffold::Helpers

It’s the weirdest thing that I’ve seen since I became a Rubyist and it is blocking me from using YARD to generate the documentation for my current Rails project. Unfortunately, cutting out ActiveScaffold isn’t going to fly because the deadline for initial release is so close and so much functionality is implemented using it already. It wasn’t my choice; if I had my way, I might never use ActiveScaffold ever again.