Noel Rappin Writes Here

Cucumber

June 21, 2011: In Brightest Day

Alternate History, Books, Comics, Cucumber, Rails 3Noel RappinComment
I'd like to pretend there was some thread connecting these things, but you and I both know there just isn't...

1. Actual News: Cucumber 1.0


Starting with something approaching a real news story, Cucumber 1.0 was released today. According to that post from Aslak Hellesøy, the project has had nearly 750,000 downloads. Oh, and there's a native JavaScript port in progress. I didn't know that.

Anyway, Cucumber 1.0 adds Rake 1.9.2 support. Recent changes you may not know about include a -l and --lines command line switch as in RSpec's and a new transform syntax that allows you to factor out duplicated parts of step definitions. Haven't seen official docs on this, but it looks like it allows you to capture bits of step definition and run a block against it. The code example within the Cucumber tests looks like this:
Transform(/a Person aged (\d+)/) do |age| 
Person.new(age.to_i)
end

Given /^(a Person aged \d+) with blonde hair$/ do |person|
puts "#{person} and I have blonde hair"
end


In other words, the snippet a Person aged \d+ is captured and transformed and the result of that transform block is what is passed to the step definition block.

Interesting. I wonder if people will use it?

2. The End of the World As We Know It


This post from the Armed and Dangerous blog tries to imagine a world without the web. The general idea is that if Congress had understood what DARPA was up to in the early 80's, then funding would have been cut, and TCP/IP would not have been developed and popularized.

It's an interesting argument, and as much as I'd like to believe it's to dark, the examples of the cable and cell phone industries are eloquent. (I'll grant that the author is probably trying to make a libertarian point I wouldn't agree with in general...)

3. Books: Fuzzy Nation


Continuing playing catch-up with brief book reviews, Fuzzy Nation by John Scalzi. Fuzzy Nation is something odd -- a genuine remake of a beloved SF classic (well, beloved by some, I've never read it), namely Little Fuzzy by H. Beam Piper. Scalzi has taken the basic elements -- a guy who encounters small, sentient aliens who are, wait for it, Fuzzy -- and wound his own story around them.

Fuzzy Nation is pretty much purely entertaining, fun, well structured, fast paced. It's not as much interested in the existential questions around alien intelligence as the practical question of protecting them from a corporation that wants to strip-mine their planet. (Subtle, it's not.) It's one of those books that isn't interested in re-defining the genre as much as telling a good story inside the existing boundaries.

4. Moving Beyond Thin Controllers To The Downright Emaciated


Gary Bernhardt over at the Destroy All Software blog posts some suggestions about using routing or routing-like structures to effectively remove controllers from the system. The theory is that if controllers just exist to dispatch to a specific method someplace else in the system, and Rails manages all the other connections, then why not route directly to that method with some declarative or rules-based logic to handle things like security logic, exceptional conditions, or other high-level logic.

It's interesting, and probably could be built within Rails 3. I suspect most systems aren't pure enough in the controllers to take advantage of it, which I guess is the point, and I wonder if the gain is worth breaking the default linkage between URL and controller/action pairs, but I'd be curious to try it.

5. In Brightest Day, In Blackest Night


Finally, I haven't seen the Green Lantern movie yet, but I've been telling anybody who will listen that I've been waiting 30 years to be disappointed by it. Thanks to io9 for reminding me why be recapping an awesomely over-the-top Green Lantern comic from 1980 that I owned, loved, and could still quote alongside the recap. Watch GL stagger through the Arctic wilderness without his ring set upon by polar bears and wolves.

Cucumber Rails 0.4: The De-Web-Step-ining

Cucumber, Rails, Uncategorized, testingNoel Rappin2 Comments
Consider this part of an occasional series where I attempt to revisit tools discussed in Rails Test Prescriptions that have undergone some revision. (NOTE: Most of this was written before the DHH Twitter-storm about testing this week. For the purposes of this post, I'm choosing to pretend the whole thing didn't happen.)

The cucumber-rails gem released version 0.4 last week, which had some significant changes, and intensified what we might call the opinionated nature of Cucumber over what a Cucumber scenario should look like.

