Head First Labs

Programming Is Fun Again!

2011-10-24T13:13:13Z

I sometimes forget one of the main reasons I like programming, and that's that programming is fun. People can talk all they want about problem solving and helping others to accomplish tasks, but for me it's all about realizing that I can do it, and that's always been a fun thing. Granted, there's some code to write because some user (somewhere) needs a new feature, or there's a bug to be tracked down and squished, but the main reason I like programming is that it's, well, fun.

Of course, what with everything else, I had forgotten this. Life is busy and I'd generally gotten to the point where any programming I did was to do with something that others were asking me to do: give a technical presentation, write an article, consult with a start-up, deliver a course, or start another book. I was programming, and it was OK, but I was doing it to get to some end-point, not necessarily to have fun. I wasn't programming for the sake of programming; I was programming because I had to.

And then something wonderful happened.

I came across Erlang. Or to be more precise, I was pointed at Erlang by one of my past-students who wrote an intriguing article about an Erlang CMS called Zotonic for Linux Journal magazine. The author of the article, Michael Connors, then sent me an email together with a "you've gotta take a look at this!" plea. Based on this, I thought Erlang interesting enough to explore it more and I've been learning Erlang for a number of months now.

In fact, I've been programming in Erlang just for the heck of it!

I'd forgotten what this was like: writing code, realizing that I can do it, and then getting it to work can be so much fun! Nobody is asking me to write Erlang code. I'm also not writing the next-best killer Erlang application. And, I've not got some darn-hard problem that needs solving in Erlang. I'm simply programming in Erlang in my spare time and it's fun. What a lovely feeling.

Of course - me being me - I couldn't resist the opportunity to tell others about my latest language "find". So, when O'Reilly Media asked me if I wanted to do another webcast, I jumped at the chance. Feel free to check out my own personal take on Erlang. Enjoy, and have fun!

[Ed note: Are any of you HF readers programming in Erlang? Even if not, do you agree with Paul--if so, what is fun about programming for you?]

Head First iPhone and iPad Development and iOS5

2011-10-14T15:40:37Z

Well, iOS5 is out, and that means that Head First iPhone and iPad Development officially needs some tweaking to work with the latest tools!

First, a quick overview of the new features in iOS 5. For the OS itself, the biggest change is the addition of iCloud to the storage solutions for apps. Primarily Apple apps are leveraging this ability to support synching at this point, with Photo Stream, iMessage, and iTunes purchasing support, among others, but as time moves on that will expand. Newsstand support has the potential to change the publishing industry by providing a centralized place on the device and method of updating subscription type materials. You can find the Apple summary of these and other features here.

There are lots of other bells and whistles, the new Siri app is a personal assistant app that can parse meaning from verbal messages and find out information for you, but it only really works on the new iPhone 4S. Twitter integration is system wide now, and the new Reminders app is also really cool. It has geo-fencing for tasks, so you can set up a task that says "remember to take my shoes home from work" and when you leave that place, iOS will send you the reminder.

What does iOS5 mean for Xcode? Xcode has two major changes. First, there is now storyboarding support. That means that instead of creating each .xib file and manually linking them together and coding the transitions, you can create a big .storyboard file that contains all of the .xibs for your app and you can graphically edit the transitions between views.

The second big change is that Apple has added ARC (Automatic Reference Counting) to Xcode. A lot of the memory management work that we teach in the book has been automated. While it is stil important to understand what is going on, all the retain/releases that we have so painstakingly put in our code are now handled automatically.

What if you want to use the book with the new Xcode? Just a couple of things that you should know about. First, all the downloaded code here on headfirstlabs.com will still work, no problem. Second, when you create new projects, there are some new checkboxes to be aware of. When the project starts, there are boxes to "Use Storyboard" and "Use Automatic Reference Counting." In order to use our book as it is, you'll need to UNCHECK these two boxes. That's it. If you keep those two things in mind, all the examples in the book will still work without a problem.

One of the things that keeps technology exciting is constant change! Fortunately, these changes are relatively minor as long as you set up the project properly and you'll have happy coding. In the meantime, we're busily working on updating the book, which will be out early next year.

It's True. Don't Believe A Word Of It.

2011-07-29T12:19:34Z

I'm often asked how I came to write for the Head First Series, specifically on their Python-related titles.

I'd been working with Perl for years and had written or co-written two Perl-related texts, and towards the mid-to-end of the 2000s had started working with Ruby quite a bit, no more so than as a result of all the (justified) hype surrounding Ruby on Rails. As a consequence, I'd read (and own) a lot of Ruby-related books.

