Newsletter

An Introduction to YAML (YAML Ain't Markup Language)

Tyler W. Phass

Tyler W. Phass

— 7 min read

Welcome back, aspiring developers and coding enthusiasts!

In this edition of The Tome of Zeal, we are delving into the fascinating world of YAML (YAML Ain't Markup Language), a versatile data serialization format that is particularly popular among developers for its human-readable and straightforward syntax. YAML, like JSON, serves as an excellent tool for data exchange and storage, and understanding it will enhance your coding abilities and open up new opportunities in your development projects.

What is YAML?

YAML, as the name suggests, is not a markup language like XML, but rather a data serialization language. It was designed to be easy for both humans and machines to read and write, making it a developer-friendly choice for configuration files, data exchange between systems, and more. Although initially inspired by the syntax of Python, YAML is language-independent, making it compatible with a wide range of programming languages.

YAML is particularly favored for its readability, as it uses indentation and whitespace to define data structures, similar to Python. This characteristic makes it easy to grasp the structure of complex data, even when examining it directly.

How is YAML Used?

YAML finds its application in various domains, just like JSON. It is commonly used for configuration files in projects, particularly in web development, where it allows developers to define settings and parameters in a human-readable format. Additionally, YAML is widely employed in container orchestration tools like Kubernetes, as it simplifies the definition of complex configurations.

Data Types Supported by YAML

YAML supports various data types. Understanding these types is fundamental to working effectively with YAML. If data types are new to you, don’t feel overwhelmed! Just take note of how each data type is meant to represent a specific kind of value in our data structure:

  • Strings: Strings are sequences of characters. They are enclosed in double quotes (e.g., "Hello, World!") and can contain letters, numbers, symbols, and special characters. You don't always have to use double quotes in YAML, but there are cases where you must.
  • Numbers: Numbers can be integers or floating-point numbers. They are written as plain values without quotes.
  • Booleans: Booleans represent true or false values. In YAML, they are expressed as lowercase "true" and "false."
  • Arrays: Arrays in YAML are represented using a list format, where values are listed sequentially, each on a new line and indented. Lists can contain any data type, including other lists and objects.
  • Objects: YAML objects are analogous to JSON objects. They are represented as key-value pairs, where the key and value are separated by a colon. Objects are also indented under their parent key.
  • Null: YAML supports the null value, which indicates the absence of a value.

YAML Syntax Basics

Let's explore the YAML syntax with some basic examples.

Objects

In YAML, we represent objects with indentation:

name: John Smith
age: 30
isDeveloper: true
programmingLanguages:
  - JavaScript
  - Python
  - Java

This YAML represents a data structure that contains information about a person, particularly a developer named John Smith. Here's an explanation of each key-value pair:

  1. name: John Smith

    • Key: name

    • Value: John Smith

    • Explanation: This key-value pair indicates the name of the person, which is "John Smith"

  2. age: 30

    • Key: age

    • Value: 30

    • Explanation: This key-value pair indicates the age of the person, which is 30 years old.

  3. isDeveloper: true

    • Key: isDeveloper

    • Value: true

    • Explanation: This key-value pair indicates whether the person is a developer or not. In this case, the value true indicates that John Smith is indeed a developer.

  4. programmingLanguages: (List)

    • Key: programmingLanguages

    • Value: List of programming languages

    • Explanation: This key represents the programming languages known by John Smith The value is a list that contains three programming languages: "JavaScript," "Python," and "Java." Each programming language is represented as a separate element in the list.

So, overall, this YAML structure provides information about a person named John Smith, who is 30 years old and is a developer familiar with three programming languages: JavaScript, Python, and Java.

Nested Objects

In YAML, nesting objects follows the same indentation principles. Here is an example of an object (user) that contains a nested object (address):

user:
  name: Jane Doe
  age: 25
  address:
    city: New York
    country: USA

Let's break down each key-value pair:

  1. user: (Object)

    • Key: user

    • Value: Object containing user details

    • Explanation: The key user represents an object that holds detailed information about Jane Doe

  2. name: Jane Doe

    • Key: name

    • Value: Jane Smith

    • Explanation: Within the user object, the key name indicates the name of the user, which is "Jane Doe"

  3. age: 25

    • Key: age

    • Value: 25

    • Explanation: Still within the user object, the key age indicates the age of Jane Doe, which is 25 years old.

  4. address: (Nested Object)

    • Key: address

    • Value: Nested object containing address details

    • Explanation: Within the user object, the key address represents another object that holds Jane Doe's address details.

  5. city: New York

    • Key: city

    • Value: New York

    • Explanation: Within the address object, the key city indicates the city where Jane Doe resides, which is "New York."

  6. country: USA

    • Key: country

    • Value: USA

    • Explanation: Within the address object, the key country indicates the country where Jane Doe lives, which is "USA."

Therefore, this YAML structure provides information about a user named Jane Doe. Jane is 25 years old and resides in New York, USA. The data is organized hierarchically using nested objects, making it easy to represent complex data structures like user profiles, addresses, and more.

Arrays

Arrays in YAML use a list format. Here is an example of an array that is a list of fruits:

fruits:
  - apple
  - banana
  - orange
  - grape

Each element within the array (item within the list), is represented by a - symbol and indentation that occurs underneath the key (“fruits”) given to the array.

Nested Arrays

Just like objects, arrays in YAML can contain nested objects and/or arrays. Let’s look at an example of a YAML structure that illustrates nested arrays.

students:
  - name: John Smith
    age: 30
    courses:
      - Mathematics
      - Physics
      - Chemistry
  - name: Jane Doe
    age: 25
    courses:
      - English
      - History
  - name: Michael Johnson
    age: 20
    courses:
      - Computer Science
      - Data Structures
      - Algorithms
university: ABC University
location: New York

This YAML structure represents data related to students, their courses, and university information. Let's look closer at each key-value pair:

  1. students: (Array)

    • Key: students

    • Value: List of student objects

    • Explanation: The key students represents an array of student objects, each containing details about a specific student.

  2. Student Object 1

    • name: John Smith

    • age: 30

    • courses: (Array)

      • Mathematics

      • Physics

      • Chemistry

    • Explanation: The first element in the students array is an object representing a student named John Smith, who is 30 years old. The courses key holds an array of three courses: "Mathematics," "Physics," and "Chemistry." This indicates that John Smith is enrolled in these three courses.

  3. Student Object 2

    • name: Jane Doe

    • age: 25

    • courses: (Array)

      • English

      • History

    • Explanation: The second element in the students array is an object representing a student named Jane Doe, who is 25 years old. The courses key holds an array of two courses: "English" and "History." This indicates that Jane Doe is enrolled in these two courses.

  4. Student Object 3

    • name: Michael Johnson

    • age: 20

    • courses: (Array)

      • Computer Science

      • Data Structures

      • Algorithms

    • Explanation: The third element in the students array is an object representing a student named Michael Johnson, who is 20 years old. The courses key holds an array of three courses: "Computer Science," "Data Structures," and "Algorithms." This indicates that Michael Johnson is enrolled in these three courses.

  5. university: ABC University

    • Key: university

    • Value: ABC University

    • Explanation: This key-value pair provides information about the university where the students are enrolled. In this case, the university is "ABC University."

  6. location: New York

    • Key: location

    • Value: New York

    • Explanation: This key-value pair indicates the location of the university. In this case, the university is located in "New York."

In summary, this YAML structure represents a collection of students and their course enrollments at ABC University in New York. It is able to do so due to the power of nested arrays.

Null

In YAML, the keyword null is used to represent the absence of a value or an unknown value.

For example, this YAML pattern might be used in scenarios where the presence of a website key is necessary for data organization, but the actual website value is not yet available or is not applicable at the moment. It allows developers to define the key and handle its absence or unknown value gracefully in their applications:

website: null

This YAML structure contains a single key-value pair. Let’s break it down.

  1. website: null

    • Key: website

    • Value: null

    • Explanation: The key website represents the name of a website or web application. The corresponding value is null, which indicates the absence of a value for the website.

In this case, the website key exists, but its value is explicitly set to null, indicating that there is no specific website associated with this data.

Real World Examples of YAML

YAML is widely used in configuration files and data exchange between applications and services. It provides a more human-readable alternative to JSON, especially for configuration files, where readability is essential.

Here is an example of what a common Kubernetes configuration YAML file might look like:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: example-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: example-app
  template:
    metadata:
      labels:
        app: example-app
    spec:
      containers:
      - name: example-container
        image: nginx:latest
        ports:
        - containerPort: 80

Breaking it Down

This Kubernetes YAML file defines a simple Deployment that ensures there are three replicas of an Nginx web server running. The Deployment uses a selector to label the Pods, and the template specifies the container to use, which in this case is the Nginx container listening on port 80.

Note: This is a basic example to illustrate the structure of a Kubernetes YAML file. In real-world scenarios, additional configurations, such as resource requests, resource limits, environment variables, and other settings, are typically included to fine-tune the application deployment and manage resources effectively.

Write Your Own YAML Files

Now that you've grasped the basics of YAML, you can start crafting your YAML files. Simply use a text editor that supports plain text and save the files with a `.yaml` or `.yml` extension. Both extensions refer to YAML files, and they can be used interchangeably without any functional difference. YAML files with either extension are processed and read in the same way by YAML parsers.

Wrapping Up

We hope you've found this introduction to YAML both enlightening and inspiring! In this lesson, we explored YAML and its use as a versatile data serialization format. Stay tuned for more coding adventures and development wisdom in the upcoming editions of The Tome of Zeal.

Subscribe

Read more