PragPub 2013-02: Issue #44

Table of Contents

Features

- RubyMotion
by Clay Allsopp
Clay shows how Ruby and Objective-C can coexist in iOS app development.

- Deploying with JRuby in the Cloud
by Joe Kutner
If you’ve been hesitant to switch to JRuby due to lack of familiarity with the JVM, Joe has some good news for you.

- Estimation is Evil
by Ron Jeffries
What you don’t know can hurt you, especially when you convince yourself that you do know it.

- The Five Cs of Offshore Communications
by Nick Krym
Offshore project success often comes down to communication. Chances are, you could be doing it better.

- Launching a Gonzo Engineering Project
by Steven K. Roberts
The legendary gonzo engineer shares his secrets for pursuing crazy dreams and succeeding in this series.

- Flashback
by Michael Swaine
Mike was going through his files and found a 1983 interview with Bill Gates about writing and selling his first BASIC.

Departments

- Up Front
by Michael Swaine
Ruby Is Twenty

- Choice Bits
We follow Twitter so you don’t have to.

- The Quiz
by Michael Swaine
A monthly diversion at least peripherally related to programming.

- Calendar
Want to meet one of our authors face-to-face? Here’s where they’ll be in the coming months.

- Shady Illuminations
by John Shade
Did the analysts who caused Apple’s stock drop also cast Ashton Kutcher to play Jobs?

- But Wait, There’s More...
Coming attractions and where to go from here.

Except where otherwise indicated, entire contents copyright © 2013 The Pragmatic Programmers.

Feel free to distribute this magazine (in whole, and for free) to anyone you want. However, you may not sell this magazine or its content, nor extract and use more than a paragraph of content in some other publication without our permission.

Published monthly in PDF, mobi, and epub formats by The Pragmatic Programmers, LLC, Dallas, TX, and Raleigh, NC. E-Mail support@pragprog.com, phone +1-800-699-7764. The editor is Michael Swaine (mailto:michael@pragprog.com). Visit us at http://pragprog.com

ISSN: 1948-3562

Up Front

Ruby Is Twenty
by Michael Swaine
Lots of good stuff this month: Ron Jeffries, two articles on Ruby, and more.

In honor of the Ruby language’s 20th birthday on February 24, we’re emphasizing Ruby in this issue, with two articles on where Ruby is going.

Clay Allsopp writes about Ruby as a development language for iOS apps, using RubyMotion. In “Expressive iOS Development,” he shows how Ruby and Objective-C can coexist peacefully in iOS app development.

Joe Kutner takes Ruby in another direction, into the cloud. In “Deploying with JRuby in the Cloud,” he walks you through the options you have for heading into the cloud by way of the JVM. As Joe explains, by moving to JRuby now, you’ll be preparing yourself for the multithreaded future.

While Clay takes you mobile and Joe takes you into the cloud, Nick Krym will take you around the world in his article on “The Five Cs of Offshore Communications.” Whether your offshore project succeeds or fails can depend almost entirely on how you communicate with your offshore team. Nick’s advice will keep you out of trouble.

Teams applying Agile ideas almost always get some improvement. One guess is that the overall improvement due to Scrum, for example, is about twenty percent over what the team was achieving before Scrum. Some teams do much better, and legendary programmer Ron Jeffries thinks he knows why. These teams understand that “Estimation is Evil.” Ron reveals all in this issue.

And there’s more. Steven Roberts continues sharing everything he’s learned in a lifetime of gonzo engineering, from scrounging parts to finding sponsors. Our resident curmudgeon, John Shade, tackles prediction. Plus we’ve got a Quiz, our Events Calendar, and some odds and ends in a collection we call Choice Bits. And in a blast from the past, we dug up some ancient comments from Bill Gates about writing his first Basic and selling it to MITS for the Altair computer.

Finally, a request. We have been producing PragPub free of charge for almost four years now, and unfortunately, that’s just not sustainable. We don’t really want to go the ad route, and we’re wondering if you would be willing to pay something to have PragPub delivered to you monthly. If you would, could you drop us a line at michael@pragprog.com? Thanks!

Choice Bits

A Smattering of Nattering

We follow Twitter so you don’t have to.

What’s Hot

Top-Ten lists are passé—ours goes to 11. These are the top titles that folks are interested in currently, along with their rank from last month. This is based solely on direct sales from our online store.

1^

NEW

The Healthy Programmer

2^

NEW

Good Math

3^

NEW

The App Design Handbook

4v

3

Agile Web Development with Rails

5^

11

The Definitive ANTLR 4 Reference

6^

9

Seven Databases in Seven Weeks

7^

NEW

Working with TCP Sockets

8^

NEW

Seven Languages in Seven Weeks

9v

6

Practical Vim

10v

5

Programming Ruby 1.9

11v

1

RubyMotion

Status Reports

I hate the tense few hours after a big server migration, waiting for server alerts to start lighting, praying for the sweet release of death. — @snipeyhead

Editing JavaScript embedded inside XML. Because I know how to party on a Friday night, ohhhhh yeahhhh. — @pamelafox

I should have been a chef; I can create spaghetti [code] like no other! — @adamgoucher

It’s a very satisfying small-chunks-of-steady-progress-coding sort of day. — @jessebeach

I started wearing a soul patch but I still crave Don Cornielius. — @mwisme

My sleep meds aren’t working very well. I dreamt about talking to a pharmacist to get more. #recursion — @amyhoy

Guy across from me on the bus is knitting something w/really pretty fluffy blue yarn on (tiny!) DPNs. Kinda want to ask what he’s making. — @epersonae

Upside: Netflix has streaming rights in Costa Rica. Downside: can’t seem to find any language setting. Guess I’ll be watching “Parque Sur.” — @zahnster

In 2013 I'm moving to Portland, so I can raise my own chickens and manage my own memory. — @hipsterhacker

Queries and Observations

Happy 13th annual Year That Linux On The Desktop Really Takes Off, everyone! — @invalidname

I wonder why anyone ever believes that people running corporations have any sense whatsoever. — @amyhoy

Working with everybody from startups to fortune 100 companies made me realize that if THOSE incompetents can do it, so could I! — @amyhoy

You can take the developer out of the Java, but you can't take the Java out of the developer, it seems. — @jeff_lamarche

Ah, heartfelt, touching, sparkly-grams on Facebook... you’re so sincere, despite being rife with grammar and punctuation errors. ~shudder~ — @MelaniePerry

Why does a morning of essential administrivia always lead to an unproductive afternoon of gaffing about and feeling a bit lost? — @Suw

Thieves break into Microsoft’s office in Mountain View to steal their iPads. No Microsoft products stolen. — @johnwilander

Suggestion Box

HTTP is to telnet what HTTPS is to ssh. Choose wisely. — @benrady

I vote that the <a> tag gets renamed to <anchor> in the HTML spec. Mostly cuz googling for anything with “a” is really, really hard. — @pamelafox

I wish all beer recipes started out as gists so I could see all of the forks and notes in a structured way. — @abedra

FWIW, as a conf speaker aware I may be a token, makes a big difference when organizers say “Can you come speak about [thing I worked on]?” — @garannm

Databases should be like a sports car. Fast and named after women. — @kellabyte

Whoever does the hair for Portlandia should win an Emmy. #omg — @jensimmons

OVER-ENGINEER ALL THE CODES! — @jeff_lamarche

Twitterites! Wikipedia doesn’t have a #bqhatevwr article... yet. You slackers better get busy. — @macartisan

Who Are Those Guys?

First, they’re not all guys. Second, we have to confess that we cleaned up their punctuation and stuff a little. OK, who they are: Chris Adamson, J. Renée Beach, Aaron Bedra, Pamela Fox, Adam Goucher, Hipster Hacker, Amy Hoy, Jeff LaMarche, Macartisan, Garann Means, Elaine Nelson, Melanie Perry, Ben Rady, Jade Rauenzahn, Jen Simmons, snipe ツ, Kelly Sommers, Suw, Michael Weber, and John Wilander.

You can follow us at www.twitter.com/pragpub.

RubyMotion

Expressive iOS Development
by Clay Allsopp
Clay shows how Ruby and Objective-C can coexist in iOS app development.

I’ve always been in the middle of two engineering worlds. I started off writing Mac and iOS apps, software defined by Apple’s constraints and the type-checked realm of Objective-C. But once I needed to make my apps networked and dynamic, I ventured into the Wild West of Ruby, where frameworks and best practices came and went like the boom-bust towns of old.

I kept on and straddled the lines for a few years. The two languages had so much in common, but sometimes seemed miles apart. If only we could unite iOS development with Ruby’s penchant for expressive frameworks and DSLs; if only we could get rid of the veryVerbose:withLongNames: Objective-C methods but still create those beautiful native iPhone apps....

And then, in May 2011, RubyMotion rolled into town. RubyMotion, from HipByte, is a toolchain that compiles Ruby into LLVM machine code run under the Objective-C runtime. In other words, you can write iPhone apps with Ruby. It’s proprietary and semi-closed-source, but is based on and made by the same developers as the MacRuby project.

Aha! At last, here was something for me! But does coding in Ruby really make writing iOS apps more pleasant? Well, let’s take a look at what the RubyMotion tools and community have cooked up in comparison to the canonical Objective-C workflow. These will all be pretty high-level examples, just a fun little survey to whet your appetite and pique your interest.

I dive a lot deeper into this in my recently released Pragmatic Bookshelf book, RubyMotion: iOS Development with Ruby, a trip from zero-to-app in about 100 pages that assumes just some basic Ruby experience.

So much for the plug; let’s take a look at the most popular RubyMotion library: BubbleWrap.

The Big One: BubbleWrap

Shortly after RubyMotion was released, the innocently-named BubbleWrap appeared sporting a few concise methods for sending HTTP requests. Since then, BubbleWrap has grown to a nifty treasure chest of wrappers and abstractions used in just about every RubyMotion project.

What do these “wrappers” look like? Well, for example, you might want to take a photo with the device’s camera. In the original Objective-C framework, there was a system of delegate methods and bit-mask configuration and all other sorts of un-Ruby constructs. But with BubbleWrap, it’s pretty simple:

BW::Device.camera.front.picture do |result|

image = result[:original_image]

end

Same goes for grabbing the location using the phone’s GPS; in fact, the iOS SDK implementation for geolocation was even more extensive than the camera’s! But with RubyMotion, it’s just these few simple lines:

BW::Location.get do |result|

from = result[:from]

p "From Lat #{from.latitude}, Long #{from.longitude}"

to = result[:to]

p "To Lat #{to.latitude}, Long #{to.longitude}"

end

BubbleWrap also contains a myriad of tiny wrappers which, although just bits of sugar, are small wins in programmer happiness. For example, you know those blue popups that show up every now and again in iOS apps? They’re represented by simple UIAlertView objects, but the syntax for spawning them remains characteristically verbose from Objective-C-land:

alert = UIAlertView.alloc.initWithTitle("Hello",

message: "I'm an Alert",

delegate: nil,

cancelButtonTitle: "OK",

otherButtonTitles: nil)

alert.show

Naturally, BubbleWrap provides a small wrapper to save our fingers some trouble:

App.alert("Hello", message: "I'm an Alert")

BubbleWrap is filled with this sort of little addition, along with the bigger wrappers around more complex APIs like HTTP requests, playing videos, UI customization, and more. Most of BubbleWrap’s abstractions and techniques can indeed be implemented with modern Objective-C, but that community is tepid towards any efforts that go against the Apple-tinted grain.

These are nice tricks, but they don’t really highlight Ruby’s unique strengths. Perhaps we need to draw inspiration elsewhere.

There’s Rails in My iOS!

