I knew almost nothing about designing a website in 2005. But if I had known anything, I would have been hearing a lot about Ruby on Rails.

I still know nearly nothing about it, except that it’s a Web application framework for the Ruby programming language. In short, it was a way to build dynamic websites — like Crunchable.

Chris Klimas described the experience like this:

The whole Ruby on Rails thing was ill-advised but I didn’t know it. I had been reading a lot of buzz online about it and got what was one of the first books about it. There were a ton of great concepts in it that I still use at work every day. […]

I was eager to do a project with RoR and it worked pretty well — on my own laptop. When it went live, it crashed and burned.

Dreamhost [Crunchable’s Web hosting provider at the time] was just not really equipped to run a RoR app — their bread and butter was PHP, so they didn’t put much time into supporting it.

If you didn’t fiddle with the config, it ran insanely slow… like 45 seconds to serve a basic request that hit the database like twice.

This means an average page on Crunchable would take the better part of a minute to load, leaving readers staring at blank screens for a looooong time.

The joke I then heard online was Ruby on Snails.

There were directions on how to make RoR faster on Dreamhost that worked ok, but there were tons of mysterious crashes. I think it was also that RoR was fairly immature itself at that point, too.

I again admit my ignorance here, but if Wikipedia is correct, the first fully-set version of Ruby on Rails was only a few months old when Chris was working with it.

Doing the RoR version was a way for me to try crazy ideas out that wouldn’t have flown at work. It wasn’t really a good move for Crunchable. […] 

I think at that point my desire to do Crunchable was pretty much gone.

And that’s where I came in.

By the middle of 2005, Crunchable was in pretty rough shape. Or, more precisely, editor Chris Klimas was in pretty rough shape.

He’d been trying to push out updates at least once a week for four years. Less than a year earlier, he (and Crunchable’s writers) had re-thought the whole model of how and when Crunchable would publish stuff, and he’d redesigned the whole site in a way that would accommodate that model. (In other words, he’d brought Crunchable to WordPress and away from its file-folder-method of content management.)

But it didn’t work. After a brief bump, submissions went back to being as scarce as ever. So Chris decided to try something new — two somethings, actually:

1. Another new publication schedule, now featuring monthly issues
2. Another redesign of the site, this time using another new content management system

(After I later took over the site, I found myself repeatedly employing very similar methods to deal with the same problem as Chris. More on that later.)

On July 1, 2005, Chris posted an intensely personal and brilliantly interactive/clickable essay describing why he started Crunchable, what it had meant to him, and the struggles it was facing. And then he converted the site to run on the latest, up-and-coming framework for Web design: Ruby on Rails.

Spoiler alert: The monthly issue format stuck around. Ruby on Rails did not.

I can fly in my dreams. I remember the first couple times it happened. The funny way you learn things in dreams without realizing you’ve learned something new — the same way you understand the situation without any narration, without anyone explaining it to you

So begins Crunchable’s very first “Snackable” post, published Dec. 24, 2004 and written by Chris Klimas.

The start of Snackables was part of a new concept for Crunchable. Chris had always solicited and edited all of the articles, which were published weekly, or even twice weekly at some points. This was a grueling schedule. But switching to WordPress opened up some new possibilities — namely, that trusted Crunchable contributors could start publishing their essays on their own, without Chris having to do anything.

I wasn’t there for the decision, but in retrospect I’m sure Chris wanted to make the publication process as easy and frictionless as possible for the writers. Because he desperately needed to do something that might get people to start writing for the site again. We writers were growing up, settling down in lives and careers, and getting us to keep Crunchable supplied with content was becoming harder and harder. (This would become a recurring theme, as you’ll soon read.)

So Chris gave each writer a login to the Crunchable WordPress setup. And when we signed in and poked around a bit, we saw two main categories:

Edit Me Please: Material ready to be looked at by the editors.

and

Snackable: Stuff that you write on the fly; isn’t edited; appears instantaneously.

It was a really good idea, actually. Rather than having writers e-mail their stories in, possibly using attached files that might or might not open on Chris’s computer, all contributors could write all of their stuff directly into the content management system! And for short, bloggy writing, they could even publish it themselves, right onto Crunchable’s homepage, and get the instant gratification of seeing it online immediately.

It was a really good idea in concept, anyway. Despite setting Snackable up to work just like a group blog, few of us writers took to it that way. Despite a strong start, Snackable submissions dropped off precipitously within about three months.

I’m also not sure how many people really took advantage of the type-it-yourself format. I know I submitted my first Snackable that way, but at the time I bet Chris almost wished I hadn’t — I vaguely recall e-mailing him in a panic because my essay somehow went live to the site before I was ready, and then the title was wrong, and then there was something else. I hope most writers didn’t require as much hand-holding as I did, but I doubt I was the only one who needed some help.

So Chris ended up killing off the Snackable concept after about half a year, when he switched Crunchable to a new content management system and a whole new publishing format, in the hopes of finally remedying the dearth of submissions.

But Snackable didn’t die completely — when I ended up in charge a little later, I decided there were things about Snackable that were worth resurrecting. (More on that soon.)

