Categories
Uncategorized

Hello, Kodu!

kodu game lab

Last week, I presented Kodu (pronounced “Code-ooh”) to a group of teachers and high school students at Corpus Christi Catholic Secondary School. Kodu is a system created by Microsoft Research for programming videogames without using a traditional programming language; instead, you use a combination of menus and visual programming. It was designed to be a gentle introduction to programming that would appeal to children, but many adults – myself included – have ended up getting drawn into it, spending hours constructing and tweaking game worlds.

Kodu was built using XNA, Microsoft’s framework, toolset and runtime environment for building games for Windows, Xbox 360 and Zune. It was released for the Xbox 360 last summer as an Xbox Indie Game; you can download it for 400 Xbox points — about 5 bucks – or you can try the free trial version (it’s time-limited, but full-featured). If you don’t have an Xbox 360, you can download the Windows version of Kodu for free.

Kodu’s a little tricky to describe – it’s one of those things that’s much easier to show rather than tell. Here are a couple of videos that should give you a bit of Kodu’s flavour. First, here’s IGN’s look at Kodu:

Here’s XNA Roundup’s review of Kodu:

Kodu was designed to be programmed with the Xbox 360 gamepad, which you can use if you’re programming it on the Xbox 360 or a computer (if you’re using a computer, you’ll need either a wired Xbox gamepad plugged into one of its USB ports or a USB adapter for your wireless Xbox gamepad). If you’re using Kodu on a computer, you have the additional option of using the keyboard and mouse.

This is the first of a series of articles on Kodu programming that will appear here from time to time. If you’ve got kids (or know some) who are curious about programming, or if you’re looking to try a completely different kind of programming, get Kodu on your Xbox or PC and give it a try!

In this first installment, I’ll show you how you can build a simple little program that lets you drive an avatar around a small world. In later installments, I’ll show you more game-like elements and the “code” for a game of mine called “Stupid Sparkling Vampire Game”.

Touring Teran00bia

In addition to a programming “language”, Kodu provides you with tools for editing the worlds in which your games take place. I often start with a simple, no-fuss world that I created called “Teran00bia”. It’s a small, flat square world suitable for experimentation. If you have the Windows version of Kodu, you can download Teran00bia here. I can also share the Xbox 360 version, but you have to “friend” me on Xbox Live first – my gamertag is “Accordion Guy”.

Teran00bia is a blank slate, a world with nothing in it. Here’s what it looks like when you load it:

kodu 00

In this exercise, we want to stick a single character – Kodu – into the world and allow the player to drive him around using the controller’s left stick.

To start programming, get into Edit Mode. Press the “Back” button on the gamepad to switch to Edit Mode. Your screen should now look like this:

01 world view

In Edit Mode, the left thumbstick moves your “cursor” (the purple “donut”) around the world, while the right thumbstick changes your camera angle. You use the left bumper (that’s the button just above the left trigger) to zoom out and the right bumper (the button above the right trigger) to zoom in. The screenshot below shows a zoomed-in view of Teran00bia:

02 closer up

The floating icons near the bottom of the screen make up Kodu’s menu. You use the left and right triggers to scroll through the menu and the A button to select a menu item.

Select the Object Tool from the menu. It’s the second menu item from the left, and its icon is Kodu, who looks sort of like a blue fish with an antenna. When you select the tool, the Kodu menu disappears and you’re now using the object tool, as shown below:

03 about to add

The Object Tool lets you add items to the world or edit any existing ones. There aren’t any items in the world at the moment, so let’s add one. Use the left thumbstick to move the cursor to the spot where you want to place an object, then press the A button. The following menu will appear:

04 add menu

This menu lists the items available to you. Starting at the top and going clockwise, the items in the menu are:

  • Kodu (the game system’s mascot, who can be used as either a player character or a non-player character)
  • Apple (useful as a health power-up, but nothing stops you from making them poisonous or explosive)
  • Bots 1 (a set of characters that can be used either as player characters or non-player characters)
  • Bots 2 (more characters that can be used either as players characters or non-player characters)
  • Objects (things that characters in the game can interact with, such as rocks, coins, castles and factories)
  • Tree (another object that characters in the game can interact with – I have no idea why trees weren’t part of the set of Objects)
  • Path (lets you draw paths which Kodu and the other bots can follow)

Use the left thumbstick to select Kodu from the menu, then press the A button to confirm the selection. A Kodu will appear:

05 kodu added

You can move Kodu around by pressing the A button to select him, using the left thumbstick to pick a new location and then pressing the A button to drop him there.

What we want to do is program Kodu to move in response to the left thumbstick, as is the convention for most Xbox 360 games. While Kodu is selected, press the Y button. The screen should look like this:

06 programming

Every programmable object in the Kodu game system has a set of behaviours, each one having two parts:

  • When, which describes the event that the object will respond to
  • Do, which describes what the object will do in response to the event

The behaviours are numbered starting at 1 and are listed in order of descending priority – that is, behaviour 1 has first priority, followed by behaviour 2, then behaviour 3, and so on.

Your programming “cursor” is the pencil. Move the pencil over the “+” in the “When” part of behaviour 1 and press the A button. You’ll see a menu pop up:

07 when menu

This menu lists the events to which Kodu can react. For now, we’re concerned with making him respond to the left thumbstick, which is part of the gamepad. Select “Gamepad” from the menu with the left thumbstick, then press the A button to confirm the selection. The menu will vanish and you’ll see that a “Gamepad” tile has been added to the “When” part of behaviour 1:

08 gamepad added

We need to specify which gamepad control Kodu should respond to. Make sure the pencil is over the “+” of the “When” part of behaviour 1, then press the A button. A menu containing various controls on the gamepad will appear:

09 gamepad menu

Use the left thumbstick to select “L stick”, then press the A button. The menu will disappear and you’ll see that the “When” part of behaviour 1 has two tiles: “Gamepad” and “L Stick”:

10 ks added

We’ve just described an event that Kodu should respond to. Now it’s time to describe the response. Move the pencil over the “+” of the “Do” part of behaviour 1 and press the A button. A new menu will appear:

11 move selected

This menu lists responses to events. In this case, we want Kodu to move where the player tells him to move, which is specified by the left thumbstick. Select “Move” from the menu with the left thumbstick, then press A to confirm the selection. The menu will vanish, and you’ll see that a “Move” tile has been added to the “Do” part of behaviour 1:

12 move added

We’ve now completely defined a single behaviour for Kodu: “When the player moves the left thumbstick, move in that direction”. It’s time to take our (admittedly simple) game for a spin.