When RubyMotion first arrived, a lot of folks immediately thought, “Hey, now we can port Rails to iOS!” That’s an interesting idea, but mobile is just too fundamentally different from a web backend: unlike a server, mobile is a stateful, evented, often resource-constrained soup where you can’t simply git push to squash bugs. But differences aside, maybe Rails does have a few habits iOS can pick up without copying it verbatim.

One place in need of improvement is Models, with a capital M. The Apple-provided iOS framework for Models is Core Data, which has an unfortunately steep learning curve; ActiveRecord, on the other hand, is fairly painless to get up and running in a typical Rails project. This is where MotionModel steps up to bat.

MotionModel is a RubyMotion gem for creating Models using an ActiveRecord-esque DSL. Take a look at the canonical Task object:

class Task

include MotionModel::Model

include MotionModel::Validatable

columns :name        => :string,

:description => :string,

:due_date    => :date,

:location    => :string

validates :name => :presence => true

end

A good start, right? Once you’ve defined a model, you can do queries and persistence with ease:

@tasks = Task.where(:description).contains('urgent')

.and(:location).contains('seattle')

@task = Task.create(:name => 'Walk the Dog',

:description => 'Remember the leash',

:due_date => '2012-09-15')

@task.description = 'Don't forget the leash'

@task.save

Since .create just takes a Hash, it could be a perfect fit for using in tandem with a JSON-based API. Beyond the basics, it sports many ActiveRecord-like features like relationships:

class Task

...

has_many    :assignees

end

class Assignee

include MotionModel::Model

columns     :assignee_name => :string

belongs_to  :task

end

@task = Task.create(:name => "Walk the Dog")

@task.assignees.create(:assignee_name => "Howard")

@assignee = Assignee.new(:name => "Douglas")

@task.assignees << @assignee

There’s more to MotionModel than these few code samples, but it frankly beats the pants off doing work in Core Data. Now, is MotionModel as performant or battle-hardened as Apple’s own approach? Probably not, but for 80% of apps it should do the trick with a warm-fuzzy familiarity.

Speaking of Rails, one thing the non-mobile Ruby community certainly got right is the emphasis on automated tests. Accordingly, RubyMotion ships with a fantastic testing framework.

Unit Test, Then Unit Test Some More

One point I see brought up time and time again among iOS developers is the difficulty of writing automated tests. Apple’s framework, UIAutomation, is actually... a JavaScript framework, tightly integrated with their Instruments application. And installing any third-party Objective-C testing library usually involves setting up multiple targets in Xcode and the whole process just escalates very quickly. Why can’t it be as simple as Rails, just one rake test away?

Well, in RubyMotion it is! Technically it’s the rake spec command, but otherwise everything works the same: you add test files to your project’s spec folder, use an RSpec-like DSL to organize each test, and then fill in your assertions and expectations. Here’s an example taken from the open-sourced and well-spec’d TinyMon RubyMotion app:

describe Account do

it "should extract attributes" do

account = Account.new(:name => 'Test',

:status => 'success', :role => 'user')

account.name.should == 'Test'

account.status.should == 'success'

account.role.should == 'user'

end

end

Objective-C testing frameworks use all sorts of C preprocessor macros and lack the plain-English readability you can see above. Ruby tests, Motion or not, are among the most pleasant to write and maintain.

And don’t get me started on how to test the user interface with Xcode! Thankfully, RubyMotion provides an equally expressive API for simulating user interaction. Again, taken from the TinyMon example:

describe LoggedInViewDeckController do

tests LoggedInViewDeckController

it "should reveal menu on swipe" do

table = view('success.png').up(UITableView)

flick table, :to => :right

point = table.superview.convertPoint(table.frame.origin,

toView:nil)

point.x.should > 150

end

end

Nifty, right? There’s also support for tap, pinch, and all manner of custom gestures. You can pretty much read RubyMotion tests word-for-word and they’ll make sense as paragraphs and sentences. And again, these are all runnable via the rake spec command, so they can fit into your automated or continuous integration workflow.

Before RubyMotion, writing iOS tests was hard, and usually just didn’t happen because the barriers to entry were so high. But now, with the power of Ruby and its seamless workflow, my own development habits are just a bit shy of completely test-driven.

Building User Interfaces

The stuff we’ve looked at so far mainly helps us with the skeleton and operation of our app, but what iOS apps are really known for is how they look and feel. Can RubyMotion help out with that, too? As in our Views, with a capital V?

Turns out, yes! One of the other popular RubyMotion libraries is Formotion. Formotion is a DSL for creating form-based interfaces, kind of like what you see in the Contacts or Settings apps. Its claim to fame is that you can create an interface like this:

Formotion Preview

Using just this Hash:

@form = Formotion::Form.new({

sections: [{

title: "Register",

rows: [{

title: "Email",

key: :email,

placeholder: "me@mail.com",

type: :email,

auto_correction: :no,

auto_capitalization: :none

}, {

title: "Password",

key: :password,

placeholder: "required",

type: :string,

secure: true

}, {

title: "Password",

subtitle: "Confirmation",

key: :confirm,

placeholder: "required",

type: :string,

secure: true

}, {

title: "Remember?",

key: :remember,

type: :switch,

}]

}]

})

@form_controller = Formotion::FormController.alloc.initWithForm(@form)

@window.rootViewController = @form_controller

This type of interface is actually incredibly tedious to create from scratch with UITableViews, so Formotion easily saves dozens to hundreds of lines of code in the process.

I think this is the most exciting development in the RubyMotion community: creating wholly new metaphors and workflows, beyond just bits of abstraction and syntactic sugar, for how we make mobile apps. This sort of thing, for technical or cultural reasons, just isn’t taking hold in the original iOS/Objective-C world.

A More Perfect Union

There’s a weird vibe in both the Objective-C and RubyMotion communities that there has to be an either/or choice between the two; that one technology has to be “good” and the other must be “bad” or “wrong.” But the thing is, the two can coexist quite pleasantly in one project. You can take your Ruby with a side of C, or cook up an Objective-C soufflé using a light Ruby dusting. At least one of those sounds delicious, right?

Because at the end of the day, both RubyMotion and plain-old Objective-C apps get compiled down to the same LLVM machine code. As in, if you use UIView.alloc.initWithFrame(CGRectZero) in RubyMotion, it should produce the exact same instructions as writing [[UIView alloc] initWithFrame:CGRectZero] in Xcode. This has a really great side effect: RubyMotion projects can bundle Objective-C code, and Objective-C projects can include libraries written in RubyMotion. They’re totally interoperable!

There are a couple ways to achieve this unity. RubyMotion supports CocoaPods, the Objective-C equivalent of RubyGems, out of the box. Simply add a CocoaPod to your Rakefile and voila!

require 'motion-cocoapods'

Motion::Project::App.setup do |app|

app.pods do

pod 'AFNetworking'

end

end

The reason CocoaPods works so readily is RubyMotion supports building arbitrary Xcode and Objective-C files into an app, which CocoaPods already builds upon. For example, let’s say you wanted to include this small Objective-C class into your RubyMotion project:

@interface CYAlert : NSObject

+ (void)show;

@end

@implementation CYAlert

+ (void)show {

UIAlertView *alert = [[UIAlertView alloc] init];

alert.title = @"This is Objective-C";

alert.message = @"Mixing and matching!";

[alert addButtonWithTitle:@"OK"];

[alert show];

[alert release];

}

@end

All you need to do is instruct the RubyMotion builder to also include the proper files in the process:

Motion::Project::App.setup do |app|

# ./vendor/CYAlert contains CYAlert.h and CYAlert.m

app.vendor_project('vendor/CYAlert', :static)

end

This is incredibly useful if you want to include non-standard libraries or memory-sensitive code that isn’t directly supported in RubyMotion. That :static option also accepts :xcode, which lets you drop in entire Xcode projects as opposed to raw files. This also means you can wean your codebase to or from Ruby, so switching isn’t an all-or-nothing game.

Finally, RubyMotion supports the compilation of your Ruby files into a single static library with the rake static task. The generated library can then be added to any normal Xcode projects and used within Objective-C code! I’ve read of developers writing their specs in Ruby to be run against Objective-C code in this manner.

The Road Ahead

I hope this gave you a better idea of how RubyMotion looks and feels in your editor. If you want to dive deeper and learn iOS properly, take a glance at my RubyMotion book and see if it’s right for you. Or if you want to see what else is coming out of the RubyMotion community, take a peek at RubyMotion-Wrappers.com, an excellent collection of recent projects and RubyGems.

At the end of the day, the choice to use RubyMotion or Objective-C is decided by the demands of your project: will the DSLs and wrappers in RubyMotion speed things up, or would the lack of Xcode integration slow development down? Engineering is all about tradeoffs, and we can only aim to be as educated as possible on all the decisions we have to make.

Clay Allsopp is a hacker, Thiel Fellow, and internet enthusiast. An iOS developer since day one, Clay has crafted beautiful mobile apps with over a million cumulative downloads for startups like Circle. He is currently building Propeller, the best way for anyone to build a mobile app. Send the author your feedback or discuss the article in the magazine forum.

Deploying with JRuby in the Cloud

Adjusting the Settings on Your Java Machine
by Joe Kutner
If you’ve been hesitant to switch to JRuby due to lack of familiarity with the JVM, Joe has some good news for you.

Cornelius Vanderbilt made his millions in the shipping industry. He started with regional steamboat lines on the eastern seaboard of the United States but knew that he would have to ship goods to California in order for his business to succeed. In 1849, the year of the California gold rush, he switched his fleet to ocean-going steamships that carried enormous loads in one trip without the maintenance overhead of hundreds of smaller ships. Deploying Ruby applications on the JVM via JRuby has many of the same advantages.

The JVM can service thousands of requests in parallel without the memory or maintenance overhead of an equivalent number of single-threaded MRI instances. (You probably know that MRI means Matz’s Ruby Interpreter, the reference implementation of the Ruby programming language.) Yet, many developers and software companies have been hesitant to switch to JRuby. The biggest hurdle is often a lack of familiarity with the JVM and its new ecosystem. But some new cloud products released in the last few months have done much to alleviate this problem.

In December, Heroku announced dedicated support for JRuby, which adds their product to a growing list of JRuby-supporting cloud platforms including those from Google, Red Hat, and Engine Yard. In this article, we’ll discuss how you can use these platforms to get the most out of your applications. We’ll assume that you have JRuby installed [[[Could you link to installations instructions here?]]], and that you have some familiarity with the Ruby language and its ecosystem. Beyond those prerequisites, there isn’t much else you need to know. Deploying JRuby apps to the cloud isn’t that different from deploying MRI-based applications.

Getting Ready for JRuby

For all of the cloud options we’ll discuss, you’ll need to first make sure your application is ready for JRuby. If you’re starting from scratch, the rails new command or the equivalent in another web framework will generate exactly what you need. If you’re porting an existing application, you’ll need to do two things:

- Download the jruby-lint gem and run the jrlint tool against your project.

- Replace your web server with a JRuby web server.

If you need more information, both of these are described in great detail in my book Deploying with JRuby from the Pragmatic Bookshelf. But for our present purposes, just note that the jrlint tool will alert you to any incompatibilities in your code (the most common is the need to replace your database adapter or any other gem that uses native code). We’ll assume you’re past that. Now all that’s left is choosing a server. There are five dominant options:

- Trinidad: a lightweight server built on the Apache Tomcat server.

- TorqueBox: a JRuby application server (AS) built on JBoss AS.

- TorqueBox-lite: Only the web bits of the TorqueBox AS.

- Puma: a pure Ruby web server.

- Warbler: not really a server, but a tool for packaging a Ruby application to run on any Java server.

