Buy new:
$40.96$40.96
FREE delivery:
Saturday, Feb 4
Ships from: Amazon.com Sold by: Amazon.com
Buy used: $29.88

Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer - no Kindle device required. Learn more
Read instantly on your browser with Kindle for Web.
Using your mobile phone camera - scan the code below and download the Kindle app.


Elegant Objects 1.0 Edition
Enhance your purchase
- ISBN-101519166915
- ISBN-13978-1519166913
- Edition1.0
- Publication dateFebruary 17, 2016
- LanguageEnglish
- Dimensions6 x 0.56 x 9 inches
- Print length223 pages
Customers who viewed this item also viewed
Editorial Reviews
Review
"I definitely enjoyed this book and will be re-reading it again soon." - Ben Nadel, Co-founder at InVision.
"This book is amazing. It's really changed the way I think of OOP. It's very actionable and easy to understand," says Andrew Shell.
"Well-written, entertaining, practical, bold and marginal at times." - Eduards Sizovs, Co-founder of DevTernity.
"It is one of the best books if you have a lot of experience in different projects." - Anton Chernousov, Founder of "The Art of Programming" podcast.
From the Author
About the Author
Product details
- Publisher : CreateSpace Independent Publishing Platform; 1.0 edition (February 17, 2016)
- Language : English
- Paperback : 223 pages
- ISBN-10 : 1519166915
- ISBN-13 : 978-1519166913
- Item Weight : 11.8 ounces
- Dimensions : 6 x 0.56 x 9 inches
- Best Sellers Rank: #843,901 in Books (See Top 100 in Books)
- #55 in Object-Oriented Software Design
- #518 in Object-Oriented Design
- Customer Reviews:
About the author

Yegor is a Director of System Programming Laboratory in Huawei Russian Research Center (Moscow, Russia); a former CEO and founder of Zerocracy.com, a creator of AI management solution for software projects; a regular blogger at www.yegor256.com; a proud holder of PMP and OCMEA certifications; a hands-on Java developer and a lead architect of a few popular open source projects, including Cactoos.org, JCabi.com, Takes.org, Rultor.com and Qulice.com. Yegor lives in Moscow, Russia.
Customer reviews
Customer Reviews, including Product Star Ratings help customers to learn more about the product and decide whether it is the right product for them.
To calculate the overall star rating and percentage breakdown by star, we don’t use a simple average. Instead, our system considers things like how recent a review is and if the reviewer bought the item on Amazon. It also analyzed reviews to verify trustworthiness.
Learn more how customers reviews work on Amazon
Reviewed in the United States on August 2, 2016
-
Top reviews
Top reviews from the United States
There was a problem filtering reviews right now. Please try again later.
This book has fundamentally changed the way I code.
The fundamentalist and dogmatic tone has caused several of my colleagues to return my copy before they were able to finish reading it. Do NOT let this happen to you! I actually found some of the more absolutist rhetoric hilarious. It is important to keep in mind that exaggeration can be used to make a larger point. You may be offended by Elegant Objects, but try to overcome your own outrage. Ask yourself, “What if I am truly wrong about what object oriented programming is?”
I waited to submit this review until I had ample time to put some of the principles in practice. Immediately following the first reading, I tried to dogmatically follow the elegant object philosophy and I failed miserably. My code had for loops and if statements all over it. It is hard to break the procedural addiction. The first step is admitting you have a problem! If you don’t think that you have a problem, you need to read this book.
I have been “object thinking” now for 8 months and my unit tests have become easier and lighter weight and my objects have become more powerful and extensible without even the slightest hint of implementation inheritance. My models are more representative of the physical model and every object actually has behavior instead of being nothing more than thinly veiled structures and function libraries.
It is important to note that Elegant Objects philosophy is not able to be 100% implemented practically as languages stand today. Yegor’s arguments in the book seem impractible and quite outrageous when thought of in terms of today's computer languages. If you can look past that, you will find useful ways to improve whatever code you are writing right now.
Elegant objects is a book that every programmer should read.
The author is a practicing programmer who writes a lot of code every day. And the book contains a lot of examples which are small and simplified of course but very useful to better understand the idea and how to implement it in code. I would recommend the author to pick one of his projects for his future books and explain all the principles using examples from that only particular project (simplified ones of course). To my mind that will make examples more consistent across the book.
I found grouping into chapters a little bit weird but still every section is more or less independent from each other. One could start reading almost from any section of the book.
So in conclusion: Great book which every Java programmer at least should read definitelly.
The book is expensive but worth buying.
The author claims that his interpretation of OO makes programs more maintainable and performant, but does not realize that he is reiterating the tension between eager and lazy evaluation. Without realizing it, he is proponent of the latter, and Is unaware that precisely lazy evaluation “by default” is a source of performance problems and excessive memory usage in Haskell, and a big stumbling block for newcomers. It is problematic to the extent that people are experimenting with Haskell dialects where eager evaluation would be the default. Even Simon Peyton Jones has said that “the next Haskell will be strict”.
Even though the book contains a few sound advices (the chapter on testing, “fail fast” philosophy), the overall tone of the book is condescending and gives an impression that the author thinks very high of himself because reading a couple of books on OO lead him to some kind of “revelation”.
Conclusion: these books are way too expensive and basically a waste of money. I’m sorry I bought them. I’ll write a longer, more thorough review on my webpage. After that, I'll give away my copies for free.
I also like author's use of objects' anthropomorphic point of view, i.e. looking at objects as living organisms with behavior. I think that helps readers shift their mindset from "thinking like a computer".
Sad aspect is author's lack of reasoning and use of strongest possible words. "pure evil", "it is dumb", "absolutely terrible", etc. This position of know-it-all paradoxically show's authors ignorance; and often he openly admits he doesn't know the reason, but "just don't do it". The advice is still good and there may be other reasons, but author would have to be open-minded and maybe read other books to acquire deeper understanding.
I also felt sometimes that I've been cheated. He writes one example to prove point of argument, and in next chapter says the example it's not actually good and changes it to prove his new point. This inconsistency doesn't add up much of credibility.
But overall good book for beginners looking for OOP approach.
Top reviews from other countries

