Tuesday, October 11, 2016

Google I/O 2009 - The Myth of the Genius Programmer

despite other slides to the contrary,
"The Myth of the 'Genius Programmer.'"
And before we get started...
Collins-Sussman: Should we do some introductions?
Fitzpatrick: Should we do-- Your mic--can't hear your mic.
Collins-Sussman: Can't hear my mic at all.
Well, let's fix that.
Hey. So let's do some introductions.
Who are we?
Fitzpatrick: My name is Brian Fitzpatrick.
I usually go by Fitz.
Collins-Sussman: My name is Ben Collins-Sussman.
I usually go by Ben Collins-Sussman.
Fitzpatrick: And we're basically a couple
of long-time Version Control geeks.
We worked on Subversion years ago.
Collins-Sussman: And we have a lot of experience
in the Open Source world,
so we tend to speak about things that are related to Open Source,
but not necessarily related to Open Source.
Fitzpatrick: Right. When we started at Google,
we worked on code.google.com.
We still work with Google Code, actually.
Collins-Sussman: Absolutely. And if you're interested
in the project-hosting service, which is what my team works on,
we're doing a talk tomorrow
about our Mercurial implementation
on top of Google infrastructure,
which is a new feature on Google Code.
So come see that.
Fitzpatrick: But enough about us.
Who are you?
So we have a couple questions for you,
so we can get an idea about the audience.
Collins-Sussman: Survey. Fitzpatrick: Survey.
So how many people in this room write code
entirely by themselves only?
Never with other people.
Collins-Sussman: Or how many people
like writing code by themselves?
Fitzpatrick: All right, yeah.
Collins-Sussman: All right, that's great.
Fitzpatrick: So how many people work in teams?
Okay, that's good. Everybody's awake.
How many people in this room do code reviews
as part of your development process?
Collins-Sussman: Wow.
Fitzpatrick: Is that good or bad?
Collins-Sussman: I'm impressed. That's great.
Fitzpatrick: All right, one last question.
Who is afraid of looking stupid in front of other people?
All right, we're in the right place.
Collins-Sussman: So before we go on,
we should let you know these are very opinionated talks
that Fitz and I give every year.
They're really based on our own subjective experience,
and that's fine.
You know, if we say things that upset you or anger you,
we've done our job. Fitzpatrick: Right.
Collins-Sussman: And we encourage you,
if you don't like it, you can...
Fitzpatrick: If you have different opinions,
please get your own talk at your own conference.
So before we go, though,
we're gonna have you do a little more work.
You're gonna have to read a few slides
and check out some of our quotes here
that we've got.
Collins-Sussman: What is this talk about?
Fitzpatrick: We're not gonna read them to you,
so here's the first one.
All right. The second one.
Okay, and now for a really good one.
Collins-Sussman: Okay.
So what do these all have in common?
You guys, any ideas here?
All right, it's a rhetorical question, but...
Right, so what's going on here,
there's a lot of insecurity going on, right?
This is a common feeling that we all have.
So we're gonna go off of this.
We're actually getting these responses last year at I/O.
People were coming up to me and saying these sort of things.
So it got us thinking about,
"Well, what's going on with psychology here?
"What's going on in people's heads?
"Why do they want to hide their code so much?
What's really at the bottom of this?"
Which is how we came up with this talk
and where we get this idea
of the myth of the genius programmer.
Let's do one more quote.
Fitzpatrick: Okay.
Collins-Sussman: Interesting. "Pervasive elitism."
Fitzpatrick: This is rooted out of a general desire
to not look stupid.
It's sort of a-- you know, everybody, I think,
wants to look like a smart developer.
I know I certainly do, to some extent.
And--but there's a lot of different reasons
behind why people do this, and we're gonna start
with something a little almost seemingly unrelated.
But why do people buy products endorsed by celebrities, okay?
Michelle Obama wore this dress to the Inauguration, okay?
Boom, suddenly, it sold out, all right?
Collins-Sussman: Or Michael Jordan
wears Nike shoes, right?
Everyone wants to buy Nikes
'cause they love Jordan or basketball.
What's really going on here?
Like, do you actually believe that if you buy Air Jordans,
you're gonna be as good as Michael Jordan?
Fitzpatrick: Yes. Collins-Sussman: No.
But there's something going on, right?
There's some nugget of human psychology going on here,
where it's in our instinct to find celebrities,
find people to idolize and want to be like those people,
and we sort of latch on to whatever simple behaviors
or materialistic pieces that remind us
of this celebrity or this behavior.
Fitzpatrick: That's true in the world of programming as well.
I mean, we have our heroes.
We have Linus Torvalds, to some extent, Bill Gates even.
Guido here at Google--
you know, I mean, he wrote Python himself, right?
Not quite true, you know?
Collins-Sussman: Did Linus write Linux all by himself?
Fitzpatrick: Right. We have Kernighan and Pike
and Kernighan and Ritchie.
I mean, these guys don't always deserve all the credit.
They certainly deserve some of the credit.
They're the leaders, right?
Or they sort of started something,
but they're mythologized.
So the personas that they become
are bigger than life, to some extent,
and, to some extent,
rooted in a little nugget of truth or fact
and a whole lot of myth.
Collins-Sussman: So that's why we have this myth.
When we say "the myth of the genius programmer,"
we're talking about the myth of, "Hey, here's a genius,
"and genius goes off in a cave and writes this brilliant thing
"and then reveals it to the world
and, 'Oh, my gosh, this person's famous forever,'" right?
Reality is, that's not really how it works at all.
They're--In fact, geniuses...
they are so incredibly rare that, I mean, it's almost--
it's kind of a meaningless term, right?
Fitzpatrick: Right. Collins-Sussman: Those folks--
That myth just isn't true.
Fitzpatrick: So, yeah, the ultimate geek fantasy
is to go off into your cave and work and type in code
and then shock the world
with your brilliant new invention, you know?
You--It's a desire to be seen as a genius by your peers.
Collins-Sussman: But there's a flip side to that too, right?
It's not just about, "I want everyone to--
I want to be a genius and shock the world."
It's also, "I'm insecure."
And what I mean by that is, you know,
"I also don't want people to see my mistakes.
"All right, maybe I won't be a genius.
"Maybe I won't shock the world with my brilliance,
"but at least I don't want them to see my trail
"of failures and mistakes,
and I'm gonna cover my tracks," right?
Fitzpatrick: Well, they want to be seen as being clever, right?
Collins-Sussman: Clever people don't make mistakes.
Fitzpatrick: Right, exactly.
So the result is people wind up working in a cave.
A classic example of this is,
how long will you drive around before asking for directions?
How long are you gonna be completely lost
before asking for directions, you know?
I mean, you're not gonna say, "Oh, I'm lost.
I'm immediately gonna ask for directions."
Collins-Sussman: Well, it's hard to admit
that you've made mistakes sometimes,
especially publicly, right?
So that's why we showed these quotes in the beginning
with people saying, you know, "Can you erase my history?
Can you hide my project until it's perfect?"
Right? I mean, it's more of this,
"I don't want to show everybody what I'm doing
till I think it's perfect."
Fitzpatrick: Right. So you may be thinking, "Well, big deal."
Collins-Sussman: Why do we care?
Fitzpatrick: Why is this a problem?
Why should I care about this?
The primary reason is it inhibits progress
and not just personal progress, but project progress, okay?
It's sort of the "many eyes make all bugs shallow" quote.
But if everyone's off working in a cave
and just occasionally throwing code out to the project,
code quality remains low,
and your bus factor remains low.
How many people here have ever heard of the bus factor?
Collins-Sussman: We talk about it every year.
Fitzpatrick: Weren't you here last year?
No, okay.
Bus factor is the number of people
on your software project
that have to get hit by a bus
that are gonna leave you in a world of hell, okay?
All right? So if there's only one person
that knows that really obscure file-system code
and they get hit by a bus,
whether that bus comes in the form of an actual bus,
or they get married,
or they have a kid, or they change jobs,
or they move away, or they get bored...
Collins-Sussman: It happens all the time.
So this is one of the things
we talk about all the time in teams,
whether it's a team at work or a team on an Open Source,
is to not get so territorial that you have low bus factor
on different components, right?
It's a common thing, right?
You know, you can't touch that code.
It belongs to Joe.
Well, wait a second, you know.
What happens if Joe's gone, right?
Now you're in trouble.
So one of the things you should be watching out for
is you should have as many people touching
and getting familiar
with as many parts of the code as possible.
You want that redundancy on your team.
But if you're off working in a cave
and you're hiding your tracks,
well, no one knows what you're doing.
Fitzpatrick: You could be working
on the wrong thing entirely, actually,
if you're off doing some really big feature
or big piece of code.
Collins-Sussman: Well, here's a nice analogy
that we like to talk about, which is, you know,
think about the way you interact with your compiler, right?
You have a really tight feedback, right?
You write a function, you compile it,
make sure it at least compiles, right?
Maybe you write a UniTest if you're doing great, right?
But nobody sits down and writes,
you know, thousands and thousands of lines of code
and then runs their compiler for the first time.
It just doesn't happen.
Fitzpatrick: Not anymore. Collins-Sussman: [laughs]
Fitzpatrick: Maybe 50 years ago, right?
Collins-Sussman: Right. In the mainframe days maybe.
So, you know, it's the same way--
if you're working on programming in any way,
you should not be doing it all in a cave
and then sort of waiting to spring it and see what happens.
You want other people seeing what you're doing
as soon as it makes sense, right?
We'll talk about what that is.
Fitzpatrick: Right. But I mean, in addition,
if you're off in the cave, you don't learn as quickly.
It's harder for you to improve your skills, right?
There's a balance between spinning your wheels
and being lost
and asking the person next to you
every question that comes into your head, right?
But I mean, this problem isn't unique to computer science.
It pervades all sciences, you know, math, anthropology,
especially when you get into hard research,
you know, you see this sort of thing.
Collins-Sussman: Well, I think if any folks
are in the academic world,
and computer science is part of this,
there's this constant tension probably caused
by the "publish or perish" philosophy, right?
Where, gee, you're all supposed to be in academia.
You're supposed to be sharing knowledge
and collaborating and helping each other
and cooperatively advancing the state of the art,
but everybody has to hold their research to their chest
and not show anybody what they're doing
until they're published, right?
And what happens?
Oh, you end up publishing a paper
which is redundant with somebody else's paper, right?
Or maybe you worked on the wrong thing and didn't realize it
'cause you never told anybody what you were doing.
Or maybe if you had collaborated with this other person,
you guys could've written a better paper together, right?
Same exact tension, just in writing software, right?
The sooner you get your idea out and other people looking at it,
you can find out, "Am I working on the right thing?
"Do I have the right idea?
"Should I go back to the drawing board?
"Should I be collaborating with this person
'cause they're working on it too?"
I mean, it's the same issue.
Fitzpatrick: Right. So a little bit of more bad news
to this for you, okay?
Is that you're not a one-of-a-kind, right?
The, uh...
If you're one-in-a-million, right?
That means there's over a thousand people just like you
out there right now, okay? Collins-Sussman: It's true.
Fitzpatrick: Glad you guys liked that. Thanks.
But even if you're a genius,
working well with others may make or break you, okay?
Like attracts like.
And we work hard to hire really smart people at Google.
And I don't care how smart you are.
If you can't sit there and communicate with someone else
or work together in a team and achieve consensus,
you're not gonna be successful working on a team of people.
Collins-Sussman: This is one of those things
that I always try to communicate,
especially to students
who are just starting out in computer science
is that software,
even though it's fun to write code alone,
you know, late at night in your basement, whatever,
actually writing software that's successful--
it's an inherently collaborative activity.
And it actually forces you to deal with people
and talk with people, and that's why we encourage people
to get involved in Open Source, because it's sort of like,
"Okay, well, maybe you're still in college,
but here's your chance to actually work with people
and work on a team and see what it's gonna be like.
I mean, one of the things I always ask people is,
"Can you name a piece of software
"that's really successful,
"really widely used by a lot of people,
and was written by one person?"
Fitzpatrick: And before anybody yells out Metafont,
that's not widely used, okay?
But anyway, so this is a trap, okay?
Of this sort of wanting to be a genius.
So how do we avoid this, okay?
Quite frankly, the first step is to drop the ego, okay?
Instead of having a large personal ego,
which actually impedes collaborating on a project,
have a strong collective ego around your project
or the piece of software you're working on.
A great example in the Open Source world
is the Apache Software Foundation, okay?
Community is the essence of every project
in the Apache Software Foundation.
That's what's most important to them, more so than code.
Companies call Apache up all the time and say,
"Hey, we want to give you guys a billion lines of code.
Blah, blah, blah."
Collins-Sussman: And then walk away.
Fitzpatrick: And then, yeah, "Have a nice day."
And they're like, "We don't want it.
"We don't want a pile of code by itself
"that it's just gonna bit rot.
We want to build a community around this."
And so, as a result, people working on the projects
tend to be proud of--I mean, I don't know about you guys,
but I want to be proud of the stuff that I'm working on.
Collins-Sussman: Absolutely.
It's a good way to keep your project healthy too.
Fitzpatrick: So you don't want to be this guy.
Collins-Sussman: Not on your project.
Next thing to think about
is how you interact with people.
How do you give each other feedback?
And it involves, you know, actually being a nice person.
Fitzpatrick: What? Collins-Sussman: I know.
It's crazy.
But it is--actually, it is a learned skill
to give constructive criticism,
whether it be a code review or just a design,
discussion of design.
And to take criticism as well.
If you work in Open Source, you learn to be pretty thick-skinned
so that you can take nonconstructive criticism
along with the constructive criticism,
but it's something that we should all aspire to do, right?
Is how to do it in a nice way.
Fitzpatrick: Right. The way to look at it is that
your code isn't part of you, right?
You want to work for the best piece of software as a whole,
not to sort of get your one little clever bit in.
Here's an anecdote.
A friend of mine left Apple a few years ago,
went to work at a smaller company
that had been around for a while as an engineering manager.
And he went in and saw that they were using Version Control,
and he set up so it would send out code-review emails,
'cause they weren't sending out code-review emails.
And he started doing code reviews.
And, you know, he thought,
"Okay, you know, I'm gonna try and get these guys
"a little, you know, more rigorous engineering.
We'll have some better practices here."
And a week and a half later,
the director of engineering calls him in and says,
"You know, I'm getting a lot of feedback
"that you're really bringing people down
with all this negative criticism of everybody."
He's like, "What are you talking about?"
"Yeah, these code-review things you're doing,
you know, people are getting really upset by that."
And, you know, how do you respond to that?
This is something that is really integral, I think,
to writing good software.
Collins-Sussman: That's a cultural problem, too,
in some companies, right?
Some people really--
Especially in a lot of corporations,
you'll see not only territorial--
You know, "This is my code. You can't touch it."
But also, "How dare you tell me what to write
"or make comments on what I just wrote?
Mind your own business."
I mean, that is a very common behavior,
and it's hard to get companies to break out of that cycle,
increase the bus factor,
do code review all the time.
At Google, we actually--
We're not allow to submit code
into our Version Control system until there's code review.
Like, it will reject your change
until there's proof that some peer
has looked at what you've done and given it a thumbs-up,
which is a great thing.
Fitzpatrick: Right. So criticism is actually good.
And the next important thing is that you have to learn
to sort of embrace failure, okay?
People, I mean-- I'm afraid of failing.
Certainly, I think most people are, okay?
But, you know, the whole NASA "failure is not an option" thing
is a load of crud, right?
Failure is an option, except in one case.
It's failing on the same thing repeatedly.
That's never good, because you're not learning, right?
Collins-Sussman: And it's embarrassing.
Fitzpatrick: Well, it's embarrassing,
but if you're failing-- You try something and fail.
Try something different and fail,
and you try something different.
Every time you fail, you learn something.
And for many people, that's the best way
that they learn how to do things.
Some people learn by sitting in a room
and hearing two other guys yammer on forever.
Some people learn by reading a book.
And some people learn by looking at pictures.
Some people learn by trying and failing.
Collins-Sussman: Well, this is also important--
I mean, it's another cultural issue here,
is when failure does happen, be ready for it.
Don't freak out.
Document what happened, what did you learn from it.
What are you gonna do different next time, right?
That's why we do postmortems on--
you know, when something crashes,
or there's some-- some bad thing happens.
We write it up and learn from it.
Fitzpatrick: Right. And the point is not to assign blame.
It's to look at what you did,
have everyone else look at what happened
so that we don't do this again.
Collins-Sussman: I think a big issue also around failure
is just natural human fear.
I have a--You know, I can relate to this personally.
I started learning banjo a few years ago,
playing in bluegrass jams.
And, you know, they would occasionally try to call on me
to do banjo solos, right?
Which is really, really hard to learn,
and I just wouldn't do it, or I--you know, bow out.
And someone took me aside, and he said, you know,
"You realize that 50% of learning to solo
"is just not caring how good you sound
and just losing the fear."
It was totally true.
I was like, "All right, these are my friends.
If I sound terrible, who cares?"
And sure enough, I mean, he was absolutely right.
I just started playing really bad solos,
but it got better and better, and I kept learning,
and that was a huge step.
So I mean, if you can just make that mental shift
and say, "It's all right.
I'm gonna fail, and it's not a big deal."
No fear. That's fine.
You move on. You learn.
You've got a better anecdote, actually.
Fitzpatrick: Well, this is a complete anecdote.
It's a story about the executive
who makes a bad business decision,
and the company loses $10 million for the company.
The next morning, comes into work.
His secretary says, you know,
"The CEO wants to see you in his office."
And the guy hangs his head down.
He's like, "This is it. I'm gonna get fired," you know?
Walks into the CEO's office, and he's like,
"So I guess you want my resignation."
The CEO looks at him and says, "Resignation?
"I just spent $10 million training you.
Why would I fire you?"
But again, I mean,
I bet you that's a mistake that guy never will make again.
I lived in Italy for three years, okay?
I moved there, and I had been studying Italian,
and I was really proud to use my Italian.
I went into a cafe, and I ordered a sandwich,
and they give me this massive sandwich,
and I wanted a knife to cut it with.
So I thought I'd be cool and use my Italian,
and I promptly asked them for a toothbrush to cut my sandwich.
[laughter] The guy just looked at me.
And I'm like, "Toothbrush." And he's like, "No."
Collins-Sussman: That's true.
Fitzpatrick: But never made that mistake again.
Collins-Sussman: Speaking languages
in a foreign country is very intimidating.
I mean, you're just so scared of looking like a fool,
but you don't learn otherwise.
Fitzpatrick: Well, it's the easiest way to learn, I think.
That sort of hot-white fear you get going up your neck
'cause you asked for something embarrassing.
Collins-Sussman: So failing is--
It's not just about embracing failure,
but it's also failing fast, right?
We're talking about iterating as quickly as we can.
This is something we actually talk about a lot at Google,
was don't just fail, fail quickly
and pick up and try something different as fast as you can.
And that's why we've got sort of, like--
We got this Google Labs site now, right?
Where are people are experimenting
with different projects.
And if they fail, that's fine.
They'll just put something up
or change it the next day and try it again, right?
The faster you can fail and the faster you can iterate,
the faster you will learn and get better.
Fitzpatrick: And you don't have to hide it if you fail.
It's okay, you know. You don't have to hide your tracks.
We talk about, you know, in a Version Control world,
you know, people use Subversion versus Mercurial
versus Git, et cetera.
Git Rebase is something
that people use often to sort of hide their tracks.
There are some legitimate uses, I think,
if you want to clean things up a bit.
Collins-Sussman: Or maintain a vendor branch.
Fitzpatrick: Maintain a vendor branch, et cetera.
But people are typically looking to say,
"Oh, you know, I was working on all this stuff.
"I made all these sort of false starts
"I don't want anybody else to see,
"you know, my stupid mistake here,
where I forgot to check the type of something."
Collins-Sussman: Rewrite my history so it's perfect.
Fitzpatrick: That's right. Yes, exactly.
Just like the history of the world.
But what it comes down to is--
One of the ways of making this problem better
is to practice, okay?
If you practice,
it makes your iteration-failure cycle faster, okay?
And it basically--
it's sort of less scary to fail,
because you'll tend to have smaller failures.
Collins-Sussman: This way, the failures
tend to get smaller over time,
and the successes tend to get larger,
and that's a trend you'll see,
especially if you're learning as you fail fast.
Fitzpatrick: Right.
And the next thing is sort of to be a small fish, all right?
If you were the senior developer
on a team or in a company or something
and everyone looks to you and you're sort of the teacher
or the king/queen bee, whatever,
if you're only working with people junior to you,
you are gonna learn things from them,
but it's gonna be harder to improve your skills
than it would be if you were working with someone else
who is smarter than you, who is a better engineer than you.
Collins-Sussman: Actually, you know,
in my experience, when you're a big fish in a pond,
it's very comfortable,
but you're not really learning very much, right?
You feel safe, but you don't get much better.
And when you are a small fish in a huge pond,
it's very scary, right?
Fitzpatrick: Sometimes you get eaten, though.
Just kidding.
Collins-Sussman: That's what it was like
when we started at Google, right?
It was very like, "Aah!"
You know, it's just so many people.
But you get better really quickly, right?
Again, it's all about the reward of facing that fear.
Fitzpatrick: It's like the old Emacs joke, you know?
It's got a really steep learning curve,
but that just means you learn a whole lot
in a short period of time, right?
But beyond being a small fish, the other thing is to sort of--
And this has to do with not only being successful,
but also being a leader, which is to be influenced, okay?
'Cause the more that you're open to the influence of other people
who might have a really good idea
or a novel way of looking at something
or accomplishing something--
The more actual influence that you bank and have on others,
the more likely they are to listen to you.
Collins-Sussman: Or it's respect is a two-way street, right?
I would say it's not just about respect being a two-way street.
It's about vulnerability,
in that if you can show yourself
to be open to change and willing to admit mistake--
I guess being vulnerable
is another form of being influenced, right?
It's an extreme case.
If you can admit your mistakes in front of your peers
and say, you know, "I was wrong. I made the wrong choice.
I had the wrong opinion."
A lot of people are afraid to admit that,
'cause they're afraid, you know, in the short term,
it's gonna make them look weak
or like they don't know what they're doing.
But in fact, you know, if you think about people
that you really admire, you may have worked with,
they make themselves vulnerable a lot.
And over the long term, they get perceived
as big figures, big strength figures, right?
Wow, that person is so strong
that they're not afraid to admit mistakes and failures.
Fitzpatrick: Oh, and it's not just about their ideas
or their way of doing things.
It's a way also to sort of cement people's dedication
to what your project is or what you're doing,
'cause, you know, we like to talk about buses a lot, I guess,
but it's the difference between being the person driving a bus
and a whole bunch of people as passengers
that are following you
and taking turns driving the bus, right?
If you're working on a project,
whether it's an Open Source project or within a company
where different people take the lead at different times,
you're gonna attract a different caliber of person,
or different type of person,
who wants to participate and carve out the path
as opposed to somebody following you.
Collins-Sussman: Absolutely. So let's talk about--
A little diversion here and talk about software tools,
since that's--our background is in software tools--
and talk about, specifically, how they affect
your collaboration and your social habits.
One of the classic Internet sayings, right, is,
"You can't fix social problems with technical solutions" right?
And there's all sorts of classic examples of, like--
For example, you know, the whole DRM issue, right?
Or if we just keep inventing
more and more complicated DRM technology restrictions,
they don't fix the problem, except most people will say,
"Well, really, there's some kind of social issue here."
What is intellectual property? What is fair use?
What is--you know, what is the nature of--
Fitzpatrick: Isn't that problem solved yet?
Nobody downloads music anymore, right?
Collins-Sussman: Clearly, it's a societal, cultural issue, right?
Not something that can just be papered over
with evermore complex DRM technologies.
Or another one I've talked about is, in Version Control,
I see a lot of people--
A lot of administrators will start, you know--
especially in Open Source projects,
they'll start trying to do path-based access control
and say, "This person's allowed to commit to this branch,
"but not this one.
And this person can only commit to this file, but not this one."
They start creating all these complicated rules,
and I sort of say, "All right, well, what's going on here?
Why are you creating all these technological restrictions?"
"Oh, we got to make sure people
don't commit to the wrong places."
And they're like, "Well, if they did, what would happen?"
You would all notice it. You'd roll it back, right?
'Cause it's a Version Control system.
You can undo, right?
You'd ask the person what happened.
If it was a mistake, they apologize.
If it wasn't a mistake, they're in trouble, right?
Or you tell them to leave the project or something.
So it's sort of, like, okay, it's a social problem.
You don't need this technological restriction
to solve it.
It's not a good solution.
Fitzpatrick: Or the endless spams arm race, right?
I mean, that's--that's-- it goes back and forth, right?
Collins-Sussman: The social problem being
the world is full of jerks.
Fitzpatrick: Right, exactly. Yeah, exactly, that's the thing.
You know, the Internet-- That's what I was saying.
The world is full of jerks, but the Internet makes it seem
like they all live right next door to you, right?
So you can't use technology
to solve these sociological problems, right?
Well, not always, okay? Collins-Sussman: Usually.
This is--this is a--
It's sort of a-- it's a false truth,
insofar as there are things you can do to encourage people
to "do the right thing," right?
For example, on Google Code,
if you want to comment on an issue on the issue track,
if you want to create an issue or something or file a bug,
you have to sign in, right?
There's a very simple reason for that.
First of all, we want to limit spam a little bit,
but more importantly, if someone reports a bug,
it's nice to have a way to get back to them.
I can't tell you how many times in the past
people have reported bugs out there,
and they leave no contact information,
or they screw up their email address or something like that.
Collins-Sussman: Right. So that's an example
of a small technological change having a big social impact.
Fitzpatrick: It doesn't solve the problem.
Collins-Sussman: But it definitely changes behavior.
Another example is on Google Code project hosting,
we only allow a small number of licenses,
which angers a lot of people, right?
They want to come in and use some Open Source license
that's fairly obscure,
and they say, "Why isn't it on the site?"
And our answer is, "Well, because we want to stop
"proliferation of Open Source licenses.
We think it's bad for the Open Source world."
And that's fine, you know.
Either they'll choose one of the standard licenses,
or they'll go host their code somewhere else,
which is okay, but we've had a definite impact,
a social impact, through that small technological choice.
Fitzpatrick: Right. Collins-Sussman: So, yeah.
Sometimes you can affect--
You may not be able to solve gigantic social problems,
but you can have--
Small technological choices
can have big social, behavioral changes, right?
Fitzpatrick: So defaults are important, okay?
I mean, you want to examine
how do tools behave out of the box, okay?
This doesn't actually fix the core social issue at hand,
but it does influence people's behavior quite heavily.
Collins-Sussman: So let's look at some--
how some software tools behave.
What's their default behavior,
and how does it affect the way you collaborate?
One example is--
How about, you know--
On your software team, when somebody commits a change,
maybe you do code review beforehand,
but certainly in the Open Source world,
it's pretty common to do code review
after somebody submits a change, right?
In a lot of projects, an email will go out with the diffs,
and it'll go into all the mailboxes
of all the participants.
And what's cool about that is that it makes it
almost effortless to do code review, right?
It's like, their changes are being pushed right to your face,
and you're reading your email, and you're like,
"Oh, looks like they got a typo here or a bug.
Let me reply really quick," right?
As opposed to projects that don't do that,
there's almost no code review at all, right?
Big social change for a small technological trick.
Fitzpatrick: Right.
So sort of set the Wayback Machine
before the Internet was really popular
and Open Source was really huge.
How many people here have heard of CVS?
The Version Control system, not the pharmacy.
Okay, good.
Collins-Sussman: We actually asked a bunch of students.
We gave this talk a few weeks ago to a bunch of students,
and we asked, "How many people have heard of CVS?"
And they all raised their hands. Fitzpatrick: I was blown away.
Collins-Sussman: We were like, "Well, you're only, like, 19."
And they're like--
"How many people have heard of the Version Control...?
Nobody raised their... Fitzpatrick: No one at all.
Which is good, really.
Collins-Sussman: Change that slide.
Fitzpatrick: You know, people talk
about Open Source getting big.
They talk about Richard Stallman.
They talk about Linus Torvalds.
But CVS actually played a really important role,
insofar as it cre--
There was a feature created in it in the mid '90s
called Anonymous Pserver.
It was anonymous network access,
where any random one of these jerks on the Internet
could download your source code
into a CVS working copy,
fiddle with it, and then send you a nice, small,
concise patch that could fix a bug,
add a new feature, et cetera.
Collins-Sussman: That was a huge social event, right?
Fitzpatrick: It had a huge impact,
insofar as it made it virtually effortless...
Collins-Sussman: ...Mercurial?
A few. Okay.
Fitzpatrick: Bizarre, anyone?
Collins-Sussman: Monotone. Fitzpatrick: No, just kidding.
Collins-Sussman: Okay, so...
But distributed versions was kind of interesting.
What are the default behaviors of distributed Version Control?
It's sort of a double-edged sword, right?
On the one hand, it's kind of not so great,
because the default behavior, when you start off,
is to fork, right?
You start off grabbing the entire history
and crawling into a cave, right?
And it's actually a little bit more work
if you want to contrib-- get your code back.
You have to find someone else to talk to,
find a server, do a push, right?
I mean, it's actually--
You know, there's a little more effort involved.
So in one sense, it discourages collaboration,
but in another sense, it also encourages collaboration,
because--excuse me--
it lowers the barrier for everyone to participate, right?
Instead of just, you know, "the official committers"
on a project having access to the history,
having the ability to do checkpoints of their code,
now everybody in the world has the exact same tool set,
and everybody can checkpoint their code
and do whatever they want, and there's no--
Being a committer really just becomes a social title, right?
It becomes a branding job rather than
a "I have special tools, and you don't" kind of thing.
Fitzpatrick: And I think this is really great,
but I think it does concern us a little bit
that, you know--
What are people gonna do in four or five years?
Is this gonna sort of tilt the dial
back in the other direction for collaboration?
Collins-Sussman: But like you said,
you know, it lowers the barrier for people walking by
to participate, right?
I mean, in the old days, you had to check out the code,
email a patch,
wait for somebody on the list to review your patch.
Maybe they liked it, maybe they didn't.
And then you were kind of helpless.
Now you don't have to wait for that,
so it might be a good thing too.
Fitzpatrick: Right. So there's a moral to this story, right?
Which is you need to pay attention
to the default behaviors of the tools that you have.
And you need to ask yourself,
"What is the social behavior of this--
this tool is encouraging for-- I mean, to use?"
And that can vastly affect the dynamic of your team, basically.
Collins-Sussman: So there's one more thing
we want to talk about, which is how to--
Right. So we're talking about--
We want to collaborate. Collaboration's important.
Don't be afraid. Pay attention to what your tools are doing.
But here's the big question--
When is a good time to collaborate, right?
Do you do it early on? Do you do it late?
So we have done some wonderful research...
Fitzpatrick: Minutes of research.
Collins-Sussman: Minutes of research
about the evolution of a project, right?
I mean, it starts out as an idea in your head, right?
And then after a little while, you make a prototype
just to sort of show other people
or maybe just to satisfy yourself that it's gonna work.
And then you say, "Hey, come take a look at this."
You show one person or a few friends.
Aah. Ooh, sorry. Nice.
And then you write a lot of code--code, code, code.
And then you dominate the Earth, and everything's fine.
So the real question is, while you're doing this phase--
First of all, you don't have to hide, right?
I mean, you can do all of these phases in the public eye.
It's really a question of,
at what point do you start advertising yourself, right?
Like, even if you've just--
If you're still working on a mock-up,
it's not like you need to be in a cave to do that, right?
Chances are, most people aren't gonna know you're working
on that mock-up, even if you're doing it
on an Open Source repository.
They're not gonna see you until you start screaming
and mailing lists and saying,
"Hey, come look at what I'm doing."
Fitzpatrick: But the real question here is,
where does the third milestone go, right?
You don't want to start involving people
too early or too late.
For good or for bad,
people typically involve people too late.
It's rarely that someone
involves people too early, you know?
If you're done, it's too late, okay?
Collins-Sussman: [laughs]
Fitzpatrick: But there's a huge risk of wasting your own time.
You know, you might be trying to come up with a project
to change the world.
It might be doing something Open Source.
You might be just coming up with sort of something
in your spare time you want to pitch to your team
that you work with at the office, right?
But if you go off and you just make a whole lot of progress
without talking to the people, getting some feedback,
there's a huge risk of just wasting your own time, you know?
You could have really bad design choices
that are undoable without starting over.
You know, anyone--Those of you guys who do code reviews,
if you ever get somebody that gives you
a 5,000-line code review,
what can you really do with that other than check it for syntax?
Or check it and say, "Oh, you forgot.
This is two spaces here. It should be one."
Collins-Sussman: Well, I mean, it's too late to really go back
and make significant changes. Fitzpatrick: Right.
And you're not gonna want to digest all that.
To digest what that amount of code would do,
you really want to see a design doc
or talk to the person about it.
Collins-Sussman: The other issue is that a lot of people
aren't gonna be interested in your project,
because there's no opportunity for them to take a stake, right?
If your project's 95% finished,
why would I want to get involved when it's mostly done, right?
There's very little opportunity
for me to come in and make a mark
and feel like I'm really affecting the direction, right?
So, uh... [laughs]
Talk about brain crack.
Fitzpatrick: Brain crack.
Yeah, so anybody here ever watch the Ze Frank on the Web?
He had this thing called "The Show" a few years ago.
He had this one episode where he talked about brain crack.
It's these ideas people have. People have ideas all the time.
You have an idea, and you think, "This is a brilliant idea."
You sort of nurture it in your head,
and you think about how wonderful it is,
and there's angels around,
and it's the greatest thing ever.
You never act on it,
because as soon as you try and implement it or act on it,
you usually find out that most of them are garbage, okay?
But, you know, you keep these ideas to yourself,
and they're sort of, like-- He calls them brain crack,
you know, 'cause you just feed on them.
So the point is to try to get things out
as quickly as possible.
Collins-Sussman: Well, let's look at the opposite scenario.
What happens if you start getting collaborators
working with you too early in the process?
And the answer to that-- I think a good example
is go look at a huge number of projects
on SourceForge or Google Code,
where there's, like, one author, and there's nothing up there
but, like, maybe a Wiki page that says,
"Dudes, we should write this cool software
and take over the world.
Let's talk about it," right?
And, like...
you know, one of two things happens.
Either nobody cares, and nobody comes, nothing happens,
'cause there's no prototype.
There's nothing to look at, right?
Or, even worse, 50 people come, or 100 people come,
and they all want to do different things,
and you end up sort of having this endless discussion
about what it could be,
and you get into sort of this design by committee
where nothing happens, right?
And the whole thing just kind of stalls.
Fitzpatrick: Well, you--you're the great--
You run the risk of attracting a lot of people
that don't want to do what you want to do, okay?
You want to go there,
and somebody shows up and wants to go here.
And you didn't really communicate
that you wanted to go there in the first place.
So they're not wrong.
You're just gonna waste a lot of time and energy.
Collins-Sussman: So what you want to do
is you want to go for the sweet spot.
What we call the sweet spot is you have a coherent design
and a mission statement, right?
Clearly written out on your Website, goals and non-goals.
What the purpose is-- exactly what you're gonna do.
So people can't show up and completely derail
the direction that you've chosen, right?
And you got to have some amount of running code.
It doesn't have to be a lot,
just enough to say that you're serious
and to get the idea going in other people's heads--
Just a proof of concept, right?
Or just a mock-up or something
so that it's far enough along
that it feels like there's some inertia, right?
But not so far enough along that people feel like,
"Oh, I can still get in and get involved
and really influence this project," right?
"Make a mark. There's a lot of work to do still."
Fitzpatrick: Right, but you have to be ready to make revisions.
You have to be ready for that, for the criticism
and, you know, it might be to make some changes
and discuss and backtrack...
Collins-Sussman: And document your failures.
Fitzpatrick: Don't hide the history.
I mean, that's really-- It's a really important thing.
One thing that we've noticed a lot in Open Source projects
is that there's a lot of documentation
about what they're gonna do and what they'd like to do
and sort of what they've done that's worked for them.
But rarely do you find any documentation
of stuff that they've tried that they failed at, you know?
People have a design doc that didn't work.
They just delete it.
They're like, "Oh, I'm gonna pretend
like that never happened," right?
Collins-Sussman: That whole branch never happened.
Fitzpatrick: Right, exactly.
But in a lot of cases, this can be a huge time-saver,
because let's say that you're having a huge discussion
about something, and you go off and you try it,
and it doesn't work, so you delete the code and whatnot.
A year later, someone comes up and has this huge discussion.
They want to try this great idea
that you did last year and failed, okay?
Now, it's easy enough if you can point them
to the change list where it happened.
Collins-Sussman: What if you've left the project, right?
What if you've left the project,
or the person who tried the experiment is gone?
They're not there to remember
or even point you to the deleted branch to read the docs.
Fitzpatrick: It's good to have that mailing list
that's read there that that happened.
It's not bad. It's okay.
The world is full of false starts
that eventually rot away.
But we have a couple case studies here to talk about.
First of all is Subversion,
which is--you know, was our project many years ago.
And, uh--Well, you go ahead and tell it.
Collins-Sussman: Well, I mean,
I don't know if this is the model,
but we think we did a pretty good job
with starting this project.
I mean, it started out with three guys in an office
writing a design doc together, just the three of them.
Took us maybe two weeks,
three weeks to actually get it right.
And I think three's kind of the sweet number.
Like, one person writing a design doc
is gonna make a lot of wrong choices.
Two or three people is great,
because they can call each other.
They can say, "That's a bad idea. Here's why."
And there's enough perspective.
If you get more than three people,
then it starts to become a circus, right?
It's the same reason, like, why meetings
with more than five people never accomplish anything.
Yeah, never converge.
Fitzpatrick: Everybody ever travel with a group of people,
like travel around Europe or backpack or something?
You get more than six people, you can't go anywhere.
You go to the next corner, and it's a big discussion.
Collins-Sussman: That's true of a business meeting too.
Fitzpatrick: Exactly. It's also true about meetings.
Collins-Sussman: So with design docs,
I think two or three people is sort of that perfect number.
And then after we got the design doc,
we went, and we brought it to a larger forum.
We gave a presentation about it.
We invited comments, and we put it up on a web site,
and we started getting feedback.
And then we just started coding,
and, amazingly, about a month or two later,
we had some working-- very basic working code.
And suddenly, as soon as we had working code,
suddenly all these people started showing up.
We didn't even advertise, but somehow,
it was like we crossed this magic threshold,
and we said, "It's okay now. Come on, come on, come on."
Fitzpatrick: We have to remember nine years ago,
it was CVS in the Open Source world.
Collins-Sussman: It was only CVS.
Fitzpatrick: It was only CVS in the Open Source world.
That was it.
But the other thing-- You're erasing history here.
You forgot to tell them about us going into a cave.
Collins-Sussman: It never happened.
Fitzpatrick: There was a lot of people
that showed up a little bit early almost,
and we said, "All right, we're gonna create
"this private mailing list
"and have our design discussions there,
because these people are distracting us."
Collins-Sussman: Well, we were embarrassed.
Fitzpatrick: Yeah, but Brian Behlendorf
was outraged.
Anybody who knows Brian Behlendorf,
the guy is never outraged.
But he was very angry,
and he told us to cut it out, basically,
and get our butts back out there.
Collins-Sussman: Stop talking in private, right?
If they're bored by what we're saying, they can leave.
Fitzpatrick: Right. And we were pretty indignantly angry
about it at the time.
But, you know, four years later,
you know, we're laughing about it.
He was totally right.
Collins-Sussman: So what's our other...?
Fitzpatrick: Our next case study--
Collins-Sussman: Well, you talk.
Fitzpatrick: All right, next case study is the two of us.
So we've given dozens of talks together
over the past, I don't know, four years, five years,
and we've known each other for about 10 or 11,
but sort of the case study is how we write our talks.
I mean, what we've done over the past five years is we take--
we put the phones away, leave the laptops at the office,
take a couple notebooks, and go to a cafe.
And then they close the cafe.
Collins-Sussman: Paper notebooks, made of tree.
Fitzpatrick: Then they close the cafe, and we find another cafe,
and they close that cafe.
So if we show up in your cafe, you might want to throw us out.
But we sit down there and--
Oh, I forgot to plug in the laptop.
Collins-Sussman: Good thing we're almost done.
Fitzpatrick: Yeah, good thing we're almost done.
Collins-Sussman: Except we lost our...
Fitzpatrick: Lost our...
Is there power? Collins-Sussman: There it is.
Fitzpatrick: Oh, uh, grab it.
It's over here, sorry.
Collins-Sussman: That's it.
Fitzpatrick: So this is a great example of failure.
This is why we did this.
[laughter] This is completely intentional.
You got the plug over there? Thank you.
Collins-Sussman: There we go.
Fitzpatrick: All right, that's much better.
Collins-Sussman: Awesome.
Fitzpatrick: Gosh, I feel stupid.
So case study is forgetting to plug your laptop in.
But so we sit down with-- on paper and we just brainstorm.
One of us usually has an idea for what we want to talk about.
And we'll brainstorm or sort of riff on that idea.
And we act as filters for each other.
"Oh, we think that's a good idea.
Let's go in that direction. Let's not."
What we wind up with at the end is a whole bunch of ideas,
and then once we get the ideas together,
we put it together in an outline
and try and make it a little bit more coherent
and group like things together.
Collins-Sussman: And then someone else goes
and puts it into slides and then gives it to the other person.
Then they change the slides.
It sort of bounces back and forth, right?
But it's a nice gradual evolution.
At no point are we hiding from each other or--
Fitzpatrick: But another thing we learned
is that if you're gonna give a talk at an event like this,
you want to actually not walk in here completely fresh
and never having spoken this before.
So we can stand at home
or in the office and do it in a conference room,
but we decided to give a presentation
at the local user group in Chicago,
and we learned some things about what did and what didn't work.
For example, when you're speaking
to a room full of 19-year-olds, they don't know what CVS is.
Then we also gave it to the engineers
in our office in Chicago,
and we got some great feedback from them.
And then we gave it here, and we learned to plug in the laptop.
Collins-Sussman: Which you're reading quickly.
Fitzpatrick: Yes, exactly.
That's the first time I've made that mistake,
and hopefully I won't fail that way again, at least.
Collins-Sussman: All right, so let's just back up really quick.
We have our obligatory summary,
just in case you forgot what we were saying.
So there are no geniuses.
Fitzpatrick: There are very few geniuses.
Is Jeff Dean here? Collins-Sussman: Okay.
[laughter] Fitzpatrick: Okay.
I was told by another Googler
if Jeff was here, we're gonna be in deep trouble.
Collins-Sussman: So right. So there's no geniuses.
It's our natural instinct to try and want to be a genius,
but we should fight that
and actually try to collaborate as much as we can, early, often.
Don't be afraid of collaboration.
And pay attention to what your tools are doing to you
and the people you work with,
'cause they do affect your collaborative behavior.
And finally, make sure you're paying attention
to when you collaborate, right?
Not too early, not too late.
It all is sort of--
There's a critical sweet spot for success in collaboration.
Fitzpatrick: Right.
And of course, there's actually a secret to all this
that you probably shouldn't share outside of this room,
but believe it or not, if you actually do all these things,
people will think you're a genius.
So--'Cause it's not the typical thing that people do.
People don't make themselves vulnerable.
They don't sort of-- They're not open to influence.
And, uh...
Collins-Sussman: That's it.
Fitzpatrick: But that's it. Thanks.
Collins-Sussman: We got 15 minutes.
Fitzpatrick: Yeah, we have some time for questions and answers.
So if anyone has any questions or preferably answers,
there are some mics in the center of the room.
If you could get up there and...
Collins-Sussman: Uh-oh, two at once.
Fitzpatrick: Protocol. Okay.
man: Two questions-- one for the audience, actually.
Who would consider themselves a pair programmer?
Fitzpatrick: See, they can't get their hands all the way up.
man: And the same question to you guys, really.
What do you think about pair programming,
kind of formally?
Fitzpatrick: I personally think it's ideal
if you're working on something really difficult.
When I wrote CVS to SVN,
which is probably one of the hardest things
I've ever worked on in my life--
I learned more about CVS and RCS than I wanted to learn ever.
Karl Fogel and I did a lot of pair programming.
It was really good,
because it was really grungy, difficult problems.
But for sort of day to day,
I prefer more of the write-code-review process.
Collins-Sussman: It creates social stress, right?
If you're pair-programming with somebody,
you better be really-- know each other really well
and be very tolerant of each other's quirks, right?
Otherwise, it can actually-- you can start arguing
about whoever's driving, right?
"Don't format the code that way."
Or, "Don't you know that shortcut?"
Or, you know, it can get a little maddening.
Fitzpatrick: There's a number of really good engineers at Google
who pair-program all the time, and they do a great job of it,
and they're amazingly productive.
man: Thanks. Fitzpatrick: Yeah.
man: So advice on dealing with egos,
'cause I agree with you guys,
but there's definitely people on the team
that, you know, their ego is always in the way.
Fitzpatrick: Advice on dealing with egos.
Collins-Sussman: What is the advice?
Fitzpatrick: How do you deal with people that have a big ego?
Is that the question? Wow.
No, I'm kidding. [laughter]
That's a hard question, because...
typically if they're running the project, they'll--
Again, like attracts like, okay?
People who are sort of the friendlier, nicer,
consensus-building people
are gonna attract people that like to work with that.
People who are the big, you know, ego--
"It's about me. Let's be aggressive here.
I'm the alpha male. Let's fight about things."
Collins-Sussman: They attract other alphas.
Fitzpatrick: Exactly. They're gonna attract other people
that either want to follow them and be like,
"Oh, yes, you're right. Wonderful."
Or they're people that just want to fight them,
because that's what they want to do.
So I don't know I'd have a particular recipe--
We have another talk that you can find on YouTube,
if you look for "poisonous people,"
that talks all about how to protect your project
from poisonous people.
So there's a little plug for that.
We gave it here last year, actually.
Collins-Sussman: That's actually probably the best prescription
we have is that talk.
It's just how to deal with difficult people in general
on your project.
Fitzpatrick: Yeah.
Next question. man: Hello.
Fitzpatrick: Hello.
man: Let's see if we can deal
with some constructive criticism here, if it's okay with you.
Fitzpatrick: Yeah.
man: It sounds to me like what you're saying
is almost like humanistically programming,
which is fine,
except what it relates--
you have to be in a certain kind of environment.
And maybe your company has set up a certain kind of environment
at a certain stage in time
that this kind of way of dealing with things works.
But in a different kind of environment--
that is, the majority of the world--
I feel that a lot of the things you're talking about,
people are gonna get crucified.
And I'm not saying that's bad or good.
I'm just saying that's the reality of things.
It's like when I talked to Kent Beck,
what, eight years ago about extreme programming,
the problem with all the guys in the class was,
"Nobody's gonna--I'm gonna take this back to my company,
and nobody's gonna want to do this."
So my first thing is that you have to be very careful
about applying these things,
because you go back and do these things,
and you're gonna get in a lot of trouble
in a certain environment.
Secondly, the no-ego thing is great.
We'll just send everyone off to a Zen center for a year.
[laughter] You know?
People have egos. I'm a psychologist for 30 years.
I deal with people, and that's real.
That's an ego thing.
Thirdly, there's plenty of evidence that there are geniuses
in the world.
I think that's obvious.
And there's plenty of evidence that there's a whole range
of people that are good at programming.
Some people are good. There's a fair amount of research
that talks about the great programmers
can write 100 times better--
Fitzpatrick: I'm gonna stop you there.
I don't disagree with you on that--Can you hold on a second?
I don't disagree with you.
I'd be glad to talk to you a little more offline.
"The genius is a myth" thing
is definitely a straw man that we're setting up.
There are geniuses,
but the point we're trying to make precisely
is that there are remarkably few.
There are far fewer than most people realize.
And I think our talk is much more aimed
at people who are able to control their project
or their environment.
If you're in a corporate environment
or something where you have no control
over the actual way the software is developed,
you're gonna have a very hard time doing that.
And you're right. You might get crucified.
And our legal staff has asked me to say
this is not medical advice.
[laughter] And please be careful.
But please, we'd love to talk to you more
about it afterwards in person. Thanks.
Collins-Sussman: We're describing the ideal here,
Getting from the ideal, actually implementing that,
making it happen, is a whole separate problem.
Fitzpatrick: Right. I mean, we deal with the Open Source world,
for starters.
And then coming to Google,
it's run inside like a whole bunch of Open Source projects,
to some great extent.
So it's a similar sort of gestalt.
Collins-Sussman: Right. Fitzpatrick: Next question.
man: Hi. I hope this will be interesting to many people.
So you mentioned being a small fish.
Do you have any advice of--
So if you're in an environment where you're not a small fish,
so how to change that,
without leaving the environment, of course.
Or how to find other ways
to improve your skills.
Collins-Sussman: So the question is, "If you're a small fish,
how do you deal with-- how do you become a big fish?"
Sorry, if you're a big fish, how do you become a small fish?
Fitzpatrick: You hire bigger fish.
Collins-Sussman: That's it.
If you're talking about in a corporate environment,
if I were in that situation,
I would start looking around for bigger fish, right?
"Where are the really hard projects?
"Where are the people who are much more knowledgeable than me?
How can I somehow get involved with what they're doing," right?
And maybe it's just slow involvement at first,
but try to sort of creep your career in that direction,
because if you're not being challenged,
if you're not a little bit scared all the time,
just a little bit, then you're not gonna improve.
Now, I mean, I--
That's not a guaranteed solution.
Sometimes you may be trapped,
in which case, I guess I might just go look for another job.
If I were truly bored at my job, right?
Fitzpatrick: Right. In the Open Source world,
you know, you typically want to attract
these kind of people and projects.
So if you're-- If it's built on consensus
and other people can still come in and have an influence,
that's typically what will attract the bigger fish.
man: So you're saying if you can change
your corporate environment,
start an Open Source project, basically.
Fitzpatrick: Again, corporate environments--
it's really risky.
If you are one of the small fish
or, like, you're just an engineer on a large project,
you know, you have no power to change that necessarily.
You can do what you do,
but you're not gonna be able to guide a project
from that seat that you're in.
Collins-Sussman: If you're a big fish in a corporation,
you probably do have a lot of power
to start migrating your career
towards other bigger fish, right?
Fitzpatrick: Right. Collins-Sussman: It's possible.
Fitzpatrick: Next question, please.
man: Hi. You talked about avoiding a low bus factor
and having as many people look
at as many pieces of code as possible.
And you talked about it in the context
of people being egotistical and wanting to own a piece of code
and no one else touch it.
But I think there's a practical factor there.
When you have a big project with few people,
that the more proficient someone is with a component,
the more quickly they can implement features
or solve bugs.
And if everyone spreads themselves too thin, maybe...
maybe development would slow down.
I don't know.
I feel like this is true on my project
and my work experience.
I feel like when bugs come in, we want to assign it
to the person who knows that component best.
They can fix it fastest.
But we've thought about maybe purposely assigning bugs
to people who know it less to help spread knowledge.
Is that a good idea, or is this concern completely false
and just coming out of ego?
Collins-Sussman: I think there's a tension there,
like you said, right?
The fastest thing to do
is to have the people who know the code best work on it, right?
But you need to sort of find a balance, right?
Where you're balancing short term versus long term.
In the short term,
it's best to have the experts work on the code they know,
'cause it'll get done faster, right?
In the long term, though, you want to occasionally,
like you said, maybe have someone
who doesn't know that code as well
pair-program a bug fix with somebody who does,
or give somebody a small task in that foreign area of code,
which isn't particularly time-critical,
but will give that person some experience with the code
so that if the expert does get hit by a bus,
you'll be covered for the long term.
So, yeah, it's about risk management, right?
Short and long term.
Fitzpatrick: And we're certainly not advocating
that everyone on your project
knows how to do absolutely everything in the code base.
There's ways of improving your bus factor
without actually making everyone into a generalist,
and that is good solid documentation
in code and comments, design docs,
and then just general documentation.
Collins-Sussman: And code review, right?
If one person--If there's code review going on,
then it's really pretty much impossible for one person
to know an area of code.
Somebody must've reviewed that code
that went in there, right?
At least have a cursory knowledge.
Fitzpatrick: Next question, please,
in front.
man: Uh, yes.
You were talking about technological solutions
for social problems.
And you mentioned that Git
and other distributed systems have this problem
where the first thing you do is fork.
But I wonder if--And I don't want to put you on the spot,
'cause I think this must be some sort of competitor of yours,
but GitHub has taken that model
and sort of mushed it together, so it's both--
You fork, but when you fork,
somebody else can see that you forked their code.
And we've had cases where I work lately
where we have fixed something, and the next day
it would get pulled back into the main branch.
So I wonder, you know, how you think about that.
And maybe even if you could-- if Google Code was thinking
about going somewhere in that direction.
Collins-Sussman: Well, Google Code
actually supports Mercurial now.
And, yes, we are working
on the whole sort of server-side clones, much like GitHub.
I think that's gonna be coming.
[man speaking indistinctly]
It's not deployed yet, but, yeah, it would be--
it's definitely on our road map to sort of have, you know--
having users be able to clone repositories on the site
and do polls from them the same way GitHub does.
But I was saying there's a balance, right?
Yeah, people start out forking, but on the other hand,
it's a much lower barrier to participation
than with a centralized system.
So I think it balances out, right?
Or maybe it's even better in the long run
for participation.
Fitzpatrick: We have one last question it looks like.
man: Hi.
You did give a very nice talk--
Fitzpatrick: Into the microphone, please.
man: Yeah. You did give a very nice talk
about how you should be to pick up team enrollment.
But usually what when you're working on one reserve,
when you start implementing what you just talked about,
it's not just someone becoming a genius,
but you become a guinea pig.
Your manager wants you to write more code.
Your peers look up to you, even though you are a small fish.
Just out of college, you know, they expect you--
You know all this, and I'll just bring up
a magical solution and, of course--
It's like a little bug trying to pull an airplane.
And then you're kind of in that limbo,
where you want a code, but you're afraid of coding.
And the more you code, your manager wants you to code more,
and then suddenly, you start to dream code.
Your girlfriend becomes angry at you
because you forget about her.
Your mother complains because you're not calling her.
So all these psychological problems come up.
So how do you actually think about this?
Fitzpatrick: We have another talk in five minutes
on how to replace your manager.
[laughter] No, I'm just kidding.
Collins-Sussman: Hmm. I don't think I've seen that situation.
Are you talking about the general pressure
to write more code?
I mean, I guess I don't quite understand.
Fitzpatrick: I think it's a pressure from management
to behave in one way
when it's not necessarily better for the team.
Is that the general gist of what you're talking about?
man: It's just a matter of becoming a guinea pig.
You are the one--
You become a victim of experimentalization.
Fitzpatrick: Right. So...
Collins-Sussman: Wow. I don't know.
Fitzpatrick: We don't have a solution for that.
Collins-Sussman: I think we're out of time.
Fitzpatrick: I think we're out of time.
Collins-Sussman: Darn. Rats.
Fitzpatrick: Thanks to everybody for comi