Polished Ruby Programming: Build better software with more intuitive, maintainable, scalable, and high-performance Ruby code

“Polished Ruby Programming”, by Jeremy Evans, is essential reading for seasoned ruby programmers who already know about the hidden superpowers of the ruby programming language, and want to know how to use them effectively.The author has a history of maintaining some of the most advanced, high-performance and featureful libraries in the ruby ecosystem (i.e. “sequel” and “roda”), and the book documents some of the considerations, trade-offs and hidden tricks that have emerged in his projects, in the form of contained examples, designed for the reader to follow.The book starts by analyzing the foundational building blocks of ruby (Integer, String, Array…), and consideration on where to use what and when, focusing of simplicity and maintainability, and then goes all the way while explaining how and when to use meta-programming, even putting on paper a smaller version of a plugin system similar to the one used in several projects of its author.Some of my favourite bits were how the author picked up on SOLID principles and how Ruby doesn’t apply them necessarily, and how that actually works for the better, thereby making the point about avoiding taking principles dogmatically (the “Single Responsibility Principle” applied to Array was particularly impressive to read), or a particular bit where the author argues how full test coverage means nothing.The book suffers from being too big (+400 pages), and some of its conceptual integrity gets lost in the last chapters, a small compendium about using ruby effectively with databases and web programming. Feels like the author has more to say about the subject, and those could be best served in a separate book.Overall, “Polished Ruby Programming” is an engaging and comprehensible read, and highly recommended for rubyists who want to up their ruby quality standard, learning from one of the most accomplished members of the community.

This book is a pretty useful distillation of core Ruby facts and techniques that are important to understand if you are moving from being able to "do things in Ruby" to being able to "do things efficiently and performantly in Ruby".Having participated in Ruby meetups/talks in which Jeremy presented, this book is the "async" version of that.Up to date for Ruby 3.x, the book moves through several parts, reinforcing your knowledge of the basics of the core language first, then moving on to extensibility (building libraries, metaprogramming, DSLs), before ending with the third section in the place where Ruby really became much more mainstream--web development.I found the examples to be pretty easy to understand, building up from the basics in small easy to consume pieces. There isn't a lot of filler code in here, instead focused examples with demonstrations of how things work. You can imagine Jeremy demoing these ideas to you as if you were in a virtual pairing session together. I appreciated that approachable style.If you are completed new to Ruby, this book may be a bit of a challenge. The book does indicate this is for intermediate+ readers. You may want to look at some introductory material first to ascertain you are comfortable with the base language and its flexibility. If you are an advanced Rubyist, I suspect you'll still get something out of this text, even if just confirming your core understanding and seeing how things work in the latest version of Ruby.

This is a great book for Ruby mid-level and soon-to-be-mid-level developers, going beyond the basics and talking about how to pick Ruby patterns that have been accepted as best practice, and talking about why the community believe these are best practices. Some of the major topics that it goes into depth on - local variables, method arguments, exceptions - seem basic but this book uses them as a way to talk more fundamentally abuot making the right choices when writing Ruby. Contentious issues such as how to deal with formatting, encapsulation, extension, and testing, are talked about in pragmatic terms of how to use tools sensibly and how to take choices that make sense for performance and the expectations of people reading the code. I could recommend this book to anyone moving beyond simply using Ruby to working with it a deeper level, working on performance, and writing libraries. I'd have preferred some more references to definitive resources - for example the sections on the meaning of ||= could have linked to some of the existing definitive blog posts, or the RubySpec specifications for it. This would have given readers the knowledge of how to answer similar questions on other features themselves if they need to in the future.

What I Like:This book is something that only the author can write. He talks about why the libraries he authored such as Roda and Sequel are better than Rails, which I enjoyed reading the most. With his knowledge as a very active Ruby committer, he also talks about Ruby 3 keyword arguments and mentions features that might get into Ruby in the future.This book discusses principles and trade-offs for a wide range of topics, not just Ruby-specific techniques. The ideas in this book would be useful even when you’re not writing Ruby, especially when it comes to web applications.What I Don’t Like:While there are many exciting contents in this book, as a Ruby developer with 8 years of experience in production web applications, Ruby core, and gems, I already knew many of the ideas and trade-offs that are written in this book prior to reading it. The whole book would be helpful for pushing intermediate Ruby programmers to advanced ones, but if you’re already an advanced Ruby programmer, it might take some time to find interesting ideas out of the chapters that talk about principles you have already thought about.

We use Chef at work so learning Ruby was going to be a necessity.It looks to be an excellent book but my boss told me to learn Python so had to return this after one day.

1. Chapter 1 -> Awesome, have good stuff, well explained.2. Chapter 2 -> Requires more explanation and little bit confusing.3. Chapter 3 -> Awesome, have good stuff, well explained.Will update review again after full reading.

If you're in the target group of this book (intermediate or advanced Ruby programmer), you'll find this book is a gem.I've been using Ruby for several years, and yet there was hardly any paragraph in the book which didn't have some nice piece of useful information I didn't know before. This is not a surprise, as the author is known for having vast experience in both maintaining high quality Ruby code, as well as in MRI Ruby internals, being a Ruby committer. And though the book is so packed with information, it feels very easy to read, because the language is direct and clear and, most of all, the examples are fantastic.Another review claims code in the Kindle version of the book is hard to distinguish from normal text; I'm adding a picture from a random page to show that's not the case with the paperback version.I'm recommending the book to every Ruby developer I work with, and I'd be remiss to not do the same here.

The author does a great job and I'm happy with the publishing.My only complaint is that it's great for a beginner, mostly useless for an experienced ruby programmer.*Fanboy alert*Kudos to the author for trying to write a book on making ruby programs nice and polished but any decent practice in ruby results in that anyways. Some other languages would have made for easier target practice. ;)

A very good book which covers some Ruby internals so the developer is getting a deep insight how easy it is to avoid some typical lazy/bad programming styles and to what costs this comes.That Book covers mostly Ruby 3.0 and sometimes the Author makes a swing to some earlier version to explain why the Ruby devs decided to change some details of this new version, why is in my opinion necessary and surprised me often.It`s all in one a good book and should be read by a Ruby dev, because the informations are valuable.Ty "Jeremy Evans"