oj

I got bitten yesterday by a PR submitted by Orbis Security that was a one line change that actually did nothing but was used to trumpet what an amazing fix it was for a blog article which was also full of inaccuracies. The PR was useful though as it show that the supposed fix was in a function that was never called. I removed it this morning. The PR if anyone is interested is https://github.com/ohler55/oj/pull/1011

Out of curiosity, I'm looking at the JSON spec. This mildly horrifies me: "This specification allows implementations to set limits on the range and precision of numbers accepted." The spec doesn't specify a precision or range limit anywhere (just suggests that IEEE754 might be a reasonable target for interoperability, but that supports up to 64bit floats, and it looks like Oj is dropping to 32bit floats?). Python and Go don't go and change the precision of floating point numbers in their implementations, but according to the standard, they're entirely entitled to, and so is Oj. I don't see anything in https://github.com/ohler55/oj/blob/develop/pages/Modes.md#oj... specifying that Strict will force floating points to specific precision vs other implementations

Ah, I figured why on the Oj side `ruby/json` appeared slower: https://github.com/ohler55/oj/pull/949

> I should point out that other Oj modes perform much better than the JSON gem Which modes are that? https://github.com/ohler55/oj/blob/develop/pages/Modes.md#oj... I tried: Oj.dump(obj, mode: :strict) and a few others and none seemed faster than `json 2.9.1` on the benchmarks I use. Edit: Also most of these mode simply aren't correct in my opinion: >> Oj.dump(999.9999999999999, { mode: :compat }) => "999.9999999999999" >> Oj.dump(999.9999999999999, { mode: :strict }) => "1000"

There are other serializers like blueprinter [0]. I haven't used it yet, but it seems like a good (fast) AMS replacement. I also recommend using Oj [1] which is a very fast JSON parser/generator for Ruby. JSON generating through DB seems like a good idea, but imo it's a bit too complicated solution. [0] https://github.com/procore/blueprinter [1] https://github.com/ohler55/oj

Don't think it's an order of magnitude faster, but oj is supposed to be the standard for Ruby. https://github.com/ohler55/oj

Using a library like Oj[1] it is vastly faster to unpack JSON in Ruby than it is even to use the built in marshaling. It's extremely portable, performs well and is easy to debug. There really aren't many practical drawbacks to using it for transport on the same system. [1]: https://github.com/ohler55/oj

If you want json to be fast in Ruby, chances are you might want to look at 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

It seems like it boils down to use oj[0] as a parser I think... [0] https://github.com/ohler55/oj

RABL caching is still not as robust as it needs to be though, it's a shame. I use OJ to speed up the actual JSON render: https://github.com/ohler55/oj