If you update cucumber-rails, you need to re-run the rails generate cucumber:install to see the new stuff.

There are a couple of minor changes -- the default env.rb file is much simpler, the capybara date selector steps now work with Rails 3, that kind of thing. The biggest change, though is conceptual, and comes in two parts.

Part one is best laid out by the new first line of the web_steps.rb file:


# TL;DR: YOU SHOULD DELETE THIS FILE


The header goes on to say that if you make use of these steps you will end up with verbose and brittle cucumber features. Also, your hair will fall out, and you will have seven years bad luck. The last may be more implied than stated.

Why would they do such a thing? And what's the "official" preferred way to use Cucumber now?

Well, it's not like the Cucumber dev team has me on speed-dial or anything like that, but since they subtly included in the web_steps.rb file links to, count 'em, three separate blog posts explaining how to best use Cucumber, I will follow that subtle, yet blazing, trail and try to put it together in some coherent way so that I can understand it.

(Note to Cucumber dev team: if you feel the need to link to this post in future versions of Cucumber, you should consider yourself as having permission to do so....)

Anyway, the Cucumber team is making a very opinionated statement about how to use Cucumber "with the grain", and I actually don't think that statement is "don't use the web_steps" file -- I think that some parts of the web_steps file have a place in the Cucumber world.

Here's the statement as I see it:


  • A Cucumber scenario is an acceptance test.

  • As such, the scenario should completely be in the domain of the user.

  • A Cucumber scenario should not have any reference to implementation details.

  • Implementation details include, but are not limited to: CSS selectors, class names, attribute names, and HTML display text.



As a good rule of thumb, if you are putting something in your Cucumber steps in quotation marks, you should at least think about whether your Cucumber scenario is at a high enough level. In the Cucumber world, the place for implementation-specific details is in the step definition files. If the acceptance criteria changes, the scenario should change, but if the implementation changes, only the step definitions should change.

This sharp separation between the acceptance test and the implementation is a feature, not a bug, in Cucumber (By the way, you do not want bugs in your cucumbers. Yuck.) The separation is what makes Cucumber a true black-box test of your application, and not a black box riddled with holes.

That said, full-stack testing that is based on knowing implementation details -- which is "integration testing" rather than "acceptance testing" -- is a perfectly valid thing to do, especially in a case where there isn't an external customer that needs or wants to see the acceptance testing. But, if you are actually doing integration testing, then you don't need the extra level of indirection that Cucumber offers -- you should drop down to Steak, or Rails integration tests, or the new Capybara acceptance test DSL or something.

Okay, so. Acceptance testing is not integration testing, and if you are trying to do integration testing via Cucumber, you will be frustrated, because that's not what Cucumber is good at. To me, there's a value in acceptance testing, or in this case, acceptance test driven development, because it's helpful to try and describe the desired system behavior without any implementation details confusing the issue.

Which brings us back to the question of how you actually replace the web steps in your Cucumber scenarios. Essentially the idea is to replace implementation-based steps with steps that describe behavior more generically. You might have something like this:


Scenario: Updating a user profile
Given a user named "Noel" with a preference for "Cool Stuff"
When I go to the edit profile page
And I fill in "bananas" for "Favorite Food"
And I select "Comic Books" from "Preferences"
And I press "Submit"
Then I should see "Bananas"
And I should see "Comic Books"


That's not horrible, because it doesn't have any explicit CSS or code in it, but it's still very much about implementation details, such as the exact starting state of the user, the labels in the form, and the details of the output. On the plus side, the only step definition you'd need to write for this is for the first step, every other step is covered by an existing web step. But... I've written my share of Cucumber scenarios that look like this, and it's not the best way to go. It's hard to tell from this step what the most important parts are and what system behavior is actually being described.

The implicit version of the scenario looks more like this:


Scenario: Updating a user profile
Given I am an existing user with a partially completed profile
When I go to edit my profile
And I fill in new preferences
Then I see my new preferences on my profile page


Two questions to answer: why is this better, and how does it work?

