This is going to be brief one: iRead.ro, one of the projects I’m working on during my spare time, was giving me major headaches lately – 2 weeks ago, it took like 15 seconds to render a page. In the last couple of days, it was taking somewhere around 100 seconds to render it; obviously too much for the nginx server that was running my two mongrels.
I *had* indexed my tables, by id, url and several other fields. Turns out, they weren’t indexed with the right columns.
Other blogs about Ruby or Rails have already touched some of the tips I’m going to show, but it never hurts to remind you these small recipes aimed at Ruby novices:
To my shame as a rubyist, it was only a couple of hours ago that I found out, while reading Ruby Inside about mod_rails and the wonders it does for the Rails community.
(more…)
Got myself a sleepless night recently and killed some time reading the Rubyisms in Rails book. The chapter about Iterators was particularly pleasant, reminding me the beauty of Ruby’s Enumerable class – feels so Lisp-ish and Scheme-ish to write stuff like col.select{..}.collect{..}.join(“, “)
For the curious, here’s a cool excerpt from the book, with Enumerable’s most important methods:
Examples of Enumerable’s Higher-Level Iterators
Selection
common = bird.select {|bird, count| count > 5 }
rare = bird.reject { |bird, count| count > 5 }Accumulation (summing up values)
sightings = birds.inject {|total, bird| total += b.count}Detection
indie = jukebox.any? {|x| x.artist.hip? }Searching
Winner = contestants.find {|p| p.has_answer? }Reordering
titles = jukebox.sort_by {|x| x.title }Partitioning
quick, dead = people.partition {|p| p.can_outrun? :bear }Recombination
blind_dates = restaurants.zip(men, women)
Go ahead, read the docs and use Enumerable without restraints – your code will look much more beautiful and, well.. Rubyish.
Ruby is so powerful it scares me. I’m far from even grasping how powerful it is. Whenever I discover something cool to do with it, I have the urge to tell it to the world.
First, here’s the context:
I’m currently working my way through building a Rails browser game in the style of these ones. For simplicity’s sake, think of it as a RPG-style game.
I have an Avatar object that belongs_to Race and Occupation.
The avatar, race and occupation have several common properties: mana, health, reactivity, initiative, etc. The avatar has its own health, mana or reflexes value, but when I access them I want to sum them up with the corresponding values stored in the Race and Occupation; this means that the race and occupation you chose when creating the avatar will impact the character’s features throughout the game.
What I could do was to define accessor methods for each property:
def get_mana
mana+race.mana+occupation.mana
end
def get_health
health+race.health+occupation.health
end
While it works just fine, the problem of this approach is that it’s not DRY(Don’t Repeat Yourself) – if I have tens of such common properties, I end up having tens of similar methods which differ only by the name of the property. So what I wanted to do was to have a method similar to the attr_reader one, with my own body instead.
If you are interested in web, databases and the like then you probably already heard of SQLITE. If not, here’s a quick intro
SQLITE is a database engine that uses just one file per database. It’s tiny, simple to use and, most importantly, very easy to use with Ruby on Rails. All you need is the sqlite ruby gem, which is already included in most Ruby installations.
What is sqlite3? Nothing much than a newer and better version of sqlite. You should use it instead of sqlite if you have the chance.
How do you set it up in Rails?
Let’s say you want to make your own database-driven Rails application. Mysql is a big download, a bit difficult to install, etc. Plus, you don’t really need it; you just want a tiny sql database engine that works with Rails, so you can develop and test your application.
Nothing easier: if not already installed on your machine, then you download and install sqlite3.
Then you make sure you have the latest sqlite bindings in place : gem install sqlite3 .
Hmm.. what else?
My assignment this week, as senior Ruby on Rails developer for TrexGlobal (an US startup with some cool online apps for real estate investors that help you save lots of dollars on your taxes) was to add tests for some of the controllers in place.
Yes, I know, we should have used TDD(Test Driven Development) and write our tests BEFORE or along with our development, but, you see, in practice this kind of things rarely happens, there are always time constraints and last minute refactorings. Plus, I didn’t have much rails testing experience before this; but it’s never too late to learn, is it?
The main issue here was that the big book Agile Web Development with Rails (Pragmatic Programmers)
You can’t call yourself a programmer if you never used Grep (or diff, or wget, or regular expressions for the matter). I couldn’t call myself a programmer till the fourth year of college, btw.. 
Still, grep has a pretty big manual page, and being a casual grep user I never see the need to memorize it. The one and only grep command I use and abuse is
grep -Rn "my pattern" . which, for people not familiar with it, means “search my pattern in all files under the current dir, recursively, and if find then print out also the line number”. Seriously, this might be the one and only use I have for grep now.
What about more complicated tasks, involving regular expressions and the like?
Since my job involves Ruby and Rails, there’s basically no need for me to use grep anymore. I mean, my tasks don’t involve real-time text line extractions; from time to time, though, they involve writing scripts that extract specific patterns from some log file.
Here’s where Ruby is my best friend. And given that I’ve had a bit of trouble putting together the bits and pieces found on the internet, I’m sticking it all together here:
My cool colleagues from Trex Global gave me an unusual assignment this week: profile the current implementation of our first two apps, DeferEm and DepreciateEm.
Among the requests, the usual ones:
Request response duration
Execution profile of flow (path taken, time in methods)
SQL Queries made
Analyze and Identify performance bottlenecks - in-memory, sql query exec
