H.R. 5353 - I called, have you?

on May 05, 2008 @ 09:58 AM

I just got off the phone with my state representative Peter Hoekstra’s office to urge him to support the Internet Freedom Preservation Act os 2008—H.R. 5353

For more information on the issue or to determine who to call and what to say, please see www.savetheinternet.com

Book Review - Ruby on Rails: Enterprise Application Development

on May 03, 2008 @ 12:50 PM

I know Slashdot is a busy place, but come on, four months and a book review is still pending, and they don’t respond to any emails? Anyways here is my review of “Ruby on Rails: Enterprise Application Development”.

Ruby on Rails – Enterprise Application Development by Elliot Smith and Rob Nichols targets a new niche in the Rails world of published books. Its goal is to connect all of the dots that make up typical Rails development for developers who have been through the tutorials, but wonder ‘what do I do next?’

The focus of this book is breadth and not depth. The authors do a good job of balancing the explanation of essential Rails concepts while letting the reader know when they are approaching a more advanced topic that won’t be covered in depth.

Throughout the book the authors follow a fictional, yet realistic scenario in which Rory the IT guy implements a simple web-based contacts management application. Each chapter builds on the previous walking the reader through the whole process of development to production deployment.

There is no Rails development until Chapter 4, pg 91. The emphasis of the first 90 pages is understanding what Rails is and why you would use it, as well as introducing the problem scenario that will be used throughout the book. This would be a bigger turn off then it was, but the authors made up for this a little walking the reader through installing everything required for Rails development on multiple operating systems.

Rather then focus on a single platform for development or production the authors use a mixed environment of Ubuntu Linux, OSX and Windows and a cross platform Eclipse IDE. They also take the time to walk the reader through installation and setup of each platform as it pertains to Rails development.

The majority of the development in this book sticks to the functionality included in Rails itself. When it comes to core components of Rails the authors do a great job of covering them: migrations, models, validations, associations, controllers, filters, views and view helpers.

Plugins are not covered except for acts_as_attachment, which is now deprecated in favor of attachment_fu.

The only issue I had with the book was with the sections on testing. The authors cover unit and functional testing with the built-in Rails testing framework. Unfortunately, the example tests are horrible and should not appear in production quality code. The sections on testing should only be used to understand how the built-in testing framework works in Rails and not as an example for writing tests. It is too bad that the authors didn’t cover integration testing either.

A good thing that did come out of the testing sections in this book is the encouragement for developers to write tests which expose bugs before fixing them. It’s the only way to ensure you really fixed it.

Rails 1.2.3 is used throughout the book so any changes, improvements or deprecations in Rails 2.0 aren’t covered. If the reader follows the book with Rails 1.2.3 they should have no issues walking through and developing the code themselves. If the reader follows the book with Rails 2.0 they should be aware of some of the changes, those can be found at http://weblog.rubyonrails.org/2007/12/7/rails-2-0-it-s-done

The things that stuck out to me were:

• view template file naming conventions
• the verbosity of not having named routes
• the lack of the db:rollback rake task

The authors take the time to walk the reader through setting up and using Subversion as an integral part of Rails software development. It also includes setting up and using Apache and Mongrel to serve Rails. As the book moves from development to production deployment the user is shown how to deploy automatically from Subversion to their production server using Capistrano.

There were a few minor typos and one redundant sentence on page 52. This is considerably lower then other technical books that I’ve read.

The only giant red sections marked in my copy are the ones on testing. Take those examples with a grain of salt.

Overall, the majority of the book is filled with good advice for novice Rails developers like, “do not wait until your application is built before you create and test the production environment” and “involve the end users throughout the process”.

If you are a novice Rails developer who understand bits and pieces of Rails this book does a good job of connecting the other dots because the authors take the time to go through the full process of development to production. On the other hand if you have a good grasp on the whole Rails development process you can skip this book.

A good chapter outline of this book can be found at PACKT’s web site

Net Neutrality - Save The Internet

on May 03, 2008 @ 12:44 AM

If you haven’t heard of Net Neutrality before, wikipedia describes it as:

”... a principle that is applied to residential broadband networks, and potentially to all networks. A neutral broadband network is one that is free of restrictions on the kinds of equipment that may be attached, on the modes of communication allowed, which does not restrict content, sites or platforms, and where communication is not unreasonably degraded by other communication streams.”

