This children’s story is an adventure through computer science concepts. The main character, Lauren Ipsum, meets a Wandering Salesman in the first chapter who is finding his way home using the algorithm of that name. It’ll be interesting to read the rest of the book and to see whether it can inspire children to think about algorithms and data from a fun perspective without introducing them as computing concepts.

Pledges on KickStarter go towards translating the book into Spanish, Portuguese, and other languages. This is pretty awesome, since much of software development lingo is taken from English, it is great to evangelize learning computer science concepts in kids’ native languages.

We applaud this effort and look forward to hanging one of the book’s illustrations in our office after the completion of the project.

Even though they have already met their goal, more funding will enable translation in more languages.

Learn more about Lauren Ipsum on KickStarter.

Here are the slides from my talk at Founder Labs:

We set up another Heroku app with just a one-line rack application.  All it needed was a rackup config file, called “config.ru” with the following line:

run Proc.new { [ 302, {'Location'=> 'http://blazingcloud.eventbrite.com' }, [] ] }

and voila! It does a simple re-direct to the new site.

it 'verifies that login is between 3 and 40 characters' do
   User.new.should validate_length_of(:login, :within => 3..40)
end

I like that validation syntax, but lately when I see a plugins, I worry that I’m in for some archaeology. I did find a replacement gem, but it didn’t work on first try, so I read up on my options. I briefly considered shoulda, which is now compatible with rspec, but I settled on remarkable because it seems to match the syntax already in use. I wrote a little test rails app with a couple of models and was pleased the results.

Setup

rails new remarkable_app -T"
cd remarkable_app

add to Gemfile:

    group :development, :test do
      gem "rspec", "2.6.0"
      gem "rspec-rails", "2.6.1"
      gem "remarkable_activerecord", "4.0.0.alpha4"
    end

Then back on the command line, set up rspec:

rails g rspec:install

edit spec/spec_helper.rb to include (after require ‘rspec/rails’):

    require 'remarkable/active_record'

Create a Model

Then make a model to play with (on the command line):

rails g model person name:string email:string
rake db:migrate
rake spec
/Users/sarah/.rvm/rubies/ruby-1.9.2-p290/bin/ruby -S bundle exec rspec ./spec/models/person_spec.rb
*

Pending:
  Person add some examples to (or delete) /Users/sarah/src/mv/experiment/remarkable_app/spec/models/person_spec.rb
    # Not Yet Implemented
    # ./spec/models/person_spec.rb:4

Finished in 0.00026 seconds
1 example, 0 failures, 1 pending

yay! ready to get started test driving some remarkable validations…

Test Driven Validation

Let’s test drive our first validation..

describe Person do
  should_validate_length_of :name, :within => 3..40
end

note that remarkable also supports:
it { should validate_length_of :name, :within => 3..40 }
For my new code I’ll probably write the more concise version, but it is nice that my old code should work.

$ rake spec
/Users/sarah/.rvm/rubies/ruby-1.9.2-p290/bin/ruby -S bundle exec rspec ./spec/models/person_spec.rb
F

Failures:

  1) Person
     Failure/Error: send(should_or_should_not, send(method, *args, &block))
       Expected Person to be invalid when name length is less than 3 characters
     # ./spec/models/person_spec.rb:4:in `block in <top (required)>'
     # ./spec/models/person_spec.rb:3:in `<top (required)>'

Finished in 0.30367 seconds
1 example, 1 failure

Failed examples:

rspec /Users/sarah/.rvm/gems/ruby-1.9.2-p290@remarkable_rails3/gems/remarkable-4.0.0.alpha4/lib/remarkable/core/macros.rb:26 # Person
rake aborted!
ruby -S bundle exec rspec ./spec/models/person_spec.rb failed

add validation to my model…

class Person < ActiveRecord::Base
  validates_length_of :name, :within => 3..40
end

Test passes!

$ rake spec
/Users/sarah/.rvm/rubies/ruby-1.9.2-p290/bin/ruby -S bundle exec rspec ./spec/models/person_spec.rb
.

Finished in 0.27601 seconds
1 example, 0 failures

More validations:

describe Person do
  should_validate_length_of :name, :within => 3..40
  should_allow_values_for :email, "sarah@foo.com"
  should_not_allow_values_for :email, "sarah", "@foo", "whatever.com"
end

Reasonably nice error output:

$ rake spec
/Users/sarah/.rvm/rubies/ruby-1.9.2-p290/bin/ruby -S bundle exec rspec ./spec/models/person_spec.rb
..F

Failures:

  1) Person
     Failure/Error: send(should_or_should_not, send(method, *args, &block))
       Did not expect Person to be valid when email is set to "sarah"
     # ./spec/models/person_spec.rb:6:in `block in <top (required)>'
     # ./spec/models/person_spec.rb:3:in `<top (required)>'

Finished in 0.29054 seconds
3 examples, 1 failure

Failed examples:

rspec /Users/sarah/.rvm/gems/ruby-1.9.2-p290@remarkable_rails3/gems/remarkable-4.0.0.alpha4/lib/remarkable/core/macros.rb:26 # Person
rake aborted!
ruby -S bundle exec rspec ./spec/models/person_spec.rb failed

Cheated a little on implementation by copying email validation from ActiveRecord docs… all good.

Now let’s add an association!

In app/model/person.rb:

describe Person do
  should_validate_length_of :name, :within => 3..40
  should_allow_values_for :email, "sarah@foo.com"
  should_not_allow_values_for :email, "sarah", "@foo", "whatever.com"
  should_have_many :addresses
end

Watch it fail:

$ rake spec
/Users/sarah/.rvm/rubies/ruby-1.9.2-p290/bin/ruby -S bundle exec rspec ./spec/models/person_spec.rb
...F

Failures:

  1) Person
     Failure/Error: send(should_or_should_not, send(method, *args, &block))
       Expected Person records have many addresses, but the association does not exist
     # ./spec/models/person_spec.rb:7:in `block in <top (required)>'
     # ./spec/models/person_spec.rb:3:in `<top (required)>'

Finished in 0.32615 seconds
4 examples, 1 failure

Make it pass:

$ rails g model address street:string person:belongs_to
      invoke  active_record
      create    db/migrate/20110721161741_create_addresses.rb
      create    app/models/address.rb
      invoke    rspec
      create      spec/models/address_spec.rb
$ rake db:migrate

.

Pending:
  Address add some examples to (or delete) /Users/sarah/src/mv/experiment/remarkable_app/spec/models/address_spec.rb
    # Not Yet Implemented
    # ./spec/models/address_spec.rb:4

Finished in 0.2998 seconds
5 examples, 0 failures, 1 pending

the rest is left as an exercise for the reader :)

Summary

Overall, I like the remarkable syntax. It seems reliable and on its way to a good release for Rails 3.

“Entrepreneurship is the heartbeat of the company. We have 8000 entrepreneurs: our employees.”
“Everyday we work very hard to rage against the machine. Big company culture will kill innovation” (via @jbollinger)

Corporate government can’t impose more than 3 rules
We don’t ask questions, we watch
Innovation is born out of constraint
A team must be able to be fed by two pizzas
Keep teams small and iterate quickly
We suffer a rich man’s disease. Innovation is borne out of constraints
The problem with big companies is with the managers, who are too used to playing Caesar.
As a leader, it is not the answers you have or the questions you have — asking the right questions at the right time in a startup team is the most important thing as a leader
Setup  an environment of experimentation
Ultimately what led Intuit to success was exposing their stuff to customers early
Double down on the stuff that  works
The culture of experiments beats the culture of powerpoint and articulation
The two most dangerous words in business are “sounds good”
Managers remove roadblocks
“Build just in time not just in case” – don’t build a multi-generational platform that will change the world
Create the environment, and let the small teams figure it out to attain success

For a new product, Brad considered it a big success to have two groups of customers: raging advocates and pissed off people
Big  companies put processes in the way of innovation. It’s not about  spreadsheets, and processes, and planning, but that’s what managers do.
The worst management philosophy is that of a genius with a thousand helpers. You have to hire people who are working closely with the customer to solve a problem you would never have solved.

Brad described a “reverse acquisition” where they acquire a company and put the new guy in charge. For example, the Mint entrepreneur took over a division that included Mint and Quicken.

Q: How to overcome internal resistance? internal employees feeling like they lost to a competitor that is bought.
A: If we didn’t invent it ourselves, it doesn’t mean we failed
Learn from startups or bring them onboard

“The greatest minds closest to the customer develop the great ideas”

Hire entrepreneurial engineers: engineers who are in love with the outcome of the science, NOT JUST the technical stuff. You have to find someone who loves watching and learning from customers

Horizon planning
- Existing business groups increase market share, increase word-of-mouth

Q: Do you plan to put more of Quickbooks online and what are your plans for growing to other countries?
A: Connected services companies are 60% of revenue
Desktop products aren’t growing

60/30/10 revenue distribution
60% to horizon 1 products, 30% to the teenagers, 10% to new projects

Eric Ries kicked it off with an update on the Lean Startup “movement.”

Eric Ries says he’s just a figurehead, later Eric Ries referred to himself a “professional talking head”. He isn’t lean startup, we are.
We are experiencing a worldwide entrepreneurial renaissance.

Everyone turn your cell phones on! Being off the internet is irresponsible and direspectful to our ancestors who created this technology for us.

Lean Startup is global — it is no longer a Silicon Valley phenomenon. Check out Lean Startup Meetups.

We are in the process of democratizing entrepreneurship.
But, it has also been institutionalized…

• Harvard Business School- MVP Product Fund
• Stanford University- Lean Launchpad
• BYU- Lean Startup Research Project

Books

• the Entrepreneur’s Guide to Customer Development
• Steve Blank’s Four Steps to the Epiphany
• (and there was another one that we missed)

Entrepreneurship is not just two guys in a garage, it is a discipline

