So, you’ve managed to pick this book up. Cool. Really, I’m excited about that! Of course, you may be wondering why these books have the oddlooking, college notebook sort of cover. I mean, this is O’Reilly, right? Where are the animals? And, really, do you need another series? Couldn’t this just be a cookbook? How about a nutshell, or one of those cool hacks books that seems to be everywhere? The short answer is that a developer’s notebook is none of those things—in fact, it’s such an important idea that we came up with an entirely new look and feel, complete with cover, fonts, and even some notes in the margin. This is all a result of trying to get something into your hands you can actually use.
It’s my strong belief that while the nineties were characterized by everyone wanting to learn everything (Why not? We all had six-figure incomes from dot-com companies), the new millennium is about information pain. People don’t have time (or the income) to read through 600 page books, often learning 200 things, of which only about 4 apply to their current job. It would be much nicer to just sit near one of the ubercoders and look over his shoulder, wouldn’t it? To ask the guys that are neck-deep in this stuff why they chose a particular method, how they performed this one tricky task, or how they avoided that threading issue when working with piped streams. The thinking has always been that books can’t serve that particular need—they can inform, and let you decide, but ultimately a coder’s mind was something that couldn’t really be captured on a piece of paper.
This series says that assumption is patently wrong—and we aim to prove it.
A Developer’s Notebook is just what it claims to be: the often-frantic scribbling and notes that a true-blue alpha geek mentally makes when working with a new language, API, or project. It’s the no-nonsense code that solves problems, stripped of page-filling commentary that often serves more as a paperweight than an epiphany. It’s hackery, focused not on what is nifty or might be fun to do when you’ve got some free time (when’s the last time that happened?), but on what you need to simply “make it work.” This isn’t a lecture, folks—it’s a lab. If you want a lot of concept, architecture, and UML diagrams, I’ll happily and proudly point you to our animal and nutshell books. If you want every answer to every problem under the sun, our omnibus cookbooks are killer. And if you are into arcane and often quirky uses of technology, hacks books simply rock. But if you’re a coder, down to your core, and you just want to get on with it, then you want a Developer’s Notebook. Coffee stains and all, this is from the mind of a developer to yours, barely even cleaned up enough for print. I hope you enjoy it...we sure had a good time writing them.
As you’ll see in Organization section, developer’s notebooks are built entirely around example code. You’ll see code on nearly every page, and it’s code that does something—not trivial “Hello World!” programs that aren’t worth more than the paper they’re printed on.
Ever read a book that seems to be aimed at pointy-haired bosses, filled with buzzwords, and feels more like a marketing manifesto than a programming text? We have too—and these books are the antithesis of that. In fact, a good notebook is incomprehensible to someone who can’t program (don’t say we didn’t warn you!), and that’s just the way it’s supposed to be. But for developers...it’s as good as it gets.
Do you really have time to sit around reading something that isn’t any fun? If you do, then maybe you’re into thousand-page language references—but if you’re like the rest of us, notebooks are a much better fit. Practical code samples, terse dialogue centered around practical examples, and even some humor here and there—these are the ingredients of a good developer’s notebook.
If you want to read a book late at night without a computer nearby, these books might not be that useful. The intent is that you’re coding as you go along, knee deep in bytecode. For that reason, notebooks talk code, code, code. Fire up your editor before digging in.
We don’t let just anyone write a developer’s notebook—you’ve got to be a bona fide programmer, and preferably one who stays up a little too late coding. While full-time writers, academics, and theorists are great in some areas, these books are about programming in the trenches, and are filled with instruction, not lecture.
This isn’t a nutshell (there, we said it). You won’t find 100-page indices with every method listed, and you won’t see full-page UML diagrams with methods, inheritance trees, and flow charts. What you will find is page after page of source code. Are you starting to sense a recurring theme?
It seems that many programming books these days have three, four, or more chapters before you even see any working code. I’m not sure who has authors convinced that it’s good to keep a reader waiting this long, but it’s not anybody working on this series. We believe that if you’re not coding within ten pages, something’s wrong. These books are also chock-full of practical application, taking you from an example in a book to putting things to work on your job, as quickly as possible.
Developer’s Notebooks try to communicate different information than most books, and as a result, are organized differently. They do indeed have chapters, but that’s about as far as the similarity between a notebook and a traditional programming book goes. First, you’ll find that all the headings in each chapter are organized around a specific task. You’ll note that we said task, not concept. That’s one of the important things to get about these books—they are first and foremost about doing something. Each of these headings represents a single lab. A lab is just what it sounds like—steps to accomplish a specific goal. In fact, that’s the first heading you’ll see under each lab: “How do I do that?” This is the central question of each lab, and you’ll find lots of down-and-dirty code and detail in these sections.
Some labs have some things not to do (ever played around with potassium in high school chemistry?), helping you avoid common pitfalls. Some labs give you a good reason for caring about the topic in the first place; we call this the “Why do I care?” section, for obvious reasons. For those times when code samples don’t clearly communicate what’s going on, you’ll find a “What just happened” section. It’s in these sections that you’ll find concepts and theory—but even then, they are tightly focused on the task at hand, not explanation for the sake of page count. Finally, many labs offer alternatives, and address common questions about different approaches to similar problems. These are the “What about...” sections, which will help give each task some context within the programming big picture.
And one last thing—on many pages, you’ll find notes scrawled in the margins of the page. These aren’t for decoration; they contain tips, tricks, insights from the developers of a product, and sometimes even a little humor, just to keep you going. These notes represent part of the overall communication flow—getting you as close to reading the mind of the developer-author as we can. Hopefully they’ll get you that much closer to feeling like you are indeed learning from a master.
And most of all, remember—these books are...
All Lab, No Lecture
—Brett McLaughlin, Series Creator