Jackson
ryu
Jackson | ryu | |
---|---|---|
4 | 12 | |
2,234 | 1,162 | |
0.5% | - | |
9.5 | 5.9 | |
8 days ago | 3 months ago | |
Java | C++ | |
Apache License 2.0 | Apache License 2.0 |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
Jackson
-
Streaming Large JSON Response in Spring.
To put things simply, this method findAllStreaming() takes an OutputStream to write the whole json response into. To write json into the stream chunk by chunk we are using JsonGenerator. JsonGenerator is provided by Jackson-Core. More detailed about how to write stream event is covered in this blog post by the author of the library.
-
Are .csv files a known 'anti-pattern' and/or not a modern data format?
So do XML and JSON.
-
Ryū: fast float-to-string conversion (Java lib, 2018 paper)
Jackson already has some improvements for string-to-number conversion over stock JDK parser (https://github.com/FasterXML/jackson-core/pull/677). Would be great if they added faster number-to-string too.
-
💾 Java Records 💿 with Jackson 2.12
🐞 Report issues here if you find any
ryu
-
Printing double aka the most difficult problem in computer sciences
Nah. This is about ryu printf.
-
Parquet: More than just “Turbo CSV”
> Google put in significant engineering effort into "Ryu", a parsing library for double-precision floating point numbers: https://github.com/ulfjack/ryu
It's not a parsing library, but a printing one, i.e., double -> string. https://github.com/fastfloat/fast_float is a parsing library, i.e., string -> double, not by Google though, but was indeed motivated by parsing JSON fast https://lemire.me/blog/2020/03/10/fast-float-parsing-in-prac...
- Faster way to convert double to string, not using "%f"?
-
After obtaning a CS degree and 16 years of experience in industry, I feel somewhat confident that I can answer your programming questions correctly. Ask me anything
Me and Ryu agree that the answer should be 0.30000000000000004
-
23 years into my career, I still love PHP and JavaScript
Apparently exact minimal float-to-string conversion is more recent than I thought, and many languages used to print more (Python?) or less (PHP) decimal digits than necessary to uniquely identify the bit pattern. Python correctly prints 46000.80 + 553.04 as 46553.840000000004, but I don't know if it ever prints more digits than needed. One recent algorithm for printing floats exactly is https://github.com/ulfjack/ryu, though I'm unaware what's the state-of-the-art (https://github.com/jk-jeon/dragonbox claims to be a benchmark and the best algorithm).
-
What's the most elegant algo in your subjective view and why?
On the huge speedup side, you have the Ryū algorithm for decimal conversion (Video, Source), which is now finding its way in most standard libraries. But it isn't a hack, and a very dense, complex and precise algo, nothing like the fast-and-loose inverse square root.
-
C++ devs at FAANG companies, what kind of work do you do?
Used a wizard's magic to print "3.14" faster
-
how to make ftoa procedure from scratch
Here's a paper that details an optimized algorithm (reference implementation). It also contains a description of a correct, but slow algorithm as well as references to classic papers on the subject. Earlier the classic implementation was the dtoa one included in netlib by David Gay.
-
Dragonbox 1.1.0 is released (a fast float-to-string conversion algorithm)
At the very core of all these theoretical stuffs, there is the theory of continued fractions. This is an immensely useful monster which I even dare call as the ultimate tool for floating-point formatting/parsing that everyone who wants to contribute in this field should learn. Before I learned continued fractions, my main tool for proving stuffs was the minmax Euclid algorithm (which is one of the greatest contributions of the wonderful Ryu paper), but it turns out that it is actually just a quite straightforward application of the theory of continued fractions. The main role minmax Euclid algorithm played was to estimate the maximum size of possible errors, but with continued fractions it is even possible to find the list of all examples that generate errors above a given threshold. This is something I desperately wanted but really couldn't do back in 2020.
-
FastDoubleParser: Java port of Daniel Lemires fast_double_parser
Ryū algorithm, the converse (doubles to strings), is also much faster than using Java's number formatting classes.
https://github.com/ulfjack/ryu/blob/master/src/main/java/inf...
What are some alternatives?
Moshi - A modern JSON library for Kotlin and Java.
dragonbox - Reference implementation of Dragonbox in C++
jsoniter - jsoniter (json-iterator) is fast and flexible JSON parser available in Java and Go
C++ Format - A modern formatting library
Gson - A Java serialization/deserialization library to convert Java Objects into JSON and back
concise-encoding - The secure data format for a modern world
Yasson - Eclipse Yasson project
proust - Compiling implementation of mustache
Genson - Genson a fast & modular Java <> Json library
rapidgzip - Gzip Decompression and Random Access for Modern Multi-Core Machines
HikariJSON - High-performance JSON parser
itoa - Fast integer to ascii / integer to string conversion