[Introductory Music]
Welcome everybody.
Before I go into my talk about the
patterns of Basecamp's Application Architecture
A little announcement
about an hour and twenty minutes ago
we released release candidate one. [Audience applause and cheers]
As well as branched for rails/4-0-stable.
So, we're really close to having 4-0 done and shipped.
And it would be awesome if everybody who's here
who is going to work on Rails code during
the next four days could try it out.
Because that's the best way for us to
figure out what's still missing, or bugs, or whatever else, have you.
We sort of have, almost, this pattern of putting out betas and release candidates
and then we ship the final version and fifty tickets come in with obvious defaults
or things that are broken.
So it'd be great if 4-0 could come out and for the first week or two at least
we wouldn't have to ship an update.
So, if you guys can help us do that that'd be amazing.
So, the story of Rails is in many ways intertwined with the story of Basecamp.
This is a screenshot of the very first version of Basecamp we released in 2004.
I started working on Basecamp in 2003, before I had any aspirations of working on Rails.
Before I had any ideas that was I going to work on was going to turn into a framework.
So, the whole approach with Basecamp and with the creation of Rails was that
I was interested in an application. I was interested in building something.
The fact that I had to build my own tools to get there was sort of secondary.
It's certainly wasn't the primary objective.
And that led to, in some ways unique style of working, I think.
That we've really embraced as a community, and in Rails core.
That, frameworks are not inventions, they're extractions.
We don't sit down and try to come up with features that we could need, or would want.
We build applications, things that actually have to run in the real world.
Things that actually have to matter to somebody. Not example code.
And from there we see, what are the pieces that we keep using over and over again?
For me, that's why Basecamp is so important.
Because -- just about, for sure, every single good feature I've put into Rails
have come from Basecamp, or Basecamp derivative.
A few bad features came exactly when I thought I could invent good frameworks.
It -- it never really worked.
The question we're asking ourselves is not
what would someone, somewhere, might want to do with Rails?
Because that sort of speculative development style -- we've had to work
I've had to work with a lot of tools that were built like that.
Teams assembled just to make tools, with
influences of listening to people in various places.
But the core motive to just build tools.
And that is what I was running away from in many ways as it came to Rails.
I didn't want something built by somebody
whose sole occupation was just to build tools for me.
Because those tools tended to never really
to match the expectations I had for real-world development.
So what we do instead is say:
I'm not going to care about anybody else right now.
I'm just going to focus on building Rails
as the perfect framework for building Basecamp.
That's my mental model.
The side effect is that Basecamp, of course, is not that special.
Most of the things it does is same kind of things
you want to do in a lot of different applications.
But, because we attack the problems
from this sort of concrete approach
we get to extract something that just feels right.
Something that feels like somebody's actually
used it in anger.
I mean, I've sworn and cursed my fair amount at Rails at certain times.
So I've certainly used it in anger, and have changed things in anger.
I find that that's really a lot of where a lot of the magic happens.
When I'm so fucking annoyed that something
takes four lines of code when it really should
just take one, that's when good stuff happens.
And it happens in sort of a different way
than that example code driven development style
that you often run into when people do this for full-time living.
Because it's very easy to make pretty examples.
We have lots of this in Rails where -- for example
the standard scaffold for a long time
it looked like it was not very DRY.
It had a lot of duplication, right?
People would often come to Rails and they would say, as the first thing:
"Well this code you're generating it's verbose, I could optimize it in all these ways"
A few people have tried, with various gems.
And what you find is, yes, you can make example code
really pretty by making a certain set of choices.
But those same set of choices are usually the ones
that makes it horrible for actual real web development.
So, 2003, 2013, I've been working on Ruby on Rails
and Basecamp for 10 years now.
That's about a third of my life.
So, I don't think it's any stretch to say
this is my life's work, at least up until this point.
And, it's funny, because in some ways, it feels familiar.
When I looked at Rails code today, it looks and feels and smells
very much like the Rails code I wrote ten years ago.
Of course it changed in a myriad of different ways
but it's much, much better now.
But the kernals and the principles are very
much still the same.
And that's interesting to reflect on
when you compare it to the things that changed.
In 2003, this was a state of the art phone. [Audience Laughs]
Seriously. Flip phones was really back then.
It's so funny because that seems so far away, right?
I mean, flip phones? Seems like another era.
Which it is in many ways
because many parts of technology move very fast.
It's interesting that we're here today and we're still
working with and discussing and debating and improving a framework
that is from the time of flip phones.
So, that's sort of like the form factor of actually
a lot of people interfacing with our applications today go through phones.
If we look at other parts of technology
just sort of the hardware we were on
I looked up these prices yesterday
and, it's like, half a gigabyte costs $50.
Now you can just 16 times as much RAM for almost half the price.
That's more than an order of magnitude change.
Which is just, it's one of those things that's also
interesting in terms of what does that change
in how we approach things?
Often times, people will almost lock their concept
of what hardware costs and how it runs to the time
they entered programming.
If something was scarce, and expensive
at the time they got into programming they'll
think that's how it's going to be forever.
Which, of course, this shows you can get
8 gigabytes for $29. How much RAM do you use?
Probably it doesn't matter as much as
a lot of other things. Which is funny
to me because that's always been --
Matz, back in 1993, 20 years ago, 20 years ago Matz started working on Ruby.
He had to care far -- I should've actually looked up
what RAM cost back in 1993.
But I'm sure it was fucking expensive. [Audience Laughs]
Yet, he sort of had the foresight to think
well, I don't know if he had the foresight,
but it turned out, that the thoughts
that he was thinking about, how we should
make programming languages, and development environments,
like, I can make something now that -- ok, it's going to take more memory,
it's going to be slower, and it's not going to matter
because those things are going to improve
drastically over time.
What's not going to improve is programming brains.
They're pretty much as mush as they were back in 1993.
So we need to optimize for that.
So, that's sort of the hardware side, that that moves really fast.
Ok, not that -- we know that, Moore's Law, and all, right?
Also funny to look at the things from 2003.
Java was actually a real thing that people non-ironically wrote.
[Audience Laughter and Applause]
This was actually -- when Rails first came out,
I was talking to a lot of Java programmers
and they were serious.
[Audience Laughs]
And it's just funny to think back about this sort of battle, or whatever
that we had in the beginning. And this was the relevant foe.
This was who were trying to sort of say, there's a better way to implement
a lot of the good ideas that you have.
Because that was the second funny thing of course.
Because Rails is from 2003, and the bulk of the
thinking of how to structure, and create nicely
factored web applications, and those
types of applications came from the Java world.
It's just that they were trapped inside that beast
and we had to liberate it.
So, there are still people programming Java.
Of course, the JVM lives on and it seems like
that has a long and prosperous future.
And people are putting it to much better use
than the Java language itself.
The other thing, struts, that was actually
a serious framework at that time that we were
sort of trying to convince people why this was better
why XML situps and so on, were not something you should to do.
It's really interesting to think about all of these things
that have changed, and how much the world
of technology has changed in the 10 years Rails has been around.
I've been trying to reflect on why that is.
Why are we still here?
Why didn't Rails go the way of Struts?
Why wasn't it just a footnote in sort of a progression of things?
Where were all these other things that were supposed
to come afterwards. I certainly never
thought, when I started working on Rails
that I'd be here 10 years later and talking to
1,500 people at a sold-out conference.
That's a pretty measureable success.
That's surprising I'd say in technology.
Just like the flip phone is not here anymore
and Struts, thankfully is neither.
You should've thought that Rails would've gone away, right?
I think the stuff I talked about last time -- or last year
that pioneering spirit, I think is what makes the Ruby community
and the Rails community unique.
We are willing to continue west.
We don't just stop when we find a comfortable resting place.
There's a lot of other communities that value
stability far higher than we do.
That's not to say that stability is bad, it's just
a trade-off. If you look at say,
the Python guys, and how long they've taken
to get on Python 3, they're not there yet, by the way.
They're still going, and it's been years, right?
How long did it take the Ruby community to move
from 1.8 to 1.9 to 2.0? [Snap, snap, snap]
And it wasn't because it was painless.
How long did it take the Rails community to move
from Rails 1, to 2, to 3, to now 4?
Again, it wasn't painless.
Anytime you want to make progress like this
it's going to hurt.
But we as a community are willing to take that hurt.
That makes the community unique.
We're willing to sacrifice for progress.
I think what's interesting about that, the pioneering spirit,
that we're willing to continue west.
We don't just stop halfway and say,
"Ah, fuck it, Kansas is good enough"
[Audience Laughs]
A lot of people just -- they stop in Kansas.
Like that's just like, things are fine
I've got my cows and the sun comes up in the morning, great.
I mean, although, some Rails people have stopped in Kansas.
[Audience Laughs]
There are still a few people still running.
This is the half-life of Rails where we are now.
It came out in 2009, that's 4 years ago.
Anyway, if you're still in Kansas, keep
going west. California awaits you.
The west coast awaits you, Portland I should say actually, my bad.
We've continued west. We've gotten closer and closer
to this sort of promise of the west coast.
And I think as we've gotten closer and closer to that
and it's taken years and years, because again
it's a painful journey.
It's a perfectly legit thing to say,
I'm just not interested in any more progress, we're stopping in Kansas.
And I will go on, and I will do Rails 2.3 for the next 4 years.
A lot of people did and it wasn't like they were necessarily
miserable. I mean people do lead good lives in Kansas.
But, I think that there is something more important here
to keep on pressing on, and not just because
we keep our own interests and this is still interesting to go to
if we had just stopped as a community and said
Rails 2.3, that's our final resting place.
Ruby 1.8, what did we end up at? Ruby 1.8.9? 1.8.8? Whatever it was.
That's the final resting place, that's where we're gonna stop, right?
That's just where we are going to park our ambition and say, that's good enough.
I don't think we would be here because then these things would just be tools.
Nothing wrong with just being a tool. [Audience Laughs]
There's just something more inspiring about pressing on and going further.
About this whole notion of pressing on and going further,
Joel Spolsky, in 2001, had this great essay: "Good Software Takes Ten Years, Get Used To It"
At the time I read that, it was funny, I read that
and was like "what a fucking jackass"
[Audience Laughs]
I can make something in fucking six months
that's going to blow the doors off whatever you've been
working on for ten years.
But I think he actually had the long end of something.
You can build something that's good for you in six months
and it could be "good software".
If you want to build something that has the kind of impact
on community, on the programming community,
on the world, for lack, for less sort of grandious vision.
It does take a long time. We've slowly but surely built this up over time.
That goes both for the work that I've put into Basecamp
and the work that I've put into Rails.
These things compound slowly over time if you keep investing in them.
You can see the sort of progression of investment that we've had with Rails
and the people who've been flowing into it on this chart.
New contributors with their first commit to Rails.
2004, first time I opened the code base and accept patches and let other people commit to it,
a few people, 40 people I think had a patch go into Rails in 2004.
The very next year, big boost, 280 people or whatever.
Then we sort of had like, I don't want to call it flat face
because this is all new people coming into the community
and starting to add something. But, for a long time
we had sort of a steady rate of new people
joining the community. And then something interesting
happens. In 2009 there's a small dip.
Everybody thinks the world is going to end and
everyone is getting fired and alright, I understand
and then after that, what happens?
There's a massive jump.
And this is actually funny. So in 2009, our Kansas,
so there's a baseline there, alright? We keep pushing.
And people respond. A lot of people are interested
in pushing on with us, interested in joining the caravan and continuing on.
Which is really just sort of interesting to see just
sort of the phase we can go through.
By 2009 I've been working on Rails for 6 years.
And we've had this steady inflow and then
all of a sudden lots of people get interested
in getting involved, awesome.
If you look at the same chart, just compounding
all of the committers, you can see it's more
of a steady climb, but the same pattern is there,
from 2009 and onwards, lots of new people got involved
because we kept pressing through.
We kept pressing through the comfortable phase.
Even though, the funny thing is, when you
do that you're sort of -- we have this
saying with Basecamp were you shouldn't be afraid to let customers go.
Sometimes customers are going to outgrow you.
They're going to think, well you no longer represent what they need in a
project management application, right?
A natural reaction to a lot of people, or for a lot of people
is to look, "Shit, we can't let that happen, no customer can leave, lock the doors"
"We will do whatever we can to take them happy"
We had that moment in 2009, where we could've said, let's just lock the doors.
Let's just improve things for people who are already here.
Big enough community, we're comfortable,
we could be self-sustaining for a long time, that could be fine.
We instead said nope, we're going to keep the doors open.
What that's going to mean is that there are going to be some people who are unhappy.
I've heard people say Rails 2.3 is the best version of Rails ever made.
[Audience Laughs]
Which is, it's sort of one of those funny nostalgic things of
you just sort of lock your timezone, like the 80's that's when music peaked.
[Audience Laughs]
It's just a funny phenomenon, and it's real, and I think
that's where a lot of technology circles an ecosystem, they stop.
And then they just stay there for the rest of life.
Anyway, we pushed on.
Here are the stats for the last 12 months running.
More than 1000 people were part of more than 8000 commits
to rails/rails GitHub repo. That is fucking amazing.
1000 people working, and this is just the people who get commits in.
We have so many more people doing all sorts of
other stuff around the codebase.
This is just the people who got a commit into rails/rails itself.
That is really and truly astounding.
And I think that that shows and validates
the approach, the uncomfortable approach that we have
to keep pushing and to keep getting better
even if it will ruffle the feathers of the people we already have.
The customers, the developers, who are already using Rails
that are somewhat uncomfortable with whatever new direction we have.
It's also a funny match to Roger's Innovation Adoption Curve Idea.
This is sort of an analysis describing how products are adopted.
So obviously, from the beginning we had a lot of innovators.
People who would use Rails even though there were
a lot of things that were broken or didn't do whatever in the beginning.
Small slice of the overall market of developers.
Okay, we've got the early adopters.
I think that's sort of our first crest.
And you sort of hit this point where you have to
make the jump from early adoptors to the
early minority. I think that's exactly what that point in 2009 shows us.
We did make that jump. We are now on sort of the next ride up.
Which is, which is pretty cool.
And I think it's also interesting for me in -- the original reason
I got into open source, the original reason
I wanted to release Rails was two-fold,
first, I wanted to give back. I had been
using Ruby, I had been using Linux,
I had been using MySQL, I had been using Apache
I'd been using all these open source projects
so, when I had something myself to share
I felt like, dude you're a dick if you don't release
something like this that other people could find value in,
when you've used all of their stuff.
So there's that. Don't be a dick.
The second part is, I'm having a lot of fun
doing this stuff. Ruby is really a great programming language
Rails enables me to use Ruby to build Basecamp.
There's going to be a lot of other people out there
who could benefit from Ruby so let's
get as much programming joy out there in the world.
So that's why this stuff is interesting because
we've having a bigger impact, we're getting
more people involved with enjoying their work.
And not being stuck in Struts, or whatever painful torture instruments of the time.
Anyway, so I think that's all great.
And it's great to see there are more people getting involved.
But you're also sitting there and have to stop
and say okay, what are we actually doing here?
What is the purpose? Why are we still working on this?
What is the improvement path? Who are we?
Who do we want to be?
So, I think a while back, decided we want
to have a big tent. There should be room
for a lot of different people in the Rails community.
Jugglers, musicians, clowns and elephants all invited, come on.
And we pulled some things in, we did
with Rails 3, we had a influx of good new ideas
from, at the time, a competing framework
called merb, which was sort of a
good reflection of okay, it can be a big tent.
We can have room for a lot of people in here
who might not agree on everything,
they might not all want to build Basecamp
but we have a general principle, a general purpose
that this is where we're going, and
we agree on these things. And once we
sit down and actually work on code together
we realize we share more opinions than we don't.
So, even so, even if you have a big tent
and you have room for jugglers, and elephants and so forth
and you're having fun, you're not a ferris wheel.
There's got to be something you're not.
You have to sort of define it in some sort of opposition
there's limits to what this is, because if
you try to be everything to everyone all the time
you're nothing to nobody none of the time.
Second, the title of this talk is "Patterns of Basecamp's Application Architecture"
The whole idea of patterns is that you see a problem
and there's a solution, but there's a third element,
there's a context. There's a context in which
that problem arises. Because you can encounter
the same problem in two different contexts
and you're going to want two different solutions to that.
So, what is the context? What is the context of Rails?
Of the work that I'm doing on Basecamp?
For me, that context is Dynamic hypertext documents.
What does that mean?
It means that this is sort of what I'm trying to produce.
It's funny because when you see HTML it looks like
it's such a good, there are books like Learn HTML in 4 Days, right?
It seems like such a low-level thing, it seems like such a simple thing,
like sort of beneath us, kind of thing, we are "serious programmers" who do "serious work",
like, all we're doing is just generating HTML, that's -- I mean, c'mon, that's for HTML monkeys, right?
Like, I need something more grand. Well, to me
the grandness is in embracing the simplicity.
Is embracing what the web is, and not just what
the web and HTML as the delivery mechanism,
sort of the web and HTML as sort of a lot of
side effects that are neat, in term of software deployment and development,
don't have to install software, you just get it from one place.
You could deliver a lot of different kinds of software where
you just use HTML as a delivery mechanism.
But, when I've been revisiting and going back through the Basecamp code base
and especially the work I've done with the new verison of Basecamp.
I realize that it's deeper than that, that this is not just a delivery mechanism.
That the actual structure of HTML, the approach to the context of
software development as a document is profound.
That profound approach is not something we should try to escape.
It's something we should try to embrace.
So, you can think about a lot of different applications that are being delivered on the web
on sort of on a contiuum. On the one end
you have something that is basically purely document based
and on the other hand you could have something that's
almost like a GUI using HTML as a delivery mechanism
but you certainly wouldn't describe it as a document.
I think if you look at that sort of continuum from document to GUI and nothing falls perfectly at either hand.
Perhaps these two, I mean Wikipedia is just a collection of documents.
It's a pretty good to, I think, my vision at least of
what I'm interested in, the kinds of applications
I'm interested in, and thus, the kinds of tools
I'm interested in building. I want to build tools
for a document based web. That approach to software development is quite
different from all sorts of other approaches that went before.
If you look at software from before the web
it looks different. I've been struggling to find a word to
describe that style of applications, GUI is the best
I can come up with, even though of course the web is a GUI, too.
You sort of know what I mean.
Maybe it's easier if you look at an example.
If you look at Google maps for example, that doesn't feel
like that's a document. That feels like
this is using HTML as a delivery mechanism for
the application that it provides. It doesn't mean
it's not a great application. It's a great application.
It just means that what we're trying to do is optimize for
a version and vision for web applications that is more
document based, this is not the primary thing
we should optimize for. So, if you're trying to
write the next Google Maps, maybe Rails, at least as
a whole package, as a full-stack framework isn't
the natural fit. You can pick parts out and you can have
a good HTTP processor and you can do all sorts of
other things that's interesting.
So, if that' 100% the camp that you're in, the
sort of not related to documents at all, maybe that's not it.
Then it becomes interesting, because as I said,
a few things are either one thing or another thing completely.
If you look at Basecamp for example, we have this
calendar there, that doesn't feel very much like
a document. It doesn't feel like it fits HTML, what's the section
what's the header, what's the paragraphs here?
It feels like we're using HTML as a delivery mechanism.
But it's a minority thing part of what we do
so we try to fit it in and it should be possible, but it's
not the main thing. The main thing is more
stuff like this. Where it actually does look and
feel like a document. This looks and feels
like something you would not have before the web
this would not be like what an application looked like.
Because this is, that native development style of the web.
If you look at something like GitHub, same thing,
it feels like a document, it feels like a document that's decorated with some dynamic behavior
and that's great, but the key part of it, it's essence and it's being, is the document itself.
It's not just a delivery mechanism. That's the, the slice, and the part of information technology
that I'm interested in. These kinds of document focused
applications are not a bad thing. It's not something
we should be trying to escape, the constraints
that it puts on us to develop an application
in this style, they're liberating.
They're not bad. We don't want to start
with an empty canvas and have to draw everything
from scratch. The fact that HTML is there, and gives us
a sort of semantically relevant containers to put
certain things in, is a benefits, it's great.
And, that's where, I guess, the insight for me is
why is it that I was never interested in Java Applets?
It wasn't just because it was Java, it's horrible enough in itself,
but it was the notion that this was just a blank canvas,
you could draw whatever you want, there are no limits here,
you don't have to fall in line to some predescribed notion of a document.
Or set GUI elements for a document, forms and so forth.
You can do whatever you want.
I don't wanna do whatever I want. I want a container, a base to put my ideas in.
That's when I find, that they flourish.
So, with that insight in mind, and with the insight in mind
that the web is the most successful software development platform of all human history,
that leaves me to think that it's not acutally that big a surprise that this failed.
Because, the architects of this sort of canvas-base, let's
use the web as a sort of delivery mechanism for
the same application architecture that we had on the desktop
they're wrong. That's not the part of the web that's interesting.
It's not just these accidental properties of oh, it's easy
to update software because it runs on my server.
The things that brought the web to it's prominence with users
and developers alike, we're the constraints.
Was the fact that that style of interfacing with information technology is
really user-friendly, really development-friendly, it's different.
Not in a worse way. And that's usually what I --
I had conversation, I think it was Rails Conf, maybe 7, or something,
and some Microsoft guy was coming up and he was going
to tell me about serverlite, and the pitch was
"I'm finally going to free you from HTML"