DAVID HEINEMEIER HANSSON: That any better?

Oh, there we go. Woo.

Software's hard, as you can see. Hardware,
too.

So last year I had the personal pleasure of

celebrating ten years of working with Ruby
and ten

years of working with Rails. But this year,
I

have a much more interesting anniversary,
which is ten

years of sharing Ruby on Rails with all of

you and everyone who's been using it over
the

past decade.

The picture in the background is actually
from almost

exactly this time, where I gave the very first

presentation on Ruby on Rails at a Danish
university

ten years ago.

Ten years ago, I had to talk a lot

about what is MVC, for example. Today, not
so

much. There's a lot of things that over the

past ten years, things we were worried about
in

the beginning, sort of leveling up as a community

and as, as programmers, that just aren't relevant
anymore.

We're just taking all that stuff for granted.

Which is awesome. We get to care about a

lot of other stuff.

But as I look back over the past ten

years, which is pretty much the majority of
my

adult life, I've been working on Ruby on Rails.

It's fun to look back even further. I think

there's a common misconception that anybody
who ends up

creating something like Rails or

doing something else within

software development or computer science,

well, they must have

been programming since they were five years
old, right.

The whole notion of a hacker is somebody who,

who sort of got their first computer twenty
years

ago and was just programming the entire time.
Well.

That wasn't me.

I did not learn to program when I was

five years old. I didn't learn to program
until

I was closer to twenty. I'd been interested
in

computers for a long time, but it wasn't really

until the late '90s, early 2000 that I dove

into computer programming as something that
I was going

to do.

I had a lot of friends who were doing

it. I knew a lot of programmers. But somehow

it, it sort of never, never caught on. Before

I started writing software that I needed for
myself,

and before I found sort of a place in

the software world for that to happen.

And the reason I, I say that is, is

I've seen a number of essays of like, what

is a true hacker, and, and as a true

hacker, one of the things that keeps being
thrown

out is those ten years, right. You should
have

been programming for ten years already,

otherwise you're way behind.

Well, I learned to program about three years
before

I released Ruby on Rails. Turned out fine.

And I don't say that as, like, it was

because I grew up on a farm and didn't

know what a computer was. This is me in,

in the center there with the stick, and the

blue shirt in 1985. These are the kids that

were living in my neighborhood.

In 1985 I got introduced to my, my first

computer. And I was about five years old.
And

I got introduced to computers through gaming.
Sort of,

we were playing ninjas in the streets around
our

houses, and then we'd play ninjas on the box.

And I found it fascinating right from the
get

go, right. Computers were really

fascinating and games really

captured my imagination early on. I remember,
at, at

that time, there were certain, lots of parents
were

like, well make sure you get out and play

a lot. Because you don't want to spend your,

or wasting your time, that was the, that was

the word, wasting your time in front of computers

inside, right.

Well, I really did want to waste my time

in front of computers. And this was the computer

to have in 1985, in our neighborhood. But
we

couldn't afford a computer like that. There
was only

one guy in the whole neighborhood that had
a

computer like that. So we all shared it and

we all played Yeah, Kung Fu, in turn.

But then the next year, so, I, I couldn't

afford this computer, but my dad somehow,
he was

fixing TVs and stereos, he traded a stereo
with

this guy for this other weird computer, which
was

an Abstraught 646.

And I was really excited. It didn't actually
play

Yeah, Kung Fu. I was a little disappointed
by

that, but it had some other crappier games.
Anyway,

it was a computer. And that was sort of

my first introduction to, to computers, six
years old.

And, and I tried to learn programming.

I, I got a magazine and, at the back

of these magazines back then, there were programs
you

could type in. And I was like, wow, this

is, this is amazing. I can control this computer.

So I built my first information technology
system.

It was messages to my mom of where I

went, where, I had this clever system that
would

really optimize the fact that writing a message
of

where I went and, and when I was going

to be home, it was too complicated. It would

be much easier if I just wrote a little

note where I gave her the location on the

tape that she had to fast forward to, and

then she could read where I was.

I thought, man this is so clever. I just

have to write down two twenty-eight, and then
I

could preprogram that note, and she'll never
know I

was over at Peter's house playing Yeah, Kung
Fu.

That really wasn't programming, right. I just
typed some

stuff in. I didn't know what the hell I

was doing. I just somehow figured out print,
OK,

that puts stuff up on the screen. That was,

that was the extent of it, right. But it

was my first stab at programming. And I, and

I, it kind of failed.

That was the extent of my programming, that
I

knew how to fast-forward to a pre-recorded
message.

Not that great.

So a couple years later, late 80s, I saw

this game for the first time. Battle Squadrant.
And

I remember thinking, holy shit, these graphics
are amazing.

How can they make this? This looks so good,

when you were used to a Commodore 64, the

graphics of the Amiga 500, which is mind blowing,

right. And once again, I felt this, like,
wow,

wouldn't it be amazing to be part of that?

To be able to create something like that?

I'd love to make games.

So I sort of started looking around, and,
and

I found this thing called Amus. I don't know,

has anybody here ever programmed in Amus?
Not a

single hand. OK. Must have been a very European

thing.

But it was sort of a real programming environment,

and, and I got the box, and sort of

my English was a little, not that great, so

I was sort of just reading through it and

trying to find the code. And it was all

about sprites and vectors and ifs and variables,
and

it, it didn't make any sense to me at

all.

So I thought, eh this is a little bit

too hard. Thankfully, there was something
called Easy Amos,

right. Oh, wow, that's gonna be great. This
other

one was too hard. Now I just have to

do the easy one.