Press the Back button to stop programming Kodu. You’ll now be in the Object Tool. Press the Back button again to return to Edit Mode, where Kodu’s main programming menu will become available. Use the left trigger to select Play Mode and press A to confirm the selection.

13 play selected

The program will start with the intro screen. Press A to dismiss the intro screen.

14 opening screen

You’ll now be in the game world. Use the left thumbstick to move Kodu around:

15 gameplay

Kodu moves, but he’s not so fast. Let’s look at a way to speed him up a little. Press the Back button to exit the program and return to Edit Mode. Use the triggers to select the Object Tool from the menu, then press the A button to confirm the selection.

16 stopped

Move the cursor under Kodu so that he’s selected:

17 kodu selected

Press the Y button to program Kodu. You’ll be return to his set of behaviours:

18 current program

Move the pencil over the “+” of the “Do” part of behaviour 1, the press the A button. A menu will appear:

19 quickly selected

The menu will contain modifiers for the “Move” response. Select “Quickly” from the menu using the left thumbstick, then press the A button. The menu will disappear and you’ll see a “Quickly” tile has been added to the “Do” part of behaviour 1:

20 1 quickly

To make Kodu move even faster, you can add another “Quickly”:

21 quickly selected 2

…in fact, you can add up to three “Quickly” tiles to push Kodu to his maximum speed:

23 3 quicklies

Play Around

I could cover more Kodu features, but you should use it the way it was meant to be used – experiment! Try adding other objects to the world and adding behaviours to them. Take a look at the  programming behind the worlds that were provided with the Kodu game system (be sure to check out “Left 4 Kodu Classic”, a cute Kodu version of the zombie thriller game Left 4 Dead).

Links

This article also appears in Canadian Developer Connection.

Categories
Uncategorized

CUSEC 2010 Keynote: Douglas Crockford – The Software Crisis

doug crockford

At long last, the fifth in my series of notes taken from keynotes at CUSEC 2010, the 2010 edition of the Canadian University Software Engineering Conference. These are from Douglas JavaScript: The Good Parts” Crockford’s keynote in which he talks about how hard it is to make software. Doug is a senior JavaScript architect at Yahoo!, the guy behind JSON, wrote one of the first important pieces on JavaScript’s unrealized power and utility and in a former life wrote videogames (of which he has some interesting stories).

My notes from his keynote appear below.

The Software Crisis

"I made the first important discovery of the 21st century: that JavaScript has good parts!"

  • The Software Crisis dominated the computer industry for a decade: 1960s
  • The crisis was that software projects were becoming too complex to manage
  • Projects were:
    • Over budget
    • Late
    • Unreliable
    • Not fully meeting their requirements
    • Unmaintainable
    • Failing
    • Insecure (this is a relatively new thing)
  • The software crisis isn’t over — we’re now in year 45
  • It never went away, we just stopped talking about it
  • "In other news, the sun will eventually exhaust its supply of hydrogen"

Craft vs. Engineering

  • Some people said that we weren’t bringing enough engineering discipline to the practice of programming
  • Some said programming isn’t the same thing as engineering and therefore engineering discipline doesn’t apply
  • Both miss the point
  • The real problem with software is that it’s the most complex thing we make
  • It requires perfection, which humans aren’t good at
  • It’s amazing we can make software at all

Software construction

  • Computer science has taught us lots of things, but not how to manage software projects
  • In some ways, building software is like any other sort of construction
  • But in some other ways, it’s quite different
  • You have to keep in mind that "construction" when applied to software is just a poetic metaphor
  • Take the case of building a wall:
    • It’s easy to estimate, based on the size of the wall how much time it will take, and also how far progress will be at any given time during its construction.
    • Try doing that with software!
  • Part of the problem is the nature of software
    • It’s both powerful and malleable
    • The qualities are both a blessing and a curse
  • One problem: The lack of metrics
    • There’s no objective measure of quality or completeness
    • We can test software, but the tests are on the same level of quality as the software being tested
    • Consider one of the old stand-by metrics: LOC (lines of code)
      • It’s not an indicator of quality
      • Nor is it an indicator of completeness
  • Another problem: Estimation is difficult
    • Programmers, by nature, are optimists
    • You have to be and optimist to do this kind of work! You wouldn’t be able if you weren’t
    • "I think rational people could not do programming"
    • As a result, we’re probably the least qualified people to do estimating
    • What doesn’t help is encouragement from management like "You’re a smart guy, you should be able to do it in 3 months!"
  • Another problem: Programmers don’t understand how they spend their time
    • They think they spend most of their time typing
    • Measurements show that most of their time is actually spent in meetings or tech conversations
    • (And there’s also the time spent staring at the screen going "My God, what have I done?")
    • As a result of this disconnect between perception and reality, programmers tend to be skeptical of process improvements that might require more keystrokes
      • [Story about developer who refuse to switch from a CamelCase naming scheme to a words_delimited_with_underscores naming scheme]
      • The programmer had an emotional attachment to the CamelCase naming scheme and argued that the underscore-based scheme slowed things down
    • Consider the first rule of optimization: optimize the process that is taking the most time
    • When it comes to programming, that process isn’t the typing!
    • It’s the thinking, worrying and puzzling
  • Programming is a social activity
    • Solo cases are the exception
  • Cost of innovation
    • Doing what’s been done before vs. doing what hasn’t
    • We’re constantly doing things we haven’t done before
    • That’s most likely to lead us to mistakes
  • Legacy
    • In other industries, legacy is seen as the wealth of practice and tradition, the wisdom of experience
    • Not ours! In software, past accomplishments are considered to be a liability
    • The age at which programs become "legacy" is getting younger and younger
    • Some programs become legacy before they’re finished\
    • No industry disrespects legacy the way the software industry has

Leaps

  • Software is not governed by Moore’s Law; it’s governed by Murphy’s Law
  • Leaps tend to come at 20 year intervals, not two year intervals
  • Leaps make it possible to implement more complex projects
  • Adoption of "leaping" software technologies tends to be very slow
  • Common responses to leaps: controversy and reluctance
  • Leap 1: Plugboards

