97 Things Every Programmer Should Know
Collective Wisdom from the Experts
By Kevlin Henney
Publisher: O'Reilly Media
Final Release Date: February 2010
Pages: 258

Tap into the wisdom of experts to learn what every programmer should know, no matter what language you use. With the 97 short and extremely useful tips for programmers in this book, you'll expand your skills by adopting new approaches to old problems, learning appropriate best practices, and honing your craft through sound advice.

With contributions from some of the most experienced and respected practitioners in the industry--including Michael Feathers, Pete Goodliffe, Diomidis Spinellis, Cay Horstmann, Verity Stob, and many more--this book contains practical knowledge and principles that you can apply to all kinds of projects.

A few of the 97 things you should know:

  • "Code in the Language of the Domain" by Dan North
  • "Write Tests for People" by Gerard Meszaros
  • "Convenience Is Not an -ility" by Gregor Hohpe
  • "Know Your IDE" by Heinz Kabutz
  • "A Message to the Future" by Linda Rising
  • "The Boy Scout Rule" by Robert C. Martin (Uncle Bob)
  • "Beware the Share" by Udi Dahan
Table of Contents
Product Details
Recommended for You
Customer Reviews

REVIEW SNAPSHOT®

by PowerReviews
O'Reilly Media97 Things Every Programmer Should Know
 
3.8

(based on 14 reviews)

Ratings Distribution

  • 5 Stars

     

    (2)

  • 4 Stars

     

    (7)

  • 3 Stars

     

    (5)

  • 2 Stars

     

    (0)

  • 1 Stars

     

    (0)

85%

of respondents would recommend this to a friend.

Pros

  • Easy to understand (10)
  • Concise (7)
  • Well-written (5)
  • Helpful examples (3)

Cons

  • Not comprehensive enough (3)

Best Uses

  • Novice (10)
  • Student (10)
  • Intermediate (8)
  • Expert (3)
    • Reviewer Profile:
    • Developer (11)

Reviewed by 14 customers

Sort by

Displaying reviews 1-10

Back to top

Previous | Next »

(3 of 3 customers found this review helpful)

 
3.0

food for thoughts

By p6ril

from Guyancourt, France

About Me Developer

Verified Reviewer

Pros

  • Concise
  • Easy to understand
  • Well-written

Cons

  • Too basic

Best Uses

  • Expert
  • Intermediate
  • Novice
  • Student

Comments about O'Reilly Media 97 Things Every Programmer Should Know:

What I like most about this "97 things" serie is that every chapter is very short. It's easy to read a chapter or two here and there.

Overall this book is basically food for thoughts. There is a little something for everybody.

However reading the book end to end the level of advices seems quite unequal. Some chapters even contradict each other, like "if it ain't broken don't try to fix it" versus "try to make the code better every time you get a chance".

In the end it's not a bad read. Everybody should find a little something. On another end I only found perhaps 20% of the book really valuable to me. So take it for what it is: food for thoughts it's nice to get some perspective and form your own opinion.

(5 of 6 customers found this review helpful)

 
5.0

Wonderful Insights for Programmers

By Steve Rafferty

from Baltimore, MD

About Me Developer

Verified Reviewer

Pros

  • Concise
  • Easy to understand
  • Well-written

