(Part 2) Best products from r/ruby

I would recommend not starting with Rails, but instead with Sinatra.

Rails is great, and you can do some amazing things with it, but for learning I found that it was more a hinderance than a help. Better to learn the core language first, then move to a framework such as Rails.

Sinatra gets out of the way and lets you write Ruby, allowing you to have a site up and running with about 5 lines of code. It's a terrific introduction to developing sites, and I found it a great way to play around with Gems and their capabilities.

As for books, I have both the PickAxe book, as well as Beginning Ruby. Both are very helpful.

There are some SUPER valuable insights in the replies of this thread that took me YEARS of programming to fully understand. So you did yourself a great service asking this question here :)

 

These insights are:

by u/cmd-t
> think in OOP in terms of passing messages from object to object. Every function call is actually sending a message to an object: a request for it to do something.

by u/saturnflyer
> Don't model the real world. Create the world you need.

by u/tom_dalling
> It's a common misconception that classes model real-world things. Classes model data, or behavior, or responsibilities.

 

To answer your question, yes, OOP is hard to master. As a result, there are many books written on the subject. And for a complicated system, even senior developers will have trouble getting the design right on a first try.

 

If you feel lost, it's not because you are not good at this. It's because the subject you are learning does require lots of time and practice.

IMHO, the best way to learn this is by actually working alongside with senior engineers in a real production project. So you can see some existing designs and also bounce ideas with other engineers.

While that might not be possible at the moment, you can

• look at existing designs of open source projects
  
• read books: Practical Object-Oriented Design in Ruby by Sandi Metz, Smalltalk Best Practice Patterns by Kent Beck These two might be a bit too advanced. I couldn't think of any good OOP introductory books of the top of my head, maybe Head First Object-Oriented Analysis and Design?
  
• practice and bounce your design ideas with other engineers
  
   
  
  Happy coding and I hope to see you posting more questions here! :D
  
  

Some great suggestions here around complimentary languages. Let me chime in on the tools. Depending on where you want your career to go deploying Ruby without Heroku wouldn't hurt at all.

• When to use Varnish / Nginx and why
  
• Why Capistrano is a popular way to deploy code
  
• How to demonize and monitor ruby processes
  
• Why people use Chef
  
• Knowing the key difference between how Unicorn scales and Puma
  
• Understanding Git, Git merging strategies and having an awarness of Git Flow style branching models
  
• etc...
  
  I've made no assumption on what you already know so please don't feel like you need to know all of this but as Rubyist these are things I look for in candidate's that I hire :).
  
  PS: I've not included Databases in all of this which I think is obvious to say is important when fleshing out a CV.
  
  PPS: Two books I would recommend highly (can easily be read on holiday in the sun)
  
  
• Seven Languages in Seven Weeks
  
• Seven Databases in Seven Weeks
  
  Both of these books are fairly light hearted, give you a grounded understanding of the core differences in languages and databases, assume your a programmer already and IMO are very interesting reads for someone that is keen to look at languages from different angles. Prolog == mind blown
  
  Good Luck

Ruby, and it's popular web-based framework rails, would actually be a fairly good fit for a simple reporting solution based on existing data/tables/database.

Some points:

1. Ruby, as a language, is a lot simpler and easier to read and write than C++. (Depending, of course, on a decent programmer doing the coding. It's possible to write bad code in any language, and unfortunately many do.)
   
   
2. You just need a little bit of ruby knowledge, to get started being productive in rails.
   
   
3. Rails, at an introductory level, through the use of scaffolds, allows you to very quickly create a simple UI for CRUD like functionality based on existing database/schemas.
   
   
4. Rails also has a lot free tutorials/screencasts, most of them free, thus enabling you to easily get started in a matter of minutes.
   
   
5. Rails is database-agnostic, and allows one to connect to existing db's across vendors. Whether you want to connect to sybase, oracle, sql server (whichever db you erp uses) it can connect without any change to your code.
   
   
6. Check out the following sites for more info:
   
   

• Practical_Reporting_Rails_Book
  
  
• A_Decent_Free_Rails_Tutorial
  
  
• Railscasts free and fairly decent screencasts
  
  
• Dynamic_Reports
  
  
• There's also plenty of free blog posts/magazine articles/screencasts on rails. Google it.

I'd get started with Rails. You'd have everything taken care of (Webserver, Database connectivity, HTML Generation, Basic Security build in). It's definitely a good starting point. Over time you'll learn more and more of Rubys core. If you like to get a more "raw" approach you can try Sinatra (http://www.sinatrarb.com/).

Rails isn't a different language. It's merely a huge bunch of classes and methods that'll ease your way. But it forces you to do things the "Rails way" (isn't a bad one, but maybe not your way, or won't fit your needs). For supplying an API I prefer "Grape" (https://github.com/intridea/grape/). For my big projects I usually use Sinatra (well, an extended and modified Version). Rails was a great starting point for me ( http://amzn.com/0321480791 ).

Sure you can get started from the ground up with bare Ruby. But most devs won't re-invent the wheel and take solid libraries that are available. (e.g. Rack).

Rails will get you very fast to a complete project. But for sure, you'll be more satisfied and have more control over all the aspects if you'll build it from the ground up.

I will agree and disagree with both menge101work and jrochkind ... rake is awesome, just not sure it is a fit here.

 

As someone who has chased one too many rabbits down the MAKE hole, rake is awesome, if it were only for the Rake::Filelists... but when you add in the dependency tracking, it becomes a godsend.

 

It takes a while to get your head around it... especially if you have never used make / ant / etc... but completely worth it if you do a lot of automation... one of the best things rails promoted...

 

Rake Task Management Essentials was my preferred book

 

BUT

 

It sounds like you may be getting more into CI (continuous integration) territory ... in that case, Travis CI might be the direction you are looking for.

Some people prefer dynamic languages, some prefer static languages. A smart compiler can make a static language feel more dynamic, like F# for example, but it's just a different way of thinking.

Well designed OOP can take you far. I still feel like nil should be avoided in your code though, but types are not necessary for that.

> My experience writing Elm/Haskell code for more complex features is a world apart from writing complex features in Ruby.

Looks like you are writing not confident Ruby code. That's actually a very common issue, especially for devs which come from static backgrounds. I recommend giving Avdi Grimm's Confident Ruby a shot.

> Also even if you can write good code, that doesn't mean you or others around you will. Sometimes having tools enforce rules for you can be a good thing.

That is true, but you can write bad code in any language. Every language has it's advantages and disadvantages. You might not make nil-related errors but you will have hard-to-change code. Code which needs a big chunk of context to be understood before you can change it, or add to it.

The single responsibility principle is easily broken in many languages.

I came here to put this same book. This book is crazy, crazy good. It would help to have some knowledge of algorithms and data structures before going in as the examples aren't vast and the information are fairly heavy, but it's a fantastic reference.

I would encourage you to change your thinking from "learning algorithms in Ruby" to "learning algorithms" and then just implementing examples in Ruby. There are a few classic Algorithms book that I'd highly recommend. In addition to The Algorithm Design Manual, Data Structures in C is written in C but fairly generic and gives you the right tools for thinking about performance and algorithms, and Introduction to Algorithms, 3ed is more academic but also stupid inexpensive right now. It's a great learning book as the examples are very detailed. It's aimed at interviewing but Cracking the Coding Interview has a nice short survey of algorithms and data structures too

I'd recommend Pragmatic studios. Its expensive, but wonderfully clear, step by step with syntax, theory and practical use. They dont code along, rather they develop an application to demonstrate and you build something similar with the exercises. Im going though it now, after both codeacedmy and code schools ruby courses, and its exactly what was missing in the "now you now what ? and ! do on a method. Now lets move on to something else" that both of those seemed to do.

http://pragmaticstudio.com/ruby

I'm also enjoying Everyday Scripting with Ruby: For Teams, Testers, and You.Its a more "on the ground" look at Ruby, making it go and do things right away. Lots of used copies for $4. Its worth that just to thumb though it alone. Im only past the first few exercises, but its already an excellent companion to the pragmatic course above.

Qt is used quite a bit; there should be numerous books/sites of use. I myself use PyQt, the Python API, of which there is an astoundingly good how-to book. I don't know if there is a Ruby-specific version, but the concepts are quite general and would still be useful.

There is also a Zetcode tutorial. These tend to be basic, but are solid.

Also, if you going full-hog with Qt, Qt basis its code on a slight variation of MVC, called Model-View-Delegate.

The RSpec Book is what I used when I first starting learning how to test. It's a great book that covers not just how to test plain ol' ruby, but also TDD/BDD methodology. The syntax is a little dated, but it's super easy to find and learn the new syntax. PDFs are also floating around online if you don't care to buy it (although it's definitely worth the money for a used copy IMO).

> Failing that, are there any good cheatsheets/references for JS "gotchas" and unusual features that devs from other languages might not be familiar with?


There are entire books dedicated to this! (Also some entertaining talks.)


Here are some good JS books not aimed at total beginners:

• JavaScript: The Good Parts
  
• Professional JavaScript for Web Developers
  
• Effective JavaScript
  
  
  Bonus (to give you a sense of the kinds of "gotchas" you'll find in JS):
  
  
  // Even though you pass in numbers, JS sorts them lexicographically
  > [5, 1, 10].sort();
  [ 1, 10, 5 ]
  
  // You "fix" this by passing in a custom comparator
  > [5, 1, 10].sort(function(a, b) { return a - b; });
  [ 1, 5, 10 ]
  
  // This probably makes sense to someone, somewhere
  > Math.min();
  Infinity
  
  > Math.max();
  -Infinity
  
  // Some things are best left unknown
  > {} + {};
  NaN
  
  > var wat = {} + {}; wat;
  '[object Object][object Object]'
  
  Here are a bunch more in quiz form.

I love Ruby Koans.
If we're going back to other references for general programming and algorithmic knowledge I would also recommend:

• Don Knuth's "Art of Computer Programming"
  
• Abelson, Sussman and Sussman's "The Structure and Interpretation of Computer Programs" (free)
  
• Reading lots of code. Reading other people's code and learning from it is one of the most valuable reference materials around. :)
  
  Edit: "general" was the wrong word to use. Thanks worst!

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.