plugboard

  • Single machine programmable with plugboard
  • The original spaghetti code
  • Leap 2: Symbolic assembly language
    • The first software tool — the first program to make it easier to write programs
  • Leap 3: High level languages
    • In the 1960s, there was a lot of research on automatic programming
    • It was believed, even back then, that programming too complex and error-prone for humans to do
    • We wanted to get computers to write programs for us: we’d feed them specifications; they’d output programs
    • The result? FORTRAN
    • Still a leap forward
    • Even today, with DSLs, it’s still progamming
  • Leap 4: Structured Programming
    • Getting rid of GOTO
    • Let us write more complex programs
    • Argued for 20 years as to whether it was good idea to get rid of GOTOs
    • People who benefited most and opposed were programmers
    • Arguments and counter-arguments
    • "Had to wait for those guys to get old and die"
    • So today, virtually all our languages are GOTO-less
    • Good thing — more sophisticated programs possible
    • What was the fuss all about?
  • Leap 5: Object-Oriented programming
    • 1967: Simula released
    • 1972: Alan Kay begins Smalltalk, which was originally intended for children
    • Most of good today in tech owes a debt to Smalltalk
    • 1980: Smalltalk released. Smalltalk took 8 years — Netscape spent 8 weeks getting JavaScript ready!
    • 1985: C++ released. Essentially some of the good ideas in Smalltalk added to C
    • 1995: Java released
    • 2004: PHP with version 5 says "Okay, we’ll do it that way too"
    • A lot of time has passed between 1967 and now. Simply because a new good idea appears means it won’t be adopted quickly
    • OOP is not the last leap. It’s just that we’re so fixed on objects that we can’t see past them
  • So we’re late for the next leap
    • I think it’ll be distributed programming, the idea of taking n components and put them together to make a functioning application
    • Will live in the cloud
    • Nobody thought that we’d see signs from the next step forward in JavaScript and browsers, but that’s where it’ll likely come from
  • Some Failed Leaps
    • Artificial intelligence
      • Intelligence is much harder to understand
    • 5th generation languages
      • Japanese invested heavily it, but without much result
    • Computer-aided software engineering
      • Reborn in IDEs
    • Subjective-oriented programming, etc.

Bugs

grace hoppers bug

  • Software does not have enough self-awareness to be afraid of bugs. That’s why it works as well as it does.
  • The term “bug”  is attributed to Edison, who used them to refer to flaws
    • From the Pall Mall Gazette, March 11, 1889: "Mr. Edison, I was informed, had been up the two previous nights discovering a bug in his phonograph."
  • Ever since then, defects in inventions have been called bugs and it’s become part of popular culture
  • There’s also Commodore Grace Hopper’s bug, a literal bug: a moth caught in the relay of a Navy electromechanical computer.
    • She pasted moth into her logbook
    • It’s the "first actual case of a bug being found"

Snake oil

  • Even though we know better, we love "silver bullets"
  • We tend to like people who make fantastic promises to fix our problems, if we just follow some crazy methodology of theirs:
    • Diagramming?
    • Documentation style?
    • Have all your meetings standing up?
  • Saying "nothing works" is discouraging; I’d like to give you a better story
  • The Mythical Man-Month
    • Written by Fredrick Brooks; I highly recommend this book
    • He said a lot of things in the book that seemed unreal at the time, but they were proven to be true over time
    • The source of what we know as Brooks’ Law: "Adding manpower to a late software project makes it later."
    • One of the first books to show an understanding that programming is social
    • Another idea in the book: the Second-System Effect
      • Take a team of programmers who’ve done something brilliant
      • Give them a blank slate for the next project
      • The result? They fail…hard
      • Why? They become overconfident. Their earlier success causes them to overreach
    • Another idea in the book: Prototyping
      • Software is like waffles: Make the system, throw it away, make it again
      • Counter to the notion of getting it right the first time)
      • "Make the first one to throw away" turns out to be a good idea
    • One last concept from the book: "A project become a year late one day at a time"
  • Literate Programming
    • Created by Donald Knuth
    • The idea: Programs designed to be read
    • I’ve seen lots of good programs done in this style
    • It doesn’t appear to work well in groups yet — but that’s mostly what we’re doing now
  • Incrementalism
    • The basic idea: "We’ll see you in two weeks" vs. "See you in two years"
    • Disappointments are smaller and more frequent, which are easier to manage; it lets us manage our expectations
    • It also makes us less ambitious, but that lack of ambition is helpful
    • It avoids second system problem — this doesn’t let you dream big
    • The project is always a beta, and perpetually unfinished
    • The downside of incrementalism:
    • There’s the potential that your project will become something like the Winchester House in San Jose
      • Built by Mrs. Winchester, wife of the Winchester behind Winchester guns
      • Her husband and child died tragically, and a medium told her that they were killed by the spirits of people killed by the Winchester repeating rifle
      • She was warned that they’d come after her too unless she found some way to confuse them
      • She came up with the idea that as long as she kept working on her house, the spirits would not find her
      • So her house was constantly under construction, with hired people adding new things to it all the time
      • It was built up incrementally. "This is an agile house!"
      • End result: things like stairways leading up to a ceiling:

winchester house stairs

      • "You’re programmers, you know what happened here!”
      • Chimneys that didn’t go up all the way to the ceiling

winchester house chimney

      • No rhyme nor reason
  • Go watch Mr. Blandings Builds His Dream House (1948)
    • It’s the best movie ever made about project management
    • Blandings’ problems:
      • Lack of knowledge of technology
      • Poor control over requirements
    • [Joey’s note: This movie’s been remade in modernized form with Tom Hanks in The Money Pit(1986) and Ice Cube in Are We Done Yet? (2007).]
  • Feature Cost
    • Development time
    • Deployment cost
    • Maintenance cost (bloat, cruft)
    • Download time
    • User confusion/training
    • Bug delivery
  • Code Value
    • Microview: good coding conventions
    • Macroview: good architecture
  • We need better program architecture
  • Architecture is hard, but conventions is easy
  • Think of how hospitals were improved just through simple conventions of hygiene, such as washing your hands
    • The simplest thing we can do to increase the value of our code is to make it readable
      • For example, when returning a value from a method, we should use return value, not return(value) — the latter implies that return is a function
    • Whatever improves human parsing of programs is helpful
  • Communicating
    • You should think of programs as a medium of intentional communication:
      • Communicating detailed instructions with the machine
      • Communicating with your development community
      • Communicating with yourself (and especially your future self)
  • Good architecture is about not collapsing into a puddle of confusion, and should enable you to change a correct program into another correct program
  • Cruft
    • It’s software scar tissue
    • Comes from lots of sources:
      • Premature optimization
      • Inexperience
      • Misread source
      • Feature enhancement
      • Death marches (which are the most avoidable source of cruft)
      • As cruft accumulates, complexity grows and progress slows
  • Eventually, the code itself becomes a source of friction