Unfortunately, in Easy Amos, it was still
programming, and

it still had conditionals and variables and
all these

other things I just did not understand. I,
it's

so funny, because, once you learn something,
it can

sometimes be hard to go back and think, like,

how was it before I knew how to do

this? But I distinctly remember, why would
you have

a variable?

Like, if you just assign something once, why
would

you ever sort of want to change that? Why

does it have to be a space. Why can't

it just be the thing. Like, I did not

get the concept of variables.

And this is at, I don't know, age ten

or whatever. So, still not getting programming.
It's still

not making any sense to me. So I gave

up on that, too.

Then, in 1993, I went to something called
the

Gathering. The Gathering three, which was
a big demo

party in Denmark, where people from all over
Europe,

maybe some from the U.S. as well, would gather

to, to show off their skills of creating these

demos.

And demos were basically just, like, little
music videos

with computer graphics. And I thought that
was really

awesome. And, again, I got this sensation
of, wow,

that's amazing. People are creating these
sequences, they look

really good. This is, this is awesome. I'd
love

to be a part of that.

This is '93, so I'm, I'm fourteen. And this

demo party, and then I met pretty much everybody

I knew for the next ten years in, in

computer software, including Allen of TextMate
fame. I was

fourteen and he was part of one of these

demo groups, and we got talking, and then
ten

years later, I'd help him release Textmate,
and this

is now twenty years ago.

Anyway.

I still didn't get the concept, right. Like,
it

was all, it was Assembler. So it was even

harder and weirder to figure out than Amos
was.

It was vectors, it was math, it was, it

was just really hard. So once again, this
is

the third time I tried to sort of figure

out programming, because I want to build stuff.

And the third time, it failed.

So I ended up building another information
system. At

that time, there's something called BBS's.
So pre-internet, you

dialed up to basically every web site individually
through

a modem, and I ran one of those things.

At that time, it was, it was called a

Where's BBS, which is where we traded all
the

illegal software that we couldn't afford,
and games, and

demos.

And I had a lot of fun doing that.

I was fifteen and I was, I was working

at a grocery store, and I spent all my

money buying modems and phone lines.

But sort of the long and the short of

that is that I failed to identify with programming

under the computer-science paradigm.

Computer science, in itself, just didn't really
appeal to

me. Like, it didn't make sense to me. Learning

programming through sort of the lens, the
prism of,

of hard science just, it didn't really, it
just

didn't click. And I was actually pretty disappointed
for

awhile. I had tried to learn programming three
or

four times over the past ten years of my,

my life, and it just, it wasn't clicking.

No surprise to sort of my teachers. This is

my high school diploma, part of it, and it

says math, final exam, F. And, and English,
I

got an A. But math was just never my

thing. Physics never, was never my thing.

Any of the hard sciences were just never my

thing. And you say, oh, well that explains
a

lot. That's why Rails is so fucking slow.

But it, it's true. It just never appealed
to

me. But, I think it also inoculated me with

something really early on, which was, it disabused
me

of the thinking that I was a computer scientist.

That I was ever going to come up with

an algorithm. That I was ever going to make

any ground-breaking discoveries at the low-level
of, of computer

science.

And that was actually really a relief. Because
when

I finally got into programming, I knew that
was

just not what I was going to do with

it. That was never, it wasn't my idol, it

was not what I was chasing. I wanted to

build information systems. Like all these
attempts I had

over the years, they were all about information
systems.

They were about using the computer to build
something

else that really didn't have much to do with

the underlying things. That there were people,
smart people,

who had come up with algorithms underneath
to, to

make it all work, wonderful. I'm not one of

them.

And that's fine.

I think as an industry, very few people have

gotten to that realization. Even if it is,
that

they, on a daily basis, build information
systems. Even

if it is that they're working on yet another

social network for sock puppets, or horror,
in my

case, yet another fucking to-do list. The
aspiration of

the whole industry, everyone in it, is that
we're

all programmers.

Right?

No we're not. I am nothing like Linus, right.

He's actually a real computer scientist. To
figure out

how to, I don't know, fucking improve the
scheduler

in the kernel. Shew. No clue. No interest.
All

good.

I am ever in debt that there are people

like that out there who can do this stuff.

So I don't have to do it. So I

can focus on something else. But I think most

programmers think that, oh yeah, that, that's
what I

do. Yeah, I work information systems, but,
we're kind

of colleagues, right? Me and Linus here.

I'm pretty sure that he would tell you, fuck

you. We're nothing alike. We are not colleagues.
What

you do is making another fucking to do list.

I'm improving the fucking kernel of Linux.
Far more

important work. He would disabuse you of your
delusions

of grandeur real quick.

And I think that's a real shame. I think

it's a real shame that if you sort of

pick your heroes in such a impossible fashion,
that

they're actually nothing like you and you
will be

nothing like them, you're gonna set yourself
up for

a bad time for the whole ride.

The truth of the matter is that most information

system development has very little to do with
science.

Yes, it's all built on top of computer science.

Yes, computer science is what makes it possible
for

us to do what it is that we do.

But it doesn't define what we do.

And I think in many ways that prism of

computer science is harmful to the development
of information

systems. It's actually not a good view on
the

world to have. Just because you can make,
you're

Steingraeber and Sohne, and you can make the
best

piano in the world, that doesn't make you
a

great pianist. It doesn't mean you can play
wonderful

tunes. Just because you can create the foundations
of

which other people can build upon, just because
you're

a great computer scientist, doesn't mean you're
a great

software writer.

Doesn't mean you're a great programmer of
information systems.

And most of all, if you are committed to

building information systems, and I am wholly
committed to

