GrokBlok

Something that I use everyday that I’ve just released for public use is the Braintree Tools Site, which is just a Camping application frontend to the Braintree APIs. It’s also a simple collection of tools that will help you figure out if your ‘hashing’ is correct and what response look like. It’s kinda like a sandbox, but you don’t need to go so far as to write your own script. You can just do it from the web.

There is certainly truth in the statement that the best tools are created by the people who actually use them. A major part of my job at Braintree is to ease the task of integration for our customers. I come into contact with people who are using everything from Ruby on Rails to customized PHP to Oracle Forms. The nice thing about our API is that it doesn’t matter. You’re simply making HTTP GETS/POSTS to interact with the Gateway. For me, customer support at it’s most basic is just typing a query string into a browser address bar and looking at the response.

Take advantage of user data to create intelligent Rails applications! This talk will focus on data mining to create complex application behavior and gain insight into the patterns and habits of your users. Examples of these techniques can be seen with recommendation systems like those created by Amazon, Netflix, last.fm, and others. Additional examples include spam filtering systems for email or comment filtering provided by Akismet.

I will focus on techniques for gathering data, specific gems and plugins for performing various data mining and machine learning tasks, and performance issues like how to distribute the work to separate servers. Theory in this talk will be light and the specific algorithms will only get a mention by name. We’ll be looking at real world Ruby and Rails code examples for building recommendation, ranking, and classification systems.

Sounds fascinating. I also found it interesting that one of my former employers, JPMorganChase is a sponsor. If you have the means to attend, I’d really recommend it. I’ll wager there will be scotch, but probably not any Highland Games.

In a previous post I mentioned a funky character encoding issue with my Emacs Autotest output. I finally looked into the cause and came across the solution. I just needed to enable ansi-colors in my Emacs shell.