Bloat

  • It’s "software obesity"
  • In the old days, memory was expensive and you didn’t get much of it, so your programs were lean by necessity
  • Having only 8K – 64K of RAM in a machine put incredible constraints on what you could do
  • I used to dream of the day when memory would cheap and abundant enough so that we wouldn’t have to do evil things to get programs to fit
  • Now I wonder if maybe those constraints weren’t so bad
  • "Bugs hide in those rolls of fat in our programs"
  • Insecurity
    • Most programs these days have marginal security
    • Programs that once didn’t have security implications now do
    • Any bug is potentially a security bug
    • Good secure programming is good programming
    • Thinking about security might make programming easier
  • Refactoring
    • The process of code refinement, involving things like:
      • Correction of formatting
      • Insertion of documentation
      • Removal of cruft and bloat
      • Restructuring
  • Perhaps we should take advice from Exodus: "Plant and harvest crops for six years, but let the land rest and lie fallow during the seventh year."
  • Maybe do six sprints where you add new features, but on the seventh sprint, don’t add new features at all
      • Sometimes the best course is to start over
        • This is quite difficult to accept
        • The pain of the crash
          • Loss of a week’s work, a day’s work, an hour’s work, is unbearable
  • The illusion of completion
    • "It’s in the can!"
    • I once worked as an expert witness on conflict between 2 game companies
      • The original game company had split up; the new company was being sued for plagiarizing the original company’s game engine
      • I reviewed both game engines and determined that the new game company had written a whole new engine in 2 month — they’d learned for the experiences writing an engine for the old company
      • The owner of the old company couldn’t accept that; he thought the value of the codebase was 100 man-years, not 1
      • An experienced team can redo what they just created quickly. The team’s focus must be on simplicity to avoid second system effect
  • Have regular code readings
    • Don’t wait until release to do code reviews
    • Do team code reading regularly during development
    • Problems can be discovered early
    • Good techniques can be shared early
    • Experienced developers can lead by example; novice developers learn from the group
    • They should be: frequent, helpful and respectful
      • You need a healthy team – a dysfunctional one will tear itself apart

Conclusion

  • Quality first. Quality last.
  • Readable code. Code reading.
  • Invest in the quality of your code base.
  • Invest in your programmers and managers.
  • Quality is the most important feature.
  • If you look at all the polished, completed code you write at the end of a year, you could type it all in a day
  • Typing is not what we do; it’s thinking and communicating

This article also appears in Canadian Developer Connection.

Categories
Uncategorized

The Evolution of Type Taste from Grade School to Present

letraset

You young’uns may have learned about typefaces and the difference between serif and sans serif from using the “font” settings on your computers, but I learned from using Letraset (and often, its budget-priced brother, Geotype). They were sheets of rub-down transfer lettering and clip art. The principle behind Letraset wasn’t all that different from temporary tattoos. The stuff went the way of the dodo once desktop publishing and laser, inkjet and dye sublimation printers caught on.

Graphic artist and typeface fancier Jessica Hische – who recently wrote the brilliant “The work you do while you procrastinate is the work you should be doing for the rest of your life” – posted this great graphic showing the evolution of her type taste from grade school to the present day. Click it to see it at full size. Oh, I remember my Helvetica Condensed Black Oblique phase…

Jessica Hische's "Evolution of Type Taste from Grade School to Present" -- from Curlz to Archer and Gotham

This article also appears in The Adventures of Accordion Guy in the 21st Century.

Categories
Uncategorized

Lessons from the Other Side

Sheep Canada and Other Perspectives

Cover of "Sheep Canada" magazine

Every now and again, I make it a point to pick up some reading material on a field or industry that’s completely unrelated to my own. I find that it both satisfies my curiosity and helps me see things from a completely different perspective. In one particular case, when I found a copy of Sheep Canada lying abandoned on a subway seat, I enjoyed the puzzled and concerned looks from the other passengers as I read the magazine. Not only did I get a little entertainment, but I learned a little bit about what goes into making the lamb chops and sweaters I love.

I also like asking people questions about their work, especially if it’s in field different from my own. It probably stems from the fact that everyone in my immediate family is in medicine; I’m the “black sheep” who went into computer programming. I often chat with my wife and her co-workers at the University of Toronto’s Mark S. Bonham Centre for Sexual Diversity Studies (a fascinating line of work, by the bye), my father-in-law about that branch of the insurance industry that concerns itself with executive benefits, friends who work in the television and movie industries, and so on. I love hearing their stories and find that seeing their perspectives broadens my own.

I’ve even taken on little non-developer side jobs just to get a different perspective. I’ve moved an entire warehouse of high-end dresses, had a fair bit of success as a street musician, gotten ink-stained at an old school print shop and even had a stint as an accordion-playing go-go dancer at a Toronto nightclub.

You Go Hither and I’ll Go Thither

It’s this “wanderlust of the mind” that probably led me, a guy who was actually quite happy in the “develop on the Mac, deploy on Linux” world, to becoming a Developer Evangelist with Microsoft. Each world has its own history, culture, customer base and approach to technology, and each offers lessons to the other. As I’ve said before, technology is a great big smorgasbord, where there are enough seats and dishes for everyone and every taste. Wouldn’t it be a waste if you stuck only with the dishes you knew?

I’ve spent the last year getting reacquainted with the Microsoft development world, and it’s different in many ways. There’s the obvious stuff such as operating systems, programming languages and tools. There’s also the more subtle stuff: conference demographics and what people do in the hallways at conference, the sort of apps that get written, what people do in their spare time and so on.

Don Dodge

Don Dodge is experiencing the same thing…just in reverse. Just as I’ve gone from being a Mac guy to running Windows 7 as my primary operating system, he’s crossed over from Windows to the Mac OS and writing about his experiences with the transition in an article titled From MSFT Evangelist to Mac Enthusiast – The Other Side of the Road.

There are some lessons to be learned from Don’s observations, a fact that wasn’t lost on Todd Bishop. In his article on Don’s “switching” experience, he writes:

This sentence, in particular, caught my attention: "After years of defending Microsoft against the Apple fanatics I decided to go to the other side of the road to see for myself," Dodge writes.

Good for him, but the fact that he hadn’t seen the other side of the road as a Microsoft employee is a symptom of a larger problem at the Redmond company. Loyalty to and appreciation for your own products is nice, to a point, but after interacting with people at Microsoft for the better part of the past decade, I’ve never quite understood, logically, why it’s taboo for its employees to use competing products.

…think what would happen if Microsoft employees experienced and saw around them, every day, a true reflection of the competitive landscape — including Microsoft products and rival technologies. My hunch is that they’d come away with a better understanding of what motivates specific consumer actions, and how they might be able to get consumers to pick Microsoft products instead.