Now, imagine my surprise when, one fine day, there I was sitting, re-reading some of the material in my well-worn copy of The Ruby Programming Language when - I kid you not - a big bolt of lightning shot out of the sky and buried itself in my beloved book. Take a look at the photographic evidence if you don't believe me.

I took this as a sign that my days of programming Ruby were numbered and that somebody, somewhere was trying to tell me something...

OK, I'll admit that some of that story is not totally true. Actually, the bit about the lightning isn't.

What actually happened was that it was my turn to cook dinner and, as Cooking for Geeks had yet to be written, I didn't yet understand how important it is to actually pay attention while cooking. You see, in one hand I had a pot which I popped on the stove-top to heat up. In the other hand, I had the Ruby book. When the pot got hot (or so I thought), I set the book down on the stove-top while I attended to the pot's contents.

It was then that I noticed a rather strange burning smell... then smoke... then (very nearly) fire. The Ruby book was smoking! Not paying attention, I'd switched on the wrong heat-ring on the stove-top and placed my book directly on top!

Needless to say, dinner was delayed that evening. But, I took this as a sign that my days of programming Ruby were numbered and that somebody, somewhere was trying to tell me something... and, anyway, the contract to co-write (with David Griffiths) Head First Programming (which uses Python) had just arrived.

Head First iPhone and iPad Development is out!

2011-06-30T18:44:59Z

Head First iPhone and iPad Development is shipping as we speak, which is very exciting! Updating Head First iPhone was a daunting task this time around, there have been lots of developments with iOS development since we printed the first time. Timing the release of the book around those updates was tricky, especially with the well-known Apple secrecy around new releases.

Going through and working on the update it was amazing to see all the changes that have taken place since the last version. The biggest changes are the introduction of the iPad, and iOS going from being the operating system for the iPhone to the OS for both. The result for developers is that the Objective-C hasn't changed, but what you're using it for is significantly different based on the device. We added two new iPad apps to the book and the last chapter has lots of good information about designing UI for the iPad instead of the iPhone.

The key difference in design for these two platforms is the time of interaction. iPhone users are almost always waiting for something. An appointment to start, somebody to meet them, the light to change. Interaction is quick and focused. iPad users are settling in for an extended interaction with the device. Sitting on the couch to shop, or read a book. The additional screen space is nice too, but just making an iPhone app bigger isn't going to cut it.

The second edition of the book uses Xcode 4, which is a vast improvement over Xcode 3. GUI layout with Interface Builder has been integrated into the main IDE, which is huge. You can graphically link outlets and actions with Xcode, code completion and documentation are vastly improved. It has an assistant editor that allows you to look at related code side by side as well. Debugging is in the main window as well. Xcode now really feels like a competitor to Eclipse or other more mature development environments. It does make development much easier.

Another big change to the iOS world is the maturity of the App store and the industry. When we published in 2009, the App store was just over a year old, and the Android Marketplace was just getting up and running, and App development was fairly immature. Since then, things have grown to the point that enterprises are getting into App development, because they need to be present on these app stores the way that they need a website. The first year the App Store made $50 - $100 million (from Business Insider). In 2010, Apps were a $5.2 billion business (from Gartner).

A quirk of this whole thing is that most enterprises, even if they have in-house developers, are PC shops. Since you can't develop for iOS on a PC, it means a fantastic opportunity for freelancers and developers who know iOS.

The book still features a cranky bartender, a bounty hunter, and a guy with relationship problems, but we fix their issues with iPhones and iPads this time. We really hope everyone enjoys the book and finishes with a good foundation to build their own apps!

No Code Is Sometimes Best

2011-05-30T11:37:36Z

I recently set my final year software engineering undergrads a task to take a simple Google App Engine webapp and add a login/registration system to it. I made a point of advising my students to RTFM (read the *full* manual), highlighting to them that there is lots of great functionality provided with App Engine "for free" and that its all just sitting there, waiting to be exploited by savvy developers.

When my students submitted their work, half of them had done half of what I'd asked. These students created the datastore descriptions required to store user-ids and passwords, created some UI forms to solicit login/registration information from the users of their webapp, and then tied it all together with lots and lots of code to make sure the logic worked as required, providing a fully functioning authentication system for their webapp. These students were quite pleased with themselves as they'd obviously done quite a bit of work here. After all, look at all the code they'd written!

The other half of the class did everything I asked, including taking my RTFM advice to heart, and - suitably enlightened - simply added the following line to their webapp's configuration file:



    login: required