The second question first. We need to write step definitions for all these steps. Normally, I write these in terms of the underlying Capybara or Webrat API rather than calling web steps. The second step doesn't need a full definition, it just needs an entry for /edit my profile/ in the paths.rb file (right now, it seems like that's about the only step in the web steps file that the Cucumber team is willing to use), but the other three steps need definitions -- here's what they might look like, this might have a typo or syntax jumble, it's just the basic idea.



Given /^I am an existing user with a partially completed profile$/ do
@user = Factory(:user)
@user.profile = Factory(:profile, :preference => "Cool Stuff",
:favorite_food => nil)
end

When /^I fill in new preferences$/ do
fill_in("Favorite Food", :with => "Bananas")
select("Comic Books", :from => "Preferences")
click_button("Submit")
end

Then /^I see my new preferences on my profile page$/
with_scope("preference listing") do
page.should have_selector(selector_for("bananas are my favorite food"))
page.should have_selector(selector_for("comic books are my preference"))
end
end



If you are used to Cucumber but haven't used the 0.4 Rails version yet, the last step will look unfamiliar. Bear with me for a second.

Why is the second version better? It's not because it's shorter -- it's a bit longer, although only a bit (the first version would need a step definition for the user step as well). However, the length is split into more manageable chunks. The Cucumber scenario is shorter, and more to the point, each step is more descriptive in terms of what it does and how it fits into the overall scenario. The new step definitions you need to write add a little complexity, but not very much, and my Cucumber experience is that the at this size, the complexity of the step definitions is rarely the bottleneck. (For the record, the bottleneck is usually getting the object environment set up, followed by the inevitable point of intersection with implementation details, which is why I'm so keen to try and minimize intersection with the implementation.)

Yes, the scenario is something you could show a non-developer member of the team, but I also think it's easier for coders to comprehend, at least in terms of getting across the goals of the system. And this is supposed to be an acceptance test -- making the goals of the system explicit is the whole point.

Okay, either you believe me at this point or you don't. I suspect that some of you look at the step definitions and say "hey, I could string those seven lines of code together and call it a test all by itself". Again, if that's what works for you, fine. Any full-stack testing is probably better than no full-task setting. Try it once, though. For me.

Back to the step definitions, the last one uses the selector_for method -- and I hope I'm using it right here because I haven't gotten a chance to work with it yet, and the docs aren't totally clear to me. The idea behind selector_for is to be analogous to the path_to method, but instead of being a big long case statement that turns a natural language phrase into a path, it's a big long case statement that turns a natural language phrase into a CSS selector. The big lng case statement is in the support folder in a selectors.rb file. The with_scope method uses the same big case statement to narrow the statements inside the block to DOM elements within the snippet.

As with the paths, the idea is to take information that is implementation specific and likely to be duplicated and quarantine it into one particular location. As I said, I haven't really incorporated this into my Cucumber routine yet, my first thought is that it'll be nice to hide some of the complex CSS selectors I use in view testing, but I worry that the selectors.rb file will become a mess and that there's less probability of duplicating a snippet.

I sure wish I had a rousing conclusion to reward you as this post nears the 1750 word mark. I like the direction that these changes are taking Cucumber, they are in line with what I've found to be the best use of the tool. Take a chance and try writing tests as implicitly as you can, as an exercise and see if it works for you.

July 30, 2010: I Always Thought It Was An Animal Native To The Rain Forest

Bundler, Cucumber, Ruby, Time, Vim, Yehuda, unixNoel RappinComment

Book Status



Beta 5 came out on Wednesday. Currently trying to figure out how to structure the Shoulda chapter in light of the direction that project has gone in since I wrote about it for the Lulu book.

Friday Links



One significant change in Rails 3 is that, because of the way Bundler works, the code for your gems is not part of the project. And if you are using RVM, each project might have a different gemset, and different directory to find those gems. Brian Cardarella has a simple script that will open a new tab in your terminal window and take it to the gem directory for the current project. OS X only, because it uses AppleScript. I will use this.

Mike Burns from Thoughtbot gives us a just-so story for the digital age, How grep got its name. I always thought it was the sound you make when you try and figure out how to use it, "Oh Grep!"