Todd, you took the words right out of my mouth. It’s right along the lines of my own philosophy, which I wrote about in the article Evangelist, Immigrant and Shaman:

What Microsoft needs badly is a shaman. They need somebody who is situated physically within their culture, but outside it spiritually. This isn’t a person who hates Microsoft, but it’s a person who can actually see it. I can do this for you. Give me a hut in your parking lot. I will eat mushrooms, roll around in your cafeteria, and tell you the Goddamned truth.

Awkward family photo featuring family in the Sunday best with one boy in biker leather.

It’s the style in which I do my work. Yes, I devote a lot of time and effort to Microsoft’s tools and technologies, but I make sure that they’re not the only things I look at. I try to keep abreast of things like the IDE conventions in XCode, what’s happening in the worlds of the iPhone and Android, non-Microsoft languages and frameworks such as PHP, Python and Django, Ruby and Rails, templating systems like HAML and Sass and the NoSQL movement. Each has lessons (the Microsoft term is “learnings”, which I refuse to use, since I consider it a non-word) that can be incorporated into the Microsoft world, just as I’m sure that we too have lessons to offer to these other worlds. And in the end, we’ll all get better tools and technologies for our work, life and play.

It’s something you should try as well. Try using some tool or technology that you wouldn’t normally use. Hang out with developers from “the other side”. Pick up a copy of Sheep Canada. Broaden your perspective and see what you’ll learn!

This article also appears in Canadian Developer Connection.

Categories
Uncategorized

Behind the Scenes at “Star Trek: The Next Generation”

Denise Crosby ("Tasha Yar") leans up against the Enterprise-D's tactical station between shots

For those of you who are fans of Star Trek: The Next Generation, there are some lovely “behind the scenes” shots of the cast and crew on the TrekCore site. I’ve posted a couple of my favourites here.

A very young-looking Johnathan Frakes ("Will Riker") poses beside an upside-down model of the Enterprise-D

LeVar Burton ("Geordi LaForge"), Michael Dorn ("Worf"), Wil Wheaton ("Wesley Crusher") and Marina Sirtis ("Deanna Troi") in the dressing room

Michale Dorn ("Worf") reads "Yachts for Sale" magazine

This article also appears in The Adventures of Accordion Guy in the 21st Century.

Categories
Uncategorized

CUSEC 2010 Keynote: Greg Wilson – “Bits of Evidence”

greg wilson 1

Here’s the fourth in my series of notes taken from keynotes at CUSEC 2010, the 2010 edition of the Canadian University Software Engineering Conference. These are from Bits of Evidence: What we actually know about software development and why we believe it’s true, a keynote given by my friend Greg Wilson, the computer science prof we all wish we had. He’s also the guy who gave me my shot at my first article for a developer magazine, a review of a couple of Ajax books in Software Development.

My notes from his keynote appear below; he’s posted his slides online.

A Little Family History

  • My great-grandfather on my father’s side came from Australia
  • He was sent there, along with many other criminals from the UK, to Botany Bay
  • Whenever we kids did anything bad, my mother would say to my father: “This your side of the family"
  • This happened until the day my sister triumphant discovered that my maternal great-grandfather was a Methodist minister who ran off with his church’s money and a 15-year-old girl from his parish
  • She never brought up my father’s family history again
  • It took years and poring over 70,000 sheets of microfiche to track down my great-grandfather, all to find two lines, which said he was sentenced, but not why
  • These days, students get upset if it takes more than 15 seconds to find answers to last year’s exam
  • Some things haven’t changed: while technology has improved, the way we develop software for it hasn’t

Scurvy

  • In the Seven Years’ War, which lasted longer than seven years (1754-63), Britian lost:
    • 1,512 sailors to enemy action
    • 100,000 sailors to scurvy
  • Scurvy’s a really ugly disease. You get spots on your skin, your gums puff up and go black, you bleed from your mucous membranes, and then the really bad stuff happens
  • In 1747, a Scotsman named James Lind conducted what might have been the first-ever controlled medical experiment
  • Pickled food keeps fresh, he reasoned, how about pickled sailors?
  • Lind tried giving different groups of sailors with scurvy various acidic solutions:
    • Cider
    • Sulfuric acid
    • Vinegar
    • Sea water (this was the control)
    • Oranges
    • Barley water
  • The sailors who had the oranges were the ones who recovered
  • Despite Lind’s discovery, nobody paid attention until a proper Englishman repeated the experiment in 1794
  • This discover probably won the Napoleonic Wars: the British navy was the deciding factor
  • As a result of this discovery, British sailors planted lime trees at their ports of call and ate the fruit regularly; it’s how the term “limey” got applied to them, and later by association to British people in general

Lung Cancer

  • It took a long time for medical science to figure out that controlled studies were good
  • In the 1920s, there was an epidemic of lung cancer, and no one knew the cause
  • There were a number of new things that had been introduced, so any of them could be blamed – was it cars? Cigarettes? Electricity?
  • In the 1950s, the researchers Hill and Doll took British doctors and split them into 2 groups:
    • Smokers
    • Non-smokers
  • The two discoveries to come from their research were:
    • It is unequivocal that smoking causes lung cancer
    • Many people would rather fail than change
  • In response to the study, the head of the British medical association said: "What happens ‘on average’ is of no help when one is faced with a specific patient"
  • The important lesson is to ask a question carefully and be willing to accept the answer, no matter how much you don’t like it

Evidence-Based Medicine

  • In 1992, David Sackett of McMaster University coined the term "evidence-based medicine"
  • As a result, randomized double-blind trials are accepted as the gold standard for medical research
  • Cochrane.org now archives results from hundreds of medical studies conducted to that standard
  • Doing this was possible before the internet, but the internet brings it to a wider audience
  • You can go to Cochrane.org, look at the data and search for cause and effect

Evidence-Based Development?

  • That’s well and good for medicine. How about programming?
  • Consider this quote by Martin Fowler (from IEEE Software, July/August 2009):
    ”[Using domain-specific languages] leads to two primary benefits. The first and simplest, is improved programmer productivity… The second…is…communication with domain experts.”
  • What just happened?
    • One of the smartest guys in our industry
    • Made 2 substantive claims
    • In an academic journal
    • Without a single citation
  • (I’m not disagreeing with his claims – I just want to point out that even the best of us aren’t doing what we expect the makers of acne creams to do)
  • Maybe we need to borrow from the Scottish legal system, where a jury can return one of three verdicts:
    • Innocent
    • Guilty
    • Not proven
  • Another Martin Fowler line:
    ”Debate still continues about how valuable DSLs are in practice. I believe debate is hampered because not enough people know how to use DSLs effectively.”
  • I think debate is hampered by low standards of proof