This directive - described in the App Engine online docs - switches on Google's own login/registration system for a webapp and provides a fully-working authentication system using the same technology that lets you into GMail, Google Docs and all those other Google cloud services. Take a moment to think about what's happening here: all that functionality from a simple configuration directive and not one line of new code in sight!

Of course you may not agree, but I'd suggest that the Google engineers have this problem pretty much solved by now and that any attempt to write a custom App Engine login/registration system is, at best, ill-advised and, at worst, unproductive. Although there's a case to be made that there's lots to learn from "rolling your own", there's also the point to be made that the savvy developer knows what to concentrate on, that is: build only the functionality that's specific to a webapp... then "beg, steal and borrow" the rest. Knowing when to and when not to write code is skill worth mastering.

Now, as readers of this blog know, I'm a big fan of the "Less Code Is Better" principle, but I'll take no code over less code any day. And I'm always amazed when a developer (not just a student) insists on writing everything from scratch. What explains this blind rush to write code? Is it inexperience? Arrogance? Madness? All of the above?

What do you think? I'd love to hear other developer's views on this.

Less Code Is Better

2011-05-10T09:46:59Z

Head First Python contains examples of Python's list comprehension technology, which is a technique that lets me take code like this:

    new_list = []
    for thing in some_list:
        new_list.append(do_something(thing))

and turn it into shorter code, like this:

    new_list = [do_something(thing) for thing in some_list]

Note that both code fragments assume the existence of a list called some_list and a function called do_something(). List comprehensions are an example of Python's functional programming facilities, whereas the three lines of "standard code" are an example of Python's imperative programming facilities. Both work, of course and - depending on your point of view, one technique may appeal to you over the other.

I'm a big fan of the "less code is better" principle, in that I firmly believe the number of bugs in my code is directly related to the number of lines of code I write. Any technique that lets me write less code always gets a big thumbs-up from me, and using list comprehensions lets me write less code. To illustrate, let's take a real-world example of where using a list comprehension can have a dramatic impact.

Imagine I've designed a web application that has a HTML form element that allows my users to select an age from a drop down list. I'm building my web application using the popular Django web framework, which has lots of built-in goodness for dynamically creating HTML. In fact, Django can dynamically generate a HTML form directly from a model definition, which is way cool. When I use code like this to define my data model, Django takes it and dynamically generates a form:

    from django.db import models 

    class StudentData(models.Model):
        name = models.CharField(max_length=50, 
                                verbose_name="Student's Name")
        age = models.IntegerField(verbose_name="Student's Age")

As well as the self-explanatory arguments to the field definitions, there's also an argument called choices which allows me to specify a list of tuples which Django will use to restrict the input values allowed. If I create a list like this:

    _ALLOWED_AGES = [(4, '4'), (5, '5'),
                     (6, '6'), (7, '7'),
                     (8, '8'), (9, '9'),
                     (10, '10'), (11, '11'),
                     (12, '12'), (13, '13'),
                     (14, '14'), (15, '13'),
                     (16, '16'), (17, '17'),
                     (18, '18')]

I can then change my model definition for age to look like this:

    age = models.IntegerField(verbose_name="Student's Age", 
                              choices=_ALLOWED_AGES)

Django will now use this list to create a HTML drop-down list within the form. The first element in each tuple is the value stored in the model, whereas the second element is displayed within the form's drop-down list. Pretty easy, eh?

Well... yes, it it easy... but, look at all that extra code. Count the lines added: 9. That's nine places where I could potentially introduce an error into my code. Remember: more code means more errors. Did you notice that I have a typo in the string-value associated with 15? It is incorrectly coded as '13', not '15'? Hard to spot, isn't it?

Let's improve things--and by improve I mean "reduce the possibility of error"--by writing some code to generate the list, instead of simply defining it. I'll start with an empty list which I then populate with the generated tuples using a standard for loop:

    _ALLOWED_AGES = []
    for each in range(4,19):
        _ALLOWED_AGES.append((each, str(each)))

Which gets me down to 3 lines of code, which isn't bad. Of course, I can rewrite this using a list comprehension:

    _ALLOWED_AGES = [(each, str(each)) for each in range(4,19)]

Which gets me down to just 1 line of code, which I think is pretty cool.

Now, ask yourself this question: which would you rather maintain? Nine lines of code, three lines of code or just one line of code?

To conclude, and to shamelessly paraphrase a famous Canadian singer/songwriter: Less code is better. Bumper stickers should be issued!

Those Crazy Fonts We Use

2011-04-18T22:32:54Z