Unfortunately there are corporations out there which want to control access, speeds and content available to those connecting to the Internet through their services. Below is an informative 10 minute video (I found it at http://www.matthewgood.org/2008/05/net-neutrality/). If you have the time please hit play.

If this issue concerns checkout www.savetheinternet.com . I urge you to spread awareness of the issue and contact your congressman.

form_test_helper, select_form update

on April 02, 2008 @ 05:28 PM

Revision 71 of form_test_helper includes a bug fix for the select_form method. Previously calling select_form with a block would submit the form. The fix forces you to call submit on the form. So…

1
2
3
4
5
6
7
8
9
10

# THIS which used to submit the form
form = select_form 'trip' do |form|
  form.trip.destination = "bahamas"
end

# WILL NOW LOOK LIKE THIS
form = select_form 'trip' do |form|
  form.trip.destination = "bahamas"
end
form.submit

This doesn’t affect the usage of submit_form which still acts as expected.

This will be included in the next release of form_test_helper. Currently trunk for form_test_helper works with Rails 2.0.0 and higher (including today’s most recent trunk commit).

The form_test_helper edge docs have been updated as well and can be found here

Rails Ticket #11491

on April 01, 2008 @ 12:46 AM

If you have a few minutes, please review and comment on Rails ticket #11491.

http://dev.rubyonrails.org/ticket/11491

In short, it adds the ability for “render :partial => some_collection” to render the correct partial based on each element in some_collection. Currently Rails uses the first element to determine what to render for every element in the collection.

Thanks in advance,

More People != More Progress

on March 25, 2008 @ 03:38 AM

There is a common misconception that the best way to add capacity to a project and reduce its completion date is simple—just throw more people at it. Although there is some truth in this, it is usually applied at the wrong times and it ends up having a very negative impact on the project.

This mindset that project development is a series of tasks and that somehow you can just throw people at them and everything will work out is foreign to me, because it won’t work out—at least not when it’s applied in haste.

Adding value to a project is more than completing tasks. Tasks are not isolated during project development. They are features which build on top of one another. Making good responsible decisions and understanding the code base both technically and conceptually goes a long way to help exploit easier and better ways of implementing features. This also helps keep the code base well factored, which in turn helps teams progress consistently and avoid creating a giant roadblock of technical debt which may have lurked just ahead.

What is a factory and why FactoryLoader?

on March 22, 2008 @ 12:58 AM

This statement and question were posted to the http://www.gr-ruby.org mailing list as it pertained to the release of FactoryLoader. This post should answer the question “what is a factory?” and also provide more insight into what FactoryLoader’s role is.

1
2

> I've read over your website, but I still have a lagging question which
> completely blinds my ability to see the usefulness of it: What is a factory?

A factory is “a mechanism for encapsulating complex creation logic” [0].

Here’s an example. Let’s say that you start writing an application that is a project management tool for a business. To start with they need the ability to create Projects. This is no big deal, you have a ProjectsController#create action and it makes your Project by doing something similar to the below:

1
2
3
4
5
6
7
8
9
10

  def create
    project = Project.new params[:project]
    if project.save
      flash[:notice] = "successfully created the project"
      render :action => "create"
    else
      flash[:error] = "failed to create the project"
      render :action => "new"
    end
  end  

Now a few weeks later the customer says that in order to create a project it needs to be assigned a project manager off the bat (the currently logged in user). This is not a very big deal since you have a “current_user” already, you just update your controller to look like:

1
2
3
4
5
6
7
8
9
10
11

  def create
    project = Project.new params[:project]
    project.manager = current_user
    if project.save
      flash[:notice] = "successfully created the project"
      render :action => "create"
    else
      flash[:error] = "failed to create the project"
      render :action => "new"
    end
  end

A few more weeks go by and your customer says that projects are tied to company budgets and when they are created they need to be automatically assigned to the correct budget based on the type of project. So we update to ProjectsController#create looks like the below:

1
2
3
4
5
6
7
8
9
10
11

  def create
    project = Project.new params[:project]
    project.manager = current_user
    project.budget = Budget.find_by_project_type(project.type)
    if project.save
      flash[:notice] = "successfully created the project"
    else
      flash[:error] = "failed to create the project"
      render :action => "new"
    end
  end  

Uh oh. There are important business rules being applied in the controller. The controller’s responsibility is to map an incoming request with an outgoing response and to know high level what the application needs to be doing. It should not know the intimate details of Project creation. Since we’re implementing the business rules on the controller we can’t re-use them for anything, unless we make a POST request to ProjectsController#create. This is quite limiting.

Another option to make them more reusable would be to tuck this away in the Project model itself. Perhaps we add a before_save callback which finds the appropriate budget. Even then we’ve only moved the budget logic out of the controller and there is still requirement for a Project to have a manager. If we go this route we’ll be separating two important pieces of how a Project gets constructed from each other. We would have the ProjectsController#create action setting the manager and then a before_save callback on the Project model finding a budget, both of which are required for a Project to be constructed.

One thought to remedy this would be put everything in the Project model, maybe in a before_save callback or overriding the constructor. But we quickly hit a roadblock because our Project model doesn’t know about the current user, that is application state and only the model knows about that. We could do something stupid and make the current_user global to the application, but that is a bad decision with pretty bad repercussions.

It’d be nice if we had a single object responsible for constructing a Project with these business rules. This is where a ProjectFactory comes into play. The ProjectFactory looks like:

1
2
3
4
5
6
7
8

  class ProjectFactory
    def create(project_attrs, manager)
      project = Project.new project_attrs
      project.budget = Budget.find_by_project_type(project.type)
      project.save!
      project
    end
  end

And the ProjectsController#create action looks like:

1
2
3
4
5
6
7

  def create
    project = ProjectFactory.create params[:project], current_user
    flash[:notice] = "successfully created the project"
  rescue 
    flash[:error] = "failed to create the project"
    render :action => "new"    
  end

This is pretty straightforward. I just moved some of the lines from the action into the factory. More importantly then just moving line of code is that the act of constructing a valid project (given the customer’s requirements) isn’t the responsibility of the Project. The act of constructing a valid project is a process by itself which is important to the customer, so we isolate it in a ProjectFactory.

This is valuable because:

• the business logic used to construct a project is in one spot. Should the customer change, add or remove requirements you only have to go to one spot to implement them. Granted if the method signature to this changes you have to go update the spots calling the create method, but you the actual logic for constructing the project isn’t spread throughout multiple files or classes.
• it promotes reusability (the whole DRY thing), since my ProjectFactory is much more reusable then my ProjectsController.
• it promotes single responsibility
• it provides clearer meaning to the code base because we aren’t muddying up the controller or the Project model with creation logic
• it makes for easier testing and easier to understand tests

The technical implementation of this pattern is mentioned in the GoF book [1]. The value of the pattern as it applies to Domain Driven Design is mentioned in the DDD book by Eric Evans.

Hopefully that helps clarify what a factory is, by seeing how it is used and some of the value it provides. This relates to the FactoryLoader because sometimes the progression of creation logic is over time.

For the first few weeks or months of a project you are hardcoding things like “Project.create” in multiple spots. When the customer starts introducing requirements for constructing (or updating) a Project you have to go update all of those spots with the same code (violating DRY) or go find all of those spots and refactor them to use a ProjectFactory, and then make a ProjectFactory. It doesn’t happen all the time, but when it does happen it can be time consuming, frustrating and painful to do.

What FactoryLoader would do in our example is it give us a ProjectFactory upfront w/o having to write any code. If we used FactoryLoader in the above example our ProjectsController#create action would look like:

1
2
3
4
5
6
7
8
9
10

  def create
    project = ProjectFactory.create params[:project]
    if project.save
      flash[:notice] = "successfully created the project"
      render :action => "create"
    else
      flash[:error] = "failed to create the project"
      render :action => "new"
    end
  end  

Where the ProjectFactory is created for you by FactoryLoader (you didn’t create the class, FactoryLoader did dynamically). There’s only one line that differs between the example that uses the FactoryLoader and the one that doesn’t.

Now when the customer starts adding business rules for creating a Project you can create your own ProjectFactory class and implement the customer’s business rules. FactoryLoader will see that you have provided your own ProjectFactory so it won’t dynamically create one. Since all of the spots where you create a Project are already using a ProjectFactory they get the changes for free. Overall you get to touch less code for the changes and you get to spend less time refactoring if any refactoring is needed.

The goal of FactoryLoader is to allow developers the ability to scale to these customer requirements with less pain. The above examples have been quite trivial, hopefully they are clear enough and meaningful enough to express why I wrote FactoryLoader,

— Zach Dennis http://www.continuousthinking.com

• 0 – Domain Driven Design by Eric Evans
• 1 – Design Patterns: Elements of Reusable Object-Oriented Software by Gamma, Helm, Johnson and Vlissides

Factory Loader

on March 18, 2008 @ 06:10 AM

FactoryLoader is intended to help scale object creation with less pain and less refactoring by creating factory classes for basic object construction.

In the early stages of a project object creation is simple and dependencies are kept to a minimum. As the project grows so does the complexity of object creation and its dependencies. It doesn‘t make sense to create custom factory classes upfront to deal with complex object construction that may not exist yet. But when those custom factories are needed it is usually painful and time consuming to update the code base to use them. It‘s also easy for developers to give-in due to time constraints and start making bad decisions.

This is where FactoryLoader comes into play. It automatically creates a Factory class for your objects and provides a create method which passes any arguments along to your object‘s constructor.

When you need to have custom factory behavior you can implement the factory without having to update other code references (assuming you‘ve used the factory in the rest of your application rather then direct class references).

  project/
    init.rb
    lib/
     |--things/
            |-- foo.rb
            |-- bar.rb
     |--factories/
            |-- bar_factory.rb

Given the above project directory structure you could have the following code in init.rb:

1
2

 factory_loader = FactoryLoader.new("lib/factories")
 factory_loader.load("lib/things")

The first call constructs a factory loader telling it which directory is used to store developer-written custom factories.

The second call will create an in-memory factory class for each *.rb file in the lib/things/ directory. A FooFactory class will be created to correspond with the foo.rb file. The generated factory will provide a create method which will pass along all arguments to the constructor of the object it wraps. So…

 FooFactory.new.create :a => :b

is the same as:

 Foo.new :a => :b

Even though a bar.rb file exists a BarFactory will NOT be created. This is because we told the FactoryLoader that custom factories are storied in lib/factories/ and a bar_factory.rb file exists there, so FactoryLoader assumes you want to use a custom factory. It also assumes that the class inside of bar_factory.rb is BarFactory.

FactoryLoader dynamically creates the factory classes — they are not written to disk. FactoryLoader also uses file naming conventions to determine what to do. For example:

1
2

   foo.rb => FooFactory
   crazy_dolphins.rb => CrazyDolphinsFactory

Factory.new

The dynamically created factories are classes and create is an instance method on them. You have to construct a factory in order to use it. This is so the factories themselves can be easily used in dependency injection frameworks.

Making a custom factory

So you’re using FactoryLoader to do the work of creating factories for you. Let’s say our Foo object now has some creation logic that we do not want in Foo’s constructor. To put it in the FooFactory just create the file in lib/factories/foo_factory.rb. The contents of foo_factory.rb might look like:

1
2
3
4
5
6
7
8
9

class FooFactory  
  def create options={}
    if business_logic_passes?
      Foo.new options
    else
      raise "business logic failed"
    end
  end
end

Install it!

gem install -r factory_loader

More Info

• RDOC: http://mhs.rubyforge.org/factory_loader/rdoc/
• Public git repository: git://github.com/zdennis/factory_loader.git
• Homepage: www.continuousthinking.com/factory_loader

Author

Me, Zach Dennis

Special Thanks

• Dave Crosby at Atomic Object
• Ryan Fogle at Atomic Object

Trying RSpec's Rubyesque Stories

on March 05, 2008 @ 12:35 AM

Today my pair and I wrote some stories using the rubyesque RSpec story style along with a corresponding step file. It went better then expected. We ended up a story like:

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
28
29

# in stories/expenses/a_user_creating_a_misc_expense_story.rb
Story "User creating misc. expense", %|
  As a user 
  I want be able to submit an expense reimbursement request for a misc. expense
  so that I can be reimbursed for business expenditures|,
  :steps_for => :expense,
  :type => RailsStory do
 
  Scenario "creating a misc. expense unsuccessfully" do
    Given "a user at a new expense reimbursement page"
    # ....
  end
  
  Scenario "creating a misc. expense successfully" do
    Given "a user at a new expense reimbursement page"
    # ...
  end
end


# in stories/steps/expense.rb
steps_for :expense do
  Given "a user at a new expense reimbursement page" do
    go_to_root
    click_new_expense_reimbursement_link
  end

  # ...
end

Mocha's error messages suck

on February 26, 2008 @ 08:04 PM

Mocha’s parameter matching error messages suck.

When writing a failing test similar to the below snippet I am given the error message “undefined method `keys’ for :no_args:Symbol”

@user.should_not_receive(:update_attributes).with(has_key('name'))

I love Mocha’s parameter matching, but what kind of error message is that?

This is not the first time I’ve gawked at Mocha’s error messages, but this time just did it for me. My pair didn’t know if we should ping or if we had broken our app.

Pair Programming in 1 sentence

on January 29, 2008 @ 02:01 AM

Pair programming is a catalyst to writing better software.

Trying out Vlad the Deployer

on January 26, 2008 @ 09:09 PM

This blog wasn’t using any form of automated deployment until late last night. For the longest time rsync and ssh seemed to be adequate enough even though I’m familiar with Capistrano and had been well aware of Vlad the Deployer’s release. Since I know about Capistrano I decided to invest some time getting to know Vlad.

This site is currently running on a 0.7.3 Mephisto installation with a custom theme by yours truly and it’s hosted on Dreamhost servers. Out of the box Vlad works with mongrel+apache+svn. Unfortunately Dreamhost uses apache+fastcgi, but thankfully tweaking Vlad was a piece of cake.

I followed the instructions on the examples page for Vlad, but ultimately found I needed to do a little tweaking for my environment. Based on those basic examples I ended up making the following changes to my Rakefile and deploy.rb recipe file.

Here’s what I appended to my Rakefile:

1
2
3

# appended to my Rakefile
require 'vlad'
Vlad.load(:app => :apache)

Here’s my config/deploy.rb file:

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

set :domain,      "continuousthinking.com"
set :deploy_to,   "/my/path/to/continuousthinking.com/"
set :repository,  "http://myserver/svn/continuousthinking.com/trunk"
set :web_command, "echo skipping web "

namespace :vlad do
  remote_task :start_app do
    run "pkill -f dispatch.fcgi"
    fork do
      puts "sending a request to the domain so dispatchers restart"
      `wget http://#{domain} -O /dev/null`
    end
  end

  remote_task :update do
    Rake::Task['vlad:after_update'].invoke
  end
  
  remote_task :after_update do
    run "ln -s #{deploy_to}/shared/system/database.yml #{deploy_to}/current/config/database.yml"
    run "rm -f /home/zdennis/continuousthinking.com &&
         ln -s #{deploy_to}/current /home/zdennis/continuousthinking.com"      
  end
  
  remote_task :deploy => [:update, :start_app]
end

I overrode the :web_command setting so Vlad didn’t try to restart apache. The other tasks were added to customize specific needs for the deployment of the blog:

• :start_app – kill all of dispatchers on Dreamhost and then send a request to have Dreamhost launch new ones
• :update – adds this task to the :update task call chain. This simulates an after_update.
• :after_update – create symlinks, etc to be performed after code has been updated.
• :deploy – update code and restart the app

Overall, it was a pleasant process. I give Vlad a +1.

ar-extensions get a little praise

on January 20, 2008 @ 09:52 PM

Alan Miles found the import functionality of my ar-extensions gem/plugin helpful and he posted about it here

I’m so glad to hear that ar-extensions is helping Alan and it’s nice to see that he’s sharing this usefulness with others via his blog

⌘-k Hotkey in bash, on linux

on December 29, 2007 @ 02:50 PM

I never thought I would say “I wish my console acted more like the OSX’s Terminal.app”, but the truth is that I said that two days ago. That day my MacBook Pro (MBP) went out of commission due to an accidental overdose of Raspberry Iced Tea. Ever since then I’ve been plugging away on my Kubuntu box using Yakuake and Emacs23 to develop.

I have this obsessive need to clear the terminal all the time during development, primarily when I’m going to run tests. On my MBP I would just hit ⌘-k to clear the terminal, but I don’t have that luxury in Yakuake or any other terminal that I know of. So why not roll my own?

After googling around for a while I found this article by Bryan Henderson from the Linux Gazette . Even though the article is seven years old it still applies. In addition to this article I also read the man page for readline which has a lot of cool information in it. Since bash relies on readline to do the input processing new doors have opened for what I want to tinker with on my system.

Writing Your ⌘-k Hotkey

Create a ~/.inputrc file. In that file put the following contents. Now log out and log back in (or fire up a new terminal session):

1
2

"\ek":"\C-a\C-kclear\n\C-y"
"\C-x\C-r": re-read-init-file

The first line expresses that I want Meta-k to map to the following set of keystrokes:

• C-a which brings me to the beginning of the line
• C-k which cuts the line
• clear which is used to clear the terminal
• a newline which executes the clear command just as if I typed it and hit enter
• C-y which pastes what I cut with C-k back onto the terminal

And now you have a Terminal.app ⌘-k hotkey on any system that uses bash. The only difference is that its mapped to Meta-k.

The second line is a simple nicety so you can reload your ~/.inputrc file without having to log out and log back in. Just type C-x C-r to reload any changes.

On Writing Good Software

on December 22, 2007 @ 10:21 PM

The craft of writing is so similar to that of software development. I recently found this out by reading On Writing Well by William Zinsser. Below are some quotes from the book with commentary on how they apply to the software developer.

You will write only as well as you make yourself write.

Substitute write with write software and it remains a truism.

Writing software is easy. Writing good software is hard. It takes discipline to become a good software developer. The only way to get there is to write better software today then you wrote yesterday. And the only way to do that is to learn from what you and others have written.

Clutter is the disease of American writing.

The same can be said for writing good software. It’s very painful to create or find a bloated method or class doing something it shouldn’t be doing. It’s even more painful to maintain. Small and simple works wonders within the design of a program.

Strip every sentence to its cleanest components.

Strip every method and class to include only the functionality it needs to do its job. Methods which might be used at some point—get rid of them. Comments which try to explain away complexity or ambiguity—simplify the code so it’s readable and remove the them. Classes which try to do everything—refactor and pull out things it doesn’t need to do into their own class or module. Clever code—turn it into simple code. Simplify, simplify, simplify.

You must know what the essential tools are and what job they were designed to do.

A carpenter must know how-to hammer nails and saw wood before he can build a house. Likewise, a developer must know how-to write good code, perform object decomposition and refactor before he can build an application. Other basic tools and skills that a developer should know are: writing testable code, testing and test automation.

Take your stand with conviction.

Care about the software you develop. Stand up for customer involvement. Stand up for short iterations. Stand up for testing. Stand up for quality, even when the deadline is fast approaching, it’s the best chance you’ve got for hitting it with working software.

Never hesitate to imitate another writer.

Never hesitate to imitate another developer, especially one that writes better software than you. It will make you better in the process. Find open source projects that exceptional developers have worked on and read that code. How are they attacking a problem? How did they solve it?

A while back a coworker asked me if I had read through Mephisto’s source and I said I had scanned it, but that I didn’t think it was anything special besides the routing. A few weeks later I started reading the source. Rick Olson, the author of Mephisto, has some great techniques and code tucked away in Mephisto, things that I would be missing out on if my coworker would have never challenged me to read the source. Thanks Drew.

...it’s hard not to be intimidated by the expertise of the expert.

Ask questions. If you don’t understand something, ask. If you think it’s a dumb question, ask. Let the resident expert enlighten you. When they explain something and you still don’t get it, ask clarifying questions. They didn’t wake up one day an expert. And neither will you.

Writing is related to character. If your values are sound your writing will be sound.

Developers who have character are exceptional people to work with. They not only write better software, they inspire those around them to write better software.

Decide what you want to do. Then decide to do it. Then do it.

For all of those “I want to learn language X”, “I want to start learning TDD”, etc. statements—start learning language X, start doing TDD.

Think small.

Two immediate thoughts come to mind. First, good object decomposition. Work with simple objects that work with a single responsibility and let the overall system evolve of those simple objects. Second, short iterations over long ones and short stories over full blown specification documents. Thinking small in these regards will help you produce cleaner and simpler code as well as produce the right working features—sooner.