Cons

    Best Uses

    • Expert
    • Intermediate
    • Novice
    • Student

    Comments about O'Reilly Media 97 Things Every Programmer Should Know:

    (I am reviewing this book in exchange for a free review copy as part of the O'Reilly Blogger Review program)

    Although I've written many, many lines of code, I've never worked in a 'world class programming shop'. After I had been programming for awhile, I sought a job in what I hoped would be such a shop: a place where things were done "right". Instead, I have always found myself in positions where creative people hack code and implement systems. And, some of those systems were high quality enterprise applications.

    I suspect, though, that my vision of a 'world class programming shop' may not really exist. There are places where protocols are developed and their use enforced and best practices identified and implemented. At the same time, no programming shop is exempt from the pressures that cause sloppy coding and shortcuts to replace (temporarily of course!) proper programming practice.

    97 Things Every Programmer Should Know: Collective Wisdom From the Experts is a collection of short essays addressing many, many facets of the application development process. The first essay "Act With Prudence" by Seb Rose addresses the situation I described in the paragraph above. Introduction of shortcuts for expediency's sake are usually made with the sincere intent to return to the code and fix it. However, in reality, the programmer will only return to that issue if she must fix it; and, if the issue must be fixed, the original shortcut has spawned other issues and will be much harder to fix than in its original iteration.

    Other essays convey useful advice such as having a coding standard and enforcing its use. Filip van Laenen notes that a very effective way of doing this is to automate checking and enforcing the coding standard by incorporating it into the build process so that every build has a consistent code base.

    Many essays relay advice that "everyone knows" but the writing is such that the reader will glean new ways of thinking about what "everyone knows". If everyone knows something, it can be very difficult to articulate the reasons that underlie doing what "everyone knows" is the right way to do things. These essays are rich in understanding of such elusive notions.

    In the 97 essays, nearly every aspect of the application development process is explored and described. While this isn't a technical book, per se, good programmers will want to read what these experienced practitioners have to say. This also isn't a management book. However, every manager of teams of programmers, particularly those that haven't risen "through the trenches" to the management role, should read this collection so as to better understand what programmers do, how they do it, and why it should be done that way.

    97 Things Every Programmer Should Know is a highly enjoyable, very readable and critically useful to anyone involved in application development -- in any role.

    (1 of 2 customers found this review helpful)

     
    5.0

    Great read on today's hot topics

    By House of Burt

    from Merced, CA

    About Me Programmer

    Verified Reviewer

    Pros

    • Concise
    • Easy to understand
    • Interesting

    Cons

    • Not in-depth enough

    Best Uses

    • Intermediate
    • Novice
    • Student

    Comments about O'Reilly Media 97 Things Every Programmer Should Know:

    The book is 97 responses to the question: "what should every programmer know?". The authors responded back with insight on items such as working on teams, dealing with refactoring, code readability and how to expand your horizons as a veteran programmer. The book had several insights I hadn't considered before and made a great reference point in finding new areas of programming to study or consider.

    (1 of 1 customers found this review helpful)

     
    4.0

    A variety of programming-related topics

    By Josh G

    from Bellevue, WA

    About Me Engineer

    Verified Reviewer

    Pros

      Cons

        Best Uses

        • Intermediate
        • Novice
        • Student

        Comments about O'Reilly Media 97 Things Every Programmer Should Know:

        [I read the ePub on my nook. I got the book through the O'Reilly Blogger Review Program.]

        There is a ton of good information in this book, from general "learn how to talk to the people you work with", to hints at common programming issues, to deeper more complex topics like "yes you can store larger numbers in this data type, but it won't be as accurate".

        Some of the topics were things I've never even though of, likely because I've never actually programmed professionally, I just went to school to do so. Sometimes you'll read a chapter with someone pointing out why something doesn't work, then next chapter will be someone saying why it does.

        I liked how similar topics were near each other instead of having chapters mostly about Testing being scattered through-out the book. I also liked that the Chapters were short.

        I probably would have put the author bios under their names in the first chapter in which they appear, instead of leaving readers wondering "who the hell is this person and why do I care what they have to say?" unless you flip to the back of the book to read their bio.

        Some things I took away from this book:
        * You can learn more about languages you already know by learning new ones–they might have you doing something differently that you can apply to other language in ways you wouldn't've previously come up with yourself. Basically, you can become a stronger programmer overall.
        * There is no One Right Way to do something. Obviously I knew this, but as I said above, one author will give you reasons to do something a certain way, and the next will give you reasons not to do it that way.

        (6 of 6 customers found this review helpful)

         
        3.0

        Review of 97 Things Every Programmer Sho

        By Brian R. Bondy

        from Windsor, Ontario

        About Me Developer

        Verified Reviewer

        Pros

        • Concise
        • Easy to understand

        Cons

        • Not comprehensive enough

        Best Uses

        • Intermediate
        • Novice
        • Student

        Comments about O'Reilly Media 97 Things Every Programmer Should Know:

        The book 97 Things Every Programmer Should Know was edited by Kevlin Henney and has no single author.

        Instead of a typical book with one, two or three others, this book has almost 1 author per topic covered.

        The book does re-use some authors across topics, so naturally there are not quite 97 contributors.

        Each of the 97 chapters in the book covers one topic, each topic being 2 pages long.
        The depth of each topic would be equivalent to what you would find on a blog post, or a well written StackOverflow or programmers.stackexchange.com answer.

        As expected with dozens of contributors for the book, I had various opinions which can be grouped into:

        - I completely agreed with some points
        - I completely disagreed with some points
        - Other topics I found were acceptable points but really didn't matter as much as the author thought

        It was nice to have so many varying contributors and perspectives, all from successful and knowledgeable authors; However, personally
        I prefer reading from a single author or very small group of authors.

        I found it a little annoying that the description of who was giving the advise on each topic wasn't inline with the topic for each chapter.
        Instead readers need to flip to the back of the book to read up on each author.

        Personally, I like to know about the author when I'm reading any article; it adds more depth and credibility to what is being said.
        At the very least, it would have been nice to have a page number reference to where the contributor description is exactly.

        Strangely enough, I think the best way to read this book may be to start with the contributor list at the end of the book, and read each person's description, and then what they have to say.

        The page references to each author's articles are inline with each contributor in the back of the book.

        (6 of 7 customers found this review helpful)

         
        3.0

        Review: 97 Things

        By Matt Hulse

        from Ammon, ID

        Verified Reviewer

        Comments about O'Reilly Media 97 Things Every Programmer Should Know:

        I've decided that the biggest problem with this book is the title. Imagine you had the opportunity, without leaving your desk, to chat with 97 would be co-workers about what they thought was important in the field of Software. Surely that would be an interesting experiment. You wouldn't expect every conversation to yield a golden egg, but out of 97 conversations, you're bound to pick up something useful. I don't agree that this book contains 97 things that every programmer should know. This book contains 97 answers to the question "what should every programmer know?". Once I viewed this book in that light, I was able to dismiss opinions that I didn't care for and embrace others that struck a chord with me. In the end, this was a useful experiment in my eyes and worth the time and effort to read the book.

        (I received a copy of this e-book as part of the Blogger Review program in exchange for writing this review.)

        http://matt-hulse.com/articles/2011/02/22/review-97-things-every-programmer-should-know/

         
        4.0

        Must read for any programmer

        By Marvin

        from Malaysia

        About Me Developer

        Verified Reviewer

        Pros

        • Easy to understand
        • Well-written

        Cons

          Best Uses

          • Intermediate
          • Novice
          • Student

          Comments about O'Reilly Media 97 Things Every Programmer Should Know:

          Each topic is only two pages long and easy to read.
          If you are a programmer, then you are very likely to find at least a handful of pages that are useful to you.
          This book also has a Table of Contents page by Category for ease of reading. The short two-page concept also made it good for read during short breaks or while in travelling time.

          Among the categories highlighted, the expert programmers also advises on Testing and automation, Programming Languages and Paradigms, Teamwork and Collaboration.

          Besides the valuable 97 topics from experienced practitioners in the industry, the topics are not any programming language specific and thus can be applied for any programmers.
          If you are a programmer by profession, and would like to be better programmer, this book is definitely for you.

          (2 of 2 customers found this review helpful)

           
          3.0

          97 Things Every Programmer Should Know

          By Hector Lee

          from Singapore

          About Me Designer, Developer

          Verified Reviewer

          Pros

          • Helpful examples
          • Variety Of Tips

          Cons

          • Bad EBook Formatting

          Best Uses

          • Intermediate

          Comments about O'Reilly Media 97 Things Every Programmer Should Know:

          97 Things Every Programmer Should Know is a collection of general tips for all programmers. Edited by Kevlin Henney, it includes 97 tips to help improve yourself as a programmer. The tips try not to be specific to a particular language so that all programers can gain something out of it. Surely not all tips might apply to all types of programmers but you will definitely pick up stuff if you read it with an open mind. The tips are written by a group of programmers, much like crowd sourcing, so you get a variety of tips. Thus, the writing style does differ from tip to tip and you might not understand some. Don't be concerned if you don't understand a tip cause it might not be related to what you do. The formatting of the ebooks are surprisingly not up to par with the other books by O'Reilly can be rather distracting at times, especially on smaller screens like the iPhone. Hopefully O'Reilly will pick up on this and fix this odd one out.

          (1 of 1 customers found this review helpful)

           
          4.0

          Professional guidance at your hands

          By ederandres_an

          from Paipa, Colombia

          About Me Developer, University Student

          Verified Reviewer

          Pros

          • Concise
          • Easy to understand
          • Well-written

          Cons

            Best Uses

            • Novice
            • Student

            Comments about O'Reilly Media 97 Things Every Programmer Should Know:

            I describe this book as one of the kind "Developer, did you know ...?" because it highlights the best practices that every programmer must keep in mind for a software engineering project. These 97 development practices are organized in 19 categories such as coding style, design principles, project planning, usage of tools, collaborating with pairs, and design for the end user.Within these 97 best practices are those that should always be applied and those that must be balanced or avoided completely. For example, organizing the source code in an easy, expressive and compact manner (pp. 26–27); and creating designs conceptually correct that reduce the collateral effects of applying the singleton OO design pattern (pp. 146–147).Each practice is described in one short, concrete article in no more than two pages. Many developers learn the best practices after reading several books, magazines and blogs, but this book organize those practices in one single place. However, it is necessary clarify that this is not a programming book, and for really applying a practice the respective technology documentation must be read.If you are a junior developer or recent graduated student, this book is a good road to achieve the knowledge acquired by senior developers.Maybe, a discussion about UML would have been interesting to include.Note: This review was in exchange of the O'Reilly Blogger Review Program [@]

            (1 of 1 customers found this review helpful)

             
            4.0

            good but covers topics already known

            By Michal Owsiak

            from Poland

            About Me Developer

            Verified Reviewer

            Pros

            • Accurate
            • Concise
            • Easy to understand
            • Helpful examples

            Cons

            • Not comprehensive enough
            • Too basic

            Best Uses

            • Novice
            • Student

            Comments about O'Reilly Media 97 Things Every Programmer Should Know:

            What I have liked from the very beginning of the book, was the way the content description was organized. There are two tables of content - first one, regular one, second one divides book into different categories, thus you can read just essays related to particular topic. Another great advantage of the book is the way essays were prepared - two pages per each of them. No wasted space, no elaborates, just the core of the problem that is discussed. The same thing refers to the index - I like books where you can find things within index easily and accurately.

            Technical part of the book is the one side of he coin, second one is the content. 97 Things... is a book that covers topics you can find in many other books (Pragmatic Programmer, Agile Developer, Developers Notebook, Productive Programmer). What distinguish this book is the way topics are presented. Authors do not go deeply into details, they just sketch the issue, provide readers with the starting point and don't give them 'silver bullet'. Many times you will fell like - 'hey, I knew that already' - but that's OK, because you started to think about the again. I liked the book, I liked the topics, however different style of each essay might be confusing a little bit. If you like consistent style over the whole book, this will be a drawback. Another thing is - if you have read books like Pragmatic Programmer or Practices of an Agile Developer, rethink buying this book. You might feel disappointed. If you haven't read them - it might be a good starting point for getting a better programmer.

            Displaying reviews 1-10

            Back to top

            Previous | Next »

             
            Buy 2 Get 1 Free Free Shipping Guarantee
            Buying Options
            Immediate Access - Go Digital what's this?
            Ebook: $24.99
            Formats:  APK, DAISY, ePub, Mobi, PDF
            Print & Ebook: $32.99
            Print: $29.99