building information systems, I've given up
the notion, long

ago, that I was going to get into games

programming or vector programming or anything
else that sounds

like hard science and is hard.

I think you're gonna be much better off. But

I think it's also really tough, because I
think

most of the paths, the celebrated paths into
programming

go through courses called computer science.
So you're sort

of taught right from the get go that computer

science, like that is the ultimate ideal,
and what

you're doing here is just sort of piddling
along

until you can get to this top of the

mountain.

Even worse, if you actually have a degree
in

computer science, right, and now you're slumming
it, with

yet another social network, or, yet another
fucking to-do

list. I mean, that's a recipe for self-loathing
if

I ever knew one.

But, as I say, this is mostly about the

prism of how you're looking at programming,
what is

programming, what is writing software. What
is that we

do every day when we create information systems?

And if you look at it from this prism

of the hard sciences, you think, well, Law
of

Thermodynamics. Physics. This is, this is
the real serious

hard stuff, right. You will laugh at French
poetry.

Ha, ha, ha, ha! They're all just, what, analyzing

what some schmuck in the 1700s did, and there's

a thousand different interpretations of, of
what that person

actually wrote and what does that actually
mean? Like,

that's pathetic, right. You can't arrive at
any ultimate,

clear, universal truths.

Math! There's a truth. There's a final result.
Physics.

There's a truth. We're knowing more about
the natural

world in a way where we can be completely

confident. Mostly. In what we know. Certainly
in math,

right.

If you carry that over into programming, you
end

up with shit like this. Law of Demeter. Practices

and principles who sort of project that they're
universal

truths about the natural world, that this
is how

good programs are made, and this is not really

an argument. The only argument is whether
you're professional

and following the laws, or you're an amateur
and

you're breaking them.

When I look at computer programming, and when
I

reach most, read most programs, I'm not reading
hard

sciences. It is much more like studying 17th
century

French poetry. What the fuck did this guy
mean?

Like, I can't follow this at all. Like, is

this some weird reference to some play somewhere?
What's

going on here?

It's actually more like forensics. It's more
like analysis.

It's much more subjective. Like, what is actually
going

on? What were they trying to communicate?
What's just

going on here, right?

So, I find it so funny that, that programmers

who work in programming, and they laugh at
all

these subjective fields of endeavor, when
that is what

they do every day. They just, no, what I'm

doing is computer science. This is empirical
truth, blah,

blah, blah, we have laws, blah, blah, blah.

I think the, the bottom line is that is

when you go in with that notion, when you

go in with the notion that we can actually

discover laws of programming, like, Law of
Demeter, of

how we should be creating our programs, you
lull

yourself into this belief that there are some
practices

that are just true. They're not up for debate.

They're not up for discussion.

They're science. That what we do is science.
Well,

I think there's another word for, sort of,
those

delusions. Pseudoscience. When people think
they're doing science and

they're not actually doing science. That's
pseudoscience. I think

a lot of what's going on in software, methodology,

practices, is pseudoscience.

Which would be fine if people would accept
that

and say, yes, what I'm doing is pseudo science.

Like, I'm not finding any grand truths here,
but

they're not, right. They're ex-pouting that
this is, this

is the truth.

Well, here's another pseudoscience. Diet schemes.
I think diets

are actually incredibly similar to most software
methodology approaches.

They all sort of espouse that I have the

truth, what you need to get slim and healthy

is the ten-day green smoothie cleanse.

That is the truth. That's how you get it,

right. And then you, shit, that, that's, OK,
smoothies.

Sounds good. But what about this super shred
diet?

Like, I lose twenty pounds in four weeks?
That's

certainly better than ten pounds in, I don't
know,

ten weeks, or whatever that hungry diet girl
is

promising. I'll go with that super shred guy,
like

he's got to have the truth, right.

And it's so funny, if you read any diet

books, and diet books are incredibly popular.
If you

look at the most popular book on Amazon, the

top one hundred list, a lot of them are

diet books. People want to be told how they

can cheat the basics. I think software development
is

exactly like that.

I think software developers are exactly like
people trying

to lose ten pounds and thinking, you know
what,

all this exercising, just eating healthier,
that's a little

too hard. Let's, let's listen to this super
shred

guy.

He's got to have the answer. An answer that's

less painful, less simple and basic. There's
got to

be some grand secret I just don't know yet.

If I can just learn the secret then everything's

gonna be great, right. But it's pseudoscience.
Those diets

are based on anecdotes. They're based on one
guy

trying something, or, or looking at a few
people,

a tiny sample size, it's just pure, poor,
pure

poor science.

External variables, uncontrolled experiments
that run for too long.

You can't derive any absolute truths from
it. But

people keep arriving at absolute truths.

And just like feeling a little overweight,
and most

people do at some point in their life. Everybody

wants to lose whatever it is. They want to

feel healthier even if they are at the correct

weight. They want to be in better shape. All

our code bases are exactly like that.

Everyone has like, oh I'd love that this part

of the code base, it's not that clean, right.

So we have that same feeling of being a

little insecure about our quote code quality,
just like

most people are a little insecure, at least
at

certain times in their life, about their body,
right.

So we're ripe for somebody to come in and

tell us what's wrong. To fix it for us

by just saying, oh, no, no, no, you don't

have to do any of the hard stuff. Writing

good code, do you know what that's about?
It's

about this one practice. This one secret that
they

don't want you to know.

If I teach you that, then all your code

is going to be wonderful. But right now, you're

not a professional. You're an amateur. You're
writing dirty

code. You should feel really bad about that.
You

have sinned.

But, I will give you absolution. I have the