GhostBusters is one of the great entrepreneurship movies of all time
All great entrepreneurs have great stories. The movies play out like this:
Act 1) Characters& timing
Act 2) Boring stuff — the “photo montage” of people at the keyboard drinking beer
Act 3) How to divide up the spoils
This conference is about Act 2 — how does it really happen.

“A startup is a human institution designed to deliver a new product or service under conditions of extreme uncertainty.” — Eric’s definition

startup = experiment

“our future GDP growth depends on the quality and caliber of our collective imagination”

We are building companies that have fundamentally no customers and are pulled off the shelves

Frederick Winslow Taylor (March 20, 1856 – March 21, 1915) was an American mechanical engineer who sought to improve industrial efficiency.

Scientific Management:
* Study work to find the best way
* Management by exception
* Standardize work into tasks
* Compensate workers based on performance

What are we doing now that will later be revealed as myth and prejudice?

The Pivot
“better to be misunderstood than ignored”
Runway- number of pivots you still have the opportunity to make
Speed Wins

Validated learning reduces the time between pivots
Acheiving Failures = successfully exeuting on a bad plan
Why is it important to do things efficiently if we’re doing the wrong thing?

W. Edwards Deming and Taiichi Ohno- start of the Lean Revolution

Who is the customer? whose eyes matter in determining value vs. waste?

Minimize the total time through the loop
Ideas -> Build -> Code -> Measure -> Data -> Learn
see image here: http://lean.st/principles/build-measure-learn

Ship it anyways and see what happens? Why spend time agruing about the details if there the chance that no one will want it.

How do we figure out what we need to learn as quickly as possible

The Toyota Way
Foundation is long term thinking -> culture that supports people to do their best work

He displayed this pyramid:

• People
• Culture
• Process
• Acountability

“We have begun to learn how to keep innovators accountable”
Use learning milestones instead of product milestones
What are the inputs to our business plan right now
better have bad news that is true than good news that we made up
“If the 10% customer adoption does not happen, everything in this business plan is irrelevant” should be a big red banner!” via @timolehes
Tune the engine –> every business has different math

Pivot or persevere? when experiments reach diminishing returns, it’s time to pivot.

“If we alllow ourselves to fail, we can train our judgement to get better over time”

I’ve tried it out on one Rails project I’ve tried, I’ve got specs running, but not passing and I’m not sure why yet. Here’s what I’ve figured out so far…

export rvm_path=~/.rvm
echo 'export rvm_path=~/.rvm' > ~/.rvmrc
mkdir -p ~/.rvm/src
cd ~/.rvm/src
rm -rf ./rvm/
git clone --depth 1 git://github.com/wayneeseguin/rvm.git
cd rvm
./install
rvm reload
rvm reset
cd $WORKSPACE
rvm install ree-1.8.7
rvm use ree-1.8.7
rvm gem install bundler --no-rdoc --no-ri
rvm exec bundle install
cp config/database.yml.dev config/database.yml
rvm exec rake db:create:all
rvm exec rake db:migrate
rvm exec rake spec

The first class is free. We’ll be looking at survey responses and decide on pricing based on a final assessment of the remote experience.

This class is an introduction to Rails and also covers the Ruby language. It is aimed at programmers who are new to Ruby and Rails. I am co-teaching the class with Curtis Shofield. We’ll be using the test first teaching approach which provides a firm foundation in best practices using the RSpec testing framework.

Class Topics
1/25 Introduction to Rails
2/1 Ruby and RSpec
2/8 ActiveRecord
2/15 Power Ruby
2/22 Controllers
3/1 REST and Integration Testing
3/8 Associations
3/15 TBD

If you want to participate, join the google group for more information, look at recent postings for setup details and I will post the URL for the meeting website before the class today.

>>  (-1).size

If this evaluates to 8 you are on a 64-bit architecture.  If it is 4, it is 32-bit.

Everything you know from Rails 2 still works and will for some time, but there is new cool stuff AND some of the Rails 2 syntax is deprecated and will eventually go away, so you should be aware.

1) Use first, last, all (not find(:first), find(:last) and find(:all)

2) New query syntax:
find(:conditions => …) will be deprecated, instead you can use the following methods:

• where – provides conditions on the relation, what gets returned.
• select – choose what attributes of the models you wish to have returned from the database.
• group – groups the relation on the attribute supplied.
• having – provides an expression limiting group relations (GROUP BY constraint).
• includes – includes other relations pre-loaded.
• order – orders the relation based on the expression supplied.
• limit – limits the relation to the number of records specified.

For a complete list and more details, see Pratik Naik’s post. The key thing to note is that ActiveRecord finder methods return a relation and no SQL is executed until it needs to be.

Examples:

Person.where(:last_name => "Woo").order(:first_name)
Person.where(:last_name => "Woo").order(:first_name).limit(1)

You can optionally specify ASC or DESC when calling order

Person.order("last_name DESC").limit(2)

You can call these methods in any sequence

Person.order(:first_name).where(:last_name => "Woo")
Person.where(:last_name => "Woo").order("first_name")