Reddit mentions: The best ruby programming books
We found 60 Reddit comments discussing the best ruby programming books. We ran sentiment analysis on each of these comments to determine how redditors feel about different products. We found 5 products and ranked them based on the amount of positive reactions they received. Here are the top 20.
1. Eloquent Ruby (Addison-Wesley Professional Ruby Series)
- Dayan Zhanchi Three Layer 3x3x3 Speed Cube
- Designed for speed solving
- One of the best speed cube in the world
Features:
Specs:
| Height | 9.13 Inches |
| Length | 7 Inches |
| Number of items | 1 |
| Release date | February 2011 |
| Weight | 1.51678036256 Pounds |
| Width | 0.95 Inches |
2. Design Patterns in Ruby
Specs:
| Height | 9.3 Inches |
| Length | 7.1 Inches |
| Number of items | 1 |
| Weight | 1.7857443222 Pounds |
| Width | 1 Inches |
3. Rails AntiPatterns: Best Practice Ruby on Rails Refactoring (Addison-Wesley Professional Ruby) (Addison-Wesley Professional Ruby Series)
Specs:
| Height | 9.13 Inches |
| Length | 7 Inches |
| Number of items | 1 |
| Release date | November 2010 |
| Weight | 1.212542441 Pounds |
| Width | 0.77 Inches |
4. The Rails 5 Way (4th Edition) (Addison-Wesley Professional Ruby Series)
- Tor Books
Features:
Specs:
| Height | 9 Inches |
| Length | 7 Inches |
| Number of items | 1 |
| Weight | 2.9101018584 Pounds |
| Width | 1.5 Inches |
5. Cloning Internet Applications with Ruby
Specs:
| Height | 9.25 Inches |
| Length | 7.5 Inches |
| Number of items | 1 |
| Weight | 1.27 Pounds |
| Width | 0.76 Inches |
🎓 Reddit experts on ruby programming books
The comments and opinions expressed on this page are written exclusively by redditors. To provide you with the most relevant data, we sourced opinions from the most knowledgeable Reddit users based the total number of upvotes and downvotes received across comments on subreddits where ruby programming books are discussed. For your reference and for the sake of transparency, here are the specialists whose opinions mattered the most in our ranking.
Interested in what Redditors like? Check out our Shuffle feature
Shuffle: random products popular on RedditTop Reddit comments about Ruby Programming:
Summary
1. Eloquent Ruby (Addison-Wesley Professional Ruby Series)
- Dayan Zhanchi Three Layer 3x3x3 Speed Cube
- Designed for speed solving
- One of the best speed cube in the world
Features:
Specs:
| Height | 9.13 Inches |
| Length | 7 Inches |
| Number of items | 1 |
| Release date | February 2011 |
| Weight | 1.51678036256 Pounds |
| Width | 0.95 Inches |
2. Design Patterns in Ruby
Specs:
| Height | 9.3 Inches |
| Length | 7.1 Inches |
| Number of items | 1 |
| Weight | 1.7857443222 Pounds |
| Width | 1 Inches |
3. Rails AntiPatterns: Best Practice Ruby on Rails Refactoring (Addison-Wesley Professional Ruby) (Addison-Wesley Professional Ruby Series)
Specs:
| Height | 9.13 Inches |
| Length | 7 Inches |
| Number of items | 1 |
| Release date | November 2010 |
| Weight | 1.212542441 Pounds |
| Width | 0.77 Inches |
4. The Rails 5 Way (4th Edition) (Addison-Wesley Professional Ruby Series)
- Tor Books
Features:
Specs:
| Height | 9 Inches |
| Length | 7 Inches |
| Number of items | 1 |
| Weight | 2.9101018584 Pounds |
| Width | 1.5 Inches |
5. Cloning Internet Applications with Ruby
Specs:
| Height | 9.25 Inches |
| Length | 7.5 Inches |
| Number of items | 1 |
| Weight | 1.27 Pounds |
| Width | 0.76 Inches |
Answers to follow, but try to make sure that you're not being overzealous in your attempts to learn Ruby. Questions about general code methodology are good, but in order to really understand and apply them you'll have to have a pretty solid grasp on the basics.
Despite how it may seem, you might be making it harder on yourself by trying to "skip ahead" and start applying later concepts early on.
There's a reason the first program most people write doesn't involve creating a Person class that responds to greet_with_hello(world).
If you've simply finished the Rails tutorial and want some Ruby experience, I'd recommend giving The Well-Grounded Rubyist a try. Many people in your position have done very well by it, and it will teach you what you need to know as you need to know it.
But as for your actual questions.
>What is the best resource to learn general code methodology and syntax, language agnostic. I'm picking things up what I would consider to be pretty quickly, but I know being able to learn about general themes and syntax of coding would help immensely.
Syntax is inherently tied to the language you're using. While there are similarities between some languages, there's no general "Guide to Syntax" that you would need to worry about. Happily, many people find that syntax is the easiest thing to pick up while learning an additional language. The general concepts are what you learn the first time, and then you learn "How do you do loops in C++ again?"
So don't worry about syntax.
However, Ruby does have the Ruby Style Guide that will answer questions about how to make your code look. As you'll find is the case with many things in Ruby, the style guide is not written in stone. It's just a good idea, most of the time.
With that out of the way, we can move on to things that are not language specific. Well, sort of.
Data Structures, Algorithms, and Design Patterns are established ways of doing or handling certain tasks. In theory/abstract, these are language agnostic. In practice, application or use can vary between languages.
There are a handful of decent books that will instruct you on advanced data structures and algorithms. I would visit /r/learnprogramming and peruse their sidebar for recommendations. That being said, I have yet to find a book written with examples in Ruby though. If you're completely unfamiliar with other languages then you might want to find something that deals in some sort of pseudocode.
It might be difficult to translate the concepts that are presented in pseudocode (or whatever language the book chooses) into Ruby. Especially if you are not decently comfortable with solving problems in Ruby, and thinking about problems in Ruby.
However, there are some books out there on how to design things in Ruby. They happen to be really good books too. I've honestly lost count of how many times I've recommended them, let alone how many time I've seen them recommended.
Practical Object-Oriented Design in Ruby will essentially guide you through learning what should and should not go into an object, and when to make those decisions. It is an eminently readable book, and conveys the information in concise and graspable fashion.
But if you're not in a position where you're really comfortable with the idea of what Objects are, and how you create/use them in Ruby, this book might be best saved for after you get a handle on the basics of that stuff.
In fact, most people seem to get the most benefit out of this book after they should have already read (and heeded) it. Sort of a situation where the right way makes the most sense only after you've been doing it the wrong way.
Secondly, Design Patterns in Ruby will show you how several common ways of doing things are utilized in Ruby. Personally, I read POODR before Design Patterns in Ruby, but I'm not aware of any reason read them in any particular order.
I'll reiterate that both of these books have general design concepts inside of them, but that they are dyed-in-the-wool Ruby books. You will absolutely learn things that you can take elsewhere, but it won't come to you in a purely abstracted manner.
>Is there a list of all the predefined calls in Ruby that I can find somewhere. Occasionally I write to do something only to find out that I'm breaking down a process that is shortened already. I'm sure these are commonplace for people who have coding experience before starting Ruby, but that's not a luxury that I'm afforded.
Absolutely! It's at Ruby Docs.
Don't get yourself down on this one. In this very particular case you might be a little better off than someone that has a bunch of programming experience in other languages.
Why you ask?
Lots of people aren't necessarily expecting the ease in which you can cause things to happen in Ruby with just a few method calls. They are waaaaaaaaaaaaaaay more used to breaking things down into smaller problems as a matter of necessity than you are. So congrats! Fewer habits to break there!
You can actually just google "ruby docs class-name" for whatever class you're working with to see what methods are available to you out of the box and what those methods do.
As a recommendation, I'd get pretty familiar with the module Enumerable, and check out the Array class. You'll end up using those a lot.
Like a whole lot.
In case you're curious, the awesomeness found in Enumerable is usually where people with prior programming experience tend to make things harder on themselves, because they're use to things being harder on them. A one line split, sort, and join is just a thing of beauty.
>Lastly if there was anything that really helped you that I didn't mention I'm open to any suggestions really.
In all honesty, what really helped me the most in learning Ruby was getting really comfortable with the syntax, and then learning what to do after that.
RubyMonk is probably one of the best places I've used to get a guide through Ruby, even advanced topics.
CodeWars is a good way to give your mind a nice stretch and workout. You'll just solve little problems that force you to make sure you know how to use Ruby when you need it.
After you're comfortable with the language, start making some small projects.
Games are usually a good first start. They have clearly defined rules and orders of events, as well as lots of things that are easy to recognize as objects.
Black Jack, Tic-Tac-Toe, MasterMind, BattleShip, and Chess are all pretty good projects to work on, and maybe in that order too.
Somewhere around then end of Tic-Tac-Toe or MasterMind I'd probably crack open POODR and giving it a read through. The value of all the lessons might not make complete sense at first, but it's that way with everybody. Just trust the author and go along with it.
Lastly, and I can not stress this enough, learn how to write and use tests for your code.
I know. It seems like tests are a waste of time. You're writing them before you're even really writing the code. On top of that, you already know how you want to do the thing you want to do, and it'll work!
Trust me. If the thing you're making is at all complicated, write some tests.
If you're ever going to want to change anything about it, write tests for it.
It will save you an incredible amount of time when you start breaking things, and will also give you the confidence that things probably aren't broken after you've fixed them.
Also, feel free to ignore everything I said about not jumping too far ahead. People learn in different ways, and desire to learn in different ways. If you feel like learning more advanced concepts now is going to be way more interesting for you, then you should totally do so.
sorry to hear you're having trouble; i get my ass kicked all the time.
if programming languages were like poems, i'd liken things like C# to an epic and ruby to a haiku. both are packed full of meaning, but the approach toward expressing it is radically different (imho: just an impression, keep the hatches battened down). the ruby community focuses very much on readability, in the sense that code sometimes reads more like pseudocode, or even just regular text, than i've seen in other lanaguages. this focus on readability is tightly coupled with a preference for terseness wherever and however possible: things like dry (don't repeat yourself), etc. are heavily emphasized.
sometimes it feels to me like i'm meeting a new person when i learn a new language, tool, etc.: it can go well or poorly, but regardless it takes a while to learn each other well enough in order to communicate effectively. the only way to expedite the process is familiarity. if familiarity is in short supply, patience appears to be the only way forward. disagreements will arise, but i try to look at those as opportunities to potentially broaden my perspective.
i'd recommend just taking some time in a low-pressure environment to work through some examples (small, easy ones just to get the feel for it) and read things like the pickaxe or the ruby way. eloquent ruby is on my reading list as well.
as far as editors go, i tried aptana (eclipse), rubymine, etc. i finally settled back on vim, with a few plugins to help along. so far, i've got pretty much everything i need out of an ide - granted, i do tend to use nix as an IDE. if you'd like some more information on that, here's a blog post i wrote a while back about my setup then. it's for ubuntu, but some of the gems, etc. it references may be helpful. of particular note is rubocop, which is a linter for ruby. about the only things i don't have via vim (either as part of default vim or via plugin) is code-completion (honestly don't use it that much) and a built-in debugger (again, nix as an IDE, plain old ruby debug gets me by. yes, pry. i know.). for built-in debugging, there's vim-ruby-debugger, and for autocompletion there's youcompleteme. i haven't personally used those plugins yet, but they're on my list to try out. there are probably others as well.
hope this helps.
Here's my list of the classics:
General Computing
Computer Science
Software Development
Case Studies
Employment
Language-Specific
C
Python
C#
C++
Java
Linux Shell Scripts
Web Development
Ruby and Rails
Assembly
If you're looking to learn Rails, why not start with a copy of the old standby The Rails Way? The OWASP wiki is a good start for web application security.
Speaking personally: rarely have I learned much of significance from classes, checklists, or step-by-step tutorials. None of these things will deeply improve your ability to understand a codebase. They are a crutch until you can learn more. It's like learning a language from a textbook. You may learn how to say some words, but it will not help you understand the culture.
Learning more is the hardest part. Good information in engineering is not usually spoon fed to you, and the knowledge to develop robust web applications is not something you can
git clone. You gain it through experience and messing up your toy applications, through seeking better answers. They may be lurking in IRC, StackExchange, Wikipedia or strange Twitter links. Explore and branch out. Find people you respect that make you feel like an absolute idiot, and read what they write, learn how they think. IMO this is the real key to progress in web dev or whatever else. It has worked for me so far. I still feel stupid, but I think that's probably a good thing.That article is specifically about legacy apps, and as such the good examples can be a little out of date. For instance:
class User < ActiveRecord::Base
scope :active, -> { where(active: true) }
scope :by_last_login_at, -> { order(:last_login_at) }
end
would just be:
class User < ActiveRecord::Base
def self.active
where(active: true)
end
def self.by_last_login_at
order(:last_login_at)
end
end
in a more modern codebase. Also, I think it's perfectly fine to use sql outside of models when you've extracted a bit of functionality into a service object. I think the nuance here might be articulated as "don't use sql in controllers, views, or other places it doesn't belong."
I agree with most of it, especially "extracting rake tasks to classes". If you're in the habit of extracting service objects to define interactions between things, you can frequently use these to make writing rake tasks easier, too and vice-versa.
Random things:
We created Hound as a hosted style checker, and I'm pretty fond of our guides.
I've worked on projects where we ran rubocop as part of a default
rake. Took some care and feeding but it was handy.You might also check out
bundle-auditandbrakeman.Codeclimate does some very clever static analysis to find issues too, very worth it.
If you're looking for info about design patterns, I love Design Patterns in Ruby.
I advise you to learn ruby first, it will be good for your understanding, rails is a huge framework that helps the developer a lot, but on my opinion, know Ruby is a key for pretty understanding Rails.
I usually recommend eloquent ruby: https://www.amazon.com/Eloquent-Ruby-Addison-Wesley-Professional/dp/0321584104
But the are a lot of good books.
Some free content:
https://launchschool.com/books
https://www.ossblog.org/study-ruby-programming-with-open-source-books/
Some Udemy courses are good too.
Thanks for the feedback, means a lot! Michael Hartl's tutorial really got me going with Rails. After going through that tutorial, I played around with a personal project that was structured very similar to just-eat. Once I had a pretty decent understanding of rails I read Rails Anti-Patterns. I highly recommend those two resources as they are both written very well. Everything I used for this site is: Ruby on Rails, JavaScript (and jQuery), BootStrap and SASS. Let me know if you have any further questions. Glad to hear you signed up, hope you enjoy the site!
Depends what you want to do in long run. If you are interested in System administration or networking, learn Perl.
If you just want a job and learn a cool scripting language, go for Python. Since you have done Python, it should not be hard for you to pick up. Start with this, that would be my advice.
If you are looking for web development, go for Ruby. Ruby is a bit more object oriented than Python or rather too high level abstraction. So to appreciate Ruby code and exploit its abstraction and not get overwhelmed, it would do good, if you did Python at first. It will make learning or appreciating Ruby easier. It will be a good foundation to learning Rails, a web framework. Do, Ruby if you are interested in web development and so holds for Python. Anyways Ruby is fun to learn. If you are comfortable with Java and just want a quick start, I recommend eloquent ruby.
You may have programmed in C++ but going back from Java, you may feel awkward. I will put the C++ as the last language in the list of priority of learning.
So in order of prioritising what you want to learn, my list would be
On a side note, if you are going for software engineering. It does no harm to learn another paradigm. You are only familiar with object oriented and procedural paradigm. If you are interested in broadening your SE skills try to sharpen up on functional programming. Haskell or Clojure (JVM implementation of Lisp and somewhat favoured by web developers) are good starting points.
How well do you know Java? I suspect you may be overestimating the time to it will take you to get comfortable in Ruby. Learning your first language is always harder than the second, because you're really learning two separate things: 1) how to program, and 2) the language syntax. The second time around, it's largely just a new syntax. Most of your knowledge of how to code will transfer. True, Ruby will introduce you to new concepts, but I think you'll find them rather more like new superpowers than like new obstacles.
Specific recommendations:
For Ruby, I like the book Eloquent Ruby
For Rails, I like Michael Hartl's Rails Tutorial
For fun and practice, look at Ruby Koans
If you're looking for more than tutorials or picking up a project as a learning experience, Code Complete by Steve McConnell and (though getting a bit dated) The Pragmatic Programmer are classics in improving your development skills. I'm also looking at Clean Code next, looks very useful for those of us in the trenches who often have to throw out some code with limited time and ever changing requirements.
Also if you're going to be digging into any rails stuff by chance, I can highly recommend Rails AntiPatterns as a great reference for more than the basics, as well as the Destroy All Software podcasts (which cover more advanced topics than most podcasts).
Sidebar
Moderation
Remove link/blog-spam. It's kind of pointless to read a summary on RubyInside, when I can read the original full-article written by the primary-author/project-lead on their own blog. Summaries of complex issues which span multiple blog-posts are OK though, I enjoy reading those.
Also, please no more articles about simple things like recursion or Arrays (that's what TryRuby and RubyKoans are for).
What's this about a Contest? Sounds fun.
All of the OO stuff is great but I've found it to be mostly subjective and repeating a lot of the same old boring stuff. I've always felt that programming with heuristics works better for me (e.g. least-visibility principle, sprinkling design patterns where it makes sense, focusing on interfaces, doing mostly TDD but trying to test meaningful contracts instead of being hardcore about red-green-refactor, etc)
Russ Olsen's Eloquent Ruby is still, and will probably always be, my favorite. It taught me how to right Ruby "the right way" by teaching me to learn the core libraries in-depth and explaining what the conventions were in them
Outside of that, Jesse Storimer's books are all good for learning how to use OS features from Ruby which is something I find critically lacking instruction of in the Ruby community
I second the comment to learn SQL really well. Also regular expressions come up frequently enough to be worth learning a bit about. Some familiarity with data structures is worth picking up, and getting a grasp on some common design patterns is well worth the time.
On the last point, I’d recommend Design Patterns in Ruby and Refactoring Ruby
Hope that helps.
There are great Ruby books that aren't aimed squarely at newbies. Just a couple are:
Practical Object-Oriented Design in Ruby is excellent.
Eloquent Ruby is great as well.
Are you looking for something to teach you specifically ruby syntax or something a little less syntax heavy? I'd HIGHLY recommend Design Patterns in Ruby by Russ Olsen.
It's answered so many common problems I have run into and have to work around. To me it seems like pretty advanced thinking/techniques but I'm not sure your level. Either way, it should provide some great insight! He dedicates a chapter to reviewing Ruby so maybe that would at least help some.
Design patterns in Ruby is great for this. Much more lighter and entertaining than it sounds, and a fantastic introduction to both OOP design patterns and more advanced Ruby techniques.
this is kind of a silly book, but it's about ruby. and pretty entertaining honestly. Why's Poingniant Guide to Ruby
EDIT: i hadn't read this in a long time so i was skimming it, but seriously if you can get past how out there the book is, its honestly a pretty legit way to learn ruby.
EDIT AGAIN SHIT: also Eloquent Ruby
Eloquent Ruby is one of the best programming books I've ever read. I highly recommend it. It'll get you started quickly with the basics, and then make you fall in love by showing the simple and powerful beauty of the language's design.
The poignant guide (the cartoon fox thing) is funny and smart, but Eloquent Ruby will make you really grok Ruby.
I mispoke (somebody else in thread linked it), but Russ Olsen most definitely wrote a great book on patterns.
http://www.amazon.co.uk/Design-Patterns-Ruby-Addison-Wesley-Professional/dp/0321490452
Well, while we're on the topic, I'll recommend another book I've liked ;)
"Design Patterns in Ruby" by Russ Olsen
http://www.amazon.com/Design-Patterns-Ruby-Russ-Olsen/dp/0321490452
It covers Gang of Four patterns (well, most of them) except in Ruby...an extremely helpful reference and very readable...my only caveat is that if you get it for Kindle, the code is not particularly well-formatted.
I'm getting good mileage out of David Copeland's Build Awesome Command-Line Applications in Ruby 2 (2013). For Ruby-specific best practices (I'm coming from PHP), Sandi Metz' Practical Object-Oriented Design (2019) and Russ Olsen's Eloquent Ruby (2011) are opening my eyes to how it's done here. In particular, Metz' focus on the role of messages in OO design has changed my approach to planning and testing - just in time for a critical project.
> Where can I learn the ruby way of things? for ex: I think ruby does str.reverse! rather than str = str.reverse()
You want Eloquent Ruby. It's a book about writing idiomatic Ruby, which is what you're asking about.
The Pickaxe book and POODR are both excellent books that you also want, but Eloquent Ruby is probably the best book for what you're specifically asking about.
I recommend Practical Object-Oriented Design in Ruby (aka POODR) and Eloquent Ruby.
I'm expert at C, Ruby, and Python, so if you post code examples of Ruby code you feel isn't idiomatic to gist.github.com I'm happy to take a look and offer feedback. I co-founded Dev Bootcamp, so I'm also familiar with the bumps along the way folks have when learning Ruby, even (and sometimes especially) if they're coming from another language.
The main thing to understand about Ruby is that everything is an object. To wit,
Foo = Class.new
foo = Foo.new
puts foo.object_id
Particular classes are instances of the class "Class," if you can wrap your head around that. Objects talk to each other by passing messages around, i.e., methods. In fact, you can define methods on individual objects (although nobody ever does this):
name = "Jesse"
def name.bark!
puts "woof woof"
end
name.bark!
But this is what's happening when you see code like
class Foo
def self.bark!
puts "woof woof"
end
end
The "self.bark!" sometimes seems like arbitrary syntax used to define class methods (or static methods as they're called in some OOP languages), especially to people coming from Java where you have these seemingly-magical keyword preludes. In Ruby you just define methods on objects, period. Classes are objects, too, and "def self.whatever" is the same as "def Foo.whatever". There's a nice nod to referential transparency there that you don't see in many OOP languages.
Every method is defined on some object, even "global" methods. Exercise: when you define a global method in Ruby what object does it get defined on?
When you need higher-order functions Ruby uses blocks, which are more like functions in JavaScript than lambdas in Python (e.g., they can contain arbitrary code, not just a single expression).
If you understand those three things -- everything is an object, objects communicate via messages called "methods", higher-order functions can be defined using blocks -- you understand about 95% of how Ruby thinks about the world.
I'll add, just because you're a C guy, Ruby "pretends" it doesn't really have a class/object distinction, but the default Ruby interpreter (MRI or sometimes CRuby) does actually have separate structs for classes and objects. It's really a language-level thing.
Design Patterns In Ruby - Russ Olsen
Practical Object-Oriented Design In Ruby - Sandi Metz
Those two are just good general Ruby/programming books. Here is a good beginner web dev book for Node.JS:
Learning Web App Development - Semmy Purewal
you can help out diaspora
https://github.com/diaspora/diaspora
you can also create a mini version with something like:
Cloning Internet Applications with Ruby - http://www.amazon.com/Cloning-Internet-Applications-Chang-Sheong/dp/1849511063
or reading the Rails Tutorials - http://www.railstutorials.org
Practicing is always good, try some of these:
https://www.bloc.io/ruby-warrior
http://coderbyte.com/
http://www.codewars.com/
http://exercism.io/
http://www.rubeque.com/problems
Learning material:
http://www.rubytapas.com/ (videos)
https://practicingruby.com/
http://www.amazon.com/Eloquent-Ruby-Addison-Wesley-Professional/dp/0321584104
http://www.amazon.com/Practical-Object-Oriented-Design-Ruby-Addison-Wesley/dp/0321721330
http://www.amazon.com/Design-Patterns-Ruby-Russ-Olsen/dp/0321490452
If you don't have a CS background reading about algorithms and data structures can also be beneficial for you:
http://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X
To go further with Rails, it's a good idea to go further with Ruby. Some of my favorites:
Rails AntiPatterns
Metaprogramming Ruby
Practical Object-Oriented Design in Ruby
Everyday Rails Testing with RSpec
I would really recommend reading Eloquent Ruby. It's a good structured introduction to practical Ruby.
You want Eloquent Ruby! This book is perfect for someone that is coming from a different language and has some of the basics of Ruby down already.
This and Eloquent Ruby. Best Ruby books.
I’ve heard great things about The Odin Project.
Aside from Sandi Metz book, I personally learned a lot from Russ Olsen’s book Eloquent Ruby.
Most of us started this way... if not with Ruby then another language...
Then you get more experience and start writing better code... some of the shortcuts take a while to get...
This book has quite the collection and is pretty much how most of us do it...
EDIT : OOPS... wrong book... that is a great one, but I meant this one for your level
Rails Antipatterns by Chad Pytel and Tammer Saleh:
http://www.amazon.com/Rails-AntiPatterns-Refactoring-Addison-Wesley-Professional/dp/0321604814
It's a little bit outdated, as it was written for Rails 3, but there's a lot of good stuff in that book.
I'd also recommend Design Patterns in Ruby : http://www.amazon.com/Design-Patterns-Ruby-Russ-Olsen/dp/0321490452
It's very straight forward and readable.
I enjoyed this one: http://www.amazon.com/Refactoring-Edition-Addison-Wesley-Professional-Series/dp/0321984137 and http://www.amazon.com/Eloquent-Ruby-Addison-Wesley-Professional-Series/dp/0321584104/ref=pd_bxgy_b_text_z
I really liked Design Patterns in Ruby https://www.amazon.com/Design-Patterns-Ruby-Russ-Olsen/dp/0321490452
Practical Object-Oriented Design in Ruby: An Agile Primer (Addison-Wesley Professional Ruby Series)
www.amazon.com/Practical-Object-Oriented-Design-Ruby-Addison-Wesley/dp/0321721330/ref=sr_1_6?ie=UTF8&qid=1398842637&sr=8-6&keywords=ruby#reader_0321721330
Eloquent Ruby
http://www.amazon.com/Eloquent-Ruby-Addison-Wesley-Professional-Series/dp/0321584104/ref=sr_1_9?ie=UTF8&amp;qid=1398842637&amp;sr=8-9&amp;keywords=ruby
Metaprogramming Ruby: Program Like the Ruby Pros
http://www.amazon.com/Metaprogramming-Ruby-Program-Like-Pros/dp/1934356476/ref=pd_rhf_se_s_cp_6_BXWQ?ie=UTF8&amp;refRID=02JTWKY2ZDHPVZWX181R
My favorite is the book design patterns in ruby
Personal favorites:
Crafting Rails Applications by core team member Jose Valim - http://plataformatec.com.br/crafting-rails-applications
Rails Anti-Patterns - http://www.amazon.com/Rails-AntiPatterns-Refactoring-Addison-Wesley-Professional/dp/0321604814
+1 for Ruby Koans.
I also recommend Eloquent Ruby to anyone starting out in Ruby and/or Rails.
So I learned when rails 3 had just come out - many of the online examples were made obselete so that made things harder.
My rough path was:
At this point I should point out that I'd come from a c# background and was not used to things "going out of date". I was not learning web dev, I was learning rails.
By the time we get to steps 5-8 I am also regularly watching http://railscasts.com, doing kata on codewars and had started working on a web application that I would eventually deploy.
I went on to have a 5 year rails career before moving to node.js a few years ago.
A friend recently passed on his copy of Eloquent Ruby. It's slightly outdated but still holds up.
Ruby by Example
Design Patterns
Well Grounded Rubyist
by the time you finish those three.. you will know what you want to move to.
If you want more guidelines and a further understanding of Ruby idioms, take a look at Eloquent Ruby.
Getting a bit dated now but rails anti-patterns is a decent book.
Also, this blog post is gold
EDIT: ruby science is also recommended by some people, but i didn't get a lot out of it - it doesn't even mention many of the modern refactorings such as service objects and so on, and i couldn't stand the way its structured, makes it very hard to find what i'm looking for.
I've learned a lot by reading Rails Anti-patterns. http://www.amazon.com/Rails-AntiPatterns-Refactoring-Addison-Wesley-Professional/dp/0321604814
read these two books:
https://www.amazon.co.uk/Rails-AntiPatterns-Refactoring-Addison-Wesley-Professional/dp/0321604814/ref=sr_1_1?ie=UTF8&amp;qid=1517938240&amp;sr=8-1&amp;keywords=rails+antipatterns
https://www.amazon.co.uk/Practical-Object-Oriented-Design-Ruby-Addison-Wesley/dp/0321721330/ref=pd_cp_14_3?_encoding=UTF8&amp;psc=1&amp;refRID=RPRY329V1QV4P8C1AJE8
They are both a bit old, but totally valid. The one is more practical (and about rails, if your Ruby job is indeed a Rails job), the other more general on OO design.
http://www.amazon.co.uk/Design-Patterns-Ruby-Addison-Wesley-Professional/dp/0321490452
Design Patterns in Ruby
https://learnrubythehardway.org/book/
https://www.amazon.com/Practical-Object-Oriented-Design-Ruby-Addison-Wesley/dp/0321721330/ref=sr_1_1?ie=UTF8&amp;qid=1499172143&amp;sr=8-1&amp;keywords=Object+Oriented+Design+In+Ruby
https://www.amazon.com/Design-Patterns-Ruby-Russ-Olsen/dp/0321490452/ref=sr_1_1?ie=UTF8&amp;qid=1499172191&amp;sr=8-1&amp;keywords=Design+Patterns+in+Ruby
Design Patterns in Ruby
For Ruby:
Universal:
Eloquent Ruby was one that really helped me out.
Fucking moron, i think you missed the most important one? http://www.amazon.com/Design-Patterns-Ruby-Russ-Olsen/dp/0321490452