Reddit reviews Practical Object-Oriented Design in Ruby: An Agile Primer (Addison-Wesley Professional Ruby Series)
We found 38 Reddit comments about Practical Object-Oriented Design in Ruby: An Agile Primer (Addison-Wesley Professional Ruby Series). Here are the top ones, ranked by their Reddit score.
Addison-Wesley Professional
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
I might not be the best person to answer this for you, since I learned Ruby after I already knew programming in general (JS, Python, C, Java) so learning Ruby for me was more about figuring out the Ruby way of doing things than learning how to program. But these are some resources I see recommended a lot that appeal to me:
I've been meaning to read Sandi Metz's book since I've watch some talks she's given and they've been very informative. And searching/browsing/reading the Ruby documentation is something I end up doing almost every day, whenever I'm programming. It's a good reference if you can't quite remember the name of a method, and it's also great to click the "click to toggle source" link so you can see how Ruby's own methods are defined. Some of the most basic and important methods are going to be in C, but a lot of the methods (especially in the std-lib) are themselves written in Ruby, and the C is often simple enough to understand what it's doing if you understand Ruby but don't have any experience with C.
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
Books
Stuff to watch
Blogs
Other resources
I strongly recommended The Well Grounded Rubyist
This gives you a great foundation, it's extremely well written and a nice reference to go back to.
I also recommend Practical Object Oriented Design in Ruby
This book is just amazing. If you're new to object oriented programming, and even if you have a bit of experience, this is going to improve your skills dramatically.
Good luck!
Eloquent ruby ( http://eloquentruby.com/) and Practical Object Oriented Design by Sandi Metz ( http://www.amazon.com/Practical-Object-Oriented-Design-Ruby-Addison-Wesley/dp/0321721330 ) are two solid books that I enjoyed a lot.
Read Principles of Object Oriented Design in Ruby. Quite a few things clicked for me when reading that book.
Programming in Ruby is also just fun, and when I get frustrated, the reason for that frustration inevitably turns out to be a pleasant surprise, as in there was a language construct that I didn't quite understand and that figuring out the solution unlocked a new way of doing things.
Also not sure how much programming you've done in other languages. In Java you inevitably run up against bone-headed decisions made by the designers to dumb-down the language. They were clearly designing Java for their intellectual inferiors.
Then go attempt to debug some C++ template errors. Dear gods what a mess that can become…
Python can't figure out where it wants to go with the v3 vs. v2.7 schism.
I'm a huge fan of Lisp, but the lack of libraries makes it difficult to use for many tasks. I see Ruby as giving me all the things that I love from Lisp along with access to a large selection of polished libraries.
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
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.
https://www.amazon.com/Practical-Object-Oriented-Design-Ruby-Addison-Wesley/dp/0321721330/ref=sr_1_1?ie=UTF8&qid=1499172143&sr=8-1&keywords=Object+Oriented+Design+In+Ruby
https://www.amazon.com/Design-Patterns-Ruby-Russ-Olsen/dp/0321490452/ref=sr_1_1?ie=UTF8&qid=1499172191&sr=8-1&keywords=Design+Patterns+in+Ruby
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&qid=1398842637&sr=8-9&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&refRID=02JTWKY2ZDHPVZWX181R
There are books out there, many of which are unfortunately not language agnostic, that deal with this. What you want to know is the basics of object oriented design and, most importantly, design patterns, which are general answers for recurring object-oriented design challenges. You may have to dabble into languages other than the one(s) you currently use in order to follow along.
The last one is the book on design patterns.
I've never used Django so I'm making some assumption here based on my Rails experience. Their feedback is pretty good.
​
cart_items = CartItem.objects.all()
total = cart_items.aggregate(Sum('price'))['pricesum'] or 0
coupons = Coupon.objects.filter(total_spending_thresholdlt=total)
Apply coupon if necessary
if request.method == 'POST' and request.POST.get('coupon', '') != '':
total -= Coupon.objects.get(pk=request.POST['coupon']).discount
All of this should certainly be in a model. You might want a Cart model that holds Items. The Cart would then have a method you call
total_pricethat would do the calculation inside that model and the controller would simply access that data.A Cart could also hold coupons and discounts too in whatever implementation they end up being.
I would rework this controller quite a bit, I would create new routes so you have a `cart' controller with a 'reset' route separate from the 'checkout' route, no need to send those requests to the same controller action and use an IF statement to determine where to send it.
So really your checkout action should basically be
context = {
'items': cart.items,
'total': cart.total_price,
'discounts': cart.discounts
}
return render(request, 'checkout/index.html', context)
Having an action 'unitItems' that sits under the route 'checkout/unit_items.html' that isn't used for actually checking out is a bad design choice. If this view is used to view an individual item, just have it be its own path like '/items/item_description' or whatever.
Same goes for 'addUnitItemToCartItems', this should just be a simple 'Cart.addItem(item)' line of code in your controller and then all the business logic goes in your Cart class. You could either return an error from that method or have something like Cart.errors that you check after (not sure what the best practice is in Django).
Also you'll see the advantage of designing everything the way I told you is you will only need a single "addItemToCart" action and only a single "viewItem" action, no need to duplicate your code to handle for weighed/unit priced items. Any of those logical differences will occur in the classes which won't matter to the controller because they will all share the same interface that they inherit from the abstract parent Item class.
My advice to you would be to get this book Design Patterns Explained. It's a bit expensive and "old", but the design patterns in it are timeless and get you thinking in the right way for OOP design. Another book that was hugely beneficial for me was Practical Object-Oriented Design in Ruby, but if you're focusing on Python maybe you can find something similar in that realm.
My biggest tips for you would be 1. if you're repeating code like you did several times in your unitItems vs weighedItems implementation, then it's time to stop and figure out how you can DRY it up (Don't Repeat Yourself) 2. Models are for business logic, views/helpers are for display, models are for business logic.
The resources everyone else mentioned are all good ones. Since you already know Java, Data Structures and OOP, I'd recommend Sandy Metz's Practical Object Orientated Design In Ruby. POODR will help you bridge the gap between your Java OOP knowledge and Ruby.
I always see people jump into Rails before they get into Ruby. Or, worse, they think that Rails is a language.
The latter makes me barf. Specifically, the kid I interviewed who assured me that Rails was indeed a language.
http://learnxinyminutes.com/docs/ruby/ and then read POODR http://www.amazon.com/Practical-Object-Oriented-Design-Ruby-Addison-Wesley/dp/0321721330
Then you should jump into Rails.
Exercism.io is a great resource where you're able to use your problem solving skills while you level up your Ruby.
In addition, Basic Ruby. This is extremely basic, however, BR does a great job with the fundamentals of Ruby.
+1 on Ruby Monk. -1 on CodeAcademy.
I'd recommend Sandi Metz's Practical Object-Oriented Programming.
read these two books:
https://www.amazon.co.uk/Rails-AntiPatterns-Refactoring-Addison-Wesley-Professional/dp/0321604814/ref=sr_1_1?ie=UTF8&qid=1517938240&sr=8-1&keywords=rails+antipatterns
https://www.amazon.co.uk/Practical-Object-Oriented-Design-Ruby-Addison-Wesley/dp/0321721330/ref=pd_cp_14_3?_encoding=UTF8&psc=1&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.
I don't think you need it explained from a Rails point of view. Ruby is an OO language, and Rails simply exploits that.
You need to learn proper design patterns in Ruby (which apply to most OO languages). Sandi Metz's Practical Object-Oriented Design in Ruby is pretty much the gold standard for Ruby and very readable.
It's based heavily off of Martin's Agile Software Development, Principles, Patterns, and Practices.
After that, you can look into SOLID but, in Ruby-land, I think the single responsibility principal coupled with the rules laid out in Metz's book (summarized here) is a good place to start.
Also, it's worth noting that if you have good test coverage it makes re-factoring much, much easier.
Good luck!
For books I'd recommend:
Practical Object-Oriented Design in Ruby
The Rails 4 Way - Good for after you've covered the basics of rails.
Sounds like you want to grab the Pickaxe book. It's a tome, but it'll take you through the Ruby way of doing things. The Ruby Way is great and easily accessible, but I don't believe it's been updated for Ruby 2.0.
Lastly, you can always skim through the Ruby docs.
Edit: You should also check out POODR. Great way of learning how to refactor!
I read it about 6 months ago and found it incredibly relevant despite actively working in Ruby 2.x. The syntax is still pretty modern, unlike, say, Why's pognant guide to Ruby.
I would read both Eloquent Ruby and Practical Object Oriented Design in Ruby which also covers the practical experience of working with Ruby. i.e. Eloquent Ruby tells you how to write good Ruby code, Practical OOD covers how to feel good doing it.
its hard to say where you should start picking up. If you've used VB (or rather, .NET), C# should be a good start. Its a very 'pure' oop language, microsoft has a lot of web stuff built on top of it that can make your life easier, and if your freelancing stuff doesn't work out, its a very popular language with corporate employers.
Python is a fine language. Rails, the ruby web framework, is more widely adopted than its python equivalents, and I personally prefer it. Both are very pleasant languages to work with, for a variety of reasons. My hesitation about learning these languages is that it might be more difficult to find resources that don't assume prior experience--ie, won't emphasis basics (especially object oriented programming and design).
I learned programming fundamentals in school, which I think gives me a more broad perspective than what you'd get reading tutorials. I think that some books would be a fairly good compromise, since they usually offer more depth than online tutorials. The definitive ruby book can be found here for free: http://www.ruby-doc.org/docs/ProgrammingRuby/
You might be more familiar with programming basics than I'm giving you credit for. Still, your frogger problem could be easily fixed by having a better understanding of OO programming and design. If you decide to go down the path of ruby, this book might be helpful: http://www.amazon.com/Practical-Object-Oriented-Design-Ruby-Addison-Wesley/dp/0321721330 . Your concerns about not having the right mindset can probably be put to rest once you've developed a good understanding of OOP--something you almost definitely wont get out of learning PHP first.
This. The tests and charity model look good, but the website controller has too much logic and is tricky to follow. Beginning on line 9, there are 4 nested ifs / unless, which could be improved.
This would be something that should be refactored into a number of smaller methods inside a model like
models/donation.rbor something alone those lines.I highly recommend Practical OO Design in Ruby by Sandi Metz. Her talks and writing are excellent and approachable and can applied in a number of contexts.
The Pragmatic Programmer
Practical Object Oriented Design in Ruby
Both have probably been the two best technical books I've ever read. They don't focus on syntax or an specific languages, but on good practices to follow when working as a Developer.
And don't worry about the title of the second book: it uses code examples in Ruby, but what it explains can be applied to every Object Oriented language
You want to learn about design patterns. This repo has very nice code examples of many popular patterns that you would be asked about in a software engineer interview:
https://github.com/gennad/Design-Patterns-in-Python
Do further research on each pattern to have it explained. Just follow whichever article helps you understand the concept, language doesn't matter.
This book made everything click for me.
http://www.amazon.com/Practical-Object-Oriented-Design-Ruby-Addison-Wesley/dp/0321721330
While yes, it's in ruby, it's great for anyone who just wants to learn how to code easily maintainable projects. The wisdom in this book is beyond any language.
Coursera is a great resource as someone else has already mentioned.
http://pyvideo.org/ is an excellent resource if you want to just watch a talk. While there's a lot of Python, there are many talks on various generic subjects like you're looking for.
Edit: autocorrect
Learning Rails is harder without coding. I recommend Ruby books instead: Practical Object-Oriented Design in Ruby and The Well-Grounded Rubyist.
Hi, I'm also still struggling about this, turns out that software architecture is really hard!
I haven't finish this book yet, but I still found so much useful information on it that I can fully recommend. I never programmed on ruby yet the book is easily one of the best that I have ever set my eyes on. You should give a try.
https://www.amazon.com/Practical-Object-Oriented-Design-Ruby-Addison-Wesley/dp/0321721330
https://www.amazon.com/exec/obidos/ASIN/0321721330/zenruby-20/ref=nosim/
Personally I tried learning from books and I found it quite tedious. There's a lot to cover and if you already have experience with other MVC frameworks you feel like you can skip most parts. Probably the best Rails-specific book is Agile Web Development with Rails.
Personally I learnt using CodeSchool and their Rails courses. That way I started hacking stuff myself, some of the Rails Tutorial also doesn't hurt, although I got bored halfway though but still, good stuff, you learn about manually handling users accounts. I dislike cucumber though, but you can ignore that part and/or use other testing library (which you learn in CodeSchool too).
Once you know the basics and the idea of Rails you can get away with google and the official ruby guides for reference, and you really need to pay attention to good OO practices in Ruby, books like Practical Object Oriented Design in Ruby and Confident Ruby are great for overall ruby coding standards :)
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.
Contribute to open source. Create something of your own, and contribute to other projects. Since you are basically self taught and you are going for your first gig, conveying to prospective employers that you care about design, testing, and that you are not a cowboy will help. Read and understand books like Practical Object-Oriented Design in Ruby. Also, don't be a one trick pony. Tackling JavaScript could be a next logical step. Needless to say, all your open source and projects you demonstrate should have good test suites.
Learn about the non-technical stuff as well. I think Land the Tech Job You Love is great, and you probably want to look into Cracking the Coding Interview as a starting point for learning more about algorithms and data structures. Upcase is another great resource for beginning/intermediate Ruby programmers who want to up their game. Start solving challenges on e.g. codewars.com.
I think learning OOP is a very good idea. There are tons of books on the subject but I would recommend these 2:
Uncle Bob's Agile Principles, Patterns, and Practices in C#
This book will teach you not only about good OOP principles (SOLID principles) but a also a lot about other programming practices such as testing and refactoring.
Sandy Metz's Practical Object-Oriented Design in Ruby: An Agile Primer
Don't worry about being a Ruby book, you should be able to understand the concepts (and learn some Ruby). Sandy ha a very good way of teaching how to think about OOP.
Hope it helps.
PS: I'm curious: what exactly did you struggle with? What made you think you should learn OOP?
Happy to help.
BTW this book could also be useful to you , very good book:
http://www.amazon.com/Practical-Object-Oriented-Design-Ruby-Addison-Wesley/dp/0321721330
For Ruby:
Universal:
Sandi Metz's "Practical Object Oriented Development in Ruby" (POODR) was the same way for me.
Well I've designed countless systems just like you did, then I wised up. You will too one day, just probably not very soon =)
You are building abstractions for the sake of having them. I won't offer you any pointers or counter arguments anymore, read this, then review your code:
http://www.amazon.com/Practical-Object-Oriented-Design-Ruby-Addison-Wesley/dp/0321721330
If you can find this book
https://www.amazon.com/Practical-Object-Oriented-Design-Ruby-Addison-Wesley/dp/0321721330/ref=sr_1_2?ie=UTF8&qid=1524292880&sr=8-2&keywords=object+oriented+ruby
That's what finally made it click for me. It's short, good, and Ruby is simple enough you can understand what's going on without knowing the language. And since you're just wanting to reinforce the concepts, you don't really need to code a long in Ruby, you can do it in Java or whatever you want.