pathway to clean code.

And it hits a lot of people right in

the impostor plexus. Like, ugh, you're saying
my code

is dirty? Yeah, I guess it is a little

dirty. There's this one part that's, like,
shit, maybe

I'm not really a computer scientist. Maybe
it doesn't

really, I don't really belong here amongst
the programmers.

Can you please tell me, how do I get

to be a computer scientist?

How can I get to belong amongst the esteemed

professional programmers? Can you tell me
how? And there

are lots of people willing to tell you how.

That the salvation will come through these
patterns and

practices, and as long as you follow these
ten

commandments of good code, all shall be well.

OK.

I think the most popular commandment, I'm
gonna spend

some time on that, the most popular practice,
the

most popular pattern for making people feel
shitty about

their code and shitty about themselves and
shitty about

their path through programming, is TDD.

TDD is the most successful software diet of
all

times. It's so alluring, it has such an appeal

in its basic principles, that everyone gets
wrapped up

in it. I got wrapped up in it for

quite awhile. I got wrapped up in the storytelling

that all software before TDD was shit and
unprofessional.

And that the only way to arrive at clean

code was to follow the principles of TDD.

And the principles of TDD, mind you, are not

about the tests. It's about test first. It's
about

test-driven design, right. That we have tests
afterwards, that's

just an accidental side-effect. A benefit,
if you will,

after the fact. And it's the perfect diet.

I tried multiple times, which is usually how
it

goes with diets, we try one and it doesn't

really work and we fall off the wagon and

then a few months later you try again and

you feel bad about it the whole time and

that's how I felt about TDD for a long

time.

I felt like TDD was what I was supposed

to do. I was supposed to write all my

tests first, and then I would be allowed to

write my code. And it just didn't work. I

kept just feeling like, this is not, I'm not

arriving at something better here. When I'm
driving my

design by writing my tests first, the code
I

look at afterwards, it's not better. It's
not cleaner.

The dirty code I wrote without being test-driven
first,

it actually looks better.

But, so successful has TDD been, that for
the

longest time, until actually fairly recently,
I just thought,

well, I'm the wrong-doer. I'm the one doing
it

wrong. TDD is not at fault, right. Just because

everybody's doing TDD wrong, doesn't mean
that there's anything

wrong with TDD. There's just something wrong
with all

of you. That's the problem.

If you would just be more faithful to the

practices, then everything would be great.

And that's what makes it such a great diet.

That it keeps people in the perpetual state
of

feeling inadequate. So, you keep having to
buy more

books, and attend more conference talks, and
attend more

workshops, and hire more consultants, to teach
you to

be truer to the religion of TDD. Hogwash.

Let's look at some code. So here's a very

simple piece of code. Person has an age method,

that calculates how old somebody is. And we
have

a test for it. This piece of code depends

on the world.

It directly refers to date today. It's a explicit

dependency. You cannot change it in there.
Well, in

a lot of languages, that's a problem. Like,
how

are you actually going to test this if you

can't somehow figure out how to change the
date

of today. Like, every time you run your test

it might be a different day and it might

be broken.

Well, in Ruby it's really easy. We just stop

that constant and make it work. That's what
the

travel-to method is about, right.

Proponents of TDD will look at that code and

say, dirty, dirty code. Explicit dependencies
hidden inside. You're

mocking a global object? What the fuck?

You need to shape up. Here's the shaped up

version. We inject our dependency, so we have
a

default of date.today, but we can put in our

own, in the test, we can put in our

own date, right. This is much cleaner. Right.
No.

Great. We improved our code base.

Did we? Is this a better code base? Is

this method better than what we just had there?

Is it simpler? Is it clearer? No. It's easier

to test. And that's the important point, right.
That's

the important point in all of these debates,
is

just, is it easier to test?

That's the measure of success. I think that's
a

shitty measure of success. I think there are
much

higher ideals than just whether something
is easy to

test. But it gets worse.

Here's another example. If you actually have
a method

that depends on another method, we have to
inject

the dependency all the way down, now you're
really

muddying things up and now the code is really

starting to get nasty. And this is such a

simple example. I've actually posted this
example online before

and had arguments with TDD proponents about
that.

And, yes, this is, I'm like, well, what does

it matter? You're just injecting one dependency,
what does

it matter? It's not that big of a deal,

right? Yes it is.

Because this is exactly the type of thinking
that

leads you down a really nasty path. Let's
look

at another example.

Here's a standard Rails controller. It has
reliance on

the world. It relies on a before action that

ensures permissions. It sets up a new object
and

sends out an email and then it responds to

something, right. The whole purpose of the
controller in

Rails is to sort of direct the world. It's

to interact with the world.

But how do you unit test that, right? That's

really hard. It's relying on the entire world.
If

we're following this scientific approach of
unit testing where

we're isolating all the variables, holding
everything else constant

except for these two things, what goes in,
what

goes out. This is bad, right.

If we instead put in something like a person

creation command and hide away all the actual
doing

of the control and then we inject all the

stuff that it depends on we can test person

creation command really well.

Is that code better? Is that code simpler?
Is

it clearer? Would you rather look at this
and

then understand what the system does or would
you

rather look at this and try to figure out

where does this thing go?

And that's the consequence of this chase of
test-first.

It leads you down a path where the gospel

of test-driven design is that anything that's
easier to

test is better. That's it. That's the measure
of

quality. If you can test it easily it's better.

If you can't test it easily, it's worse.

Boo. Exactly right. Boo.

It's not better. We're losing sight of what
we're

actually trying to do. Tests were supposed
to support

us. They weren't supposed to be the main thing.