Derek Kastner of Brighter Planet has an interesting look at how to use more advanced features of Bundler to to manage gem dependencies when building a gem, and creating the gemspec. Definitely something I would not have figured out on my own.

Matt Aimonetti, after doing a little Ruby memory quiz/rant on Twitter last night has published a longer blog post about Ruby's object allocation. This is interesting, and makes me wonder if it would be possible to build a Ruby runtime optimized for long-running processes. Still, make it work, make it right, make it clean, only then make it fast -- it's much easier to optimize clean code.

Louis Rose has a short snippet or three on using Timecop and Chronic to manage time-based Cucumber scenarios. Read through to the updates to avoid a couple of gotchas. Chronic, by the way is one of my favorite gems to use in projects, because clients often like the demo of being able to type in "next Tuesday" in a date field.

Finally, Yehuda Katz has what is maybe the first "I switched to Vim" story that makes me actually think about switching to Vim. Seems like a useful approach and set of tips.

June 30, 2010: The Triumphant Return of the Monster Link Post

Cucumber, Don Norman, Rails 3, Ruby, Shoulda, Steve Martin, UXD, iPhone, rvm, writingNoel RappinComment

The end of the repair story



At the end, a very positive experience with Apple support. The repair was free, done when they said it would be done, and all told, I spent less than fifteen minutes in the store between both halves of the visit. Plus, they replaced the top part of my pre-unibody MacBook, which was worn down and discolored from my gunky hands, almost as though they didn't want an ugly Mac in the field.

Book Status



With the laptop back, I'm back to work, last night going back over the Style chapter. I think now the plan is to do a slightly smaller next beta that would get out next week, just the Coverage and Style chapters, with the next batch, probably the Legacy and redo of the startup example coming shortly on its heels.

Also, the book has somewhat quietly shown up on Amazon and, I presume, other online outlets.

Of course, the beta is still available at PragProg.

Links



Many, many links, as I catch up on an entire week's worth.

Thoughtbot announces that factory_girl is now split into a separate Rails 3 gem, in much the same way that Cucumber and RSpec are.

Also in Thoughtbot-land, the should_change command has been deprecated from Shoulda.

Jeremy McAnnaly announces the 2010 Ruby Hoedown, after some rescheduling due to the Nashville flooding. Again, it's the low, low, price of free. I'm hoping to break my 0-for-2010 streak on conference proposals with my submission.

Everyday Rails has a good post about getting Rails 3 and RVM working together.

I haven't watched this video yet, but a little Don Norman is a good thing, right? (via Joel Spolsky)

Test Inline is a Ruby library from Eric Anderson to put tests in the Ruby source file. Eric freely admits that this is an experiment, which is good because my experience with this kind of tool (Python doctests) is that it gets messy pretty quickly.

Ever think that Lemmings would make a great iPhone game? Me too. Also, the people who have the rights to the code. Coming soon.

I love Steve Martin. He's posted the rider for his tours. A sample: "BUFFET ... Six-packs of any canned beverage for Steve to compare his abs to."

I've been waiting for this: Lifehacker posts some Handbrake presets for iPad and iPhone 4. Seem decent, but a bigger file size than what I had been doing.

Please don't do this. It's a bad idea and will make your code harder for other Ruby developers to maintain.

Two from David Chelimsky: Having a topic branch when contributing to git projects, and a change in how views are handled in controller tests in RSpec 2.

I really need to watch this presentation from RailsConf on Beautiful Markup by John Athayde.

Speaking of RailsConf, here's a retrospective from John Trupiano of the BohConf "unconference" that happened alongside.

Dan Ingalls was one of the people behind Smalltalk 80, here's an interview with him.

Over at Teach Me To Code, a screencast about setting up a Rails project and writing the first Cucumber feature.

Still in Cucumber, Michael Orr shows how you can use an instance variable to track objects in a Cucumber test. I do this a lot, myself, although I'm not completely convinced that you get a cleaner test suite at the end.

Rands has a great post about his writing process. I love that everybody does this a little differently, although calling what I do a "process" is probably a little much.

