« swipe left for tags/categories
swipe right to go back »
More from our friends Nate and Natty at Everlater – this time on debugging.
One of the most important techniques we used when learning how to code is debugging. It allowed us to do two things: fix our own code when it was broken and parse through others’ code to better understand how they were doing things.
From a backend perspective, debugging is essential. When I first started writing code, I would write what I *thought* was the correct way to do it. Ninty-nine times out of a hundred I was wrong and the code would blow up with some ugly exception that I had no clue about. Copying and pasting the exception into google got me decent mileage, but the real silver bullet I discovered was just start from the beginning of the method and step through it using the ruby debugger and figure out where I had gone wrong. Almost always I had forgotten to assign some variable or I was calling a method that did something different than I thought.
The other huge thing that is related is that I read and still read copious amounts of open source code written by other people. I’m better at understanding it now, but at the beginning I would take a debugger and walk through the code myself to try to figure out exactly how their code was working so I could make my own code better.
This is super important on the front end as well. Using tools like firebug or web inspector to take apart existing sites and figure out how they’re doing something or making something beautiful is a great way to learn better techniques for front end development. They’re also essential for figuring out how to fix a layout when it’s broken, or how to figure out why an ajax request didn’t respond the way you would expect.
This is a great, free resource to use when learning how to program and really helped us to bridge the gap from a basic programming book to what current philosophies on development were. A huge hat tip goes out to Jeffrey Kalmikoff for posting a comment on a previous post in this series that made me remember how important this is.
Somewhat related are tools that help you keep your code/team in order. By far the most important is a good version control system. This is something that they don’t ever teach even in college classes, but it’s hugely critical to building a project in the real world. We use git at Everlater and it’s been an amazing choice. When coupled with GitHub, it makes working even in a team of two seamless even if you’re working on almost the same code.
Also important is some way of keeping track of the quality of your code as your project grows. This includes a good issue tracker (we simply use the to-do list feature of the free version of Basecamp), and a good way to know when there’s something wrong in your application (Hoptoad is great for Rails devs.)
I know it’s been a few weeks since my last Nate and Natty / Everlater post on learning to program. I’ve gotten a few notes asking for more – expect a couple of posts over the next few days. In the mean time, here’s Nate’s view on how to divide tasks between partners – in this case him and Natty.
Having good systems in place around your coding is just as important as the coding itself. Natty and I spent a huge chunk of our time figuring out a great workflow that would allow us to program more effectively, and we think it’s paid huge dividends over the lifespan of Everlater.
- Mock up the pages super roughly with pen and paper and figure out the different database models
- Do Photoshop mockups and build the routes and models
- Actually build the pages in HTML/CSS and build out the controller actions associated with each view
At each point in the process Natty and I would sit down and talk about how it was going, and implement our side of the task. It bears repeating that this is also a highly personal part of learning how to program. The following worked very well for Natty and I but other people might be better off pair programming the whole thing, work at completely different speeds, etc. The most important thing is thinking about the workflow in general and making sure it’s a conscious decision rather than something that just happens.
Thanks for all the feedback and comments on the Learning to Program series with Nate Abbott and Natty Zola from Everlater. In the last post, titled Web Sites and Books for Novice Programmers, I foreshadowed some of the tools that Nate and Natty chose to build Everlater. Now that you know how they got started, here’s what they ended up choosing.
The technology stack that they’ve ended up with has evolved over time. The very first decision – which web framework/backend language to use – was the toughest. Once again, our friend Google appeared – this time for the phrase “web framework comparison.” A few days later, the exploration shifted from simply finding and poking around in the various languages (most notably Ruby/Rails, PHP/CakePHP/CodeIgniter, Python/Django, ColdFusion, .net, and Java), to figuring out the salient points in the debate: speed, ease of use, active development of the platform, security, and cost.
Over beers, Nate and Natty put on blindfolds and threw darts at a board. After incorporating these results into their decision matrix, they chose Ruby/Rails mostly because they felt that it had an active community developing it and seemed to be the easiest to learn the quickest. It took roughly a week to come do a decision, start to finish.
After choosing Ruby as the main language they would be working with, they immediately began searching out every possible Ruby coding Meetup. Through those meetings they became connected with Boulder’s Ruby community which is an amazing group of incredibly smart people. They also found two great people, Charlie and Ryan who began working with Everlater for equity early on and helped make some of the key early decisions.
In the continuation of the Learning to Program series with Nate Abbott and Natty Zola from Everlater, I asked them a few questions about which web sites, books, and blogs they consumed at the beginning of their journey when they knew nothing about programming.
It turns out that Nate and Natty spent most of their time simply searching for what they were looking for. Whenever a specific topic came up, they’d use Google, be patient when reading through the search results and forums, refine their search, and keep trying. They discovered that there are an amazing number of programmers who publish code on their personal blogs. As they were trying to get basic stuff to work, they spent time searching for and then reading the full posts and comments.
While they like sites like Stack Overflow and Github’s wiki pages on different open source projects, Nate and Natty never found a great site on the web that has comprehensive documentation on how to program. Instead, they concentrated on being smarter than the problem, really thinking it through and isolating what they needed to learn, and then being patient in searching for and researching the answer.
As Nate and Natty landed on a language and a set of frameworks to work with (more on that in another post) they spent a lot of time with the API documentation for languages and frameworks. As dry as it might be, they waded through the Rails API, the jQuery API, and even the WC3 documentation. But they often quickly ended up back at Google searching away.
It turns out that Nate and Natty have only bought three programming books in the history of Everlater and one was a forgettable SEO book that doesn’t even merit being mentioned. The other two were HTML, XHTML, and CSS published by Visual Blueprint and RailsSpace by Michael Hartl and Aurelius Prochazka. They felt the HTML/CSS book was so-so but it was enough to get them started. On the other hand, they thought RailsSpace was an incredible book that taught Ruby on Rails by walking through the steps to create a social network for Rails programmers. While they felt this was a little corny, it also ended up being very effective.
Not surprisingly, Nate and Natty read a lot of blogs. They read typical tech news blogs like TechCrunch and VentureBeat, popular VC blogs like Fred Wilson’s and Dave McClure’s, and entrepreneur blogs like 37signals blog Signals vs Noise. But when they went deep technically, they spent a lot of time with RailsCast, the Engine Yard blog, and Yehuda Katz’s blog. For design, they went with SpeckyBoy and Smashing Magazine. And when they needed a break from development they read Tech Trader Daily which was a holdover from their old life as junior investment bankers.
As I reflected on this, I found it fascinating how little they relied on books. True to form, they sat down in front of their computers and just got started. All of the information was already out there – they just had to be disciplined about finding it, reading it, and learning it.
What have you read lately?
Day one was totally overwhelming. Overwhelming because we didn’t know what we didn’t know. It’s one thing when you don’t know how to do something (e.g., validate email addresses or change a button’s hover state). But we didn’t know what we needed to learn, and that made it difficult to even start down a path. The first week was spent just googling "web site design", "web site architecture" and "web server" to try to get a handle on all of the acronyms we were coming across (such as CSS, HTML PHP MYSQL, ROR, JS, AJAX). Our goal was to piece together the list of skills that we were going to collectively learn in order to create a web service like Everlater.
Day one was also thrilling and exciting. It’s the same feeling I get when I’m starting a long bike ride in the mountains, the same feeling I got when I first got to college, or when I got my first offer letter for ibanking in New York. To me, there’s nothing more exciting than beginning a large task, and nothing I had done was quite like the task at hand.
Natty responded shortly there after with a few things to add:
We also researched sites we liked and benchmarked what they were doing/using to get a feel for what the popular/hot sites were using. Most notably I remember looking at Facebook and seeing .php at the end of the url string. This gave us ideas of where we should start our research.
I was excited like Nate, but also somewhat afraid. We quickly realized we were going to be learning another language, but much harder than a foreign language because we couldn’t rely on familiarities like verbs, nouns, and sentence structure. Worse, we would have to learn the basics of speech in becoming functional at the command line, databases, and editing programs.
The other interesting thing was that before we put any code down or started day 1 of our idea, we had spent a month brainstorming what we wanted to build. While this was pre-day 1 it enabled us to focus on making code/tech decisions and learning the code rather than also having to think about what we were doing with it. I think this sped our research because we had a framework within which to think about the decisions we were making.
Lastly, it really helped to research with Nate because we could bounce ideas around, problem solve, and challenge each other. Plus, it made it significantly more fun knowing we were diving into the unknown together.
To summarize. They were simultaneously overwhelmed and excited. But fearless – they just jumped into the swimming pool off of the high dive and hoped there was water in the pool.