Chris Klimas had been organizing all of Crunchable’s articles in file folders for more than three years before he decided it was time for the site to switch to an actual content management system — namely, the WordPress open-source blogging platform.

The change wasn’t just technical — it was also part of a reimagining of how Crunchable would work, and it resulted in some parts of the site that are still with it today. As he described it in a recent note to me:

Wordpress seemed like a big deal, there were other blog platforms like Movable Type and TextPattern, but Movable Type required money (probably not that much in retrospect, but I was used to doing everything for free) and TextPattern was a bit obscure. It seemed worth it to be able to include a site search and autogenerate author profile pages

It’s hard to imagine this now, but when Chris started Crunchable back in late 2001, WordPress didn’t even exist. Its first version went live in 2003, and Crunchable was using it by the end of 2004.

I’ll cover most of the technical stuff in another post, but the basics of WordPress was that all of the articles would be stored now in a database (a MySQL database, if you want to get technical) instead of in file folders, the new system would allow for more sophisticated article templates, and, as Chris noted above, it would let readers search for articles and create author pages listing everything each one had written. Plus, WordPress was (and is) free, and it’s easy to modify because it’s open-source and written in the relatively simple php programming language.

To make this change, by the way, Chris had to convert each and every Crunchable story published since 2001 into a new WordPress post. I suspect he either wrote or found some code to import all of them automatically. Still, it’s daunting to think about.

What Chris didn’t mention in that quote was that the move to WordPress also was the birth of Crunchable’s “Snackable” posts, and a new idea for how the site would get and publish content. More on that in the next post.

I remarked many months ago about how Chris Klimas must have organized all of Crunchable’s content when he first started up the site. At the time, I speculated that he either “set up a ‘content management system’” to manage Crunchable’s growing library of articles, or that maybe he simply “chuck[ed] it all in alphabetized folders on a server somewhere.”

That second explanation turned out to be closer to the reality than I had imagined. After I posted that, Chris sent me a note about how he actually set things up, and he agreed to let me excerpt from it here:

It’s actually not that exciting nor mysterious.

I picked up either from college or early work that you could do a super simple version of templating with Apache include directives. Basically, you can define a header and footer in another file and have Apache (the web server) mix them in for you. 

“Templating” in the sense that all stories on Crunchable should have exactly the same stuff before and after the story — the site logo, the sidebar, and so on. Apache is the software that runs on the server (the Internet-accessible computer where Chris’s code files lived); Chris told the software to grab the same header and footer and stick them on every page, before and after every story.

So I wrote the HTML for the article (think I basically did lots of find/replacing to insert paragraph tags, etc.) and sandwiched the content between predefined content.

This is interesting to a geek like me for two reasons. The first is that now his initial means of organizing Crunchable’s content suddenly makes sense — it is, in fact, revealed in the URL structure:

www.crunchable.net/02/0420.shtml

He had a folder on the server for each year (“02”, in this example), and inside were a bunch of html files — one for each story, with a filename that indicated its publication date (April 20, in this example).

The second reason it’s fascinating is that, without knowing it, I created some pretty similar systems four years later when I was rebuilding Crunchable. Even though Crunchable had an actual CMS at that point (the blogging platform WordPress), I didn’t use it to manage any of the pictures in stories. Instead, I used a system of file folders and names like Chris’s original setup. I still use it today.

Moreover, WordPress has never quite accommodated the subtleties of HTML that let articles appear the way I want. So for years I’ve been writing every single article as HTML, doing “lots of find/replacing to insert paragraph tags” and so on before putting it into WordPress. Plus ça change.

So, remember when I set up those goals of stuff to finish by the end of June? Yeah, well, about that …

There were family things that came up, and work things, and personal things. Suffice it to say that Life intervened.

And, in fact, other things with Crunchable intervened, too. I spent a good chunk of August and September nailing down the final details for the Crunchable Colloquium, which turned out to be a great event back at Washington College. To coincide with that event, I also rounded up a bunch of Crunchable writers who graciously agreed to help me start publishing Snackable pieces again. Between the Colloquium and the renewed Snackable schedule, I’d say it’s been a pretty good way to mark the site’s 11th anniversary.

So, now, back to Project Bloo. If the main goal here is to get the site redesigned, I have a lot of work to do. One of the challenges I hadn’t anticipated is how hard this design is to do piecemeal; each piece of the picture connects to all the others. I’m starting to think my best bet will be to take a few days off work and do a coding “sprint” to get a bunch of this done quickly.

In the meantime, I have a lot of conceptual work I should be doing, and I really need to finish up this history project I’ve started. Arguably, this history thing is just procrastination — okay, it definitely qualifies as procrastination — but it’s still useful. In addition to documenting how this site came together over the years, cataloging this history has already given me a lot of design ideas. It’s also going to get increasingly useful, as I start thinking about how I set stuff up back in 2006 and how I refined that model over the years; I need to know how much of that stuff I can (or should) keep, and which parts need to be junked and replaced.

So I’ll get cracking on those history posts and see if I can’t wrap those up in the next week or two. Plus, I ought to write here about the other stuff that’s been going on behind the scenes at Crunchable: We’ve shifted some of the staff responsibilities around and have been having some really productive conversations about where we want to take Crunchable over the next few months.

Much more to come, very soon.