Your choice of server will be largely dictated by the cloud platform your decide to use. Fortunately, you have several choices again, but we’ll begin with the newest of the bunch.

JRuby on Heroku

Heroku is a cloud application platform that has supported both Ruby and Java applications for several years, but it’s only recently introduced dedicated support for combining the two with JRuby.

Setting up a JRuby app to run on Heroku is largely the same as setting up an MRI app. The primary difference is that you will need to add a line like the one below to your Gemfile.

ruby '1.9.3', :engine => 'jruby', :engine_version => '1.7.1'

This instructs Heroku to use JRuby version 1.7.1 and run it in 1.9.3 compatibility mode.

Next, you’ll need to pick your web server. Heroku does not provide direct support for any single server, but it does recommend Puma. That’s because Puma has the smallest memory footprint of the options described above, and it can fit on a single dyno with ease. (A dyno is the basic unit of composition on Heroku, “a lightweight container running a single user-specified command.”) To use Puma, replace your existing server with this line in your Gemfile.

gem 'puma'

Trinidad and TorqueBox-lite also work on Heroku. TO use them, you need to replace the puma gem with the trinidad or torquebox-lite gem respectively. Be aware, though, that the underlying Java servers they are built on will consume more memory, which could be a problem if your app is particularly large.

In any case, the next step is modifying your Procfile to start the JRuby server you’ve chosen. For Puma, it would look like this:

web: bundle exec rails server puma -p $PORT -e $RACK_ENV

Finally, create a Heroku account and download the command-line tool. Then run the following commands from your application’s root directory:

$ heroku create --remote jruby-master

Creating severe-mountain-793... done, stack is cedar

http://severe-mountain-793.herokuapp.com/

| git@heroku.com:severe-mountain-793.git

Git remote jruby-master added

$ git push heroku jruby-master

Counting objects: 692, done.

Delta compression using up to 4 threads.

Compressing objects: 100% (662/662), done.

Writing objects: 100% (692/692), 141.01 KiB, done.

Total 692 (delta 379), reused 0 (delta 0)

-----> Heroku receiving push

-----> Ruby/Rails app detected

-----> Using Ruby version: ruby-1.9.3-jruby-1.7.1

-----> Installing JVM: openjdk7-latest

-----> Installing dependencies using Bundler version 1.2.1

# ...

You app is now running on JRuby in the cloud, and you can start taking advantage of all that JRuby has to offer.

Aside from the servers mentioned earlier, it’s also possible to run the full TorqueBox server on Heroku. However, there is a bit of finagling required to get past issues with slug size, timeouts and memory limits. Even more unfortunate is that deploying TorqueBox to Heroku compromises many of the TorqueBox features, such as clustering and STOMP support.

If TorqueBox is what you’re after, a better solution may be the OpenShift platform.

TorqueBox on OpenShift

OpenShift is a platform-as-a-service (PaaS) offering from Red Hat. The main advantage of OpenShift over other PaaS options is that the underlying technology is open source, which means you could potentially set up an OpenShift cloud within your own organization.