By now, this study (PDF) by a team of psychology researchers from Princeton and Indiana University has stirred up some interesting press (and plenty of "I knew it" nodding of heads amongst the Head First team) given the unusual results. Students asked to memorize relatively foreign material (characteristics of "aliens") performed better on recall tests if they were presented the study materials in fonts like Comic Sans (a font we often take a lot of flak for using in our books), which is notoriously harder to read than a more traditional font like Arial. The differentiators weren't size or formatting like bolding or italics, but rather the difficulty of reading the font itself.

One of the study authors, Daniel M. Oppenheimer, recently said in the New York Times, "The reason that the unusual fonts are effective is that it causes us to think more deeply about the material. Think of it this way, you can't skim material in a hard to read font, so putting text in a hard-to-read font will force you to read more carefully."

The implications for Head First books is almost comically clear (apologies). Often you may note that we reinforce key teaching points on a page in a big, funky font. We use Comic Sans, and we're not afraid to admit it. It turns out we're not just admirers of (potentially otherwise) bad fonts. There's some real cognitive science method to our madness.

I found one other interesting nugget related to this result in that same NYT article (which I originally thought was just going to be a rehash of the font study results). It quoted a series of experiments conducted in 1996 by researchers at Macalester College and New York University who were interested in whether prior exposure to answers for an exam would indeed positively impact student's performance on exams. Not that surprisingly, they found a positive correlation. But they found something even more interesting along the way--the nature of the preparatory information had an even more profound impact. To wit:

"In one experiment, researchers found that participants studying a difficult chapter on the industrial uses of microbes remembered more when they were given a poor outline -- which they had to rework to match the material -- than a more accurate one."

Now we're not suggesting that we give you "poor" material when it comes to Head First, but we do let you screw up occasionally. And we do so on purpose. Finding something that isn't working and figuring out why proves to be a far more compelling (and successful) learning strategy than just being handed the answers up front.

Would you agree? Are our bad fonts and FUBAR moments part of what makes Head First work well for you?

Head First Holiday Gift Guide

2010-12-03T21:39:26Z

We're a bit behind the ball since Hannukah already started, but hopefully we're not too terribly late. As you can imagine, we're big fans of giving (and receiving!) books for presents (okay, we'd take an iPad too if you're feeling generous). If you or anyone you know is trying to learn more about Web Development, Programming, or Dealing with Data, the Head First Holiday Gift Guide has you covered. Check the groups below for suggestions for anyone on your list, from people just starting out to those mastering best practices and advanced concepts. We start with Web Development first, and the other two are hot on its heels. Don't forget some Code Magnets for stocking stuffers, too. Happy holidays to everyone in Head First land!

Web Development

Getting started

You want to learn HTML so you can finally create those web pages you've always wanted, so you can communicate more effectively with friends, family, fans, and fanatic customers. Head First HTML with CSS and XHTML helps you do that, and do it right so you can actually maintain and expand your Web pages over time, and so your web pages work in all the browsers and mobile devices out there. If you've never heard of CSS, that's okay--we won't tell anyone you're still partying like it's 1999--but if you're going to create Web pages in the 21st century then you'll want to know and understand CSS.

Whether you're building a personal blog or a corporate website, there's a lot more to web design than divs and CSS selectors, but what do you really need to know? With Head First Web Design, you'll learn the secrets of designing effective, user-friendly sites, from customer requirements to hand-drawn storyboards all the way to finished HTML and CSS creations that offer an unforgettable online presence.

Back and forth: building dynamic sites and client-side scripting

If you're ready to create web pages more complex than those you can build with HTML and CSS, Head First PHP & MySQL is the ultimate learning guide to building dynamic, database-driven websites using PHP and MySQL. Packed with real-world examples, this book teaches you all the essentials of server-side programming, from the fundamentals of PHP and MySQL coding to advanced topics such as form validation, session IDs, cookies, database queries and joins, file I/O operations, content management, and more.

So you're ready to make the leap from writing HTML and CSS web pages to creating dynamic web applications. You want to take your web skills to the next level. And you're finally ready to add "programmer" to the resume. It sounds like you're ready to learn the Web's hottest programming language: JavaScript. Head First JavaScript is your ticket to going beyond copying and pasting the code from someone else's web site, and writing your own interactive web pages.

Becoming a backend guru

Maybe you've written some simple SQL queries to interact with databases. But now you want more, you want to really dig into those databases and work with your data. Head First SQL will show you the fundamentals of SQL and how to really take advantage of it. We'll take you on a journey through the language, from basic INSERT statements and SELECT queries to hardcore database manipulation with indices, joins, and transactions. Expect to have fun, expect to learn, and expect to be querying, normalizing, and joining your data like a pro by the time you're finished reading!

