Among modern programming languages, Ruby is relatively easy to learn and use. Given that fact, a book designed to introduce Ruby to experienced programmers should be a fairly straightforward endeavor. O’Reilly’s Learning Ruby succeeds in this regard, but unfortunately tries to teach people new to programming as well. If you ignore the oversimplified (to the point of inaccurate) explanations of programming theory and just concentrate on translating your current programming knowledge to Ruby, you’ll find this book an excellent resource.
Writing analysis
At 238 pages, Learning Ruby is among the shortest programming books I’ve yet read. I wish I could say that the reduced length means that it’s superbly written, using fewer words with more powerful and specific meanings, but I can’t. Were this book brilliantly written, it would probably be about 3/4 of its length, and would be maximally functional. As it is in this edition, Learning Ruby is difficult to read — the language is cluttered, non-specific, and meandering.
The author is obviously a fruithead, and over-covers the Apple platform while predictably over-generalizing instructions and advice for Linux. Fortunately, very little of the book focuses on platform-specific technical instructions.
Each of the eleven chapters focuses on a particular programming topic, and each section narrows the topic down to specific methods and processes for doing work in Ruby. Since Ruby is versatile and offers a number of different problem-solving approaches, the author shows as many of them as possible in each section. Every chapter ends with review questions that pertain to the preceding material; some readers may find these helpful to retain the information they’ve just read.
There are no programming exercises in Learning Ruby, and the code samples are small and only functional as an example of how a particular function or process is used.
Putting the book to the test
I can’t stress enough how difficult it is to read Learning Ruby. Here’s an example of what I mean, taken from a warning box in chapter 1:
“If you get a permission denied message when running matz.rb, and you aren’t sure what to do about it, I’d like to offer you a hand. Go to the section ‘Permission Denied’ near the end of this chapter to find out what to do.”
Language like this makes my liver itch. Teach me — tell me what to do. Don’t tell me the story of what I should do. In the same number of words, the author could have told us how to fix the problem, rather than bluster on about how we might feel and what he would like to do for us, and then tell us where else to go to find a solution. Learning Ruby is one scatterbrained abomination of a sentence after another, which makes it difficult to learn from.
The technical discussions are equally substandard. The explanation of object-oriented programming is particularly terrible. Learning Ruby’s author took what should be a simple overview of classes, methods, and objects, and turned it into something that, after reading it ten times, I still could not accurately decipher.
The only good part about Learning Ruby is that it excellently imparts the mechanics of the Ruby language. If you already know data types, object-oriented design, and other programming essentials, the author brilliantly shows you how they are all applied in Ruby. He shows not just one approach, but several that you might know from a variety of different programming languages. So if you have, for instance, an existing C++, Pascal, or Java program that you would like to re-code into Ruby, Learning Ruby will be a great help to you.
Conclusions
Learning Ruby claims to be aimed at both beginning programmers and experienced software developers. In that, there are explanations of programming principles as well as examples and commentary that show you how to write Ruby programs. Unfortunately, the elementary explanations are insufficient at best, and vague to the point of incomprehensible at worst. If you intend to learn how to program by following this book, you will be badly misguided in the elements of software development.
On the other hand, if you’re an experienced programmer, Learning Ruby is an efficient (if difficult to read) guide to translating your current knowledge into Ruby-friendly terms.
The Mambo content management system (CMS) is among the most popular Web publishing tools in use today. It’s easy to install, configure, and use on a basic level, but runs into various problems with complex configurations. Learning Mambo seeks to prepare readers for configuring almost every aspect of Mambo, but it falls short in important ways.
Writing analysis
Learning Mambo starts out with a basic overview of the system, and establishes its primary example — a site for the fictional Zak Springs Golf Club. Chapter 2 is an overlong description of how to install Mambo on your local machine; instructions for uploading the site to a remote server are not given until the very last chapter. The middle of the book concentrates on exploring and configuring Mambo through its backend interface, and installing new templates and add-ons via the extremely easy-to-use interface. The last — and most useful — parts of the book give some tips and advice for customizing Mambo on a deeper level by hacking some of its files.
The language in Learning Mambo is at times jumbled and difficult to follow. It probably could have done with a good editorial cleanup to eliminate unnecessary words, phrases, and ambiguities. This book is by no means unreadable, but it’s also far from its maximum potential in terms of use of language.
Putting the book to the test
The main problem with Learning Mambo is that most of its content covers obvious subjects, or topics that are already thoroughly documented through the Mambo help system. The remaining information is useful to people who are new to content management systems, but it won’t solve all of their problems. Learning Mambo frustratingly ignores Mambo’s dirty secrets, like the bugs in the menu and SEF systems that show permissions errors when you delete a menu or move content to a new category, or the RSS feed module’s non-SEF compliance, or the difficulty in upgrading to a new version, or the horribly bad scalability of the Mamboboard forum component, to name a few. These are the problems that experienced Mambo administrators have been dealing with for years, and I speak for all of them when I say that we would gladly have paid $45 for a book that would have told us how to solve them without spending hours hacking PHP files and scouring various forums for clues.
Aside from the several parts of the book that concentrate on obvious or elementary topics, Learning Mambo gives a lot of detailed advice for hacking various Mambo functions and components. I wish these Mambo hacks were more detailed and wide-ranging in subject matter, but even as they are, these tips are the book’s saving grace.
Despite the shortcomings of its content, Learning Mambo is easy to follow along with, and doesn’t have any glaring errors or omissions aside from what has already been mentioned above.
Conclusions
Learning Mambo functions well as a basic introduction to Mambo. However, Mambo is easy enough to use and figure out on this level that a book is unnecessary — let alone a book that costs a whopping $45. If you’re serious about creating a popular, monetized Web site with Mambo, this book has little useful information to offer you. If you’re looking for a good Mambo primer, Wiley’s much less expensive Mambo Visual Blueprint may be a better choice, though even with that book you will still have to discover Mambo’s dirty secrets on your own.
Ruby is a hot topic among software developers — and rightly so. It’s an exciting language to learn for “old school” programmers because it allows many luxuries and conveniences that you used to have to code around at length. Ruby is equally as attractive to new developers because it is easy to learn and can be implemented on almost any platform. A good book that introduces this interesting language by designing scripts for software development and testing would certainly be welcome; unfortunately, Everyday Scripting With Ruby isn’t it.
Writing analysis
What a terribly written book this is. The language is so poorly crafted that whatever information the author is trying to convey is at best muddled, and at worst totally lost. The author speaks over-colloquially, as though a shift in style will somehow make the book’s content easier to understand. Writing simply does not convey complex concepts more simply; all it does it make the material more difficult to understand.
The author irritatingly worships feminist propaganda by using female pronouns exclusively, which is such a distraction in itself that it is difficult to focus on the technical content. If you want to protest a male-dominated culture, go march in parades and hold signs at protests — don’t cheat your readers out of a good, non-political, technology-centric text that teaches them how to solve important problems with an interesting programming language.
Putting the book to the test
I did not get very far into Everyday Scripting With Ruby before I was so thoroughly disgusted with it that I could no longer continue. There are a shocking number of technical errors, inaccurate oversimplifications, and errors of fact in the first 50 pages. Particularly frightening is the author’s misunderstanding of operating systems. He claims that Linux, the BSDs, and OS X are based on AT&T Unix (does Brian Marick work for The SCO Group?), and that OS X is “Unix with a pretty face.” All of this nonsense, in addition to the fact that all of the book’s screen shots are of Mac OS X, suggests that this book is yet another misinformed fruithead’s musings on technology he doesn’t understand. To clarify, there is no evidence to suggest that there is Unix code in Linux; BSD was originally a rewrite of AT&T Unix, but no longer exists in that form; and OS X has absolutely no basis in AT&T Unix (or any other trademarked UNIX or SVR4 code). I did not feel that I could trust the author to teach me how to write scripts with Ruby after reading these blunders.
Flipping through the rest of the book I see lots of unnecessary first-person narrative, and colloquial speech that hinders the uptake of useful technical information. There are better languages to use for the kind of software development-centric scripting that the author tries to focus on in Everyday Scripting With Ruby, but he never explains why he feels that Ruby is a superior choice.
Conclusions
Avoid Everyday Scripting With Ruby at all costs. You’re likely to find it confusing, non-specific, inaccurate, and inappropriate as a Ruby resource. Considering the large number of Ruby books out there, nearly all of which are guaranteed to be better at helping you how to learn Ruby, it’s not worth wasting your time and money on this one.
Cascading Style Sheets (CSS) are not difficult to learn how to create and implement, but going beyond the basics take a lot of thought, creativity, and knowledge. The thought and creativity part are up to you, but the knowledge portion has to come from a competent source that can show you some real technical wizardry. O’Reilly’s CSS Cookbook, 2nd Edition is the perfect book for anyone interested in advancing from a beginner’s CSS level to an expert’s.
Writing analysis
CSS Cookbook, 2nd Edition is laid out in typical O’Reilly “cookbook” format. A problem is presented, the best solution is provided, and then it is explained in detail, including alternative solutions. A complete listing of the necessary code and screen shot of its implementation in a Web browser are also part of each “recipe.” A large appendix offers extremely useful lists and tables of CSS elements for HTML tags and which Web browsers they will work with.
There is some value in reading a book like this from cover to cover, but it would probably be more appropriate to consult it whenever you come across a technical challenge in building a Web site.
Though the book starts out with some CSS basics, it would be most helpful to readers to have a firm grasp of CSS basics before reading. I suggest the W3Schools free online CSS tutorial as a prerequisite to CSS Cookbook, 2nd Edition.
Putting the book to the test
There is so much great CSS information in this book that it’s hard to talk about specifics. No single chapter or recipe stands out above the others — they’re all useful to working Web designers and developers, and appropriate for modern design practices and standards. The first thing I did when reading it was open up to a random place, a little more than halfway through the book, and read the first recipe I saw. It happened to be a series of solutions for creating a variety of multi-column layouts using <div> tags, and addressed problems that I have struggled to solve on my own several times. I wanted to go back and read that section later, so I put a piece of the press release in that spot and flipped back to some earlier sections. Everything I saw was not only useful to any professional designer or developer, but it was brilliant in its analysis of relevant problems and solutions. This book was definitely written by someone who knows the challenges we face as Web site creators and editors.
The only negative point about the book — and this is totally a matter of personal preference — is that all of the screen shots show the OS X operating system. I can’t stand Apple or OS X, so seeing screen shots of its nonsensical, toy-like interface is a distraction and an annoyance.
Conclusions
Every Web designer and developer who has to deal with XHMTL or CSS — even if only infrequently — should have this book on his desk. It deals with the difficult challenges that Web designers deal with every day and on every project. Even if you think you’re a CSS guru, CSS Cookbook, 2nd Edition is still likely to teach you something new.
I’d also strongly recommend this book for hobbyist Web designers who want to get into hand-coded XHTML and CSS, or who want to graduate from WYSIWYG Web editors to the real thing.
Many people would do well with a good lesson on how to behave on the Internet — on forums, on mailing lists, in IRC and other chat, and in email. Even some who have been actively participating in online communities for years never really had a firm grasp of Internet etiquette. For those of us who know the rules, educating newer or plainly ignorant users is something that we avoid until it annoys us to the boiling point. Perhaps a better solution would be to send a link to Netiquette and let the book’s author do the work for you. It’s not perfect, but this book covers the basics thoroughly enough to provide an excellent beginner’s primer or intermediate’s refresher on the etiquette of Internet communication.
Writing analysis
Netiquette is divided into three primary sections covering etiquette in the various forms of online communication, online services, and miscellaneous other netiquette details. Each section is divided into numbered topics, with a quick introduction to the issue and the rules pertaining to it. A handy glossary at the end of the book explains most of the technical terms in the book. Altogether, it’s an in-depth resource for learning the way of the Web.
Putting the book to the test
The concept of a book on how to behave on the Internet is a good one. The implementation of Netiquette is intelligent in its presentation, and mostly correct in its rule quotations. There are a few things the book says that are either debatable or incorrect, though, most notably its advice on “top posting” in email messages. Most people’s instinct is to top post because that’s the default configuration in most graphical email clients. Mailing list etiquette, however, specifically demands that you quote relevant messages above your responses. This is particularly important in the open source software development community. The book also encourages the occasional use of emoticons (smiley/frowny faces), which is not necessarily wrong, but I disagree with it. I think the world would be a better place if we stopped relying on emoticons and instead concentrated on meaning what we say, and saying what we mean. You shouldn’t need a graphic to explain what your words mean.
I also disagree with some of the book’s reasoning. For instance it says that flame wars start because people misinterpret messages and can’t see emotional cues in what would be our tone of voice and body language in a physical conversation. My experience in online communication says that this theory is a fallacy. The real reason why flame wars start is because there is a perceived lack of accountability for our online actions. If you call someone names online, it’s difficult or impossible for them to respond in any other way than with another message, which you can then ignore. If you call someone names in real life, you might get punched. The lack of consequence is what feeds online flame wars, not simple miscommunication.
Conclusions
Despite the few disagreements I had with some of the book’s content, the majority of it is perfect. It’s easy to read because each rule is numbered and short, and comprehensive in its coverage of online communication etiquette, from email to forums to chat rooms. I would definitely hand Netiquette to a friend or family member who is new to the Internet (or was never properly educated). It’s a little expensive for its size and content, but not unaffordable.
If you’re serious about publishing on the Web, you cannot circumvent its mechanics. Learning HTML, CSS, and a little bit of JavaScript is a necessity, not a luxury. Over the years there have been many books, Web sites, and computer-based training applications that attempt to teach people how to create Web pages with HTML and CSS. O’Reilly’s HTML & XHTML: The Definitive Guide is among the oldest extant HTML teaching materials. Unfortunately, it seems to be past its prime. The 6th edition of this classic is embarrassingly dated, offers poor advice for would-be Web designers, and in general offers absolutely nothing that you can’t get for free through online XHTML and CSS sources.
Writing analysis
HTML & XHTML: The Definitive Guide 6th Edition starts out with an overlong history of the Internet, the World Wide Web, Web browsers, development tools, and HTML, including how the HTML standard has evolved over the years. The reference portion represents the bulk of the book, where each HTML tag is profiled with a lot of words but not enough details.
I didn’t discover any language errors in this book, but I did find a number of anachronisms, the biggest being the repeated reference to Netscape Navigator as though it were still a current, popular browser that anyone used. The obsession with Netscape helps form the eerie sense that this book was not properly updated to reflect modern technology. This sentiment is solidified by the rest of the book’s focus on outdated HTML standards and practices.
Putting the book to the test
When I began reading this book, I had high expectations for it. This is a well-regarded reference in its 6th edition, so it should be the best source in the industry, right? Wrong. The introductory section is terrible, the reference portion is incomplete, and the entire book — despite being specifically updated for modern technology — is horribly dated.
I hardly know where to begin with criticism of HTML & XHTML: The Definitive Guide 6th Edition, except perhaps with the overlong beginning. The authors could have conveyed the same amount of important information in less than half the words in the introductory historical chapters.
Moving on to the advice and instructions on how to use HTML tags, I was astonished to see some of the worst-written HTML I have ever seen pass as professional. The authors encourage readers not to use closing HTML tags where they are not specifically required by the old 4.01 standard, and in general ignore XHTML standards. What got me more than the fact that they say closing </p> tags are unnecessary is the fact that they insist that some modern, educated Web designers don’t know that closing paragraph tags even exist! Sure, some people don’t know what they are doing, have not studied modern standards, don’t actually create meaningful Web pages by hand, and probably don’t know that closing </p> tags make code more readable and forward compatible with the latest standard… perhaps such people even go on to write books on HTML. XHTML in essence is the new HTML standard and should be treated as such, not dismissed as some new-fangled contraption those damn kids are using these days. To design a site to the bare minimum requirements of the HTML 4.01 standard would be pure folly in this day and age.
To make matters worse, the HTML reference does not list the CSS properties of each tag — only the old HTML 4.01 properties. That makes HTML & XHTML: The Definitive Guide 6th Edition effectively useless as a reference text for designing anything other than old-fashioned, hard-to-read, hard-to-maintain, tag soup HTML pages. Following that advice would make you a terrible Web designer.
Conclusions
As a Web publisher, I have dealt with XHTML and CSS every day for the past several years. I have watched it evolve from HTML to XHTML, and from sloppy “tag soup” to clean CSS. Every article I write goes directly into the Bluefish HTML editor, complete with headers, tags, and other code. I picked up my initial understanding of HTML through an old Netscape book on Web design, and later honed my skills through W3Schools, which offers free courses on XHTML, CSS, and other Web languages and technologies. Not only are the W3Schools courses better than the introductory teaching chapters in HTML & XHTML: The Definitive Guide 6th Edition, but the online reference is actually complete, separated by standard, and includes descriptive examples of nearly every tag. So in essence, you can get a quicker, better HTML education and tag and property reference for free on the Web than you can get from this poorly executed $33 book.
This is the worst professionally-created reference for static Web page design I have ever seen. It fails in every possible way — it does not show best practices, is not comprehensive, is too expensive for the information it provides, and presents readers with an inaccurate portrait of modern Web page design. The reason this book gets a 3 out of 10 rating is not because it has a few redeeming qualities; it is because it could theoretically be worse.
JavaScript is a difficult language to learn, and thus requires a good book, class, or mentor to really learn how to use it effectively. There are many good reference books on JavaScript, and a few that focus on Ajax in general, but both assume that you are already a JavaScript master (or at very least a journeyman). What the market needs is not another advanced book on Ajax, but a good JavaScript primer. O’Reilly’s Learning JavaScript appears to fit that niche at first glance, but it quickly descends into an over-technical, poorly explained, typo-filled mess that is entirely inappropriate for JavaScript beginners.
Writing analysis
The first major failing of Learning JavaScript is the copyediting. There are more typos in the first half of this book than in the previous 5 books I’ve read combined. Some of them are even in the code samples, which make them unusable. The example code is purely theoretical and never represents a working program anyway, so there is little to fear from typographical errors. The capitalization of Web (in reference to the World Wide Web) is inconsistent, as well.
Learning JavaScript starts out with a basic description of the language and how it works, then immediately delves into advanced object-oriented programming principles, stopping to explain very few technical terms along the way. Most chapters do end with some reader questions and programming problems to work on (with answers in the appendix) — and that is something many teaching books lack — but many readers will find themselves too poorly instructed in JavaScript basics to answer or solve them.
Putting the book to the test
You will have a difficult time learning JavaScript programming from this book, even if you have a background in some other high-level language. The author says in the introduction that Java is difficult to learn, and implies that JavaScript, by contrast, is easy. If you agree with that sentiment, this book might be of some value to you. Most readers will probably find themselves searching for other JavaScript references (to understand concepts the author glosses over) or teaching texts (to move to another book altogether) by the second chapter.
Conclusions
This book is, at best, inappropriately titled and unsuitable for its intended market. If you already know a little about JavaScript and have created your own JavaScript functions in the past but don’t have a solid understanding of how to do more with it, then Learning JavaScript may be a good fit for you. For everyone else — the beginners and the advanced JavaScript programmers — this book is not the best choice.
I’ve read and reviewed many O’Reilly books over the past two years, and this is undoubtedly the publisher’s lowest point. Learning JavaScript was poorly executed on all levels, and not at all on par with any other O’Reilly programming book.
Few software technologies are more difficult to learn to implement than the Lightweight Directory Access Protocol (LDAP). Most commonly you’ll know LDAP as Active Directory on Windows or OpenLDAP on just about every other operating system. It was designed to make system administration easier, but unless you know how to install, configure, and successfully implement it, OpenLDAP can’t do a thing for you. Fortunately for those of us who weren’t born omniscient, O’Reilly has a great book on the subject: LDAP System Administration.
Writing analysis
LDAP System Administration is not a very long book, and I think that’s a good thing. The core technology is excellently explained in the first part, and the rest is all about how to integrate OpenLDAP with other services and technologies. A small third portion of the book offers some example schemas for specific situations.
The writing is clear, concise, well-considered, and in general this book is easy to read and follow. The example configuration files and snippets show exactly what the supporting text is teaching, and seem to work as presented. Technical terms are sufficiently explained. Overall, the writing is top-notch and properly matched to the book’s content.
Putting the book to the test
LDAP System Administration starts out with the most basic of directory information, and gradually builds on that new knowledge to show you every facet of OpenLDAP installation and configuration. If you are totally new to OpenLDAP, you will need to take notes, but if you’re serious about learning it, you’ll advance very quickly. This is by no means a beginner’s text; it assumes that you are already a system administrator and that you want to centralize your user authentication and other peripheral services through OpenLDAP. The other services that the book mentions are covered lightly; it’s assumed that you already know these technologies and just need to learn how to integrate them with OpenLDAP.
By following the first section of LDAP System Administration from start to finish, you will be properly prepared to install and configure OpenLDAP on your server or as part of your network. The second section shows you how to integrate your existing services with OpenLDAP, so you won’t need to read everything in it. A small third section is full of example schemas for use with a variety of OpenLDAP usage scenarios, to be used primarily as a reference so that you can see how it’s done.
The second section covers integrating OpenLDAP with the following programs, servers, services, and technologies: Eudora, Thunderbird, Outlook, Pine, Postfix, Exim, Sendmail, FTP, HTTP, LPD, RADIUS, DNS, and Samba. There is also a section that shows you how to replace a NIS implementation with OpenLDAP, and a chapter on integrating OpenLDAP with Active Directory. Lastly, the second section features a chapter on scripting and control of OpenLDAP functions with Perl.
Summary and conclusions
I bought this book to learn how to implement OpenLDAP on some OpenBSD and GNU/Linux systems, and I couldn’t have been more pleased with the result. LDAP System Administration is the perfect sysadmin’s introduction to LDAP. If you have serious plans to switch over to OpenLDAP on your network, with this book as your companion you can generally expect to have everything finished in one work week or less, depending on the complexity of your situation.
Be warned that this is not a developer-centric text. You will not learn how to hack OpenLDAP or build programs based on it from LDAP System Administration. To put it bluntly, the book’s title says everything you need to know about its content.
The majority of computer science education focuses on software functionality. You’re taught the process of building a program, usually from small, hypothetical programming problems and case studies. Once the program is working as expected, the project is over forever and you move on to the next one. While this approach may be effective for teaching future programmers how to use a specific language and implement certain functions, processes, and theories, it is terrible at preparing them for what the author of Code Craft calls “the software factory” — the actual software development industry. It is only too late that so many programmers learn how to write secure, maintainable, readable code; some never do. Code Craft is the perfect segue from a computer science degree to the “real world” of software development.
Writing analysis
The design of Code Craft is brilliant. It’s concise, straightforward, easy to read, intuitively organized, and leaves no technical details uncovered. Most of the book concentrates not on actual code — though there are many short, theoretical pseudocode examples — but on informing readers of the correct attitude toward solving the various problems they will encounter in the software industry. Much of the book concentrates on writing great software, but there is also a significant portion dedicated to the social and political aspects of working with other programmers in a software company.
Each chapter begins with a famous quote, then introduces the problems that the rest of the section will address. Key concepts are clearly defined when they are introduced, and all conceivable angles of every issue are covered. The chapter ends with a summary and some questions for the reader to ask himself to determine if he’s following the book’s principles as intended.
I was immediately put off by Code Craft’s frequent quotations from the Bible, but the majority of these religious quotes are found early in the book, and don’t continue to ruin the author’s credibility beyond the introduction and the first two chapters. Still, there should be no religious crap in a technical book.
Code Craft’s layout is such that you can start reading anywhere. If any of the book’s material is useful to you, however, I suspect that most of it will apply, and therefore recommend reading the entire thing from cover to cover.
Putting the book to the test
Reading Code Craft and applying its teachings to your life means asking yourself some hard questions about your programming habits, work ethic, and even the approach you take toward your career. If you don’t have an active desire to become a better software developer, whether you are a hobbyist or a professional, you won’t get much from this book. In essence, Code Craft is a self-help book for programmers.
Code Craft revolutionized the way I think about programming. Granted, I am only a hobbyist programmer, but I’m frequently required to evaluate software and source code, and to hack in some necessary function or fix a bug that the program’s developers won’t fix. This book made me realize that I was causing a lot of my own programming difficulties by concentrating on creating something that works instead of creating something that I can easily modify, maintain, and confidently run in a production environment.
Summary and conclusions
Despite the great things this book has to offer, I’m giving it a 9 out of 10 for several reasons. I think the title is inappropriate for the content, I think the cover design reflects a hobbyist readership whereas the content is geared toward professionals, and I think that the Biblical references, however innocent they may seem, are a totally unnecessary distraction. The author quotes the Bible in his introduction and dedication, which almost made me abandon Code Craft outright. Is this a book on Jesus, or are we going to talk about programming here? Is this author going to give us myth and madness that we just have to take on faith, or will he present us with verifiable facts and valuable career experience? Readers should never know what your religious beliefs are.
Anyway, this book is definitely recommended to all computer science students, and doubly so to anyone who works within the software industry — even if they have nothing to do with writing code. By far this is the best book on general programming that I have ever read.
I’ve been a fan of the Head First series from O’Reilly since the original Head First Java, and though I still think it could do with some improvements, it’s among the best and most innovative ways to learn a new programming technology or technique. Head First Object-Oriented Analysis and Design follows perfectly in Head First Java’s footsteps not only in its style and methodology, but also in its subject matter. This book is the natural next step to Head First Java — it might be what you read after you’ve written several meaningful Java applications and are ready to go pro.
Writing analysis
Head First Object-Oriented Analysis and Design is not unlike other Head First books in terms of teaching style and presentation. It reads quickly because each page is a collage of photos, drawings, diagrams, faux handwritten notes, sidebars, and margin scribblings; there is less of a focus on straight, ordered text, and more of a focus on the presentation of ideas in a variety of interesting and entertaining ways. One of the book’s primary examples, for instance, is a program that operates an electronic dog door. In explaining the entire development process — from taking the requirements and brainstorming potential problems to implementing, testing, and later modifying the actual Java program that controls the dog door device — you’re treated to silly photos of a dog and its owners, and other whimsical drawings that show the development process as it applies to the problem.
Instead of traditional programming problems (which I find extremely effective for learning a programming language), Head First Object-Oriented Analysis and Design uses more unusual methods. You’re given crossword puzzles, asked to rearrange refrigerator magnets, create lists, and complete sentences or phrases. While I don’t feel that these cute exercises are sufficient for teaching someone a programming language from scratch — nothing can replace programming problems that require a student to design and write programs to solve them — they are extremely effective for teaching concepts, best practices, and design patterns, which is what this book is all about.
For a book with such wacky formatting, the editing is impeccable. I did not find any typos, coding errors, spelling mistakes, or punctuation gaffes in the entire book. That’s not to say that there are none, but the reason why I point out mistakes like these is that they are very distracting to readers and can break their concentration and possibly mislead them.
Putting the book to the test
Head First Object-Oriented Analysis and Design assumes that you are already a Java programmer — not just “familiar with” or “proficient in” Java, but actually able to create meaningful Java programs without much trouble. Specifically the book is aimed at working Java programmers who may not have learned to design and develop software efficiently. Head First Object-Oriented Analysis and Design seems focused on breaking experienced programmers of bad habits, and concentrates on the process of creating a software application rather than the mechanics of writing a simple program.
The book uses only a few regular and recurring examples: an inventory application for a guitar shop, a program that controls an electronic dog door, and in the latter parts of the book, some computer games. Each of them reasonably represents a working Java program, though the real guts of the software isn’t fully shown. Presumably this is because there is hidden data and other outside factors such as machine control for the electronic dog door.
With Head First Java I was disappointed that there were few opportunities to create meaningful programs through coding exercises. I still stand behind that — you can’t learn a programming language by simply reading a book. You have to create programs to solve problems. Head First Object-Oriented Analysis and Design is more in tune with the Head First philosophy in that it requires the reader to already have programs (or at least ideas for them) to work on and refine. Readers are expected to bring their own exercises, so-to-speak. In this instance that’s fine because it deals with advanced programming material and is squarely aimed at people who should already have a number of Java applications on their resume.
Can you use this book if you don’t program in Java? Possibly — it depends on the language you’re using. The less focused it is on object-oriented design, the less useful Head First Object-Oriented Analysis and Design will be. C++ and PHP programmers should find a great deal of value in this book if they can get past the Java code and concentrate on the design concepts the book teaches.
Summary and conclusions
This book dramatically changed the way I think about writing software. Though I’ve never been a professional “for hire” programmer, I have written many programs in different languages over the years, and frequently have to code my way around problems with open source Web applications. If I’d had a better foundation in designing software for production use rather than just for academic problem-solving, I’d have saved myself a lot of time and stress over the years. This book is able to instill such a foundation in you, assuming you have a solid understanding of Java 5.0 or above.
Don’t let the page count scare you — this is a surprisingly quick read, and if you can follow the material, it’s a lot of fun as well.