And I think this is leading to a lot

of Zombie astronautic architectures. Things
that I thought we

moved past long ago. If you look at, at

this person create command, that reminds me
very much

about Struts 1 point 2, and how they had

every action as their own object. And that
it

was great because it was easy to test, and

it was shit when you were trying to put

a whole architecture together, because you
had all these

create commands and all of the sudden you
had

a million objects. Yes, they were easier to
test,

but the system was much harder to reason about.

You see the same thing around ActiveRecord,
for example.

You see, well ActiveRecord should just be
data access

objects. They shouldn't actually have any
logic. They should

just be about interfacing with the database,
because then

we can split out everything else. Our domain
logic,

it's just that it doesn't have to touch the

database, so that our tests can be simple,
so

that our tests can be fast, right?

Again. Order of priority. Test, test fast,
oh, your

architecture. That'll just fall from that,
right?

I recently read James Coplien, has a great
paper

out called "Why Most Unit Testing is Waste."
And

for me, this is the money quote. Splitting
up

functions to support the testing process,
destroys your system

architecture and code comprehension along
with it. Test at

a coarser level of granularity.

TDD is focused on the unit. The unit is

the sacred piece, because that's the science
piece. That's

what we can control all of the variables.
We're

just looking at these few pieces, right.

What James is saying, maybe that's not the
right

level. Maybe testing, the role it should have,
shouldn't

be about the unit most of the time. And,

I sort of alluded to this awhile back, I

wrote a post called Testing Like the TSA,
and

the main thing about that was about over-testing
and

sort of this testing theater that goes on.
But

I hadn't really made the switch that it, the

problem is that we're trying to test at the

wrong level.

It's not testing itself. Testing is great.
I'm not

advocating that we shouldn't have tests. I'm
advocating that

driving your design from unit tests is actually
not

a good idea. That you actually end up destroying

your system architecture and your code comprehension
along with

it.

So if unit tests aren't the thing, what could

we do instead?

Well, I think there are higher levels of testing.

We've already sort of moved to that in Rails.

It's no longer called test unit, where you
place

your tests, it's called test models. That's
already one

step up. That sort of frees you from feeling

bad about the fact that your, your model tests

actually touch the database. That's not a
bad thing.

Yes. They run slower. But they also test more

things.

You can make anything fast if it doesn't have

to work.

And I think that's the problem with testing
in

a lot of cases. We recently had a really

bad bug on base kim where we actually lost

some data for real customers. And it was incredibly

well-tested at the unit level. And all the
tests

passed. And still we lost data. How the fuck

did that happen?

It happened because we were so focused on
driving

our design from the unit test level, we didn't

have any system tests for that particular
thing. And

it was a really simple thing. It was like,

if you were editing an object and you were

editing the attachments, you could lose an
attachment. And

we lost some attachments and it was a terrible

thing.

And after that, sort of thought, wait a minute.

All these unit tests are just focusing on
these

core objects in the system. These individual
unit pieces.

It doesn't say anything about whether the
whole system

works.

Most TDD proponents, I find, are much more
focused

on the unit level, because that's where they're
driving

their design. And they're not very much focused
on

the system level at all, which is what people

actually give a shit about.

Does the system work? I don't care about whether

your units work. Does the whole thing work?
That's

what matters.

So that kind of freed my mind up a

little bit. That if we give up this need

for hard science experience, where we have
to control

all the variables and boil everything down
to a

single unit that can be tested, we can float

freely with the world.

Awesome.

This realization, I came to realize, was why
people

hate fixtures. So fixtures in, in Rails is
about

spinning up a world, it's about setting up,
sort

of, small size version of the whole world.
Where

most approaches, they focus on just one unit.

I don't want to have an account in here

and a project in here if I'm just testing

my message. I just want to test this one

single thing, right. And if you're doing that,
yeah,

fixtures are probably not a good thing. It
doesn't

really work for that.

It works really well when you're not concerned
about

the hard science focus on unit tests. It works

really well when you're focused on a larger
level.

When you're focused on models, when you're
focused on

controllers, and most importantly when you're
focused on systems.

But all that is sort of usually swept away

by the holy trinity of test metrics. Coverage,
ratio,

and speed.

I've been in a lot of internet arguments lately.

In such esteemed establishments as Hacker
News, and, and

elsewhere, and I find it really interesting,
because each

individual argument will make me rage, but
then the

larger set of all arguments, like a meta study,

actually reveals really interesting things
about what people care

about. What they value.

And what I find is, in most discussions about

design, especially around Rails, what people
care about these

things, and these things only. It's about
the test

coverage. It's about the test ratio. And it's
about

how fast your tests run.

Like, that's the pedestal. That's the holy
grail. What

actually happens underneath, the design of
the rest of

the application is, eh. Doesn't really matter.

And thus, a lot of people come to celebrate,

oh, I have a one to four test ratio.

For every line of production code, I have
four

lines of test. Oh yeah.

And they say that with pride. And I'm like,

what? So you're saying for every line of production

code you write, you have to write four lines

of code? And that somehow makes you a hero?

How, how does that work?

So your system is now five times as large,

reasoning about the whole system is now five
times

as complex, and you're proud of this, why?
Well,

of course, because I have a hundred percent
coverage.

My five thousand tests run incredibly fast
because they

never actually test very much.

They certainly do not test the system. They
test

all these little slices of unit. Wonderful.

It's not wonderful. You have anemic fucking
tests. They

don't prove shit. You're gonna have the same
bug

that we have on base camp, and the system

is not going to work even though you've proudly

proclaimed, oh, well, your units are working.

