1. Overview

In this quick article, we'll take a look at the differences between YAML and JSON through quick and practical examples.

2. Format

To have a better image, let's start by looking at the JSON and YAML representations of a simple POJO:

class Person {
    String name;
    Integer age;
    List<String> hobbies;
    Person manager;
}

First, let's look at its JSON representation:

{
    "name":"John Smith",
    "age":26,
    "hobbies":[
        "sports",
        "cooking"
    ],
    "manager":{
        "name":"Jon Doe",
        "age":45,
        "hobbies":[
            "fishing"
        ],
        "manager":null
    }
}

JSON syntax is somewhat cumbersome as it uses special syntax like curly braces {} and square brackets  []  to represent objects and arrays.

Next, let's see how the same structure would look in YAML:

name: John Smith
age: 26
hobbies:
  - sports
  - cooking
manager:
  name: Jon Doe
  age: 45
  hobbies:
    - fishing
  manager:

YAML's syntax looks a bit friendlier as it uses blank spaces to denote relations between objects and ‘‘ to represent array elements.

We can see that although both are easily readable, YAML tends to be more human-readable.

Another bonus point for YAML is the number of lines it takes to represent the same information — YAML takes only 11 lines, while JSON takes 16.

3. Size

We've seen in the previous section that YAML is represented in fewer lines than JSON, but does that mean that it takes less space?

Let's imagine a deeply nested structure with a parent and five children represented as JSON:

{
    "child":{
        "child":{
            "child":{
                "child":{
                    "child":{
                        "child":{
                            "child":null
                        }
                    }
                }
            }
        }
    }
}

The same structure would look similar in YAML:

child:
  child:
    child:
      child:
        child:
          child:
            child:

On first sight, it might look like JSON takes more space, but, in reality, JSON specification doesn't care about whitespace or newlines, and it can be shortened as follows:

{"child":{"child":{"child":{"child":{"child":{"child":{"child":null}}}}}}}

We can see that the second form is much shorter, and it occupies only 74 bytes, while the YAML format takes 97 bytes.

4. YAML Features

Besides the basic features that JSON provides, YAML comes with additional functionality as we'll see next.

4.1. Comments

YAML allows comments by using #, a feature that is often desired when working with JSON files:

# This is a simple comment
name: John

4.2. Multi-Line Strings

Another feature missing in JSON but present in YAML is multi-line strings:

website: |
  line1
  line2
  line3

4.3. Aliases and Anchors

We can easily assign an alias to a specific item using & and anchor (reference) it using *:

httpPort: 80
httpsPort: &httpsPort 443
defaultPort: *httpsPort

5. Performance

Due to the simple nature of JSON specification, its performance in parsing/serializing data is much better than YAML.

We're going to implement a simple benchmark to compare the parsing speed of YAML and JSON using JMH.

For the YAML benchmark, we're going to use the well-known snake-yaml library, and for our JSON benchmark, we'll use org-json:

@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.SECONDS)
@Measurement(batchSize = 10_000, iterations = 5)
@Warmup(batchSize = 10_000, iterations = 5)
@State(Scope.Thread)
class Bench {

    static void main(String[] args) {
        org.openjdk.jmh.Main.main(args);
    }

    @State(Scope.Thread)
    static class YamlState {
        public Yaml yaml = new Yaml();
    }

    @Benchmark
    Object benchmarkYaml(YamlState yamlState) {
        return yamlState.yaml.load("foo: bar");
    }

    @Benchmark
    Object benchmarkJson(Blackhole blackhole) {
        return new JSONObject("{\"foo\": \"bar\"}");
    }
}

As we might've expected, JSON is the winner, being approximately 30 times faster:

Benchmark             Mode  Cnt    Score   Error  Units
Main2.benchmarkJson  thrpt   50  644.085 ± 9.962  ops/s
Main2.benchmarkYaml  thrpt   50   20.351 ± 0.312  ops/s

6. Library Availability

JavaScript is the standard for the web, meaning that it's almost impossible to find a language that doesn't fully support JSON.

On the other hand, YAML is widely supported, but it's not a standard. This means that libraries exist for most popular programming languages, but due to its complexity, they might not fully implement the specification.

7. What Should I Choose?

This might be a difficult question to answer and a subjective one in many cases.

If we need to expose a set of REST APIs to other front-end or back-end applications, we should probably go with JSON as it's the de facto industry standard.

If we need to create a configuration file that will often be read/updated by humans, YAML might be a good option.

Of course, there might also be use cases where both YAML and JSON would be a good fit, and it will be just a matter of taste.

8. Conclusion

In this quick article, we've learned the main differences between YAML and JSON and what aspects to consider to make an informed decision as to which one we should choose.

Jackson bottom

I just announced the new Learn Spring course, focused on the fundamentals of Spring 5 and Spring Boot 2:

>> CHECK OUT THE COURSE
2 Comments
Oldest
Newest
Inline Feedbacks
View all comments
John
John
3 months ago

In our organisation, we try to avoid YAML as much as possible. While the apparent advantages like comments and a supposedly better readability for humans seem compelling at first, we found the sentiment to change quickly when people started spending hours searching for bugs with the indentation in their own and especially in customers’ configurations. We prefer JSON and use XML for larger, non-trivial structures. (Knowing that some people seem to hate XML’s angle brackets so much that they rather throw out all the excellent and well-defined infrastructure like XSLT, XPath, Schema Languages etc. along with it. 😉 For JSON,… Read more »

Loredana Crusoveanu
3 months ago
Reply to  John

Hi John,
Thanks for sharing your perspective! That is a problem, but there will likely be more tools and IDE features added to help debug indentation issues. YAML seems to be gaining more speed, at least for now.

Comments are closed on this article!