Web applications are hot (plain old web pages, not so much...). As a web app developer, you can free yourself from the grip of deployment problems all standalone apps have, and deliver your app to anyone with a browser. But to build a truly powerful web app, you need Java. You need servlets. You need JSP. Because static HTML pages are so, well, 1999. Today's users expect sites that are dynamic, interactive, and customer-tailored. Head First Servlets and JSP will help you move from web site to web app.

From here, a seasoned web developer would be more than ready to jump into the array of titles we've selected in our Head First Programming list.

Programming

Getting started

Ever wished you could learn how to program from a book? If you have no previous programming experience, you might be wondering where to start. Head First Programming introduces the core concepts of writing computer programs--variables, decisions, loops, functions, and objects--which apply regardless of the programming language, but uses concrete examples and exercises in the dynamic and versatile Python language to apply and reinforce these concepts.

You learned some basics in Head First Programming, and now it's time to take your Python skills to the next level. Head First Python will help you quickly grasp Python's fundamentals, then move on to persistence, exception handling, web development, SQLite, data wrangling, and Google App Engine. You'll also learn how to write mobile apps for Android, all thanks to the power that Python gives you. Head First Python is a complete learning experience that will help you become a bona fide Python programmer.

A lot of good people have screwed up a lot of well intentioned software--you already know you don't want to be one of them. Head First Software Development pulls together years of software development experience to give you the hard lessons learned by people who have written software before you. We believe there isn't one process to fit every organization. Instead, we take the ideas that work from different processes like iterative development, design patterns, and risk driven scheduling, and help you understand why they work and what they could do for you.

Becoming multi-lingual

Despite its playful appearance, Head First Java is serious stuff: a complete introduction to object-oriented programming and Java. You'll learn everything from the fundamentals to advanced topics, including threads, network sockets, and distributed programming with RMI. And the new. second edition focuses on Java 5.0, the latest version of the Java language and development platform. Because Java 5.0 is a major update to the platform, with deep, code-level changes, even more careful study and implementation is required.

Head First C# is a complete learning experience for programming with C#, the .NET Framework, and the Visual Studio IDE, covering everything from inheritance to serialization. You'll query your data with LINQ, draw graphics and animation, and learn all about classes and object oriented programming. The book also includes a number of labs designed to simulate a professional programming task, increasing in complexity until-at last-you build a working Invaders game, complete with shooting ships, aliens descending while firing, and an animated death sequence for unlucky starfighters.

Mastering patterns

Tired of reading Object Oriented Analysis and Design books that only makes sense after you're an expert? You've heard OOA&D can help you write great software every time-software that makes your boss happy, your customers satisfied and gives you more time to do what makes you happy. Head First Object-Oriented Analysis & Design shows you how to analyze, design, and write serious object-oriented software: software that's easy to reuse, maintain, and extend; software that doesn't hurt your head; software that lets you add new features without breaking the old ones.

You're not alone. At any given moment, somewhere in the world someone struggles with the same software design problems you have. You know you don't want to reinvent the wheel (or worse, a flat tire), so you look to Design Patterns--the lessons learned by those who've faced the same problems. With Head First Design Patterns, you get to take advantage of the best practices and experience of others, so that you can spend your time on...something else. Something more challenging, more complex. Something more fun.

Going mobile

Let's say you have an idea for a killer iPhone app. Where do you begin? Head First iPhone Development will help you get your first application up and running in no time. You'll quickly learn to use iPhone SDK tools, including Interface Builder and Xcode, and master Objective-C programming principles that will make your app stand out. Whether you're a seasoned Mac developer who wants to jump into the App store, or someone with strong object-oriented programming skills but no Mac experience, this book is a complete learning experience for creating eye-catching, top-selling iPhone applications.

Often, once you've built a killer site or app and unleashed it on the world, you're going to start having to deal with the business ends of things--you know, counting beans and running the numbers and whatnot. That means it's time to start Dealing with Data.

Dealing With Data

Back to the basics

Do algebraic concepts, equations, and logic just make your head spin? Then Head First Algebra is designed for you. Full of engaging stories and practical, real-world explanations, this book will help you learn everything from exponents to solving systems of equations and graphing polynomials. You'll skip solving hundreds of repetitive problems, and actually use what you learn to make real-life decisions. Does it make sense to buy two years of insurance on a car that depreciates as soon as you drive it off the lot? Can you really afford an XBox 360 and a new iPhone?