Well, whoopity-doo. This decoupling is now
free. People think

that, oh, this is like that saying, like,
quality's

free. Right. Testing is free. Not when you're
doing

it like this. It's not free.

And most importantly, it's not free, not so
much

in time, but in conceptual overhead. Understanding
a system

that has been test-driven designed from the
unit perspective

is really hard. Because you have all these
levels

of indirection. You have all these levels
of intermediation.

To separate the tests from slow things, like
HTML

or the database or, any of the other parts

of the system that actually makes up your
system.

And they focus just on that one thing. So

they can be very fast, if they don't have

to work. They don't actually have to test
your

system.

So that's sort of two charges in one. It's

a charge first that your design is not going

to improve. Your design is going to deteriorate
by

doing test first programming, because you're
going to construct

your units of testing, your methods, in a
different

way, like we say with the age example. You're

going to inject all your dependencies in a
way

that does not prove things.

And second of all, you're not gonna get the

benefit of great coverage. You might have
a lot

of tests, but they don't test your system.
It

doesn't improve your confidence in actually
the whole thing

working, and then what good is it?

Well, I thought about this for a long time

and thought, like, this is not really, it
doesn't

seem like that great of a revelation. Why,
why

do I keep having these arguments over and
over

again? Why are people focused so hard and
so

intensely on this trinity of test metrics?
How did

that come to be the main thing that people

are arguing about?

How did that come to be the main decider

of what's good design and what's bad design?
Really,

couldn't really figure it out. Until I started
thinking

back of like, what is this prism we're looking

through? We're looking through computer science.
Engineering. Professionalism.

James Harrington wrote a bunch of books on
quality

of engineering, and he has a great quote here.

If you can't measure something, you can't
understand it.

If you can't understand it, you can't control
it.

If you can't control it, you can't improve
it.

That makes a lot of sense. Cause like, yeah,

yeah, that makes sense. That's gotta be why.
And

then I got another great quote. Just because
you

can, just because something is easy to measure
doesn't

mean it's important.

This, I think, is exactly what's going on
here.

Programming of information systems is a lot
more like

French poetry than it is like physics. But
programmers

grow up thinking that they're computer scientists,
so they

want it really badly to be like physics. They

want it really badly to be a hard, professional

science.

And coverage, ratio, and speed. You can get
that

fucking thing down to six decimals. Like,
that, I

can be so precise about how fast my test

runs, eighty-four point seven percent coverage,
boom. Got it.

Doesn't say anything about whether or not
that's actually

important. Doesn't say anything about whether
that's actually producing

a good system. Doesn't say anything about
whether the

person after you, or you yourself, three months
from

now, can understand what the hell is going
on

in this code base.

You haven't necessarily made anything any
clearer. You've made

it very easy to produce metrics. And if there's

one thing we love with, with science, it's
clear

concise objective truths and coverage and
ratio and speed

fit that bill. So we adopted them with open

arms, even though they were not that important.

Second part of it. Cost is not value. A

lot of people have invested so much in building

up their expertise, their time, their four-to-one
ratio in

tests. The investment is massive. Well, of
course they're

gonna be defensive about it. Like, you've
invested so

much of your ego and your time and your

resources on this project, into testing. So
of course

it must be valuable. Of course it must be

important.

That's not how it works. Just because something
is

really expensive, just because something takes
a lot of

your time doesn't mean it's valuable. Doesn't
mean it's

important.

So I was sort of giving a brief description

of this talk yesterday at dinner with Aaron
Patterson,

and he trolled me right back and said, TL;DR,

just don't test, right. Like, that's what
I'm supposed

to get out of this.

No. No. Testing absolutely has value. Regression
testing absolutely

has value. Driving your design through test
first? In

my mind, rarely has value. Not never. There
are

times where I'll write my tests first, usually
when

it's something like a translator of some kind,
where

I know exactly what's going in and I know

exactly what I want out.

That could be a good case to start with

test first. Most information system design
is not like

that. I'm trying to figure out and sell what

the system is supposed to do. What I'm going

to arrive at is the test, is this set

of tests, it's a set of regression tests,
that

make me feel good about that after the fact,

that I can still change my system and not

break it, right.

So TDD. Kent Beck. Main proponent behind TDD
has

a very sensible quote that goes exactly along
these

lines. I get paid for code that works, not

for tests, so my philosophy is to test as

little as possible to reach a given level
of

confidence.

Immensely sensible. I find that that's actually
often the

case with these things that get taken too
far.

TDD started out as a pretty sensible thing.
Kent

has an even more sensible perception of it
now,

I think, than when he wrote the test-driven
book

originally. But that's not what most people
take away.

That's not what most people run with if they

want to build a career on making people feel

shitty about their code bases and their dirty,
dirty

code.

They take a much more extremist approach,
that unless

you're doing test-first, you're not a professional.
Certainly not

what Kent's saying.

OK. So for me, this really boils down to,

we're, we're trying to wear the wrong hat
the

majority of the time. Thinking of yourself
as a

software engineer will lead you down the path
of

coverage, speed, metrics, hard sciences - all
these things

we can measure and it leave you laughing at

shit like interpretation of French poetry.
Of subjective evaluations

of a design in the system, even though these

are the only tools that we have.

So this has taken me awhile to arrive at

this conclusion. I've hated the word software
engineer for

quite awhile. Cause I never felt it fit me.

I never thought of myself as a software engineer.

I kind of tried to be one, a few

times, and I failed all the time. And by

the time I finally arrived at programming
as something

that I wanted to do, it sure as shit

wasn't software engineering.

Yes. It's a hard hat that I wear occasionally,