Paolo Perrota, author of Metaprogramming Ruby, has a nice note about how great the Ruby community is.

UxMyths seems like a useful site to browse.

Speaking about great writing, I loved, loved the opening of this article by Adam Keys about why he always comes back to TextMate. Also some good comments. I hadn't thought of the issue exactly this way, but it makes perfect sense.

The Time of Day gem lets you treat ActiveRecord time columns without their date information for certain kinds of comparisons.

Finally



I think I mentioned that I did a talk at Refresh Chicago last week. It was fun, but we think turnout was down due to the tornado warning over Chicago that night -- it's possible the sirens acted as a deterrent. Well, video of that is not up, but here's a video of the storm that night, featuring lightning striking three Chicago skyscrapers at the same time.

June 1, 2010: June, she'll change her tune

Chicago Ruby, Cucumber, JRuby, Kent Beck, RSpec, iPadNoel RappinComment

iPad Note



I keep wanting to write about the iPad, but so, so many other people are writing about it that I'm not sure I have anything to add. More or less at random, I really liked the brief rant Joe Posnanski added in the middle of an otherwise-unrelated blog post, and Charles Stross' typically complete take. Right now, I just would add that I still use it more than I thought, that the form factor makes more of a difference than I expected (being able to easily walk to show the screen). Also, I'm somewhat idiosyncratically waiting for turn-based strategy games to pop up for it, along the line of Avalon Hill's old games -- the thing is perfect for them.

Today



One last reminder of today's Chicago Ruby meeting featuring Matt Polito talking about Git, and me talking about testing.

And then



Looks like Kent Beck has gone and evolved the Agile Manifesto at the Startup Lessons Learned conference. This moves in the direction of what Beck has been calling Responsive Design.

Sarah Mei has a really nice example of outside-in BDD going back and forth between Cucumber and RSpec. Very nice overview of the process.

Ruby 1.9.2 preview 3 is out and available via RVM. Also over the weekend RSpec 2.0.0 beta 9.1 was released.

Charles Nutter has a long technical examination of performance in JRuby.

May 21, 2010: Meetings

Chicago Ruby, ChicagoDB, Cucumber, Rails 3, Snow LeopardNoel RappinComment

Book Status



Committed what I hope will be the Beta 3 version of the Cucumber chapter. Most of the changes were in the various conclusions. When I originally wrote the chapter, Cucumber was still quite new, and I had kind of a ragged set of thoughts about how it should be used. Since then, I've used it more, and more importantly, there's been a lot more community discussion about how Cucumber is best used, so I needed and was able to tighten up that part a bit.

Meetings, I've Got Meetings



If you are in the Chicago area, you might want to check out some group meetings.

The brand new ChicagoDB user group will have its first meeting Monday June 21 at Obtiva World HQ in Chicago. RSVP if you plan on coming.

Also, the Chicago Ruby meeting on June 1, now has a more detailed description of the schedule.

And then



A couple of links on setup:

This week in RailsDispatch, upgrading from Rails 2 to Rails 3.

Rogelio Samour has posted a set of steps that Hashrocket currently uses to create their standard Ruby setup for Snow Leopard machines. Looks nice.

Finally



A few weeks ago I linked to a This American Life story about the NUMMI auto plant that recently closed after a long time being the flagship GM plant for running based on Toyota/Lean principles. Interesting follow up yesterday: the plant will be part of Toyota's investment in Tesla, and will be used to build Tesla's cars.

May 14: Moving To Beta 3

Cucumber, Git, HTML5, Rails 3, RailsRx, YehudaNoel RappinComment

Top Story



Just a quick update here.

Cucumber chapter newest draft is complete, and I'm hoping it will be beta 3 early next week. Not sure what to do next, I need to look around and see what's relatively stable with respect to Rails 3.

The book is still on sale. Tell all your friends.

And then



Rails Dispatch this week is about the new routing in Rails 3.

Yehuda Katz has a really nice article on workflow with git.

A brief rant on Ruby 1.9 and encodings.

Finally