Because OpenShift and TorqueBox are maintained by the same organization (Red Hat), the two technologies align well with each other. OpenShift has only recently come out of beta, and there have been many gyrations in the set-up steps for TorqueBox. The current standard is to use the openshift-quickstart tool, which is maintained by the TorqueBox team. To use it, you’ll need an existing JBoss AS7 application, which can be created with the rhc command-line tool provided by OpenShift. You can download it when you create an account at (http://openshift.redhat.com). Then run the following command:

$ rhc app create -a yourapp -t jbossas-7

This creates an empty JBoss AS7 application—not a JRuby application. So you’ll need to delete the scaffolding with these commands:

$ cd yourapp

$ rm -rf pom.xml src

Then merge the openshift-quickstart code into your project like this:

$ git remote add upstream -m master

git://github.com/torquebox/openshift-quickstart.git

$ git pull -s recursive -X theirs upstream master

Once you git push the changes to your remote OpenShift repo, which will already be configured, you’ll be running TorqueBox in the cloud. Now you can leverage background jobs, scheduled jobs, daemon services, and many other enterprise-class features that are integrated into your application. You won’t need to set up additional infrastructure like workers or slave instances to run them.

While OpenShift and Heroku are the most promising JRuby cloud environments, they are both relatively new options. Several other vendors have products that have been around for a while.

EngineYard, CloudBees, Google, and More

EngineYard’s JRuby cloud platform was first released in 2011 with dedicated support for the Trinidad server. To use it, simply select the JRuby and Trinidad options when creating a new instance. Then deploy your Trinidad app as you would deploy any other Ruby or Rails application to their cloud platform.

If you’re using Warbler to package your application into an archive file, then you have even more cloud deployment options. CloudBees, the maintainer of the Jenkins CI server, supports code-hosting, databases, and WAR files in the cloud. Jelastic and Google AppEngine (GAE) provide similar support. To get started with these services, you’ll need to install the warbler gem, and then run the warble war command from your application’s root directory.

The warble war command generates a WAR file, which is essentially a Zip archive file that follows a few conventions. This archive contains everything your application needs to run (including its gem dependencies) on CloudBees, GAE, or Jelastic. All that’s left to do is to deploy the WAR file with the respective platform’s tools.

Each of these solutions, including Heroku and OpenShift, has its own approach to background jobs, databases, and other external components. But you’ll essentially get the same benefits no matter what web server and cloud vendor powers your JRuby application. So that brings us to the basic question: is JRuby in the cloud worth it?

Why Use JRuby in the Cloud?

You may be aware that many of the advantages JRuby has over MRI relate to infrastructure and scalablility. But these features lose their importance when deploying to a PaaS where infrastructure and scalability are managed for you. Instead, the JRuby capabilities that are most worthwhile in the cloud include integrating Java libraries into your apps, writing multi-threaded code (that actually executes in parallel), and having applications interact in ways that were not possible before (such as sharing resources).

These are significant advantages. But there’s also this: you’ll be preparing yourself for the future. MRI won’t become multi-threaded anytime soon, and without concurrency or additional infrastructure the user demand on your application will likely overpower your ability to scale. The easiest way to avoid this problem down the road is to use the best platform now.

Looking Forward

Cloud computing is young, and moving to the cloud can be a bumpy ride. None of the vendors we’ve discussed here support the full spectrum of JRuby’s power. Notable features that are missing include clustering (i.e. the ability to replicate data and share computation across instances) and tooling (such as the Java Management Extensions). But these features don’t exist in an MRI environment anyways. Hopefully, these JRuby vendors will provide them soon.

The missing features shouldn’t stop you from getting your Ruby or Rails application on JRuby, though. Only the JVM can provide your products with the highest levels of performance and up-time. With JRuby cloud support, you’ll be up and running in seconds and you won’t miss the next California gold rush.

Joe is a principal at LogicHaus, a software consultancy specializing in Ruby, JRuby and iOS application development. He's the author of Deploying with JRuby and The Healthy Programmer from the Pragmatic Bookshelf. Send the author your feedback or discuss the article in the magazine forum.

Estimation is Evil

Overcoming the Estimation Obsession
by Ron Jeffries
What you don’t know can hurt you, especially when you convince yourself that you do know it.

Many Agile teams—I believe it’s most Agile teams—get some improvement from applying Agile values, principles, and practices.

These teams do a better job of predicting when they’ll be done, and a better job of being done at the time they predict. They break requirements down into a backlog, they estimate how long items will take, and they burn through that backlog pretty well. Usually by the predicted end of the project, they’re closer to done than they used to be before they went Agile.

Agile teams break down their work into a couple of weeks at a time, and often estimate that work. They usually get done most of what they predict they’ll get done in that iteration. They don’t get too many defects coming back, and they meet regularly to try to improve.

These teams get better transparency, inside the team and with their management and stakeholders. They come closer to shipping on time than they used to. They have fewer defects when they ship. Their management feels that they have more control over what happens.

Teams applying Agile ideas almost always get some improvement. I’d guess that the overall improvement due to Scrum—the most popular Agile approach—is about twenty percent better than what they were doing before.

Some teams do much better, and we’ll talk about what they do later on. Teams that are getting good but not great results are our main concern here, because there are some common elements to what they do, common elements that are holding them back.

These teams are better than they were, but are still undistinguished. Undistinguished teams often seem to have an excessive concern for one or more of these things:

- Completing a pre-defined backlog of work;

- Delivering everything they’re asked for by a fixed date;

- Estimating what they can do every two weeks and keeping to their promises;

- Improving the quality of their estimates;

- Explaining discrepancies between estimates and actuals;

- Improving velocity, their rate of producing features.

In short, these teams are often excessively concerned with estimation, and with living up to their estimates.

These concerns are understandable. Most organizations’ experience with software development is not good. Promises were made and not kept. Projects that were supposed to be done on a certain date dragged on and on, burning valuable time and money. When products finally got done enough to ship, they didn’t meet the vision of those who had asked for them. When users began to use them, they discovered seemingly stupid errors and omissions.

Software development has been quite disappointing to almost everyone who encounters it. That’s why we read about things like the “software crisis” all the time.

It seems quite natural, then, that we would demand that software developers get better at predicting when they’ll be done. It makes sense that we’d use the additional transparency of Agile methods to keep an eye on development, and to hold their feet to the fire, to be sure that they get done what they have promised. It’s only reasonable to demand that they learn to estimate better and learn to hit their estimates. It’s good business to demand that they go faster.

It seems natural. It makes sense. It’s only reasonable. It’s good business. The only problem is: it’s wrong. These are the things that cause an Agile project to be only about twenty percent better than whatever was going on before. Let’s look at why these things hold us back, and at what to do instead.

Starting with All Our Requirements Is Wrong

Most of us were taught to write down all our requirements at the very beginning of the project. There are only three things wrong with this: “requirements,” “the very beginning,” and “all.” At the very beginning, we know less about our project than we’ll ever know again. This is the worst possible moment to be making firm decisions about what we “require.”

Anyone who has ever looked at a list of “requirements” has seen some items that were very important, and some that were—well—not so important. Not so important like 1/100th as important as the most important things. Not so important like downright bad ideas. There is a very strong “80-20” rule at work in requirements lists. The bulk of the value comes from a very small subset of the so-called requirements. So these other things aren’t “requirements” at all. They’re ideas, and some of them are not very good. How could they all be good? We made them up before we began the project, when we knew the least.

Worse yet, when we write down our “requirements,” we act like this is our very last chance to ask for anything. So we ask for everything we can think of, everything we might need. We’re pretty sure we won’t get it all anyway, so let’s ask for a lot and hope we get something we can live with.

Estimating When We’ll Be Done Is Wrong; Forcing the Answer Is Worse

Then we demand that the developers “estimate” when they’ll be done with all this stuff. They, too, know less about this product than they ever will again, and they don’t understand most of these requirements very well. But they do their best and they come up with a date. Does the business accept this date? Of course not! First of all, it’s only an estimate. Second, clearly the developers would leave themselves plenty of slack—they always do. Third, that’s not when we want it. We want it sooner.

So we push back on the developers’ estimate, leaning harder and harder until we’re sure we’ve squeezed out all the fat they left in there. Sometimes we even just tell them when they have to be done.

Either way, the developers leave the room, heads down, quite sure that they have again been asked to do the impossible. And the business people write down the date: “Development swears they’ll be done November 13th at 12:25PM.”

I’m pretty sure no one in the room believes that date. If some people do, I’d like to get a gig going around betting with them against the date. I’m pretty sure I’d be driving a Ferrari real soon now, because this date can’t possibly be right. It’s based on an unrealistic list of requirements, using weak estimates, made at the moment of maximum ignorance, by people who are always optimistic about their own abilities. It has been squeezed down by managers who think they need to be tough, and sometimes it is just overridden by someone who has made a rash promise to someone higher up the food chain.

It’s all right, though. We’ll just keep the pressure on, and they’ll do fine.

Except that they rarely do fine, even in an Agile context. Let’s look at what happens.

Agile Teams Work in Short Iterations; They Pick an Amount of Work that They Forecast They Can Accomplish

Agile processes usually proceed in iterations or “Sprints” of a couple of weeks duration. Every iteration, the team works with their “Product Owner” to select the work for the upcoming iteration. They are supposed to choose an amount of work that they forecast they can accomplish in that time. The emphasis is on “choose.”

Too often, their Product Owner, or a member of management, expresses disappointment with the amount they pick, and encourages them, urges them, or demands that they take on more work. “People need stretch goals,” one of those people said to me when I asked why they had done that.

Does it surprise you to know that if a team has more work thrust upon it than they think they can accomplish, they generally fall short? It shouldn’t. Does it surprise you to know that it is common, only two weeks after someone pushed more work on them, that same someone expresses disappointment that the team has “broken its promise?” It shouldn’t.

Having Demanded the Impossible, Management Asks for Better Estimates

To no one’s surprise, having been overloaded, the team falls short. Nonetheless, management tells the team that they need to improve their estimates. What management really means is that estimates are promises—even forced estimates—and the team needs to keep their “promises,” even if they never promised. The team accomplishes all that it can accomplish. Then management tries to force the team to do more than they can do, demanding that the team “become more productive,” which means “go faster, promise more, and get it done.”

Teams that are asked to do more than they can do will say, “We’ll try.” And they will try. This rarely works out well. To be sure of getting done, they’ll begin to over-estimate everything. In order to get done quickly, they’ll cut back on important aspects of work you can’t see. It’s like sweeping the dirt under the rug. They’ll do a little less testing than was needed. It’s OK, we’ll get a bug report and fix it then. They’ll keep the code a little less clean than it needs to be. It’s OK, we’ll clean it up later, and it won’t slow us down much.

Why should you care? You should care because the defects won’t show up until near the end of the project, or even after the project is released to users. Then you’ll have to do the work that should already have been done to make the code work. You should care because as the code gets worse, the work becomes more difficult and the team slows down. In addition, as the code gets worse, even more defects slip in.

All these things result in a product that is late, delivers less than it might have, has more defects than it needed to have, and that will cost more to maintain than it should have.

“OK, Captain Negative, these things are abuses. But there are legitimate needs for estimates and prediction, so why not rage against the abuses and get on board with the good aspects?”

“What are those good aspects, again? I’ve forgotten.”

“Well. Um. We need to know how long the project is going to take to get done. We need to know how much it is going to cost. So we need to estimate all the requirements and see how many people we need, how much time, and how much money. Then we’ll know when we’re running late and we can, um, do something.

“And, um. Our teams work in iterations. They have to know how much work to take on, and to do that, they need to estimate. And obviously we want them to get better at knowing how much work to take on, so we’ll measure their performance against their estimates and when they fall short we’ll get them to improve.”

There’s our problem: this slope is very slippery. Let’s consider first long-term planning, and then short-term planning.

One of the best-known long-term Agile projects was Chrysler’s C3 payroll, the first Extreme Programming project.

I was once present for an exchange between Sue Unger, then CIO of Chrysler Corporation, the highest-ranking IT executive I’ve ever met, meeting with the C3 team. Kent Beck had just explained how we’d be working in iterations of a few weeks duration, building whatever our “Customer,” Marie DeArment, asked us to build. Ms. Unger asked “How will I know whether you’re on track or not?”

Kent held up our stack of story cards for the payroll. “Here are all the things we have to do. We’ll be adding things as we discover them, and removing any that don’t need to be done. We ask you to visit us every month. We’ll show you these cards, and show you how many are done and how many are left to do. If you’re not satisfied with the progress, cancel the project.”

Sue Unger, the highest-ranking IT executive I’ve ever met, said, “I can do that.” If she can, so can you.

Now the C3 project was a payroll program, and Marie was a payroll expert, so she knew exactly what had to be done. The team had been working on payroll software, so they had a good idea of the need and what it entailed. Even so, we added and removed things over the course of the project, deferring work that didn’t need to be done, and picking up new items along the way. This was one of the best-planned projects I’ve ever seen, and even so, at least one third of the requirements were added, removed, or substantially changed.

Nonetheless, the team, and Ms. Unger, were able to tell whether things were going well enough by looking at the stack of work that was done, and the stack remaining to do.

As students of Agile history know, however, the C3 project was not entirely successful. Despite shipping a number of versions on time, the project was ultimately cancelled. The reasons were largely political, but clearly if the project had been perfect, it wouldn’t have happened. It took us some time to realize that there was a big lesson hiding inside that history.

The C3 project’s purpose was to replace the entire family of Chrysler payroll programs. It didn’t accomplish that. Many years later, the subsequent project to replace the entire family of payroll programs has also not accomplished it. We now realize what should have been done.

We should have replaced the broken bits, one at a time, most valuable first.

The fundamental idea of making a complete list of everything payroll, and clicking through it, was wrong.

Parts of the old payroll programs were just fine, and didn’t need replacing. Other parts never belonged in payroll at all. Some of these, like tax, were recognized as external, and were done using external programs. But other parts were assumed to be part of payroll, and therefore the new payroll couldn’t be released until it included those parts.

This was not the right idea. There was a much better, simpler idea that we didn’t see. There were things Chrysler didn’t like about its existing payroll suite. This part was too slow. That part was done differently in different payrolls. Another part was hard to maintain. And so on. We supposed that the job was to build a grand new payroll program to rule them all. Wrong.

What we should have done, and could have done, was to solve the problems one after another, in the order that Marie and the other payroll people wanted them solved, and deployed those solutions as soon as they were ready. Some of those solutions would have been kept in a central program, and some would have been separate modules. For example, the overall flow of payroll is important, and it should be managed carefully. At some point we would have needed to organize this into what we called “the line.” It’s not clear that we needed to do that first.

Another area that needed work was Chrysler’s savings programs. There were many savings plans, they were complex, and they interacted. We should have written a program, or a series of programs, to deal with that. Those programs needed to interact with the line, but they didn’t need to be part of it.

And so on. We could readily have worked on the problems a few at a time, in the order Chrysler needed them solved. We could have deployed those solutions as soon as they worked. There would be issues with keeping them cooperating, keeping them maintainable, and so on, but we had those problems anyway, and smaller independent modules would have been the right way to address that. We could even have run separate modules on different computers, at different stages in the time-keeping, calculation, disbursement process, and would very likely have produced a more efficient, more modular program.

Had we done that, much of that work would still be running today and only the parts that really needed to be redone would have been redone.

The C3 Payroll, held up as one of the original successes—and original failures—of Agile, would very likely have been more successful had it not assumed that the job was to predict when it would all be done, or even track and project when it would be done. The job was to convene a team to solve the problems of the Payroll organization, and when the return on that investment declined, to move on. More would surely have been accomplished, and quite likely more of it would be still running today.

It’s not ideal to think of our product as a long list of things we must do. It’s not the best idea to predict when we’ll be done, or even project when we’ll be done. The Agile Manifesto calls for Working Software. Take the next problem, solve it with working software. Really solve it, which means getting that solution in the hands of the people who need it. It’s not about planning, predicting, and projecting. It’s about choosing, building, and providing.

Of course there are good ways to use estimation, and to do it. Here are a few:

How Big Is This Project?

It seems that “they” often want to know how long something is going to take, and how much it will cost. My view is that “they” don’t even know what they want, so we bloody well can’t possibly know how long it will take. However, “they” are often powerful and have the money we need, so we need to answer their question, even though we cannot.

Mind you, if you know a way to estimate correctly how long and how much, please just go ahead and do it. In your copious free time, please write it up for the rest of us. Please include true stories of what actually happened on the projects you have estimated that way, including the changes encountered and the lives destroyed. Meanwhile, we’ll just carry on here.

Most of the time, “they” know how many people they’ll give us, and how much time. They do that head-shaking thing until we “estimate” the numbers they have in mind. So we should turn the question around. “How much did you want to spend, and when did you hope to see the product?” Then they tell us, and we decide whether we can do something reasonable within that budget. If we can, we go ahead. If not, we politely decline the business. If we have decided we can’t, then we have an estimate in mind and we should just say what it is. Frankly, it is likely as good as anything we’ll come up with using a more complex method.

If no one knows, and no one has an idea, odds are the project is too vague and too big. Run away. However, if for some reason you enjoy leaping off cliffs hoping to generate a plan on the way down, here’s something to try. Chet Hendrickson and I call it the “Five Card Method.”

Consider the product idea and divide the vision up into about five major topics. Each topic should make business sense: don’t divide it up in some technical way. “Online Bookseller” breaks down into, oh, maybe “Have info on a huge number of books,” “Search, find, and recommend books,” “Shopping Cart and Billing,” “Back-end Picking and Shipping,” “Reporting and Accounting.” Who knows? Find your own five.

Can you estimate any of those five now? You may know a lot about shopping carts and have a good idea how long it will take. If so, estimate those items. For each item you couldn’t estimate, break it down into about five more smaller ideas. Maybe “Search, find, and recommend books” turns into, I don’t know, “Search by Title,” “Search by Author,” “Search by Similarity,” “Search by other customer purchases,” “Search by this customer’s purchases.”

Wow! We can almost write the SQL for title and author. Customer purchases sounds like a join and then a simple summary. Similarity still seems large. So we estimate the ones we understand, and repeat, splitting the ones we don’t.

Generally, within a couple of levels of breakdown, we come up with things we can estimate. Use whatever means of estimation you like.

Then add up the numbers, multiply by any integer between e and pi, and there’s your estimate. Or use your own magical incantations. It almost doesn’t matter.

It almost doesn’t matter because this is still an estimate. It’s a very weak estimate. It’s pretty much guaranteed to be wrong. But it might be large enough to let you get started, and start making fine-grained decisions on what to do next and what to defer. Do the Agile thing, producing a running system every couple of weeks. Maybe your first version only knows four books, has a trivial shopping cart, charges everything to your boss’s credit card, and sends an email to James in the shipping department to go to the local book store, buy the book, and stop at the post office on the way back to the office.

No, I’m serious. Why not have a full product that does very little at first, then more and more? Each time we look at that product, we see what to do next.

How Much Work Should We Accept This Time Around?

An Agile team needs to decide how much work to accept into its next iteration. One way to do this is to look at each proposed work item and estimate how much time it will take to do. Add up those times to get a quick check on the proposed iteration backlog.

It can be tricky just adding up times. No team gets eight hours a day of work on task, so you have to decide how to adjust. One way is to keep track of how you do against your estimates. It might be best to consider how much time you actually spent working on the thing—that is, did it really take you four hours of work to do it—and to consider how much time elapsed before your got your four hours in. Sometimes it can take days to get four hours’ work done.

You’re on a slippery slope here, so beware. It will be tempting for people to ask why it takes two days to get four hours’ work done, and to demand that people work harder, go faster, and so on. This is the edge of the cliff we’re concerned about. Keep concerns and analysis inside the team.

There are a number of ideas about how to estimate using something other than time. Points, Gummi Bears, Fibonacci numbers, T-shirt sizes. These were originally invented to obscure the time aspect, so that management wouldn’t be tempted to misuse the estimates. (I know: I was there when they were invented. I may actually have invented Points. If I did, I’m sorry now.)

There’s a good idea hidden inside these methods, which is to compare one feature idea to another and think about whether it is “larger” or “smaller,” and to classify the features into groups. With a couple of measurements of how long these similar items take, a team can learn to estimate quite quickly and effectively.

Remember, though. We are doing all this to decide how much work to take on in an iteration. We might want to improve our ability to do that, and we might benefit from thinking about why we thought that thing would be easy and it turned out to be hard. At the end of the day, however, teams who look at the work, discuss, look each other in the eyes and say “this much” do just as well as those who spend a lot of time in numerology. Often they do better, because teamwork and commitment are more powerful than number crunching.

So what’s my advice? It’s really pretty simple. It’s probably hard to do. You need to find your own way, but here are two decent ways to go. The second is far better than the first.

Good, But Not Ideal: Pick Your Delivery Date; Deliver Every Week from Now Until Then

The “big guys” have a date in mind. In the rare case where they don’t, pick one yourself. Pick it to be soon enough that no one can possibly get impatient waiting for your project to complete. Count your people, multiply by the time available. Guess about what you’ll have by then, with about five major items. If you must, break them down. Keep them vague: you need the room to steer. Voila! You now have a budget, complete with estimates.

Now get yourself a “customer” or “product owner” who can make decisions on what to do next and what to defer. Work in very short cycles. Two weeks. One week. One feature at a time, in two days. Short. Do features from most important to least. Every time a feature is done, or at least every two weeks, build an integrated, tested version of the software. Show it to everyone. If possible, get it to users who need it. If your software is slated to save lives, save some lives with it. Observe what happens. Factor that into what you do next.

You’re shipping a complete product now, every week or two. When the deadline arrives, it’s just another shipment. If everyone is satisfied, and likely they will be, stop. If they want more, you’re all set to do more, every two weeks.

Ideally, Skip Estimating; Just Build Something Now

Why not start every product with a simple experiment? Do we think it’s pretty simple? Take a real product visionary as a product owner, and have them sit with a few developers for a week or two to build something. Then ask yourself whether to go ahead. Is this a bigger project, possibly taking six months or a year? Then build in two-week iterations for a few cycles. See where you are. If it’s good, go ahead. If it’s not, stop.

Seriously. Put a person who understands the problem right in with the people who understand how to solve problems, and solve problems in the order that seems most important. Ship everything you do right away. See what the users say, see what the market says. Adjust.

Are there “issues” with this approach? Sure. You have to be very good to do this. You need to have someone who can take a good guess at what is needed, and a team that can build it rapidly, at high enough quality to give it to users really quickly. And you need to know how to build software that is soft enough, malleable enough, to grow smoothly as it needs to. The technical side of this is well understood. The decision side—the customer side—is not, but waiting won’t make it better. Get the product out there and see what happens.

This approach shortens all the cycles that delay getting value. It shortens the communication lines between the people who want things and the people who do things. It shortens the communication lines between the people who create things and the people who use them. Take the most important ideas, build them quickly, get them out there.

Yes, it’s hard to do. That’s why it’s best. Stop estimating. Start shipping.

Ron Jeffries has been developing software longer than most people have been alive. He holds advanced degrees in mathematics and computer science, both earned before negative integers had been invented. His teams have built operating systems, compilers, relational database systems, and a large range of applications. Ron’s software products have produced revenue of over half a billion dollars, and he wonders why he didn’t get any of it. Send the author your feedback or discuss the article in the magazine forum.

The Five Cs of Offshore Communications

What You Don’t Know Can Hurt You
by Nick Krym
Offshore project success often comes down to communication. Chances are, you could be doing it better.

Whether your offshore project succeeds or fails often depends almost entirely on your communications with your teams.

It was the first time my friend Nour, a founder of an innovating on-line services company in Canada, saw the demo of the system that was being developed for her by a team in India. She spent over two months in face-to-face sessions and Skype discussions with the team communicating the requirements for the site and now was looking at the first batch of functionality. After 15 minutes into the presentation she was about to scream or burst in tears. “It’s not at all what I told them to do. They misunderstood every basic concept! My requirement documents explicitly spelled out...” Sounds familiar?

Outsourcing success depends often almost solely on the ability to maintain effective communication channels between your local and offshore teams. Given that the communication abilities of your offshore personnel are at best unknown and their tenure will be brief, the responsibility for maintaining communication lies squarely with you.

To build communications that enable you to use your offshore team effectively and efficiently, you need to learn how to navigate the five seas (Cs) of communications. These five Cs are:

- Conciseness

- Clarity

- Completeness

- Cross-cultural aspects

- Consideration

Let’s take a closer look at each of these Cs.

Conciseness

Concise communications are both time- and cost-saving, they radiate respect for your audience, and they leave less room for misinterpretation.

Contrary to the common belief that over-communicating is better than under-communicating, the fact is that every element of communication is a potential liability. The flabbier your communication is, the greater the chances it will be misinterpreted. The cultural, organizational, and language differences of your offshore team will exacerbate the possibility that any additional instruction that was intended to add clarity or act as illustration will only cloud the issue.

Here are a few guiding principles for staying concise:

- Limit email size—recipients should need no more than 10 seconds to read it.

- Aim for no more than two lines per sentence in printed documents.

- Use one page for install instructions, checklists, system diagrams, and other technical instruction.

- Use no more than seven bullets to communicate / support your idea.

- Limit presentations, recurring meetings, and conference calls to 30 minutes.

To make your communications more concise, expand this list to cover the communication media you employ, and enforce it across all communication channels with your local and offshore teams.

Clarity

The first steps towards improving Clarity are brevity and focus. Try, for example, the “one point per email” rule. If you want to thank your team member, request that he review some piece of code, and ask for advice on shopping in Mumbai, you’ll get much better results by sending three short emails instead of one.

A critical step to providing clear communications is using vocabulary that everyone understands. Even if your outsourced team is located in another English-speaking country, don’t use complicated words when simple words will do.

Be aware of language differences. English probably isn’t the mother tongue for most of your offshore team, even if the team is based in India, so be extremely careful how you communicate. Avoid slang, even professional lingo. Most novice language users tend to interpret / translate language literally, as if they were reading the first entry in a dictionary. Just imagine how using a dictionary to understand “Please bounce the server” would work.

Minimize the use of proverbs, sayings, euphemisms, and idiomatic expressions. They make understanding your speech for non-native speakers tenfold more complex. Look at it from someone else’s point of view: what would you think if your manager told you to stop “putting noodles on my ears?” That’s a common Russian idiom for “feeding me a bunch of baloney,” or “misleading.”

Finally, be concrete. Stick to facts, specific figures, and metrics. In particular, this is important when you give directions to your team, do a root-cause analysis, or provide feedback.

Completeness

No matter what communication channel you use, you must provide your audience with everything they need to comprehend your message and take appropriate actions. Not doing that is probably one of the most common mistakes of rookie managers—and overdoing it is probably the second most common. “Guys, we need to kick off this project. Get the stakeholder buy-in, requirements, and... You know the drill!” Well, chances are, they don’t.

One of the difficult aspects of being complete is maintaining the balance between providing “not enough” and “too many” details. You do not want to assume that your audience knows the subject as well as you do.

Skipping over items that your local team takes for granted may turn out to be a lethal mistake with an offshore team. (“Oops! We didn’t know that we have to put code in a source control.”) On the other hand, nobody likes the guy who starts telling you how to build a watch when he’s asked what time it is. So, how do you give your offshore team enough rope to do the job but not so much that they hang themselves?

To ensure that your communications are complete, try using templates. Think of replacing an email-based bug submission process with a dedicated defect-tracking system. One of the best aspects of that is a strict template with a number of mandatory fields. That ensures completeness.

Using a similar approach in every aspect of your communications will do wonders. For example, create a template for a status report you expect from your team members. Start your email with a simple outline that enforces the completeness of the message.

For high impact, complex, or large-audience communications, ask for help. A fresh pair of eyes could review your drafts, provide feedback, and eliminate ambiguities. Think of code reviews or pair programming—there are good reasons we use those tools. And the cost of misunderstood communication could be far more significant than clunky code.

Cross-cultural Aspects

Even working with a team from your own city may introduce “cross-cultural” challenges—just think of communications in startups compared to large corporations. Stretching your communication channels around the world makes these challenges far more significant. Understanding a few important concepts will help.

One important idea is Geert Hofstede’s concept of the Power Distance Index (PDI), presented extremely well by Malcolm Gladwell in Outliers. PDI measures the extent to which the less powerful members of an organizational hierarchy accept and expect that power is distributed unequally.

In low-PDI cultures, boss and employee communicate as if they are at the same level of a corporate pyramid. As the value of PDI grows from country to country, the boss moves into a corner office or to the top floor, becomes master and commander, even royalty, and at some point, a divine authority. In cultures with a small PDI, an entry-level employee can chat with the CEO in a cafeteria. But in cultures with high PDI, even a single step on a corporate ladder can create a master / slave relationship.

Implications of PDI on communications are difficult to overestimate. If an employee is at the same level as her boss in terms of cultural hierarchy, they tend to collaborate. A straightforward question gets a straightforward answer. When the boss is wrong, the employee has no qualms about pointing it out. That is unacceptable in cultures with high PDI, where open disagreement with a boss hovers on a border of a crime.

PDI is particularly relevant to outsourcing projects since the “buyer” countries tend to have relatively low PDIs—for example, the USA (ranked 40), UK (35), and Germany (35), while “provider” countries are predominately on the high side—for example, India (77), China (80), and the Philippines (94).

To minimize the damage that a PDI difference can inflict on your engagement:

- Educate yourself and your staff, especially employees with low-PDI background.

- Develop communication vehicles that inhibit PDI-related miscommunications.

- Adjust project lifecycles to minimize potential damage and insert elements minimizing the impact.

Another of Hofstede’s concepts is comparing the measurement of the degree of Individualism to Collectivism—that is, the degree to which individuals are integrated into groups (IDV). In cultures with a higher value of IDV, people stress on personal achievements and individual rights, while people from countries with low IDV tend to form strong, cohesive groups that shield or mask individuals’ contribution and performance—and distribute rewards to the group.

As with PDI, we find a significant difference between IDV value for “buyers” such as the USA (91), UK (89), and Germany (67) and “providers” such as India (48), China (20), and the Philippines (32).

The most important impact that IDV has in offshore outsourcing is in the way the teams are perceived, built, and managed and then how individual performance is recognized and how employees are motivated.

Hofstede describes three other cultural dimensions that are worth researching as well: masculinity (which measures gender role in society), uncertainty avoidance (which measures tolerance for uncertainty) and long-term orientation. The last one has significant implications that go far beyond instant gratifications or ripping long-term benefits.

Probably rooted in one of Hofstede’s dimensions is how the approach to delivering bad news is stunningly different in different cultures. In the States, giving bad news—such as telling a patient, “you have cancer”—is considered normal medical practice. In some Eastern European countries, this declaration is highly unethical and even could be illegal.

The difference in approach to delivering bad news plays a significant role in offshore engagement. When things go wrong, don’t expect your provider to rush to deliver you the account of events. Chances are you’ll need to apply modern torture techniques to get even a hint of what happened. No matter how often you tell your offshore team that “bad new doesn’t get better with age,” you still could be the last one to know.

One of the incarnations of “bad news avoidance” is reluctance to confront the issue or to say “No.” You ask your offshore coordinator a simple question: “Can you get this task done in time?” You hear “Yes” in return. Don’t jump to assume that “yes” means that the task can be done in time. “Yes” is just a brief way of saying: “I heard you. I’ll take your request into consideration, and I’ll see what we can do.”

Your best bet in communicating with an offshore team that exhibits strong signs of “bad news avoidance” is to:

- Identify the risks and risk mitigation techniques. Then create an environment where the risk mitigation, problem prevention, and early warnings are considered a great achievement.

- Do not ever get visibly upset about bad news. Accept it as an exciting challenge instead. You can significantly reduce the perceived severity of the blow that bad news delivers by exhibiting troubleshooter mentality.

- If you must ask a closed-ended question, always follow up with an open-ended discovery: How will you go about it? What resources would be involved?

Finally, think about who is responsible for the message. In Western cultures, it’s the speaker. We tell our conversation partner what we think, and we assume that our message is understood. In the East, the speaker gives the conversation partner the courtesy to process the message by themselves. In an offshore scenario, this idea is particularly important when you are the listener. A simple hint on the difficulty of a task could mean that the listener is really giving you a resounding No—so a comment like “This task may require some research” could translate as “No way it could be done in this time!!!”

Consideration

In communications, “consideration” means understanding and considering your audience and implies that you need to step into their shoes and see things from their point of view. Several points are important here.

Working remotely has plenty of challenges. You might be annoyed with the accent of your developers from a faraway country, or how they misinterpret everything you say. But the same thing happens on the other site of the Skype calls—your perfect English is a foreign language to them. Time differences, convoluted requirements, vague statements, conflicting messages—your offshore team has to cope with all that, and they can’t even complain, since you are the customer and thus always right.

Remember that your team is “the servant to two masters”—they have to keep you and their own bosses happy, and yes, sometimes that causes serious conflicts of interest. Just consider the most obvious one: you want your team to get the project done faster. The vendor wants to extend the project to get more billable hours. And your developer is squeezed in between.

One more aspect of Consideration deserves further discussion. Your offshore team comes from a different culture that has its own rules of conduct and behavior. It is important not to push your team members to break these rules or put them in a position where they are affected by your behavior that could be considered unacceptable. To illustrate, think about the cultural phenomena we know as “saving face.”

Saving face is a core social value in many offshore provider countries, particularly in Asia. It is a drive to avoid humiliation or embarrassment, to maintain dignity or preserve reputation. For those of us who have not been exposed to this concept from early childhood, crossing that boundary and causing someone to lose face is easy to do. An innocent joke or off-the-cuff remark can turn into a significant issue for someone on your offshore team. As a result, you could lose a valuable team member or—even worse—gain a hidden adversary, who will strike back when you least expect it.

To minimize the chance of causing someone to lose face, never point out anyone’s mistakes or accuse anyone of lying or wrongdoing in public. Err on the “higher respect” side, especially with elders, and people of rank or authority, and stay professional even in casual settings.

Giving ongoing attention to the five Cs of communications—Conciseness, Clarity, Completeness, Cross-cultural aspects, and Consideration—will help you increase productivity of your offshore team, reduce risks of engagement failure, and greatly improve overall outcomes of your outsourcing initiatives.

Nick Krym is a technology professional with more than 25 years in the IT industry—20 of those in offshore outsourcing with companies and freelancers from Asia, Latin America, and Eastern Europe. His experience spans a broad range of technologies in delivering mission-critical systems to Fortune 500 clients, commercial off-the-shelf products, and applications delivered under an SaaS model. Send the author your feedback or discuss the article in the magazine forum.

Launching a Gonzo Engineering Project

II: Just Do Something
by Steven K. Roberts
The infamous 580-pound, 105-speed BEHEMOTH, with Mac, SPARC, and DOS environments as well as satellite datacomm, HF/VHF/UHF ham radio, heads-up display, head mouse, handlebar keyboard, 6-level security system, speech synthesis, 72 watt solar array, and deployable landing gear to keep the monster upright on killer hills. The bike now resides in The Computer History Museum.

This is the second installment in a series of articles unlike anything we’ve ever published. Steven K. Roberts has figured out how to live passionately, pursuing crazy dreams and building fantastic machines (like BEHEMOTH and Microship, both of which are pictured and briefly described here) and going on amazing adventures. He calls what he does Gonzo Engineering, and in this series he tells you everything you need to know in order to pursue your own crazy gonzo engineering dream.

Formal Tools, Briefly Considered

Sometimes I wish I could claim that Microship development had been a tightly managed progression in which, beginning with a vaporous initial concept, we generated increasingly refined formal specification documents, mapped everything onto a PERT chart to establish dependencies, used that to drive human resources and purchasing departments, then underwent a tightly scheduled fabrication and coding phase focused on milestones and design reviews. That’s how big companies claim to do it... and, hey, we even have some nifty project-management software that knows how to convert TO-DO lists into pretty pictures.

During the BEHEMOTH era, I spent a very interesting afternoon at Trimble Navigation, makers of the bike’s GPS. These weren’t colorful, user-friendly handhelds wrapped around off-the-shelf chipsets back then; they were extremely complex DSP engines coupled with RF hybrid black magic that pushed just about every envelope in the book. I remember being captivated by a massive floor-to-ceiling PERT chart, spanning an entire hallway, the completed boxes bright yellow, the web of interconnections revealing Deep Understanding of the design process and accurate predictions of every step remaining.

“I should do this for the bike,” I mused to my host. “It looks like a great tool.”

“Nah,” he replied. “Project management tools assign resources to tasks. You work alone. Just do something.”

He was right. Even with first-class volunteers and occasional contract help, Nomadic Research Labs is a tiny operation, a de facto non-profit, beset by overload and bad work habits, constantly challenged by such fundamental issues as demotivation, distraction, and lack of funds. A PERT chart in this environment would be masturbatory, and would presuppose a stable design.

Engineering in a Nutshell

What actually happened was much more organic, and I’ve noted with amusement that, despite protestations to the contrary among the engineering population, it’s typical of the way things usually work in industry. Here’s how to manage a huge, complex project:

1. Accept going in that your first tentative decomposition of the fundamental concept will yield an over-simplified TO-DO list, distorted by misunderstanding of key issues.

2. Avoiding all the items labeled TBDWL (To Be Dealt With Later) or ATAMO (And Then A Miracle Occurs), dive headlong into the well-defined parts, finishing some of the electronic design so early in the game that it is guaranteed to be obsolete before the physical substrate is built.

3. Blunder ahead on the non-obvious parts, getting pleasantly distracted by learning curves and occasional moments of certainty, only to discover basic flaws in your reasoning.

4. Now that you are forced to re-think the initial concept, map it onto newly recognized reality to yield a fresh TO-DO list (with new lab notebooks and computational tools to keep things lively) and another cycle of enthusiastic activity.

5. Repeat steps 3-4 countless times at varying levels of abstraction ranging from the entire system down to individual components.

6. Meanwhile, since technology evolves with frightening rapidity, acknowledge the fact that any computer-based system is such a moving target that if it’s not completed quickly, it will be irrelevant by the time it ships.

7. Respond by simplifying the design, further refining your objectives and abandoning dead-end ideas while doggedly pursuing others that have come to represent too large an economic or emotional investment to allow a graceful retreat.

8. Compromise here and there, bang out a few things that weren’t on the list, then add them and cross them off to make yourself feel good.

9. Get totally sidetracked a few times, and periodically dive into major development marathons to meet public deadlines like trade shows, pulling all-nighters in PFD mode (Procrastination Followed by Despair).

10. Announce new completion dates whenever a previously predicted one has passed, and keep driving your PR engine to maintain interest during a process that is a textbook illustration of Hofstadter’s Law (“Everything takes longer than you expect, even when you take into account Hofstadter’s law.”)

Part of this development heuristic is just sloppy management, but it also reflects the way we think. This is why engineering is, at its heart, an art form (and why the average completion time of a home-built boat is 135 years).

Perhaps the most interesting thing about this seemingly ugly process is that it’s iterative and self-correcting. Grandiose or stupid ideas may not be obvious during first-pass blue-sky analysis (when the project is glued together by wishful thinking), but it’s another story entirely when it all has to be converted into Clearly-Defined Tasks (CDTs) and drawings that make sense to machinists. Without some kind of closed-loop intellectual process to fine-tune your thinking, it would be impossible to get to the point where you can start using engineering tools to convert fantasies into contraptions.

Trying to shortcut this by starting on Day One with formal design methodologies can have the catastrophic effect of committing you to an ill-defined goal state, whereupon the end result is shaped more by your toolkit than by the supposed objective. That’s why so many products seem malformed, patched, and otherwise inelegant: management loves formal methods and looks askance upon such frivolous notions as approaching product design as a delicate blend of art and engineering.

So it appears that designing a system isn’t nearly as rigid a process as typical engineering textbooks would have you believe. Your component choices affect the shape of the thing you’re building; said shape in turn creates constraints that affect your choice of components. Such psychological race conditions can only be resolved by tweaking the granularity knob while adding inputs to your evolving mental model, until the correct solution congeals in a flash.

It’s easy, and here’s how to do it: Prop your feet up on your desk, relax, and form a fantasy of the desired results. Now turn it slowly in your head while calmly examining it from all sides, allowing input variables to float until an unanticipated combination satisfies your psychic fantasy-comparator and generates a flash of recognition. Since all your noodling is saved in a big circular buffer called short-term memory, let this recognition event pre-trigger a snapshot of the conditions that immediately preceded it (before accumulated pondering-propagation delays introduce conceptual drift). There’s your design specification. Take that and run with it!

This is probably not an engineering methodology that makes managers comfortable, though it’s a good summary of life in the trenches. There is a pervasive myth that structured methods and sequential procedures, used in isolation, will get you there... but I’ve never seen it work that way. The tools don’t actually start to become useful until you’re quite thoroughly immersed, and that can take weeks of appearing, to outside observers, as if you are loafing.

The Microship, the result of an 8-year development project involving extensive sponsorship, students, and volunteer teams. This is an amphibian pedal/solar/sail micro-trimaran with retractible wheels, hydraulic systems, 480 watts of peak-power-tracked solar panels, and zippy performance under sail. BEHEMOTH, the Microship, and the later Nomadness project are all documented at microship.com.

A Sense of Urgency

Speaking of time, there’s another big difference between gonzo engineering and life in industry. Schedules and deadlines, the X-axis of project management, are anathema to the independent worker. Don’t tell me that I have until Monday morning at 9:00 to hand you a report on the solar array thermal retrofit; I’m still in the wall-staring phase on that one and expect to be here for days! I might emerge occasionally to troll the web for prior art to steal, get distracted by other parts of the project, or just say “screw it” and go sailing on a friend’s catamaran in the name of research, but a deadline? Imposing order on the project would send me on a search for something better suited to my interpretation of the term “work.”

Alas, life isn’t like that in a corporate environment, where people actually pay you to behave. Critical-path management, release dates, pre-production prototypes, purchasing cycles, trade shows... there are countless reasons why the long-suffering denizens of cubicles and labs are not given free rein to go with their instincts. But despite the importance of scheduling in coordinating a complex enterprise, there are huge costs involved: design compromises, sneaky shortcuts, employee burnout, kludged patches, bad assumptions, useless documentation, and incomplete testing, just to name a few. This is analogous to sailing: it is well understood that a sailor with no schedule always has fair winds. The people who find themselves calling MAYDAY in a Force 10 gale are usually those who have decided to push their luck for some time-related reason: they’re in a race, vacation’s almost over, the crew has to reach port in time to use a return ticket, or some arbitrary schedule laid out over charts and cruising guides in a cozy den long ago is now affecting the skipper’s judgment.

Working alone and with volunteers on something that will be done when it’s done (and not before), we have the luxury of ignoring the calendar—although with that comes the dangerous temptation to give in to the dreaded BEHEMOTH Effect (“Hey, here’s a cool gadget; let’s see how we can integrate it into the system!”) Somewhere in there is the right compromise, but we are going to assume that when you’re building your life around the Ultimate Project, schedules are not a factor.

Convenient, eh?

Economics

Finally, let’s talk about money. From an engineering perspective, this can be even more annoying than time—there’s nothing like “aggressive cost minimization” to take all the fun out of a design. Fortunately, one of the intrinsic features of passionate dream-chasing is that everything else is secondary, and it’s thus easy to justify spending as much as you have (and then some). Combine this with poverty consciousness, and one can get amazingly creative at scrounging. In addition to all the expensive bits from West Marine and McMaster-Carr, our crazy research vessel contains thousands of parts that were donated, bought surplus, extracted from dumpsters, horse-traded, repurposed, cannibalized, or fabricated on the cheap. But one issue that never came up was worrying about manufacturability and component cost. There’s a sort of certainty here that is immensely liberating:

“This is the most important thing I can possibly be doing, so it doesn’t really matter what it costs to get the job done. I’ll afford it somehow.”

Next up: The Business Angle.

Steven Roberts was the original “technomad,” covering 17,000 miles around the US on a computerized recumbent bicycle from 1983-1991 while publishing tales via CompuServe and GEnie, then extending the same design objectives to water with an amphibian pedal/solar/sail micro-trimaran that consumed all available resources until 2002. As is typical of homebuilt boat projects, however, by the time it was finished he didn’t really want to do that anymore... so he has since made the transition to a full-time life aboard a 44-foot steel pilothouse sailboat, and is now based in the San Juan Islands north of Seattle. The ship is extensively networked with embedded data collection and control systems, streaming telemetry, and a user-interface layer reminiscent of the Enterprise... with a wrap-around console that includes communications, R&D lab, audio production studio, and a piano. Roberts has published 6 books ranging from travel and adventure to microprocessor design, and prior to becoming a technomad spent a decade developing custom industrial control systems, early home computers, and other paleo-geekery. More on his technomadic projects can be found at microship.com (with the new boat at nomadness.com). He is publishing the ongoing technical narrative of the new project as a monthly PDF “Nomadness Report,” as well as a series of Boat Hacking design packages detailing the subsystems. Send the author your feedback or discuss the article in the magazine forum.

Flashback

Bill Gates on Writing and Selling Basic to MITS
by Michael Swaine
I was going through my files and found a 1983 interview with Bill Gates about writing and selling his first BASIC.

Paul Freiberger and I are currently writing the third edition of Fire in the Valley, our history of the personal computer—to be published by The Pragmatic Bookshelf, naturally. In the process I came across an interview we did with Bill Gates back in 1983 about writing and selling the original Microsoft Basic to Ed Roberts of MITS for the Altair.

For those who don’t know the story, Ed owned a hobby electronics products company in Albuquerque, New Mexico, and had been nearly wiped out in the early 1970s when Texas Instruments started selling calculators for little more than the price of the processor inside. Ed’s company, MITS, had been selling build-your-own calculator kits into the hobby market, and believe it or not that had been a lucrative business. But now MITS was on the ropes, and Ed’s brainstorm to save the company was to build a kit computer. At the time this generally regarded as a pretty crazy idea, but Ed got a sweetheart deal on chips and a smart engineer named Bill Yates and a sympathetic banker and a cover story on Popular Electronics, and it all came together in 1975. Paul Allen saw the magazine cover in Harvard Square that January and ran to tell his pal Bill that the thing they’d been hoping for was happening and they had to jump on board.

Here’s Bill telling about that:

“Roberts has this bankrupt company, makes the computer, crazy idea, they project they’ll sell 3000, they get the orders for 10,000. So we call them up in January and say—well, we had a fairly aggressive posture, we said, ‘We have a Basic, do you want it?’ And he said, ‘Oh sure, sure, a lot of people call me up and tell me they have stuff. Why don’t you come down and show it to us?’ We say, ‘OK, sure, fine, in two or three weeks we’ll come down and show it to you.’

We get the instruction manuals, because we never had the specific one. Paul writes a simulator in macroassembler, I write the Basic. Three weeks I call the guys up. It was a subset of our Basic. It was essentially the 4K Basic, but it was quite an effort and a lot of fun to go back into that clear goal, clear way of measuring success mode and just work. I stayed up the whole time, virtually. And enjoyed it a great deal.

“So we wrote the thing and then we called up Roberts and asked, ‘Hey, how do you read characters in and out of this thing?’ He said, ‘You’d better talk to Yates.’ So Yates gets on the phone and he says, ‘You really want to know that, huh? You’re the first to ask. Maybe you guys really have something.’

“Because everybody was promising these guys software. It’s so easy to do.”

The Quiz

Code in Code
by Michael Swaine
Here’s a short program. It is an example designed to introduce a particular programming language, published on the website for the language, and written by the language’s author. The only modification I’ve made to it is to encrypt the letters with a simple substitution cipher. All numerals, punctuation, spacing, and capitalization remain unchanged. Oh, and ignore any colorizing: that’s just decoration added by our build system.

What is the language?

CGYTU [

Vnvug: "Inrnvku Xutxf"

Zgcbntj: 1.3.3

Kavptc: "Xkcu Bkbbgjckvp"

Hachtbg: {K bnqhug inrnvku xutxf.}

]

w: ukmtav [

tcnrnj 0

y: ykjjgc 140o32 ckvg 1

gwwgxv [rckingjv 0o1 0.0.150 0.0.50]

wggu [gjrkrg: wajx [w k g]

[bgv-wkxg y jtd/vnqg]]

]

cgbnsg: itgb [

y/bnsg: qko 20o20 qnj 1000o200 w/bnsg

y/wtjv/bnsg: qko 24 w/bnsg/m - 40

y/vgov: "Cgbnsg Qg"

y/bnsg/o: 1024 ; wtc bnsg-vgov

y/bnsg/o: 20 + wncbv bnsg-vgov y

w/bnsg: y/bnsg

bptd w

]

zngd/thvntjb/jgd w 'cgbnsg

cgbnsg

njbgcv-gzgjv-wajx [

nw gzgjv/vmhg = 'cgbnsg [cgbnsg]

gzgjv

]

it-gzgjvb

Solution right here next issue. Or on Twitter right now, no doubt.

Solution to Last Issue’s Quiz

In January, we presented seven quotes from famous programmers. Your first challenge was to name the author of each quote, and your second challenge was to say what these programmers have in common. The programmers, some of whom were responsible for more than one quote, were: Microsoft co-founder Paul Allen, Virtual world designer Richard Bartle, Quicksort creator Tony Hoare, Algorithm analyzer Donald Knuth, Pac-Man creator Toru Iwatani, and Sims creator Will Wright.

These characters doubtless have many things in common, but what I had in mind is that they were all born in January. So here are the quotes, paired with their authors and their birthdays:

- Beware of bugs in the above code; I have only proved it correct, not tried it. -Donald Knuth, 1/10.

- I'm not saying we purposely introduced bugs or anything, but this is kind of a natural result of any complexities of software... that you can’t fully test it. -Will Wright, 1/20.

- We didn’t have to pay for the time as long as we could find bugs in their system and report them. -Paul Allen, 1/21.

- There are two ways of constructing a software design. One way is to make it so simple that there are obviously no deficiencies. And the other way is to make it so complicated that there are no obvious deficiencies. -Tony Hoare, 1/11.

- I’ve always been fascinated with the idea that complexity can come out of such simplicity. -Will Wright, 1/20.

- First of all, the kanji word “taberu,” to eat, came to mind. Game design, you see, often begins with words. -Toru Iwatani, 1/25.

- The most important thing in a programming language is the name. A language will not succeed without a good name. I have recently invented a very good name, and now I am looking for a suitable language. -Donald Knuth, 1/10.

- You know your time has passed when you become a question in a general knowledge quiz. -Richard Bartle, 1/10.

Calendar

Want to meet one of our authors face-to-face? Here’s where they’ll be in the coming months.

Here’s what our authors will be up to in the coming months.

- 2013-02-02, Detroit Mobile City
Core Audio Introduction Chris Adamson (author of iOS SDK Development)

- 2013-02-02, FOSDEM 2013
Live pair programming with Julien Biezemans, lead developer of Cucumber-JS Matt Wynne (author of The Cucumber Book and Cucumber Recipes)

- 2013-02-04, BDD Kickstart, Brussels
Get a flying start with BDD, the collaborative process that's changing the face of software development (with Julien Biezemans) Matt Wynne

- 2013-02-04, JFokus - Sweden
Workshops and talks on Functional Programming and JVM related languages Venkat Subramaniam (author of Practices of an Agile Developer, Programming Groovy, Programming Scala, Programming Concurrency on the JVM, and Programming Groovy (2nd edition))

- 2013-02-08, NEScala 2013, Philadelphia PA
Building Scala Hygienically with Pants. Describing a new, bottom-up build system that allows developers to statically declare build dependencies. Mark Chu-Carroll (author of Good Math)

- 2013-02-11, Trondheim XP og Agile Meetup
Kom og lær Ruby! Paolo Perrotta (author of Metaprogramming Ruby)

- 2013-02-18, DevNexus - Atlanta
Talks on Java 8 and also CoffeeScriptVenkat Subramaniam

- 2013-02-20, RubyConf Australia
Full day Advanced Ruby tutorial Dave Thomas (author of Programming Ruby (2nd edition), Programming Ruby 1.9 (3rd edition), Agile Web Development with Rails (3rd edition), The Ruby Object Model and Metaprogramming, and Agile Web Development with Rails (4th edition))

- 2013-02-21, RubyConf Australia
KeynoteDave Thomas

- 2013-02-26, Agile India - Bangalore
Workshop and talks on Agile technical practicesVenkat Subramaniam

- 2013-02-28, Big Ruby Conf -- Dallas, Texas
Build a Bigger Brain: How Healthy Living Makes You Smarter Joe Kutner (author of Deploying with JRuby and The Healthy Programmer)

- 2013-03-01, Joy of Coding, Rotterdam, Netherlands
Java is from Mars, Ruby is from VenusPaolo Perrotta

- 2013-03-01, The Joy of Coding - Rotterdam, the Netherlands
Keynote at a conference focused on developer joy Chad Fowler (author of The Passionate Programmer (2nd edition) and Rails Recipes)

- 2013-03-04, SpeakerConf - Aruba
An opportunity to hang out with fellow speakersVenkat Subramaniam

- 2013-03-07, CocoaConf Chicago
Mobile Movies with HTTP Live StreamingChris Adamson

- 2013-03-07, AgileIndy Conference
Tutorial: Agile Project Management: Do You Have What it Takes? Johanna Rothman (author of Behind Closed Doors, Manage It!, and Manage Your Project Portfolio)

- 2013-03-07, CocoaConf Chicago
Game Dev WorkshopJonathan Penn

- 2013-03-07, CocoaConf Chicago
iPad Productivity APIs (All-Day Tutorial)Chris Adamson

- 2013-03-07, CocoaConf Chicago
Core Audio in iOS 6Chris Adamson

- 2013-03-08, NFJS - Minneapolis, MN
Talks on HTML 5 and JVM languagesVenkat Subramaniam

- 2013-03-08, CocoaConf Chicago
Zen and the Art of iOS Gesture RecognizersJonathan Penn

- 2013-03-08, AgileIndy Conference
Keynote: Agile ManagementJohanna Rothman

- 2013-03-09, CocoaConf Chicago
UI Automation - Automate ALL THE THINGS!Jonathan Penn

- 2013-03-13, 33degree - Warsaw, Poland
Various JVM languages related topicsVenkat Subramaniam

- 2013-03-20, Pragmatic Studio, Reston, VA
Three days, two presenters, one objective—to get you up and running with Rails Dave Thomas

- 2013-03-21, CocoaConf DC
iPad Productivity APIs (All-Day Tutorial)Chris Adamson

- 2013-03-21, CocoaConf DC
Mobile Movies with HTTP Live StreamingChris Adamson

- 2013-03-21, CocoaConf DC
Core Audio in iOS 6Chris Adamson

- 2013-03-25, #inspect 2013 - Brussels, Belgium
CoreData In Motion - An overview of how CoreData works, when to use it, and how to use it in RubyMotion Jonathan Penn

- 2013-03-28, #inspect, Brussels Belgium
Wrapping RubyMotion - Discussing techniques for making Objective-C APIs more pleasant in Ruby Clay Allsopp (author of RubyMotion)

- 2013-04-04, DenverJS - Denver, CO
JavaScript related topicVenkat Subramaniam

- 2013-04-04, Ancient City Ruby, St. Augustine, Florida, USA
Clojure for the UnsuspectingPaolo Perrotta

- 2013-04-05, NFJS, NYC
Talks on HTML 5 and JVM languagesVenkat Subramaniam

- 2013-04-12, ACCU, Bristol, UK
Workshop "Gumption Traps Reloaded" with Ivan Moore and talk "Is eXtreme Programming still alive and kicking?" Rachel Davies (author of Agile Coaching)

- 2013-04-18, CocoaConf San Jose
Core Audio in iOS 6Chris Adamson

- 2013-04-18, CocoaConf San Jose
Mobile Movies with HTTP Live StreamingChris Adamson

- 2013-04-18, CocoaConf San Jose
Core Audio Workshop (All-Day Tutorial)Chris Adamson

- 2013-04-21, NFJS, Reston, VA
Talks on HTML 5 and JVM languagesVenkat Subramaniam

- 2013-04-21, Problem Solving Leadership Workshop, Albuquerque, NM
5.5 days of leadership training for people who want to learn to be problem solving leaders Johanna Rothman

- 2013-04-22, Railsberry - Krakow, Poland
A talk on something other than Rails. This is a Rails conference about everything except for Rails. Chad Fowler

- 2013-04-22, Percona Live MySQL Conference and Expo 2013
"How to Design Indexes, Really" and "Extensible Data Modeling with MySQL" Bill Karwin (author of SQL Antipatterns)

- 2013-05-07, Great Indian Developer Summit, Bangalore
Workshops and talks on various topicsVenkat Subramaniam

- 2013-05-20, Let's Test Conference, Sweden
Tutorial: Hiring for Your Team: Culture Trumps Skills Johanna Rothman

- 2013-05-21, Let's Test Conference, Sweden
Keynote: Becoming a Kick-Ass Test ManagerJohanna Rothman

- 2013-05-22, GR8Conf, Copenhagen
Talks on various topics related to Groovy and the JVM Venkat Subramaniam

- 2013-05-28, Fluent 2013
Flow Control with Promises: Learn to control async tasks in JavaScript with Promise-based interfaces Trevor Burnham (author of CoffeeScript and Async JavaScript)

- 2013-06-12, NDC Oslo
Talks on various topicsVenkat Subramaniam

- 2013-07-16, ÜberConf
Workshops and talks on various topicsVenkat Subramaniam

- 2013-09-11, BDD Kickstart, Barcelona
Get a flying start with BDD, the collaborative process that's changing the face of software development Matt Wynne

- 2013-09-14, Barcelona Ruby Conference
Hexagonal railsMatt Wynne

- 2013-09-14, Baruco
TBD David Chelimsky (author of The RSpec Book)

O’Reilly Events

Upcoming events from our friends at O’Reilly.

- 2013-02-12, TOC New York, New York, NY
Tools of Change New York:“For six years, the O’Reilly Tools of Change for Publishing Conference in New York has been the seminal event for professionals and companies engaged with the challenges and opportunities of new publishing technologies and business models.”

- 2013-02-26, Strata 2013, Santa Clara, CA
O’Reilly Strata Conference: “Tap into the collective intelligence of more than 150 data experts at Strata 2013. Strata gives you the skills, tools, and technologies you need to make data work today.”

- 2013-03-24, TOC Bologna, Bologna, Italy
Tools of Change Bologna: “Happening in conjunction with the Bologna Children's Book Fair, TOC Bologna is where the children's publishing and technology industries come together to discuss, learn, and share ideas around the art, craft, and business of storytelling in the digital age.”

USENIX Events

What’s coming from our USENIX friends.

- 2013-02-12, FAST ’13, San Jose, CA
11th USENIX Conference on File and Storage Technologies: “FAST '13 brings together storage-system researchers and practitioners to explore new directions in the design, implementation, evaluation, and deployment of storage systems.”

- 2013-02-24, NDSS , San Diego, CA
Network & Distributed System Security Symposium: “The purpose of NDSS is to bring the global Internet community together to learn about and discuss cutting-edge advances in the science and application of network and distributed systems security.”

- 2013-03-15, Cascadia IT, Seattle, WA
Cascadia IT Conference 2013: “A gathering of professionals from the diverse IT (computer and network administration) community in the U.S. Pacific Northwest / British Columbia to learn, share ideas, and network.”

- 2013-04-02, TaPP ’13, Lombard, IL
5th USENIX Workshop on the Theory and Practice of Provenance: “The workshop may cover any topic related to theoretical or practical aspects of provenance, including but not limited to: provenance in databases, workflows, programming languages, security, software engineering, or systems; provenance on the Web; real-world applications of or requirements for provenance.”

- 2013-04-03, NSDI ’13, Lombard, IL
10th USENIX Symposium on Networked Systems Design and Implementation: “NSDI focuses on the design principles, implementation, and practical evaluation of large-scale networked and distributed systems.”

- 2013-04-15, EUROSYS, Prague, Czech Republic
Eurosys 2013: “EuroSys has become a premier forum for discussing various issues of systems software research and development, including implications related to hardware and applications.”

Shady Illuminations

Prediction
by John Shade
Did the analysts who caused Apple’s stock drop also cast Ashton Kutcher to play Jobs?

Every quarter, a public company’s earnings either meet analysts’s expectations or they do not. It’s one or the other.

Every four years, a Republican or a Democrat is elected President of the United States. It’s one or the other.

We Americans love binary decisions, and we love guessing how those decisions will come out, and we really love to follow those who make a living off these binary guesses.

The most famous and beloved binary guesser in America today is a reclusive little guy with bad eyesight who spends all his time holed up in the Northeast until his handlers bring him out to make his predictions. So far, he has a 39% accuracy rate.

On 50/50 bets.

We love predictions, but clearly we couldn’t care less about accuracy.

The famous and beloved binary guesser I’m talking about, of course, is Punxsutawney Phil (sorry, Nate), the Pennsylvania groundhog who comes out of his hole at the beginning of February every year to tell us what kind of spring we’re going to have. Will it be an early spring, or will we have six more weeks of winter? It’s one or the other.

And in 116 years, lovable Btfsplk Phil has called it 39% of the time. That’s what, 45 out of 116? So how bad is that? Let’s consult our friend the binomial distribution. Here’s what Wolfram Alpha says:

- number of trials: 116

- success probability: 1/2

- left endpoint: 0

- right endpoint: 46

- p ( 0 < x < 46 ) = 0.00994

I’m guessing that Mxyzptlk Phil isn’t guessing. He knows something. You can’t be wrong this often by chance. He’s an excellent predictor; he’s just wrong most of the time.

Not like newspaper psychics, astrological charts, or political pundits. They’re just bad. (And they know it: long-time pundit Bay Buchanon announced this year that she’s quitting the prognostication racket and taking an online real estate course.)

Of course Presidential election predictions are a crap shoot. At least the kind where you look at past elections and try to extrapolate to the next one. The clinker is the paucity of data. Since 1788, Presidential elections have only generated a bit less than half the number of data points ol’ Bqhatevwr Phil has.

Fifty-six Presidential elections. That’s all you’ve got to work with, and for most of those elections you have little in the way of helpful demographic data. You can be pretty sure George Washington was elected without carrying the usually crucial Ohio electoral votes, but how did John Tyler do among urban seniors (which in 1841 probably meant people over 44)? We just don’t know.

Usually Presidential predictions based on past elections restrict themselves to even less data. When you hear, “Since World War II no one has been elected President without...” you can tell the speaker to stop right there. The bar predictors have to get over to get out of anecdote space and into statistics is about twenty data points. There are not twenty data points in the number of Presidential elections since World War II.

I’m not saying that articles on what past Presidential elections can tell us about the next one are worthless. I’m saying that their worth lies in the discipline of literature, not science.

There are things you can predict with some confidence. Like predicting that Ashton Kutcher playing Steve Jobs wasn’t going to work out well. Or that the you’d already have broken most of this year’s New Year’s resolutions by now.

And predicting where technology is going, piece of cake. Like this delicious angelfood on the future of ERP.

Then there are the people whose job it is to predict how a public company will perform in the next quarter. That’s a tough job, clearly, because—no, wait: their job is to predict how well a company will turn out to have performed in the last quarter. Huh. That seems like it would be easier. Anyway, how well do they perform? Apple makes more money than any other company in the history of the world, and its stock goes down. Why? Because the predictors predicted badly.

Those predictors suck.

At least there’s one bit of rationality that emerges from all this tea-leaf failure. It now makes perfect sense that Google has hired Ray Kurzweil to chart its course into the unknown.

But this story need a moral. How’s this: Esther Schindler passed along the fact that the guy who predicted the end of the world last year—OK, yeah, I know, that doesn’t narrow it down enough—Harold Camping, the guy who predicted that the world would end on May 21—that guy? He’s a former engineer. Esther quotes TIL: “Which just proves what we always knew: NEVER trust an engineer when he gives you a schedule.”

John Shade was born under a cloud in Montreux, Switzerland, in 1962. Subsequent internment in a series of obscure institutions of ostensibly higher learning did nothing to brighten his outlook. He confidently predicts that tomorrow he will be just as morose as today. Follow John on Twitter, send him your feedback, or discuss the article in the magazine forum.

But Wait, There’s More...

Coming Attractions

This may be the last page, but that doesn’t mean it’s the end of the conversation. Keep up with what’s going on in the Pragmatic universe by subscribing to our newsletter and drop by the Pub again next month for more Pragmatism. We’ll keep a seat warm and a mug chilled and a candle burning in the window.

Coming Soon in PragPub

Paul Callaghan and Uncle Bob Martin have been collaborating on something that looks pretty interesting regarding functional programming. If all goes well, they’ll be sharing that next issue. Plus, Steven Roberts will continue telling you how to pursue your dreams as a gonzo engineer, Matthias Günther will take you on to the next step in mastering the Pomodoro Technique, and John Shade and our other regular features will be here as well.

Recent Releases, Betas, and Upcoming Books

“Mobile” is no longer the future, it’s the present.

Android is booming like never before, with millions of devices shipping every day. Create stunning 3D games and visuals on the Android platform using OpenGL ES for Android.

And over in the iOS world, Core Data is Apple’s recommended way to persist data: it’s easy to use, built-in, and integrated with iCloud. It’s intricate, powerful, and necessary—and Core Data, 2nd. Ed. is your guide to harnessing its power. You can visit our site for even newer news.

Right. But to really be in the know, you need to subscribe to our weekly newsletter. It’ll keep you in the loop, it’s a fun read, and it’s free. All you need to do is create an account on pragprog.com (email address and password is all it takes) and select the checkbox to receive newsletters.

While you’re waiting for the next issue of the newsletter or of PragPub to come out, you can follow us on twitter at @pragpub, @PragmaticAndy, or @pragdave. Or on Facebook at facebook.com/PragmaticBookshelf. Or email us at michael@pragprog.com.