Hope

  • The good news is that things have started to improve
  • There’s been a growing emphasis on empirical studies in software engineering research since the mid-1990s
  • At ICSE 2009, there were a number of papers describing new tools or practices routinely including results from some kind of test study
  • Many of these studies are flawed or incomplete, but standards are constantly improving
  • It’s almost impossible to write a paper on a new tool or technology without trying it out in the real world
  • There’s the matter of the bias in the typical guinea pigs for these studies: undergrads who are hungry for free pizza

My Favourite Little Result

  • Anchoring and Adjustment in Software Estimation, a 2005 paper by Aranda and Easterbrook
  • They posed this question to programmers:
    ”How long do you think it will take to make a change to this program?”
    • The control group was also told:
      ”I have no experience estimating. We’ll wait for your calculations for an estimate.”
    • Experiment group A was told:
      ”I have no experience estimating, but I guess this will take 2 months to finish.”
    • Experiment group B was told:
      ”I have no experience estimating, but I guess this will take 20 months to finish.”
  • Here were the groups’ estimates:
    • Group A, the lowball estimate: 5.1 months
    • Control group: 7.8 months
    • Group B, the highball estimate: 15.4 months
  • The anchor – the “I guess it will take x months to finish” — mattered more than experience.
  • It was a small hint, hint buried in the middle of the requirements, but it still had a big effect, regardless of estimation method or anything else
  • Engineers give back what they think we want to hear
  • Gantt charts, which are driven by these estimates, often end up being just wild-ass guesses in nice chart form
  • Are agile projects similarly affected, just on a shorter and more rapid cycle?
  • Do you become more percentage-accurate when estimating shorter things?
  • There’s no data to back it up!

Frequently Misquoted

greg wilson 2

  • You’ve probably heard this in one form or another:
    ”The best programmers are up to 28 times more productive than the worst.”
  • It’s from Sackman, Erikson and Grant’s 1968 paper, Exploratory experimental studies comparing online and offline programming performance
  • This quote often has the factor changed – I’ve seen 10, 40, 100, or whatever large number pops into the author’s head
  • Problems with the study:
    • The study was done in 1968 and was meant to compare batch vs. interactive programming
      • Does batch programming resemble interactive programming?
    • None of the programmers had any formal training in computer programming because none existed then
      • (Although formal training isn’t always necessary – one of the best programmers I know was a rabbinical student, who said that all the arguing over the precise meaning of things is old hat to rabbis: “We’ve been doing this for much longer than you”.)
    • What definition of “productivity” were they using? How was it measured?
    • Comparing the best in any class to the worst in the same class exaggerates any effect
      • Consider comparing the best driver to the worst driver: the worst driver is dead!
    • Too small a sample size, too short an experimental period: 12 programmers for an afternoon
    • The next similar “major” study was done with 54 programmers, for “up to an hour”

So What Do We Know?

  • Look at Lutz Prechelt’s work on:
    • Productivity variations between programmers
    • Effects of language
    • Effects of web programming frameworks
  • Things his studies have confirmed:
    • Productivity and reliability depend on the length of program’s text, independent of language level
  • The take-away: Use the highest-level language you can!
    • Might not always be possible: "Platform-independent programs have platform-independent performance"
    • Might require using more/faster/better hardware to compensate
    • That’s engineering – it’s what happens when you take science and economics and put them together

 

  • Discoveries from Boehm, McClean and Urfrig’s (1975) Some Experience with Automated Aids to the Design of Large-Scale Reliable Software:
    • Most errors are introduced during requirements analysis and design
    • The later a bug is removed, the more expensive it is to take it out
  • This explains the two major schools of software development:
    • Pessimistic, big-design-up-front school: “If we tackle the hump in the error injection curve, fewer bugs get into the fixing curve”
    • Optimistic, agilista school: Lots of short iterations means the total cost of fixing bugs go down
  • Who’s right? If we find out, we can build methodologies on facts rather than best-sellers\

Why This Matters

greg wilson 3

  • Too many people make the "unrefuted hypothesis based on personal observation"
  • Consider this conversation:
    • A: I’ve always believed that there are just fundamental differences between the sexes
    • B: What data are you basing that opinion on?
    • A: It’s more of an unfuted hypothesis based on personal observation. I have read a few studies on the topic and I found them unconvincing…
    • B: Which studies were those?
    • A: [No reply]
  • Luckily, there’s a grown-up version of this conversation, and it takes place in the book Why Aren’t More Women in Science? Top Researchers Debate the Evidence (edited by Ceci and Williams)
    • It’s an informed debate on nature vs. nurture
    • It’s a grown-up conversation between:
      • People who’ve studied the subject
      • Who are intimately familiar with the work of the other people in the field with whom they are debating
      • Who are merciless in picking apart flaws in each other’s logic
    • It looks at:
      • Changes in gendered SAT-M scores over 20 years
      • Workload distribution from the mid-20s to early 40s
      • The Dweck effect
        • Have 2 groups do a novel task
        • Tell group A that success in performing the task is based on inherent aptitude
        • Tell group B that success comes from practice
        • Both groups will be primed by the suggestions and “fulfill the prophecy”
        • We send strong signals to students that programming is a skill inherent to males, which is why programming conferences are sausage parties
      • Facts, data and logic

Some Things We Know (and have proven)

Increase the problem complexity 25%, and you double the solution complexity. (Woodfield, 1979)

The two biggest causes of project failure (van Genuchten et al, 1991):

    • Poor estimation
    • Unstable requirements

If more than 20 – 25% of a component has to be revised, it’s better to rewrite it from scratch. (Thomas et al, 1997)

  • Caveats for this one:
    • It comes from a group at Boeing
    • Applies to software for flight avionics, a class of development with stringent safety requirements
    • Haven’t seen it replicated 

Rigorous inspections can remove 60 – 90% of errors before the first test is run (Fagan, 1975)

  • Study conducted at IBM
  • Practical upshot: Hour for hour, the most effective way to get rid of bugs is to read the code! 

Cohen 2006: All the value in a code review comes from the first reader in the first hour

  • 2 or more people reviewing isn’t economically effective
  • Also, after an hour, your brain is full
  • Should progress be made in small steps? Look at successful open source projects

Shouldn’t our development practices be built around these facts?

Conway’s Law – often paraphrased as “A system reflects the organizational structure that built it” — was meant to be a joke