In your .emacs file, add the following:

   ;; Add color to a shell running in emacs 'M-x shell'
   (autoload 'ansi-color-for-comint-mode-on "ansi-color" nil t)
   (add-hook 'shell-mode-hook 'ansi-color-for-comint-mode-on)

Cheap and easy. Now, you’ll get all the cool ansi colors, like the kids.

For those of you in the Columbus area, I’ll be speaking at the Columbus Ruby Brigade meeting this evening regarding Rails 2.0. This will be a high-level talk around some of the new things and some of the deprecated behaviours in everyone’s favorite web framework.

We’re really getting things rolling on Gonowdo and as part of that, we’re starting to accept users on a somewhat limited basis. When signing up, I need to make sure that users accept our terms of service. With Rails, this is extremely simple, but after spending a few minutes on mailing list archives and forums I didn’t find a good resource or howto. Hopefully, this post will serve as that for anyone in the future.

The key to accomplishing this is to use an active record validation called “validates_acceptance_of”. Adding this to the User model with a method will create a virtual attribute for that named method, in my case, I used “terms_of_service”. There is no corresponding column in the database needed. This will not allow a model to be saved without it. By default, this method will allow the record to be saved if it is nil. Setting it to true will mean that you must pass this value to the record everytime you want to save it. One other thing, in order be able to access this method from the view, you need to make it accessible by creating an accessor. Here is the example from our application.

1
2
3
4
5
6
7
8

  class User < ActiveRecord::Base
    # ...
    validates_acceptance_of :terms_of_service
    # ...

    attr_accessible :terms_of_service
  end

In the view, you just need to add a control to the form for selecting this checkbox. Without checking this box, the form will throw a validation error and the model will not be saved.

1
2
3
4
5
6

  <% form_for :user, @user, :url => users_path do |f| %>
    <p>... other controls ...</p>
    <p><%= f.check_box :terms_of_service %> I accept the terms of service.</p>
    <p><%= submit_tag "Save" %></p>
  <% end %>

There are several other configurations that you can pass to validates_acceptance_of, similar to other validations. Check the documentation for this method for more information. If you have more stringent auditing requirements, then you may need to think about just using a boolean field in the database and using a regular validation. Extending this further might even allow you to track acceptance of versions of your terms of service as they get updated. Since we’re allowing nil by default, you will need to make sure that create a test/spec to specifically pass a :terms_of_service method. I would keep this in a special test case and not worry about including it throughout your test suite.

Hopefully, this will get you going, best of luck!

Today marks the last day that I’ll be working at Cardinal. I’m extremely excited to be working for a new company, GoNowDo. We’re going to be working on solving some interesting problems in the online travel industry. Stay tuned for more information.

Thanks to everyone at Cardinal!

I’ve been read in several places about how to get emacs and autotest to play nicely together. This package runs a shell buffer just giving autotest’s output. It’s a nice way to automatically have that visual representation in the same window. It’s actually quite simple to do.

To begin with, you’ll need to download the autotest.el file and also a depencency, toggle.el. From there, I simply added the following to my .emacs file:

  ;; adding autotest integration
  (require 'toggle )
  (require 'autotest)

Restart emacs, and you should be good to go. Note, I also had to add the unit-test.el file, but that wasn’t mentioned anywhere on the wiki.

Navigate in emacs to a the root folder that you want to run autotest in and you can start this mode by typing:

M-x autotest

That’s one less terminal that I’ll have going, meaning that more of my life will be spent in emacs, which is good.

I spent the evening migrating this mephisto installation from apache to nginx. It was quite easy to install and configure. I’ve also cut down my memory by a few MBs. I’m having a little problem with some of the virtual hosts, but I think it’s an issue with my DNS, not necessarily the configs. My initial impression is that my pages are loading in the 1/2 the time. I’m too tired to post more, I’ll try to get to it tomorrow, including statistics, but if you have a choice, you should be using nginx, NOW.

As you might know, I’ve been spending a lot of time at work writing some dashboard-type applications using _whytheluckystiff’s Camping Framework. I’ve been experiencing some incredible productivity gains by prototyping with this very small framework, and I think I’m only just beginning to realize exactly how much. I’ve recently undertaken rewriting one of these dashboards in Rails.

The Camping Application

Several months ago, I was tasked with providing some statistics on budget and project management performance for senior management. The maturity of datasources wasn’t very good, many of them were excel spreadsheet laden with macros, access databases, and csv files from 5 or 6 datasources. To further compound the problem, these datasources weren’t always in a consistent data format, so I made the design decision to just create a simple CRUD interface to manually enter the data. All compilation would be handled outside the application for the time being. The benefit of this approach would be that eventually, I could turn the data entry over to someone else.

I developed this solution over the course of about 2 weeks, working on and off until there was a format visually appealing to all parties. I wrote the most basic tests possible using Topfunky’s Mosquito Testing Framework. This solution worked until the application needed to be expanded to the entire organization, not just a subset. It was time to move to Rails.

The Rails Application

In addition to changing the domain to fit the entire organziation, I really wanted to have an extremely clean interface for someone else to enter the data. My goal was to have someone else take over entering the data, and I would just be responsible for the support of the application. Rails also gave me an opportunity to more easily explore automating some of the data entry.

In 2 days, working on it for 8 hours a day, I’m 90% complete, including adding the additional models and unit and functional tests. I realize that it’s a small Rails application, but now if there are enhancement that need to be made I’m on a much better platform.

+----------------------+-------+-------+---------+---------+-----+-------+
| Name                 | Lines |   LOC | Classes | Methods | M/C | LOC/M |
+----------------------+-------+-------+---------+---------+-----+-------+
| Controllers          |   560 |   395 |       8 |      49 |   6 |     6 |
| Helpers              |    20 |    19 |       0 |       1 |   0 |    17 |
| Models               |   152 |   130 |       7 |      18 |   2 |     5 |
| Libraries            |    14 |    11 |       0 |       3 |   0 |     1 |
| Integration tests    |     0 |     0 |       0 |       0 |   0 |     0 |
| Functional tests     |   434 |   342 |      14 |      63 |   4 |     3 |
| Unit tests           |   745 |   565 |       8 |     154 |  19 |     1 |
+----------------------+-------+-------+---------+---------+-----+-------+
| Total                |  1925 |  1462 |      37 |     288 |   7 |     3 |
+----------------------+-------+-------+---------+---------+-----+-------+
  Code LOC: 555     Test LOC: 907     Code to Test Ratio: 1:1.6

So in proper enterprise +3/-3 format, here are some observations…

Eagles

• My models are almost an exact copy from Camping, with more validations and a couple of additional models that I needed to add for the extra functionality.
• I already knew the domain of what I needed to create so any reworking could be accomplished on the first pass with Rails.
• I already had lots of good data to use for Rails development as I just pulled fixtures down from the Camping app.

Turkeys

• I miss clean view syntax of Markaby in Rails. I realize that I could use Markaby, but if support for this application eventually gets turned over to another group, I thought that the barrier to entry would be lower for the JSP-style syntax of ERB templates.
• I had to manually copy and paste a lot of code from one Emacs screen to another. There was rumored to be a gem that would transistion a Camping application to Rails, DeCamper, but I couldn’t find any code that had been released. This bears further research.
• Rails migrations and Camping migrations aren’t very similar, and I wanted to have the cleanest Rails application possible. I reworked the models enough that it just didn’t transfer very well.

Summary

I’ve been in too many situations where I work on things for too long only to have the organziation go in a different direction. Using Camping to prototype before moving on to Rails gets something for my users to react to before I’m too invested in the outcome of my work. When, and if I do need to move to Rails, the transition is seemless and probably cuts down on the total time to get a finished product into production. I’ve been very pleased with this approach, but I think I can reduce the turn around time even further. I think some possible options would be to use ERB with Camping or Markaby with Rails. Also, I think I should have perhaps gone to Rails a few weeks ago, but time was just too hard to come by. The next time you come across a situation that warrants creating something of immediate use that may or may not be thrown away after an initial pass, you should think about this approach.

So, it would appear that the Rails trademark discussion isn’t quite over. On the 27th of July, Dr. Nic Williams registered a trademark for:

• Educational publications, namely, training manuals in the field of information technology
• Dissemination of advertising, scheduling and managing of training courses and programs for others via a global computer
• Arranging professional workshop and training courses

This is in addition to the one originally filed by David Heinemeier Hansson about the usage of Ruby on Rails in Computer software, namely, software framework for developing web applications. Apparently, that one isn’t completely through the door, yet.

What does all this mean? 1) Patent and trademark law seems completely jacked up in the US. 2) It means that the name of a thing is valuable, not the thing itself.

For those of you thinking about filing a trademark on your service, let me ask a question. Are you a great Rails developer, or are you a great developer who uses Rails?

Here’s a hot tip fresh off-the-press. If you’re an Ubuntu user you know that even Feisty Fawn comes with 1.8.5. If you want to get the latest Ruby release, 1.8.6, beware, there’s an issue with Readline support when you compile Ruby. Readline is a command line processing tool.

  sudo apt-get install libreadline5 libreadline5-dev

I’m not voluteering, but I’d still like the Ubuntu maintainers and Ruby package maintainers to work a little more closely.

• General Instructions on Green Programming
• Expressica writes about what to do if you’ve already compiled ruby

I am no longer an innocent bystander to the world of open source projects. I’ve had my very first patch applied to a code base. While working on a tiny Rails project, I used Rick Olsen’s restful_authentication plugin/generator. The tests failed immediately due a change in the api for assert_difference. I made the changes, and submitted a patch to Rick, and he applied it last night, along with a couple of other small changes.

I’ve been wanting to start getting involved with more patching, but just haven’t had the opportunity. I even set-up a specific workspace on my laptop just for things that I’m going to be patching, that way I can keep it separate from my own projects.

How exciting!

1
2
3
4
5
6
7
8

class Add
  def post
    @person = Person.create(:name => input.person_name, :age => input.person_age)
    redirect R(List)
  end
end
  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# models
def Person < Base; has_many :addresses, :as => :addressable; end
def Address < Base; belongs_to :addressable, :polymorphic => true; end

# relevant portion of the views
...
label 'Type', :for => 'addressable_type'; br
addressable_select("addressable_type"); br
label 'person', :for => 'person_id'; br
person_select("person_id", @people); br
...

# controller
class Add
  def post
    @addressable = Person.find(input.person_id) if input.addressable_type == "Person"
    @address = Address.create(:street => input.address_street, 
                                          :city => input.address_city,
                                          :state => input.address_state, 
                                          :zip => input.address_zip,
                                          :addressable_type => @addressable.class,  #use the class name to get namespace
                                          :addressable_id => @addressable.id)
    redirect List
  end
end

Happy Camping!

May’s list for my Xubuntu laptop. I think next month, I might try to write a script that will just pull out the ones that are different from the previous month.

abstract (1.0.0)
    a library which enable you to define abstract method in Ruby

actionmailer (1.3.3.6552, 1.3.3, 1.3.2)
    Service layer for easy email delivery and testing.

actionpack (1.13.3.6552, 1.13.3.6548, 1.13.3, 1.13.2)
    Web-flow and rendering framework putting the VC in MVC.

actionwebservice (1.2.3.6548, 1.2.3, 1.2.2)
    Web service support for Action Pack.

activerecord (1.15.3.6552, 1.15.3.6548, 1.15.3, 1.15.2)
    Implements the ActiveRecord pattern for ORM.

activeresource (0.9.0.6552)
    Think Active Record for web resources.

activesupport (1.4.2.6552, 1.4.2.6548, 1.4.2, 1.4.1)
    Support and utility classes used by the Rails framework.

acts_as_versioned (0.2.3)
    Simple versioning with active record models

ajax_scaffold_generator (3.1.11)
    Ajax scaffold generator is a rails generator for ajaxified scaffolds

builder (2.1.1)
    Builders for MarkUp.

camping (1.5.180, 1.5)
    minature rails for stay-at-home moms

camping-omnibus (1.5.180)
    the camping meta-package for updating ActiveRecord, Mongrel and
    SQLite3 bindings

capistrano (1.99.0, 1.4.1)
    Capistrano is a utility and framework for executing commands in
    parallel on multiple remote machines, via SSH.

cgi_multipart_eof_fix (2.1)
    Fix an exploitable bug in CGI multipart parsing which affects Ruby
    <= 1.8.5 when multipart boundary attribute contains a non-halting
    regular expression string.

daemons (1.0.6, 1.0.5)
    A toolkit to create and control daemons in different ways

deprec (1.7.0, 1.4.2, 1.4.1, 1.3.1)
    deployment recipes for capistrano

equipment (1.5.104)
    Equipment (for Camping)

erubis (2.2.0)
    a fast and extensible eRuby implementation which supports
    multi-language

fastercsv (1.2.0)
    FasterCSV is CSV, but faster, smaller, and cleaner.

fastthread (1.0, 0.6.4.1)
    Optimized replacement for thread.rb primitives

flickr (1.0.0)
    An insanely easy interface to the Flickr photo-sharing service. By
    Scott Raymond.

flickraw (0.4.2)
    Flickr library with a syntax close to the syntax described on
    http://www.flickr.com/services/api

gem_plugin (0.2.2)
    A plugin system based only on rubygems that uses dependencies only

gruff (0.2.8)
    Beautiful graphs for one or multiple datasets.

highline (1.2.7)
    HighLine is a high-level command-line IO library.

hoe (1.2.0)
    Hoe is a way to write Rakefiles much easier and cleaner.

hpricot (0.5.140, 0.5)
    a swift, liberal HTML parser with a fantastic library

image_science (1.1.2, 1.1.1)
    ImageScience is a clean and happy Ruby library that generates
    thumbnails -- and kicks the living crap out of RMagick.

json (1.0.4, 1.0.3, 1.0.2, 1.0.1, 0.4.3)
    A JSON implementation as a Ruby extension

markaby (0.5)
    Markup as Ruby, write HTML in your native Ruby tongue

merb (0.3.1, 0.2.0)
    Merb == Mongrel + Erb. Pocket rocket web framework.

metaid (1.0)
    slight metaprogramming helpers

mime-types (1.15)
    Manages a MIME Content-Type that will return the Content-Type for a
    given filename.

money (1.7.1)
    Class aiding in the handling of Money.

mongrel (1.0.1)
    A small fast HTTP library and server that runs Rails, Camping, Nitro
    and Iowa apps.

mongrel_cluster (0.2.1)
    Mongrel plugin that provides commands and Capistrano tasks for
    managing multiple Mongrel processes.

mosquito (0.1.2)
    A Camping test library.

needle (1.3.0)
    Needle is a Dependency Injection/Inversion of Control container for
    Ruby. It supports both type-2 (setter) and type-3 (constructor)
    injection. It takes advantage of the dynamic nature of Ruby to
    provide a rich and flexible approach to injecting dependencies.

net-sftp (1.1.0)
    Net::SFTP is a pure-Ruby implementation of the SFTP client protocol.

net-ssh (1.1.1, 1.1.0, 1.0.10)
    Net::SSH is a pure-Ruby implementation of the SSH2 client protocol.

newgem (0.9.4, 0.9.3, 0.8.1)
    Make your own gems at home

oz (0.1.1)
    oz is a command line tumbler for ozimodo tumblelogs

pidify (0.2)
    This allows a script to check if there is currently another running
    instance of itself (like a daemon), and give it the ability to kill
    that instance based on PID.

piston (1.3.3, 1.3.2, 1.2.1)
    Piston is a utility that enables merge tracking of remote
    repositories.

rack (0.2.0)
    a modular Ruby webserver interface

rails (1.2.3.6552, 1.2.3, 1.2.2)
    Web-application framework with template engine, control-flow layer,
    and ORM.

rake (0.7.3, 0.7.2)
    Ruby based make-like utility.

rapt (0.2.2)
    Rails Plugin Tool.

RedCloth (3.0.4)
    RedCloth is a module for using Textile and Markdown in Ruby. Textile
    and Markdown are text formats.  A very simple text format. Another
    stab at making readable text that can be converted to HTML.

redgreen (1.2.2, 1.2)
    redgreen is an expanded version of Pat Eyler's RedGreen

rote (0.3.4)
    Adds template-based doc support to Rake.

rubycas-server (0.3.0)
    Provides single sign on for web applications using the CAS protocol.

rubyforge (0.4.1, 0.4.0)
    A simplistic script which automates a limited set of rubyforge
    operations

rubygems-update (0.9.3, 0.9.2)
    RubyGems Update GEM

RubyInline (3.6.3, 3.6.2)
    Multi-language extension coding within ruby.

sources (0.0.1)
    This package provides download sources for remote gem installation

sqlite3-ruby (1.2.1)
    SQLite3/Ruby is a module to allow Ruby scripts to interface with a
    SQLite3 database.

syntax (1.0.0)
    Syntax is Ruby library for performing simple syntax highlighting.

sys-admin (1.4.1)
    A unified, cross platform replacement for the "etc" package.

termios (0.9.4)
    Termios module are simple wrapper for termios(3). It can be included
    into IO-family classes and can extend IO-family objects. In
    addition, the methods can use as module function.

tweet (0.6)
    A generalized notification daemon.

xml-simple (1.0.11)
    A very simple API for XML processing.

ym4r (0.5.4)
    Helping the use of Google Maps and Yahoo! Maps API's from Ruby and
    Rails

zentest (3.5.0)
    ZenTest provides 4 different tools and 1 library: zentest,
    unit_diff, autotest, multiruby, and Test::Rails.

ZenTest (3.5.2, 3.5.1, 3.4.3)
    ZenTest provides 4 different tools and 1 library: zentest,
    unit_diff, autotest, multiruby, and Test::Rails.

Some of you might know that I recently started working at Cardinal Health, which may or may not seem relevant until you realize that Cardinal is #19 on the Fortune 500. Taking that in conjunction with the fact that I worked at JPMorgan Chase & Co. for 5 years and they are listed at #11 on the Fortune 500 and I feel comfortable in saying that I know there is a spot in all enterprises for Ruby and Rails. I’m finding that decision makers are more open to open source, more open to going outside the enterprise comfort zone, and more open to selecting the solution is is done the quickest, with the most business value, and meets their needs the most.

So, what am I doing? In short, I’m helping technology leaderships make the best investment decisions, while becoming an industry leader, not an industry follower. I’m proving to them that you don’t needs teams of consultants or a pricey support contract to business value out of the data that your organization holds. I’m proving that Ruby belongs.

Rails at JPMorganChase

At JPMC, I led the team that created the 1st fully-supported and fully-funded Rails application inside the bank. Of course, things got complicated because we had to work with other technologies and people who weren’t receptive to Ruby, but that’s the real trick anyways, isn’t it? In 3 short months, we went from discussion and a single SVN commit to an application with a user community in excess of 10,000 people. We were hooked into the global authentication system, and living like good citizens of the enterprise application community. The benefit is that now people can more easily get access to the revenue generating systems and spend less time just sitting at their desk when they start new (which was the basic premise of the application that we created).

I’m a little unfamiliar with the current status of the application, but the current project lead, John Andrews has taken the ball and run with it. The user community continues to grow and the application continues to morph and integrate and become fully assimilated within the JPMC universe. One of JPMC Retail banks lead architects, who is a Smalltalk developer at heart is very interested in Rails and has been suggesting it to other teams in order to help him make a strategic decision. It could perhaps become as ubiquitous to them as Java or .NET. The part that I’m most proud of is that 1 year ago, there were no full-time Ruby/Rails jobs at JPMC, today there are 3, and that’s a great thing for the community.

Ruby at CardinalHealth

At Cardinal, I’m doing something that I think is even more edge-leading and innovative. I’m in the process of deploying several small Camping apps, which work together to create a dashboard of information for IT leadership to make investment decisions. It’s the simplest possible thing that could be done. I take several ruby scripts that use active record and I pull data, manipulate it into something a little more friendly and then load it into an SQLite database that my applications use. I’m not tied to the system of records, but since these data mover scripts are called from cron, they’ll give a very accurate depiction of the environment. I plan on blogging about this idea further.

What is the effect? In short, it’s been marvelous. I’ve done in several weeks something that probably would have taken much longer to do in other frameworks. It’s exactly what the decision makers needed at the time, no more, no less. The first taste has been enjoyed, and now they want more. Ruby has been established as a tool that gets things done. This will place dynamic languages into conversations in team AD team meetings where previously they would not have been. I’m really looking forward to extending on the work that I’ve started there.

Exhortations and Encouragement

If you are looking to try to get Ruby or Rails in the door at your job, take heart, there is a bright future on the horizon. Eyes are opening, discussions are being had, and Ruby is finding itself in some of the most unlikely places. What can you do? You can look for opportunities to present themselves. Start small, write ruby scripts instead of bash scripts for some automated tasks. Use ruby to parse files that get data moved from one system to another. Prove to your boss, and their boss that not only is Ruby an incredibly beautiful and capable language, but it’s also one that will provide them the quickest business value in their toolbox.