Discover new selections
$9.99

These promotions will be applied to this item:

Some promotions may be combined; others are not eligible to be combined with other offers. For details, please see the Terms & Conditions associated with these promotions.

You've subscribed to ! We will preorder your items within 24 hours of when they become available. When new books are released, we'll charge your default payment method for the lowest price available during the pre-order period.
Update your device or payment method, cancel individual pre-orders or your subscription at
Your Memberships & Subscriptions
Kindle app logo image

Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer - no Kindle device required.

Read instantly on your browser with Kindle for Web.

Using your mobile phone camera - scan the code below and download the Kindle app.

QR code to download the Kindle App

Follow the author

Something went wrong. Please try your request again later.

Naming Things: The Hardest Problem in Software Engineering Kindle Edition

4.2 out of 5 stars 99 ratings

Naming is one of the most difficult and enduring challenges in software engineering, but few of us do it well. This practical and comprehensive book provides a set of principles, rules, and application guidelines for efficiently choosing good names in your code.

These skills can be used throughout your career, and they’re useful for every programming language, technical domain, and experience level. The book incorporates real-world examples to illustrate how to choose good names and avoid bad names.

This book includes:
  • Rules for how to choose good names and avoid bad names
  • Principles to help you remember the general qualities of good names
  • Real-world examples
  • Guidelines on the application of these rules and principles, including balancing tradeoffs, renaming best practices, and choosing domain-specific names
  • Tips on how to develop your naming skills throughout your career

Changes in the second edition:
  • Improved conciseness
  • Removal of less important content
  • Grammatical improvements
  • Formatting improvements

Great on Kindle
Great Experience. Great Value.
iphone with kindle app
Putting our best book forward
Each Great on Kindle book offers a great reading experience, at a better value than print to keep your wallet happy.

Explore your book, then jump right back to where you left off with Page Flip.

View high quality images that let you zoom in to take a closer look.

Enjoy features only possible in digital – start reading right away, carry your library with you, adjust the font, create shareable notes and highlights, and more.

Discover additional details about the events, people, and places in your book, with Wikipedia integration.

Get the free Kindle app: Link to the kindle app page Link to the kindle app page
Enjoy a great reading experience when you buy the Kindle edition of this book. Learn more about Great on Kindle, available in select categories.

Product details

  • ASIN ‏ : ‎ B0BT15GFZG
  • Publication date ‏ : ‎ January 24, 2023
  • Language ‏ : ‎ English
  • File size ‏ : ‎ 3.3 MB
  • Text-to-Speech ‏ : ‎ Enabled
  • Screen Reader ‏ : ‎ Supported
  • Enhanced typesetting ‏ : ‎ Enabled
  • X-Ray ‏ : ‎ Enabled
  • Word Wise ‏ : ‎ Not Enabled
  • Print length ‏ : ‎ 100 pages
  • Customer Reviews:
    4.2 out of 5 stars 99 ratings

About the author

Follow authors to get new release updates, plus improved recommendations.
Tom Benner
Brief content visible, double tap to read full content.
Full content visible, double tap to read brief content.

Tom has over 15 years of software engineering industry experience in startups and public companies, including roles as engineering manager, software architect, technical lead, and CTO. He has professional experience across a variety of technical domains, including software engineering, product engineering, data engineering, ML engineering, and infrastructure engineering. In his free time, he has created two successful SaaS businesses, mentored software engineering students, spoken at technology meetups, and built several popular open source projects.

Customer reviews

4.2 out of 5 stars
99 global ratings

Review this product

Share your thoughts with other customers

Customers say

Customers find the book's naming style practical and concise, with one mentioning it serves as a great resource for programming. They consider it well worth the time and money to read.

AI-generated from the text of customer reviews

Select to learn more

8 customers mention "Naming style"8 positive0 negative

Customers appreciate the book's approach to naming in programming, finding it pragmatic and concise, with one customer noting it serves as a great resource.

"...The value of the book is that these rules are organized into 4 principles and explained together in a way that it all hangs together, and then the..." Read more

"...things, this will be more of a checklist and a nice walk through the problem of naming things." Read more

"...There’s something to be gained for programmers at every level–it’s tempting to say it’s most beneficial to developers early in their career, but I..." Read more

"I like the message and the general lessons and rules are well presented. The trouble is that they are presented over and over and over again...." Read more

6 customers mention "Value for money"6 positive0 negative

Customers find the book well worth the time and money to read.

"...$10 on Kindle and well worth it...." Read more

"...are unique, and it’s a relatively light time commitment, so well worth the effort...." Read more

"The author's guidelines, references to studies and relevant books are commendable. However, some sections lacked depth...." Read more

"...Well worth the time and money to read. I’d highly recommend this book." Read more