Nagappan et al (2007) and Bird et al (2009) got their hands on data collected during the development of Windows Vista and learned:

  • Physical distance doesn’t affect post-release fault rates
  • Distance in organizational chart does
  • If two programmers are far apart in the org chart, their managers probably have different goals [Joey’s note: especially in companies like Microsoft where performance evaluations are metrics-driven]
  • Explains why big companies have big problems
  • I remember once being told by someone from a big company that "we can’t just have people running around doing the right thing."

Two Steps Forward

  • Progress sometimes means saying "oops"
  • We once thought that code metrics could predict post-release fault rates until El Emam et al (2001): The Confounding Effector of Size on the Validity of Object-Oriented Metrics, where it was revealed that":
    • Most metrics values increase with code size
    • If you do a double-barrelled correlation and separate the effect of lines of code from the effect of the metric, lines of code accounts for all the signal
  • It’s a powerful and useful result, even if it’s disappointing
  • It raises the bar on what constitutes "analysis"
  • We’re generating info and better ways to tackle problems

Folk Medicine for Software

  • Systematizing and synthesizing colloquial practice has been very productive in other disciplines – examples include:
    • Using science to derive new medicines from folk medicine in the Amazon
    • Practices in engineering that aren’t documented or taught in school
  • There’s a whole lot of stuff that people in industry do as a matter of course that doesn’t happen in school
  • If you ask people in a startup what made them a success, they’ll be wrong because they have only one point of data
  • If you’re thinking about grad school, it’s this area where we’ll add value

How Do We Get There?

  • One way is Beautiful Code, a book I co-edited
    • All proceeds from sales of the book go to Amnesty International
    • In its 34 chapters, each contributed by a different programmer, they explain a bit of code that they found beautiful
    • I asked Rob Pike, who contributed to the development of Unix and C, and he replied "I’ve never seen any beautiful code."
    • I asked Brian Kernighan, another guy who contributed to the development of Unix and C, and he picked a regex manager that Rob Pike wrote in C
  • This has led to a series of "Beautiful" books:
  • The next book is "the book without a name”
    • I would’ve called it Beautiful Evidence, but Edward Tufte got there first
    • The book will be about "What we know and why we think it’s true"
    • Its main point is knowledge transfer
    • I’m trying to change the debate
    • I want a better textbook, a believe that this will be a more useful textbook
  • "I want your generation to be more cynical than it already is."
  • I want you to apply the same standards that you would to acne medication
    • How many of you trust research paid for by big pharma on their own products?
    • I want you to have higher standards for proof
  • The real reason all this matters? [Shows a slide with a picture of the world and his daughter]
    • “She is empirically the cutest kid in the world”
    • Public debate is mostly evidence-free
    • You’re not supposed to convict or release without evidence
    • I want my daughter to inherit a better world

What University is For

  • [Asks the audience] Hands up if you think you know what university is for
    • One student answers “A piece of paper!”
    • Greg’s reply: "Remember when I said I wanted you to be more cynical? Don’t go that far."
  • In my high school in interior BC, there was no senior math or physics course, because there was no interest
  • I went to university, hungry to learn
  • I later discovered that it wasn’t about the stuff you learned
  • Was it supposed to teach us how to learn?
  • It’s supposed to train us to ask good questions
  • Undergraduates are the price universities pay to get good graduate students
  • This thinking got me through the next 15 years
  • Then I went back to teaching, at U of T, and I think I know what universities are for now:
    • We are trying to teach you how to take over the world.
    • You’re going to take over, whether you want to or not.
    • You’re inheriting a world we screwed up
    • You’ll be making tough decisions, without sufficient experience or information
  • Thank you for listening. Good luck.

Comments from the Q&A Session

  • Who’s going to an anti-proroguing rally this weekend?
    • It won’t do you any good
    • You want to make change? It’s not made at rallies, but by working from within
    • The reason you can’t teach evolution in Texas isn’t because fundamentalists held rallies, but because they ran for the school board
    • We have to do the same
    • To make change, you have to get in power and play the game
    • “Dreadlocks and a nose ring does not get you into the corridors of power”
    • The ACM and IEEE are arguing your case
      • Join them and influence them!
  • Do we want to turn out engineers, who are legally liable for their work, rather than computer scientists, who are not?
    • Some of us will have professional designations and be legally liable, some of us won’t — there’s no one future

This article also appears in Canadian Developer Connection.

Categories
Uncategorized

CUSEC 2010 Keynote: Reg Braithwaite – “Beautiful Failure”

Reg Braithwaite, standing at the lectern, giving his keynote at CUSEC 2010

Here’s the third in my series of notes taken from keynotes at CUSEC 2010, the 2010 edition of the Canadian University Software Engineering Conference. These are from Beautiful Failure, a keynote given by my friend Reg “Raganwald” Braithwaite, who’s forgotten more about combinators than I will ever learn.

My notes from his keynote appear below; Reg has also published his slides online.

  • I gave a talk at Stack Overflow DevDays Toronto in which I was thinking out loud about programming about programming
  • I was trying to rewrite the way we program
  • The language we use for coding guides the way we think about the program and the solutions
  • When you write things to change your programming language, you change the way you think

