While we're talking about serialization formats, we can't forget about YAML.

YAML stands for yet another markup language, and

is a common serialization format in use today by many Ruby projects.

YAML is also a plain-text format, and you can find parsers for

it in many languages besides Ruby.

Let's take a look at working with YAML now, using workspaces.

Now we're gonna take a look at YAML.

Now we'll have the link to the YAML documentation right below the video, so

go ahead and check that out.

YAML is another markup language, and the way that YAML is represented

is usually with three dashes and then the data type.

Now let's go ahead and see how that works.

Ruby includes built in serializers for most classes to YAML.

So first we'll have to require it like we're used to and

we'll say my_hash = { name: "Jason",

email: "jason@teamtreehouse.com" }.

Now, if we wanted to dump this out using YAML serialization,

we would say YAML.dump(my_hash).

And that would be a string representation, but that's kind of hard to read.

What this would actually look like with those escape characters is the following.

So we have the three dashes and then the hash key, name and

hash key email with a colon separating the data.

Say my_hash[year] = 2015.

And you can see we don't need to do anything special for that to work.

It will automatically work with numbers and strings as well.

Similarly to outputting the YAMLl, we can load YAML.

One of the easiest ways to do that is using the load file method.

I've prepared an example YAML file, which has an array of hashes.

We represent an array with a dash for each separate item.

If I scroll down here, I'm going to clear my screen, and

we could say YAML.load_file.

And pass at the name of the file, which is example.yml.

And that will return our array of hashes after reading it from the file.

And so we could assign that to a variable if we wanted to.

And then we would have access to this people array.

Similarly, we could call to YAML on that and we would get a string back,

so we'll say yaml_output i= people.to_yaml.

And just like load file, we could serialize this back again

using the load method which takes a string rather than a file location.

YAML.load (yaml_output) returns another Ruby object.

Now, once again, security considerations with YAML

is that you don't wanna load untrusted data with it.

It's unsafe and could compromise the security of your program.

YAML's very useful for configuration files,

A lot of Rubyists have traditionally used YAML to store application configuration.

Go ahead and try working with YAML on your own now using work spaces.