Top reviews from the United States

  • Reviewed in the United States on July 23, 2023
    This thin book, if read by software engineers, and taken to heart, would improve code quality everywhere. Just naming things properly is an incredible way to write correct code in the first place, or improve it when you find problems.

    And it really is the hardest problem in software engineering - it's so hard to even name things at all that coders will do things they know are wrong to avoid it: long long methods with all code inline, class names that are just some noun with "Manager" or "Factory" or "Processor" or "Action" tacked on to the end as if that was sufficient to let you know what was going on, throwaway names that don't describe the entity named, not changing test names to reflect changes in the test (many times the test name doesn't even accurately state what the test is testing!), etc. etc.

    Yet I have found over and over that naming things properly - and breaking things out and giving them a name - contributes significantly to correctness.

    The most obvious way is that a correct name breaks the connection between one section of code and another section - especially if that other section would be embedded in the first one if you didn't break it out to give it a name.

    * You start with the named thing: you read the name, understand what it is supposed to do, then you read the code there, locally, and decide if it does what the name says it does.
    * Now you go back to where the name is used - you know the name accurately describes what's going to happen so you can consider it's use right there without referring again to the code behind it.

    Another way proper naming works well is if you name things in such a way that uses of the name in conditionals makes everything simpler.
    * This is why in code reviews I constantly point out that expressions used in conditionals should be:
    * Broken out into a named predicate (even if only a local Predicate - maybe especially then)
    * And that the predicate name should be positive
    * Because IMO it leads to much easier to understand boolean-valued expressions

    In 30 short pages this book lists the rules you need to follow to name things properly. And you've probably heard each on of rules principles before, one at a time. The value of the book is that these rules are organized into 4 principles and explained together in a way that it all hangs together, and then the principles - and many of the rules - stick in you mind, where you can have them ready when you need to name something.

    There's another 30 pages on how to apply the principles/rules in various settings.

    $10 on Kindle and well worth it. Even pay the extra $5 and get it in paperback - it's small and thin and very easy to flip through to refresh your understanding with.
    4 people found this helpful
    Report
  • Reviewed in the United States on February 13, 2025
    The book approaches the problem of naming things in the context of software development. As somebody who prides in having named lots of classes and method, I found this reassuring on the importance of using the right names and abstractions, as it's not just a software artifact, but also helps in the understanding of the problem or domain you and your team (or the whole company) tries to solve.

    If you suck at naming, this will be a five star book, if you are good at naming things, this will be more of a checklist and a nice walk through the problem of naming things.
  • Reviewed in the United States on February 22, 2023
    It's odd that a book on this topic hasn't been written before, and I'm glad it now has. This slim volume contains a wealth of good practical advice and wisdom gained through experience. There’s something to be gained for programmers at every level–it’s tempting to say it’s most beneficial to developers early in their career, but I’ve struggled through codebases written and maintained by experienced teams that were less readable than they should have been due to unfriendly naming choices. My personal challenge: slipping jokes or pop culture references into code. But as the book rightly points out, a clear identifier is “even more timeless” than name-dropping Metallica albums.

    When I first skimmed the table of contents I thought it might benefit from a chapter on cloud computing and naming in the context of Infrastructure as Code, but the concepts are sufficiently general as to cover that. It can be a little repetitive about the most important points it makes, but the specifics in each chapter are unique, and it’s a relatively light time commitment, so well worth the effort. I’ll be including a copy in our onboarding package for newly hired engineers.
    12 people found this helpful
    Report
  • Reviewed in the United States on June 24, 2023
    I like the message and the general lessons and rules are well presented. The trouble is that they are presented over and over and over again. It's almost like this should have been a blog post rather than trying to pad it out into book length.

    I quit reading it about 75% of the way through, I couldn't take it anymore. I get it.
    14 people found this helpful
    Report
  • Reviewed in the United States on October 15, 2024
    The author's guidelines, references to studies and relevant books are commendable. However, some sections lacked depth. Overall, this book is a good attempt at addressing naming in software engineering and strategies to mitigate its negative effects.
  • Reviewed in the United States on November 26, 2023
    There are plenty of great nuggets of wisdom in this book. While some guidance is inherent, it solidifies many ideas that should be common knowledge (but definitely aren’t).

    Well worth the time and money to read. I’d highly recommend this book.
  • Reviewed in the United States on July 2, 2023
    I’ll admit I was curious how the topic of variable names could justify a $19 book and the short answer is that it doesn’t. The book is nicely formatted but the content is just not worth the price of admission. It should have been a blog post, but it’s been expanded with over-long, repetitive writing to fill its still-small page count. A true book could be much more interesting. Explain the history of variable names! Where “i” as a loop variable came from! Show good and bad naming in open source code examples! Instead, it’s like a half dozen decent bullet points stretched to 100 generously-padded, small pages.
    10 people found this helpful
    Report
  • Reviewed in the United States on February 10, 2023
    I found this book pretty useful. The rules were thorough, but easy to follow and the examples were for problems I see all the time. There were some sections outside of the principles/rules that don’t seem as useful to me right now, but I can see myself reading them again later when I want to think about different naming topics. Overall, very pragmatic!
    4 people found this helpful
    Report

Top reviews from other countries

  • Kevin Jerome
    3.0 out of 5 stars Good yet shallow advice
    Reviewed in Canada on June 7, 2024
    This book is shallow, both in the number of pages and the depth of the content.

    It's not bad per se, but it's mostly common sense or well-trodden ideas put to paper. If you've been programming for several years, none of this advice will surprise you.

    The advice is not always well-motivated, often being heavily opinionated without referring to any data to back it up. This is fine for some people, but I would have preferred case studies or other forms of objectivity to have been introduced.

    The print quality was ok, but the book feels flimsy and the cover is easily stained from touches.

    I wouldn't spend too much on this book if you're looking to get it. You can easily find similar content online.
  • Blackmagic
    5.0 out of 5 stars Simple book which is quite helpful.
    Reviewed in Germany on August 3, 2023
    The content seems obvious when you read it but its quite helpful to clarify the way you write code.
    I would recommend it if you're a software professional.

Report an issue


Does this item contain inappropriate content?
Do you believe that this item violates a copyright?
Does this item contain quality or formatting issues?