Thinking About Programming About Programming

  • I often get called in by clients to automate a process
  • Often, during this process, they want to change the process that I’m supposed to automate
  • Automating a process forces you to think about it
  • The very act of thinking about how you do things helps you understand what it is you do
  • The exercise of thinking it through is useful, even if it fails or you don’t end up using it
  • Languages and frameworks come and go, but everything you to do fix what’s between your ears stays with you forever
  • Programming languages are just a notation for the way we think

 

  • Some people try to do things like add a "sum" method to Ruby’s Enumerable mixin
  • What happen when you try [[1, 2], [3, 4], [5, 6]].sum?
  • [He showed two implementations of a “sum” method:
    • One by “Alice”, which when applied to [[1, 2], [3, 4], [5, 6]], yielded 21,
    • and one by “Bob”, which when applied to [[1, 2], [3, 4], [5, 6]], yielded [1, 2, 3, 4, 5, 6]
  • With “monkeypatching”, it’s possible for two different modules to implement Enumerable#sum, and then for someone else to import both modules.
    • In which case, which version of sum will get called? It depends on the load order of the module
    • But what if these were written as gems? Then there’s trouble
  • To solve this sort of problem, I decided to steal extension methods from C# and add them to Ruby [Joey’s note: extension methods are a C# feature that let you add methods to an existing class without subclassing]
  • It works, but what’s wrong with what I’ve done?
  • My extension methods for Ruby are a hack…
  • It eliminates the annoyance without solving the core problem
  • Do extension methods reengineer the way we think about problems? Or do they simply deal with an annoyance?
  • Do they reengineer the way we think about programs?

 Reg Braithwaite, standing at the lectern, giving his keynote at CUSEC 2010

  • Take the Single Responsibility Principle (SRP)
  • When you write an extension method, you break SRP
  • When you monkeypatch, you violate SRP
  • Is that bad? I don’t know
    • C# breaks SRP with extension methods
    • Rails "runs roughshod over it"
    • If two popular languages break SRP, maybe SRP isn’t all that
    • What does the sum method tell us?
    • Why is this a beautiful failure?
    • Maybe we’ve gone beyond the class — Ruby is not C++ or Smalltalk
    • Hacks like this scratch an itch and suggest a flaw — what else is flawed?
  • You have an advantage over me
    • I have this ball and chain of experience
    • I’ve been fucking with computers for almost 40 years
    • They way I’ve been doing things has made me a living; I’m not incented to change the way I do things
    • You’re not tied down
  • So now I present a few ideas that have occurred to me — think about them!
    • I don’t have the answers

 

  • Unit tests tell us that compilers are flawed
    • If we need them, what is wrong with our programming languages and compilers that requires us to step out of what we’re doing to implement them?
    • Why do we need to take a great language and bolt something onto the side?
  • Github tells us that our existing idea of a program is flawed
    • Most people think of programs as static things
    • In Github, there is no "program" — there are branches, forks and tags
    • Languages themselves have no notion of what a version is
    • Looking at the way we actually use tools shows that there’s a disconnect between our toolsets and the way we write code
    • Are Github commits congruent to objects?
      • If you change 4 classes in a commit, there must be something they have in common, but that’s not apparent from the way we write them
  • Do we manage work the way we manage code?
    • Project management seems awfully disconnected from our tool chain
    • Consider the complete disconnect between issue tracking and time tracking
    • Maybe not so important in your company, but more important for personal projects
    • Git and Lighthouse — “like two cups connected by string”
  • Do we manage object versions the way we manage API versions?

 

  • "Do not follow in the footsteps of the sages, seek what they sought."
  • What I think is particularly cool and interesting is…but to me
  • Think about what your heroes were trying to achieve using the tools available to you today
  • An example of following blindly in the footsteps of sages:
    • In November 2002, I attended Paul Graham’s “Lightweight Languages 2” conference in Boston
    • The morning keynote was by John Armstrong, who presented Erlang, which today is considered an important language for concurrent programming
    • The afternoon keynotes was Matz, who presented Ruby, one of the most influential dynamic languages that soon after enjoyed a meteoric rise in popularity
    • Many people in the room, die-hard Lisp-heads, were shouting them down because their languages didn’t have macros [Joey’s note: Macros are a Lisp feature that smug Lisp weenies often use in the never-ending “Why my language is better than your language” argument]

Four Ugly Failure Modes and How to Avoid Them

Reg Braithwaite, standing at the lectern, giving his keynote at CUSEC 2010

Confusing correlation with causation

  • I think it’s one of the most prevalent diseases in the business world
  • Ruby is not a silver bullet
    • Was the success of many Ruby projects [such as Rails and Twitter] because of Ruby the language?
    • Or was it that smart people who could get things done were picking Ruby at a given point in time?
  • Agile is not a process
    • It’s a set of values
  • Here’s how many companies fail:
    • They start a little consulting company
    • They enjoy some successes, which leads to more business
    • As a result, they hire people and the company grows
    • But they can’t hire smart people faster than the work is coming in
    • So in order to hire people to meet the demand, they start hiring people who aren’t as smart
    • That’s when things go downhill
    • Who here doesn’t think this isn’t standard for any consulting company?
  • Toronto Agile User Group recruiting process
    • In our field, "best practices" are cow patties
    • I’ve gone to many companies where they combine "best practices" simply by smooshing them together
    • I’ve been to many Toronto Agile User Group meetings where very few attendees work at companies that even practice agile
    • The important thing is that the people there are attending because interested in finding a better way of doing their work – those are the people you should be hiring!
  • The plural of "anecdote" is not "data"
    • Greg Wilson will talk about this in his keynote later today – listen to him!
    • Problem: Talks are given by narcissists (or masochists)
    • When you read something in a blog, see something on TV or buy a book, you’re not getting a large enough sample, and the content is biased
    • Another problem is that history is written by the survivors
    • People write about really notable successes or failures

Confirmation bias

  • "Most of you will be immune to this, because you’re all sensible people"
  • You might fall victim to confirmation bias if you have an overly-inflated (or under-inflated) ego
  • You might also fall victim to it if your worldview is too narrow
    • If you’re a Ruby developer, you probably don’t read C# blogs, and vice versa
  • Seek out more representative info; not just the stuff that confirms your opinions

Local maxima

  • The innovator’s dilemma
    • If you have customers, they will trap you in a local maximum
    • They’re not trying to be mean, they’re trying to give you money
    • You might end up optimizing to serve your customer base while the rest of the world (and eventually your business moves on)
  • The Principle of Least Surprise is a trap!
    • Familiarity comes from doing the old things the old way
    • This doesn’t apply to just UI, but also naming variables or coding styles
    • Once in a while, you should say "Maybe this one time, we should do things differently"
  • Iterative anything is a trap
    • It’s hill climbing
    • Sometimes you have to leap
    • It’s supposed to be bad to "go dark" in development for a longer period rather than go through many small iterations, but sometimes it’s the only way to make a great leap
    • You can’t climb a big mountain if you do things in small increments

"A Market for Lemons"

  • What happens when you sell to people who don’t fundamentally understand what they’re buying?
  • If customers don’t understand what they’re buying, they make their decisions based on easily differentiable features
  • One example is buying a house, which you’re not going to do very often in your life, so most people know very little about it
    • As a result, they focus on easily differentiable features like square footage, number of rooms, and other features that can easily be picked out
    • But it’s better to focus on whether the house’s design makes it more liveable, which is harder to suss out
  • Another example of this is feature checklists on the back of product boxes
  • Gresham’s Law — “bad money drives out good” — applies to talent: When you have good currency and bad currency in an economy, the bad currency drives the good currency out
    • This happens in Cuba, where the good currency – black market US dollars – gets hoarded while the local currency gets spent
    • It also applies to information: people put the crappy information out, and it drives the good information down
    • It also applies to talent: headhunters, not knowing what sort of people to look for, end up grabbing the people who put the most buzzwords on their resumes
  • You don’t want to be one of those buyers

At the end of the presentation, posted a slide dedicated to his late friend, Sam Roweis (1972 – 2010).

This article also appears in Canadian Developer Connection.