when I do performance optimization. That's
hard science. You

make a change. You measure it. Was it an

improvement? If not, revert. If yes, deploy.
Very scientific.

Very good.

Great to wear the hard hat when that fits.

Is what, that what I do the majority of

the time? Is that how I think of myself

when I write most of the things that I

write? When I add a new feature to base

camp or do forensics to figure out how a

bug came about, or what somebody meant when
they

wrote a bug in or something? No. That's not

what I do.

So I don't try to think of myself as

a software engineer.

OK. If we're not software engineers, most
of the

time when we make information systems, what
are we

then? What other hat should we try to wear?

What other identity should we try to aspire
to?

I think we had it all along. I think

we had it in the language all along. We're

software writers. Writing is a much more apt
metaphor

for what we do most of the time, than

engineering is. Writing is about clarity.
It's about presenting

information and motivations in a clear-to-follow
manner so that

anybody can understand it.

There are not bonus points for making something
convoluted,

as there often is with engineering and with
test-first

design. Making things more convoluted gives
you the benefits

of, perhaps, easier to test. They don't give
you

clarity. So those things are often in opposition.

Clarity is all about being succinct without
being terse.

WE can write things using as small words as

we know how, using as little complication
as we

know how, using as little conceptual overhead
as we

know how to get the job done.

That's a much better approach. And I think
it

comes very easy if you think of software development

as writing. If you look at a piece of

writing that somebody has written and it's
kind of

convoluted, can't really follow the argument,
and paragraphs are

not broken up neatly, is the first thing you're

gonna say, you know what the problem with
this

is? You're not using big enough words.

If we just shoved some bigger words into this

text, it's gonna be there. That's good. Oh.
The

problem here is like, like your sentences
are too

clear. If you just insert a sentence in the

middle, that'd be great. Oh, do you know what?

This needs more semicolons. That's what this
needs. If

this has more semicolons, boom. You got clarity.

No. More indirection. More third-person. These
are not the

things that make for great, clear writing.
And that's

obvious when we talk about things like writing.
SO

if we talk about software development as writing,
I

think it'll be obvious too. I think if we

supplant the high ideal of what matters for
design

is how easy it is to test, how easy

it is to make engineering driven, and put
clarity

of the code base above all else, we're gonna

be much better off. And arguments are gonna
be

settled much easier. And it's gonna be much
easier

to read the fucking code you wrote three months

ago, because you had that in mind.

That was your motivation. That was what you
were

going for.

So what is clarity? How do you figure that

out, right? That's real easy to say, oh it's

just clarity. Boom. It's open to interpretation,
right. It's

not as clear as just saying, oh if you

can just get your code coverage above 85%
then

you're gold, right.

Clarity doesn't work like that. There's not
a metric

we can just apply, because, again, it's not
hard

science. Clarity of writing is not hard science.

So the easy answer is, I know when I

see it. Right? There's not just gonna be a

list of principles and practices that somebody
can be

taught and then they will automatically produce
clear writing

every time. Right? If you want to be a

good writer, is it enough just to sit and

memorize the dictionary? No. Just knowing
the words available

to you, knowing the patterns of development
is not

gonna make you a good developer.

You have to develop an eye. You have to

develop an eye for clarity, which means first
of

all, you have to decide that that's important
to

you. So that's the first step. If you're still

stuck in, the most important thing about my
system

is how fast my tests run, and how many

of them I have, well. Forget about it. You're

not gonna get to this point.

You have to decide that the most important
thing

for your system is clarity. When you do decide

that, you can start developing an eye. I started

getting into photography maybe six years ago.
When I

first got into photography, like, I would
look at

a picture and it was like, well, looks like

a good picture.

Now, I've been looking at thousands of pictures.
I've

been taking thousands of pictures. And I've
developed an

eye. I can see when the white balance is

off. I can see, oh, this has a blue

tint. Oh, this actually, if we crop it just

a little bit more, only the subjects we want

to have in focus are in focus. Oh, this

would actually be better in black and white.

That eye just came from doing it. A lot.

It didn't come from just sitting down and
reading

a lot of photography books. And I think it's

the same thing with code. I think a lot

of programmers, coming at it from a software
engineering

angle, thing that just all they have to do

is learn the practices, learn the patterns,
memorize them

all, and then they will be good programmers.

No, they won't. The only way to become a

good programmer, where, by definition, I define
good programmers

as somebody who programs, who writes software
with clarity,

is to read a lot of software, write a

lot of software.

Just like how do you become a good photographer?

You take a lot of pictures. And you look

at them. And you practice. And you practice.
And

you practice.

I think it's quite similar to the problem
with

diets, right. The fundamental truth with diets
is to

be healthy you should probably exercise regularly,
you should

probably eat a reasonable amount and it should
be

good stuff. Like, that's three things. Incredibly
hard to

do. Most people do not do that, right. Figuring

out how to write good software: read a lot

of software, write a lot of software, aim
for

clarity. It sounds too simple.

Why is it simple? Because there's not just
a

secret. There's not just one answer somebody
can give

you. The only way you can get there is

by doing it. So when I first started developing

Rails, I read a ton of software. I read

the entire Ruby standard library. Partly because
documentation of

Ruby at that time was pretty poor, and the

only way to figure out how it worked was

to actually look at the code. But that was

also where I learned so much.

Today, we have it so much easier. Bundle open

name of any gem, and it'll open, boom, right

up in your text editor. You can look at

any code.

How many of you have read through a complete

gem recently. Something you did not write.
Awesome. That's

actually really encouraging. I thought it
would be much

less.