The excellent Dive Into HTML 5 book/site has a quick reference on how to detect all kinds of HTML 5 related browser behavior. I'm pretty sure I'll be coming back to this page again.

May 12, 2010: The Raffle is Done

Cucumber, RailsRxNoel Rappin2 Comments

Top Story



I ran the Lulu raffle last night, and all five winners have responded. For what it's worth, I took a list of users from my database, generated a random series of numbers from random.org, and the users corresponding to the first five numbers in the sequence were picked.

Congratulations to Peter Bosse, Tim Harvey, Cameron Pope, Joshua Ball, and Christian Knappskog. You'll be contacted shortly with information about receiving your prize.

Thanks to everybody for being supportive of this process. I appreciate it.

Book Status



Still working on Cucumber chapter, still expecting it to be Beta 3 next week.

And Then



Not a lot of links today, for some reason. Portal is coming out for the Mac today, that should be cool.

May 4, 2010: MacRuby and more

Cucumber, Dave Hoover, Dropbox, MacRuby, Rails, RailsRx, Ruby5, Watir, iPadNoel RappinComment

Top Story



MacRuby 0.6 is out. Big new features include a debugger, a new interface to Cocoa's Grand Central Dispatch, and a rewrite of the internals of basic Ruby classes.

In a related story, the early text of Matt Aimonetti's MacRuby book from O'Reilly is available for free online. Nice job all around.

I'm not sure if I've mentioned it here, but I use MacRuby and its ability to manipulate AppleScriptable programs to power my crazy-obsessive iTunes random playlist generator, so speed improvements are hoped for.

Book Update



Still in the Cucumber chapter. Had to go back to the beginning to make sure everything still made sense with Cuke 0.7. The end of proofing what I had is near, but I also need to write about newer features, most notably tags, and I need to make sure I still agree with all the ideas about when to use Cucumber that I had a year ago.

I changed the Cucumber in the chapter to use Capybara instead of Webrat, but it broke on test (having to do with a checkbox being checked). Not sure if it's an issue in Capybara, the Cucumber web steps, or me.

The book, of course, is still on sale.

Lulu raffle tomorrow, so get those address changes in if you need to.

And Then...



Big day for O'Reilly releasing stuff. Obtiva's Own Dave Hoover's book Apprenticeship Patterns was also released for free -- the whole book this time.

Gregg Pollack put together a big list of links on the official Ruby on Rails blog. All of these were originally covered on Gregg's podcast, Ruby5.

Brian Hogan has a set of matchers for using Cucumber with Watir, looks like it gives you in browser tests using a syntax similar to the existing Cucumber web steps, but more detailed.

Finally



Dropbox for iPad is out as of last night. If you care about that, it's really nice.

May 3, 2010: Hi, I'm Back

Cucumber, JavaScript, Obtiva, Peanuts, Podcasts, Rails 3, RailsRx, Teaching, cheat sheets, testingNoel RappinComment

Hey, where were you?



Sorry about that, I spent most of last week running the Obtiva Ruby/Rails/TDD 4-day boot camp training, and I didn't have time to do this daily catchup. Hey, if you think you need me or somebody like me to come to your company and blather about Ruby and Rails for a few days, contact us at http://www.obtiva.com. It's fun.

Book Status



Rails test prescriptions: still on sale. Please do go to the forum to talk about what's there and what's not there.

Lulu raffle: still open, I think for another day or two.

Meantime, I've been working through the Cucumber chapter, and also proofing the mock article that will be in the May Pragazine.

Tab Dump



Several days worth of stuff.

Cucumber 7 is out of beta and in the wild. I'm hoping this doesn't mean too much updating of the chapter I'm in the middle of editing. The big change is a new parser advertised as 50-100 times faster. Which sounds like an outstanding change.

This week in Rails Dispatch, an article outlining the new ActiveRelation/Arel implementation of ActiveRecord for Rails 3

Thinking in Rails has a nice list of Ruby and Rails podcasts.

This is exactly what I want from a Rails plugin in: short, sweet, and solves a problem. In this case, from Ryan Bigg, finding database records by partial date.

I think I'll probably use this one: a detailed cheat sheet for all things Rails Migration.