Wouldn't it be great if there were a statistics book that made histograms, probability distributions, and chi square analysis more enjoyable than going to the dentist? Head First Statistics brings this typically dry subject to life, teaching you all the fundamentals of the discipline using engaging, real-world scenarios, ranging from analyzing sports stats to casino gambling and prescription drug testing. Whether you're taking Stats 101, preparing for the AP exam, or just curious about statistical analysis, you'll learn how you to apply statistical principles in everyday life.

Dominating data

Do you use Excel for simple lists but get lost when it comes to functions? Would you like to be able to do something useful with all that data, like a real Excel power user? Head First Excel will revolutionize the way you use information in your life, taking your spreadsheet skills from rudimentary to sophisticated. You'll see how to incorporate Excel into every aspect of your workflow, from making calculations across a number of worksheets and exploratory analysis with PivotTables, to optimizing outcomes with Goal Seek and presenting your conclusions with polished data visualizations.

Whether you're a product developer charged with researching markets for viability of a new product or service, a marketing manager who needs to gauge or predict the effectiveness of a campaign, a salesperson who needs to interpret and present data to clients to convince them to buy the product, or a lone entrepreneur responsible for all of these data-intensive functions and more, Head First Data Analysis is a complete learning experience for wrangling data into the most useful tool in your business.

New to Head First: WordPress in Tandem course

2010-11-17T18:40:26Z

Well, it's clear that blogging hasn't been a big priority for the Head First team this year, but we're back with some great news. We're testing out a new online course format with Head First WordPress, which was released this past summer.

It's called Head First WordPress in Tandem. As most Head First fans will know, we think of our readers as learners--people who are actively along for the ride while learning about a given topic, not just passive butts in seats in a boring classrom. This new online course format is based on the same principles.

Over the course of three weeks, you'll receive an email at the start of each day with an assignment based on a chapter (or two) in Head First Wordpress. Then at the end of the week on Friday, we'll host an hour-long live Q&A with author Jeff Siarto, who will work through the examples with everyone, tackling any trouble spots people ran into, or delving into more complex topics and ideas if time allows.