Some of the choices the author prefers might be fine choices for the projects the author has worked on, but are definitely not universally true. Making the argument that anyone that disagrees is an idiot as the book does is not a good way to educate programmers.
A much better book is "Timeless Laws of Software Development" https://www.amazon.co.uk/Timeless-Software-Development-Jerry-Fitzpatrick/dp/099933560X/ref=sr_1_1 which explains why/how certain solutions are good at solving certain problems.

Now that I have read it, I am really eager to apply the principles defined in the book.
Problem is that, it is not very easy to change a way of thinking one has had for years.
Also it is really hard to "isolate the diseased" when the language you are writing in and the API framework you are using violate the principles defined in the book.
Even after reading the book, I would say that I still write code that is not very maintainable, but now I know that I can improve this code.

There are many books, articles, blogs about OO. Everyone seems to think they know what it is. But this book tries to convince you otherwise. A lot of people will probably have a negative reaction to it just because of the fact that it basically tells them "you've been doing OO wrong the whole time". But I would strongly advise you to read the book and really try to understand what the author is saying.
The good parts:
* A rather short book without much needless small-talk
* Most of the book's ideas are applicable even if you don't adopt the whole philosophy of the book (things like "don't use singletons", "make classes immutable", "keep classes/objects small", etc.)
The less good parts:
* Some things the author says sound a bit "dramatized"
* What author says is not always exactly what he means (for example, "Never use -er names", tells you not to name classes with words that end with "-er" suffix, but what the author is trying to say is something like "A LOT OF class names that end with '-er' are bad because their names imply procedural code wrapped in objects rather than real objects; basically, things like "CashFormatter", "PageLoader", "UserDeleter" or "ImageTransformer" are bad, but things like "User" and "Programmer" are OK).
Despite a few flaws, it's still an excellent book.

The writing style definitely challenges you to consider the suggested approaches to writing pure OO software. I won't say I agree with everything but I feel the strong opinions offered, if taken with a pinch of salt in some chapters, have definitely helped me to think about the design of the systems I write from a new angle.

the quality of the paper and the font from this book. Both are extremely pleasant.
This book is not for beginners, you have to write very ugly code first.
Only then, you'll fully enjoy this master piece.
Each chapter you'll start by: Yep, another rant.
And you'll always end as: I just can't believe I write such ugly code.
Birth, education, and employment. This is the path to write OOP software.
![]() |