I think that is exactly the path you need

to take. You need to read a shit ton

of code. And it's not so much just because

you read this code and then, oh that's all

great stuff. Just as important as it is to,

to develop your sense of writing by reading
a

lot of shit writing, so is it with code.

And I think you will find that that is

actually very easy. Because a lot of things
you'll

do bundle open on will follow Sturgeon's Revelation.
90%

of everything is crap.

Well, at least you know you have company if

you write crap software and I certainly do
from

time to time. And that's a great way to

learn. I actually find that I learn the most

about software and learn the most about what
matters

to me, I learn the most about what clarity

is when I read poor software.

Because what I do is, I take a piece

of software, I take a class or method, and

then I look at it, how could this be

clearer? Like this is, I think this is poorly

written. I think this smells. How can I rewrite

it?

So by just sitting down and going through
that

exercise and rewriting it, I find I learn
a

whole lot about what I care about. So that's

what I've been doing lately. Engaging in a
lot

of these internet arguments. Somebody will
submit a piece

of code, and usually the submission will come
along

with the proposed solution, too, right.

I have this shitty piece of code. Then I

learned about these three patterns. And now
it's wonderful.

And what I have found every single time, and

I've only done this maybe a handful of times,

maybe a little more, is that every single
time,

you just took the shitty code and you stuck

it into some different boxes.

Like, it didn't actually improve. Applying
the pattern to

it did not improve the underlying clarity
of the

code, because you just wrote it poorly. Like,
the

problem with the code was not that it was

missing patterns. The problem with the code
was that

it was crap. That it just had to be

rewritten.

Now, that leads us to sort of a mission,

in some ways, from Rails is and what Ruby

is, and it leads also to clarify some of

the arguments we've had in the Rails community
for

awhile. Readability is incredibly important
to Ruby. We have

a lot of duplicated methods that do exactly
the

same thing, just so we can improve readability.

I remember the first time I saw unless, when

I was learning about Ruby. That was one of

those light bulb moments. It's like, wait
a minute.

Unless is exactly the same as if not, but

it's a different keyword. Huh.

Right? It was not just about making the most

efficient, compact language. It was about
readability. Poof!

Mind blown.

And decade-long love-affair with Ruby established.
And I think

that this is what we're trying to achieve
constantly

in Rails as well. A lot of people will

gripe about, oh, ActiveRecord is too big or
something

is too big, or have too many methods. The

surface area is too big or there's, whatever
it

is, right.

Like, who gives a shit? Is it more readable?

Is it more clear? That's the only thing that

matters. What do I care whether the surface
area

of a method is a hundred methods or it's

two hundred methods? I don't give a shit about

that. The only thing I give a shit about

is whether, is the code I'm actually reading,
is

the system I'm trying to understand, is that
more

clear. When you put clarity as your number
one

mission, a lot of concerns just fall by the

wayside.

It just doesn't matter anymore. And it's liberating.

So, I think this actually comes from sort
of

the same rope. I didn't have time to write

a short letter, so I wrote a long one

instead. I think that describes about eighty
percent of

all that ninety percent of shitty code.

Most people did not take the time to write

a short piece of code, so they wrote a

long one instead. And then they wrote that
long

one, piece of code, and they like, pulled
out

their suspenders and like, oh yeah, I'm done.
My

tests pass.

Boom. Right? Or they look at it and decide,

oh shit, this is too long. I must be

missing some patterns. I just sprinkle some
patterns over

this. Wonders, right? No. What you wrote was
a

draft.

This was just a first draft, right. Any piece

of code you write down is just a draft.

Mark Twain actually had the hard job, right.
He

wrote in ink. If you actually had to change

that, well that was kind of hard, right. So

his drafts were a lot more complicated. Ours?
We

have it so easy. A text editor? You just

delete stuff. And you don't need any of the

little stuff that you, you fill over the page

and you spill it everywhere and so forth.
An

eraser.

You can just delete stuff. Like that's my
favorite

key. The delete key. It's the number one tool

for improving code. Delete key.

So when I was in high school, I submitted

a bunch of first drafts as essays, and they

were really shitty. And of course they were.
They

were the first draft. And my teacher at the

time said, oh, all right, all right, this
is

actually not bad. You just told me the step

one. If you have something on your mind, you

should write it down.

That's what I did. I, I wrote it down.

And then I handed it in. Oh, if you've

written something down, you should rewrite
it.

Oh. That was the step I missed. And I

think that's the step most people miss when
they

write down code. Cause they're focused on
all these

other things. They're not focused on the clarity,
because

when you are focused on the clarity, you will

realize that all your first drafts are terrible.

All my first drafts are terrible. All my first

attempts at writing a good class are poor.
They're

too long. They're not at the same level of

abstraction. They're not clear. And that's
OK. I wrote

something down. I was trying to figure out
what

the system was supposed to do.

That's hard work. And often times you don't
get

perfect code out of that when you're still
trying

to figure out what it is that you're writing.

But once you've written it down, you should
rewrite

it.

And I think the key part of rewriting is

omitting needless words when it comes to regular
writing.

When it comes to programming, it's omitting
needless concepts.

It's omitting needless patterns. It's omitting
needless practices. It's

omitting needless classes. It's omitting all
these extra things

that aren't getting you closer to clarity,
right.

How do you know? You develop an eye for

it. How do you develop an eye? You read

a lot of code. You write a lot of

code. You rewrite a lot of code. And you

forget about fucking patterns for awhile.
You forget about

fucking TDD for awhile. And you focus on just

what's in front of you. The piece of code.

How can I write it simpler?

Write software well. Thank you very much.