It starts on Monday, November 29, and the price is $49.99. The course cost includes a PDF of Head First WordPress. (If you already have Head First WordPress, then we'll offer you any other Head First PDF of your choice instead.)

We're really excited about this new avenue for Head First, and hope you'll join us for the class.

New Year, Lots of New Books (and an iPhone app)!

2010-01-05T19:36:00Z

Are you sitting down? Hopefully you are, because we've got a lot to discuss here. Since the last time we posted, we've released four more new books, and an iPhone app to boot. Speaking of iPhone apps, let's start with one of the more recent books we just published...

Head First iPhone Development
In true Head First fashion, you'll be building an app right out of the gate in the first chapter of Head First iPhone Development. Obviously, if you want to build iPhone apps, you want to sell them in the app store, so the book is geared towards getting you creating apps quickly, and also focuses on designing top-notch apps and how to navigate the app submission process. Back in November, co-author Dan Pilone taught a great workshop, Build, Compile, and Run Your iPhone App in 2 days, which covered a lot of the material in the book, namely, getting a developer who knows how to code in an Object Oriented environment coding on a Mac in Objective-C. And Tracey Pilone (co-pilot of the most prolific Head First writing couple since Kathy and Bert!) also recently posted over on the O'Reilly Community blog about her experience as a Head First author, which is a great read for any aspiring Head First authors. (You can follow them both on Twitter as @danpilone and @traceypilone.)

Head First Programming
Completely new to programming? Based on experience with Head First's successful books on programming languages, design patterns, and technologies, learners have long been clamoring for a general Head First introduction to programming for the absolute beginner. In November, Paul Barry and Head First veteran David Griffiths teamed up to finally fill that need with Head First Programming. Of course, this being Head First, you can forget "Hello, World!" and pages upon pages of dull, dry, boring text you'll never apply to real-world problems. By the time you've worked through the first few chapters of this book, you'll have written a numeric guessing game and interfaced with Twitter's API. And by the end of the book, you'll have a completely functional and attractive graphical desktop application! Though the authors use the dynamic and versatile Python language to apply and reinforce the general programming concepts illustrated in concrete examples and exercises, you'll be able to apply this knowledge to whatever language or software project you need or want to learn.

Head First 2D Geometry
Geometry is the stuff of many people's nightmares, but Head First 2D Geometry navigates the world of lines, points, and shapes in a way that will have people singing the praises of triangles in no time. We'd have more to say from authors Lindsey Fallow and Dawn Griffiths (yes, another dashing Head First duo with husband David) here, but they are already furiously working on the next book in the series, Head First 3D Geometry. In the very first chapter, we launch a space mission, which is very exciting!

Head First Data Analysis
For anyone whose job it is to make sense out of a world of data out there (and doesn't that include all of us?), author Michael Milton completed Head First Data Analysis, a learner's guide to harnessing big numbers, crunching statistics, and making good decisions. Head First Data Analysis helps you organize your data in Excel, take it further with R, find meaningful patterns with scatterplots and histograms, draw conclusions using heuristics, predict the future by experimenting and testing hypotheses, and display findings with clear visualizations. Since the book's release, Michael has delivered an O'Reilly webcast on two data analysis tricks everyone can use immediately and is drawing on the enthusiastic response and questions raised to make his next book (Head First Excel, forthcoming in spring 2010) that much more useful and effective.

And last but not least:

Head First PMP iPhone App
We get that you don't always want to carry around your copy of Head First PMP while prepping for the exam, and a dedicated iPhone app is definitely easier to use on your iPhone than our online practice exam. With the Head First PMP Exam app you can practice for the exam while standing in line, eating lunch, or just taking a break from work. It covers the same 200 questions in the print and online practice exams, so you're practice-ready wherever you go.

2010 is primed to deliver a whole set of exciting new books, from WordPress and Excel, to ActionScript and much more. Any other Head First books you'd really like to see? Drop us your suggestions here.

Four Short Links

2009-08-21T13:48:15Z

Borrowing Nat Torkington's useful "four short links" format, I thought I'd round up a few items related to Head First you may have missed:

Four ways that writing Head First has blown my mind -- Michael Milton explains four ways working on Head First Data Analysis has changed his writing forever.

A few quick thoughts on keeping readers motivated -- On the heels of completing the Second Edition of Head First PMP, Andrew Stellman talks about the challenge of keeping learners interested and engaged.

The Tortoise and the Hare: Made to Stick -- A video supplement to Made to Stick, by Chip Heath and Dan Heath (a Head First recommended read), using Aesop's fable and a personal twist to help explain the key concepts of SUCCESs.

Introducing the Back of the Napkin -- A brief, hands-on introduction to Dan Roam's excellent book, another book high on the Head First recommended reading list.

The Learner's Journey in Practice

2009-07-08T16:08:13Z

Earlier this year, while Michael Milton was in the early stages of developing Head First Data Analysis (publishing later this month), we brought him to Cambridge to meet with the Head First editorial team for a focused training session. Our primary goal was to help crank out storyboards for chapters of Michael's book, but in the process, we further refined our thinking about the purpose and process for the Learner's Journey [1] to help get us there.

Because we had positive results using this new iteration of the Journey, I decided to summarize how it worked in the following short video, which I originally posted to the private group for Head First authors on Facebook. But in the spirit of Brett's public examination of Head First elements, I thought I'd share this behind-the-scenes view with Head First fans, as well as authors, in the hopes that it might reveal something interesting about what makes Head First teaching different.

Note: For better accessibility and detail (including larger versions of the low-resolution diagrams shown in the video), I've provided my original script below the video.

While you're staring at your blank whiteboard, sheet of paper, or computer screen, you've likely already given considerable thought to the topic of the chapter you're preparing to write.

But, as you know, the purpose of the chapter needs to be functional, so the first step after choosing your topic is to zero in on that functional goal. What will the learner be able to do after completing this chapter that they weren't able to do before? Tying that functional knowledge with the topic at hand is a big part of the point for the Learner's Journey.

The next part of the process is to work out the primary teaching points you need to cover to complete the topic. Plot these points chronologically on a line, ending with the final topic covered to complete the objectives in the chapter. We'll call this line, which covers pure teaching points only, the "story line." The points on this line represent the general concepts the learner is learning in the chapter.

Here's a real example of how this might look, for the Experiments chapter of Head First Data Analysis (click for larger view):

This line has six major points to cover, which is fairly ambitious for a single chapter. Because of the complexity, Michael found it helpful to add subcategories within the larger topic areas (click for larger view):

Depending on the topic at hand, this might be helpful or more detail than is necessary, but in this case, adding the subcategories helped us focus the story before going to boards.

Next, plot your Learner's Journey against the corresponding teaching points. This line, shown in red here, we'll call the "narrative line." This shows the events and milestones that represent the path taken by the learner on the way to learning the general topics. These events include the "Oh crap" valleys and the "I rule" peaks.

Here's the Experiments chapter example, with the narrative line added (click for larger view):

In this iteration, the narrative is lightweight and focuses on major learning events without being specific a particular scenario. Taking this extra step sometimes helps keep the scenario from forcing the direction of the chapter, because you're teaching general milestones, rather than to specific character plot lines, which might not be able to accommodate the core teaching points you've established on the story line.

Next, we add the specifics of the scenario to the narrative line (click for larger view):

Here, the more general narrative event "Some subgroups don't appear to show the association" becomes "Survey results at the Park avenue store don't indicate that coffee drinkers feel they're not getting enough value for their money." This makes sense only in the context of the specific scenario chose for the narrative.

With the Learner's Journey in place, it's time to go to boards. Having the teaching points and narrative in place first make this process go much more smoothly. And when you encounter problems, the specificity of the journey makes it clear when you're missing an important element or when the scenario needs to bend to fit the teaching.

And, of course, after boards, it's on to InDesign, editing, tech review, Production, and a finished book, which at this point should be a piece of cake. Right?

[1] While this post focuses on the construction of what we call the Learner's Journey, the concepts behind the idea really warrant a post of their own. In brief, though this particular approach and visualization was developed in house, the ideas behind it are loosely modeled on Joseph Campbell's Hero's Journey, combining teaching elements with a compelling scenario to create a rewarding quest for the protagonist (the learner) to accomplish. Before this visual format, we'd taken a cue from screenwriting by using text-only beats to organize a chapter before storyboards, which was effective but didn't capture the connection between scenario and teaching points quite as explicitly.

"Brain Power" Up Close

2009-06-24T14:17:29Z

Over the next few weeks, I thought we'd take a close look at some of the common Head First elements. A lot of folks love getting into the pedagogy of Head First, so this is almost a mini-primer to how we use lots of our elements [1].

First up? Brain Power:

Brain Power is not just an "ordinary" exercise, like a Sharpen Your Pencil or Exercise. Instead, it's a little bit tougher. In fact, you'll often have to think more critically about Brain Powers (when they're well done) than almost anything else in a Head First book.

We also don't typically put answers to Brain Powers in the book. You'll find text like this in most books' Read Me sections, up in the front matter:

Why no answers? Well, there are two reasons. First, without an answer, your brain is left to puzzle at what to reply. What do you think? And is what you think correct? Is your solution tenable and workable? Your brain hates irresolution. So forcing it to whir along without a definitive answer is really a dirty trick we're playing to get you to continue thinking.

But there's another reason. Brain Powers pose hard questions, without (hopefully!) easy answers. Because of that, there's always the risk a less-experienced learner gets the answer wrong. There's nothing like rubbing a learner's face in a wrong answer to turn them off and cause them to disengage. While we're by no means afraid to tell a learner that they've made a mistake, it's tricky to ask a very hard, abstract question, and then present an answer on the next page, as if to say, "Get it? Nope? Well, too bad!"

And another reason (yeah, I said just two, but hey, who's counting, anyway?): Brain Powers might have a range of correct answers. Lots of the time, these abstract questions can be solved in several ways. We really don't want to take up 10 pages with possible answers; or rather, if we did, we'd take you through that learning process, rather than handling it all with a Brain Power.

Like I said, Brain Powers are all about critical thinking, and not coming up with a simple answer. One thing I often tell authors is this: Don't ever phrase a Brain Power so that you can answer it with a "Yes" or "No." For example, here's a (bad) Brain Power question:

Do you think it's possible to build an MVC implementation using Objective C that runs purely on an iPhone?

It's an interesting question, but the brain of a learner can read the question, and simply think, "Sure." That little bit of closure is all it takes to turn the page. This could easily be made more effective, though:

How would you build an MVC implementation using Objective C that runs purely on an iPhone?

In this improved case, you've got to really think. The brain wants resolution!

There's a lot more to be said about these elements, but that's a pretty good start. What other things do you think Brain Powers accomplish? Do you work on them much? Not at all? Do you ignore them totally? What do you think?

[1] Just so we're clear, lots of people -- including some in O'Reilly -- will think that it's insane to "reveal" how we use our elements and build Head First books. I tend to think that's silly. First of all, there's very little I'll be writing on this blog that an astute observer couldn't figure out on their own. Second -- and maybe this is just my naivete -- I think it's our editors that make the key difference. If you can take these little discussions and go write Head First Basket Weaving for another publisher, then best of luck to you. (Although if that's the case, I'd much rather you come write for us. Except we aren't looking for a basket-weaving book...)

Where do I start if I want to write for Head First?

2009-03-11T17:26:13Z

Brett McLaughlin http://www.oreillynet.com/pub/au/152

What does it take to be a Head First author?

2009-03-06T02:17:58Z

Click To Play