
Benchmarking JSON Generation in Ruby - bretthopper
http://techblog.thescore.com/benchmarking-json-generation-in-ruby/
======
rb2k_
If you want json to be fast in Ruby, chances are you might want to look at
[https://github.com/ohler55/oj](https://github.com/ohler55/oj)

Not sure how easy it is to jam oj into either of these two serializers though.

EDIT: rabl seems to support it according to the webpage

~~~
bretthopper
These benchmarks are already using OJ:
[https://github.com/thuva/json_serialization_benchmark/blob/m...](https://github.com/thuva/json_serialization_benchmark/blob/master/Gemfile#L4)

edit: although not sure it's being used properly yet

~~~
mrinterweb
I forked and fixed the ActiveModel::Serializer and presenter examples to us Oj
with MultiJson. I was unable to get rabl to work with the Oj engine for some
reason. I didn't feel like spending any extra time to track it down. Anyway,
from the benchmark, I was seeing that the Oj json serializer was approximately
3-10x faster than the normal to_json method.

[https://github.com/mrinterweb/json_serialization_benchmark](https://github.com/mrinterweb/json_serialization_benchmark)

~~~
ttharma
Including Oj in Gemfile and not using it properly has caused some confusion.
The original purpose of the benchmark was to test the relative performance of
RABL, AMS, and presenters. In that case, the choice of the JSON library should
not matter.

Having said that, it would still be nice to see the best performance we can
get out of the 3 tools we're benchmarking. But, we need to get Oj working with
all 3 of them in order to avoid unfair comparison of performance.

------
rubyn00bie
I've had the exact same experience. Rabl is horribly slow in template
generation...

Also, FWIW-- older versions of AMS, with caching, are a total crapshoot due to
marshal dumping the objects into the cache and re-serializing them to JSON
each time. Much better to cache the response itself instead of the objects
making up the response.

Granted the caching feature was yanked out of AMS, but pretty painful for
those of us that actually tried using it. Carrierwave + AMS caching =
Problemzilla

At this point, we too have had Rabl, AMS, and Representers and the best one of
the lot-- by far, for our use cases has been: Roar.
[https://github.com/apotonick/roar-rails](https://github.com/apotonick/roar-
rails)

Plus, it's the only system which will de-serialize the data using the
representer. Boom-shaka-laka.

------
steveklabnik
AMS maintainer (though admittedly doing a poor job of it lately :/) here.

Which version were you benchmarking? The in-alpha 0.9 was a total re-write, so
it'd be interesting to see how it compares.

Also, AMS has a caching feature (that is being re-written, too) that'd make
for an interesting benchmark.

~~~
josai
Can I take this response as a sign AMS is not abandonware?

Some of us are getting concerned...

~~~
steveklabnik
There was just a thread on the ML the other day about a new plan forward,
actually.

------
shadeless
No mention of jbuilder? When I looked at the popularity of json generators it
seemed to be the most popular one, but now it occurred to me that it may be
because it's included by default in Rails.

~~~
bretthopper
It would be great if someone familiar with JBuilder could make a PR to add
support for it. It would actually be pretty simple to add.