A very detailed article on unobtrusive JavaScript that I really need to read more carefully.

The Thoughtbot team shows a nice design retrospective, walking through their process.

A couple of test links:

José Valim gives out some awards for best test suite features.

Will Leinweber tells you what the winning integration test stack looks like.

Bryan Liles at the Smarticus blog also responds to the question of whether you need unit tests and provides a good overview of the TDD process. I think he's got this right.

Finally



Apparently the Peanuts brand is still worth something, even without daily content, as an 80% stake in the brand rights for Peanuts just sold for $175 million. And if you want a sense of exactly where the pecking order is here, the article casually mentions in the next-to-last paragraph that the rights to Dilbert are also included...


April 27, 2010, Now Writing About Cucumbers

Cucumber, Git, Kent Beck, RailsRx, RubyMine, Webrat, iPad, testingNoel Rappin1 Comment

Top Story



For me, the top story is still Rails Test Prescriptions on sale, and my discussion yesterday of the raffle for the old Lulu customers.

Book Status



Now re-doing the Cucumber chapter, which was written long enough ago that it didn't consider tags. Cucumber has had approximately seventy-million releases in the interim, so there's some writing to do. This is the first chapter where I'm adding Rails 3 setup instructions, which will eventually go everywhere in the book, of course.

Tab Dump



Have to say, RVM support in RubyMine is potentially really cool.

Kent Beck would like to analogize goat farming and software development. I've heard worse.

I know you all have been following this story closely, so you'll be pleased to know that you can now bring your iPad into Israel with impunity. Again, carrying two of them with the roman numerals I to X as wallpaper.

Macworld has released an epub-formatted, iBooks compatible, user guide to the iPad.

Webrat bumped it's version to 0.7.1.

I frequently complain that there's no good visualizer for git repositories. This fork of GitX looks like it comes pretty close, though.

Finally



I'm pretty sure I disagree with some of this article by Josh Clayton talking about integration tests being more useful than unit tests. He's probably right about integration tests being more useful for ultimate correctness, but that's not everything that TDD is about. Unit tests are critical for the development process, and writing great code in the moment of development, and for supporting design changes and refactoring. Unit and integration tests have two complementary functions, just because they cover the same code doesn't mean they are redundant.



April 22, 2010: Annnd We're Live. Really. I mean it this time.

Bundler, Cucumber, Pragmatic, RailsRx, YehudaNoel RappinComment

Top Story



So, about yesterday... Funny story.

Some of you may have gone to the Rails Test Prescriptions book site hoping to buy the book only to see a conspicuous lack of an "Add to Cart" button.

The book was for sale for about ten minutes, just long enough for me to start jumping up and down about it, then was pulled due to some issues with the ebook files. I heard that the famous PragProg ebook generating gerbils went on strike, but that's just a rumor.

Anyway, the book did go back on sale somewhat latish Wednesday evening, (although a lucky few of you may have gotten more chapters than we originally intended to be a part of this beta, all the chapters will get there soon enough). Thanks to Colleen Toporek, my editor, for helping work through the process.

Also thanks to Matt Polito, whose been saying for weeks that he'd be the first in line to buy the book when it came out. And I can prove he was -- only one person managed to buy the book in the brief window it was online in the morning.

Now, though, I can tell you for sure: the book is up, I like it, I hope you like it, too. Buy early, and buy often.

Book Status



Finished up a draft of the article for the PragMag, hopefully that'll be in the May issue.

Tab Dump



Continuing the Pragmatic theme, here's an interview with Dave Thomas, that I haven't listened to yet. Looks like that'll be a two-part interview when all is done.

Yehuda Katz has another great bundler article, this one on named gem environments.

Cucumber released a beta of version 0.7 promising much, much faster parsing of feature files. Among other things, that makes using tags much more practical. Time to revisit that chapter, I think.

Finally



Jason Seifer and Peter Cooper talk about ugly old programming book covers, then create their own. If you've followed Jason for a while, I think you'll agree that his book contains all of his received wisdom on how well Rails can scale. But, guys, I don't think it gets worse than my face on the cover.