So friends, in this particular video, what I want to do to talk to you about
the concept
of serialization.
And no, I know what you're thinking.
This is not about watching a whole bunch of serial killer documentaries on
Netflix.
This is actually related to the management of data.
Yeah, no, much, much less exciting, but we have to talk about it, so let's get
to it.
No, but seriously, serialization is actually very, very useful.
Okay, John.
What actually is it? Well, when we're talking about serialization, all we're WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
What actually is it? Well, when we're talking about serialization, all we're
talking about
is the ability to transform data based on a particular real set.
Now, the question is, is what set of roles are we even actually talking about?
We're talking about the roles of the actual file format that the data is adher
ing to.
Hmm, okay, that sounds not so clear.
Well, what file formats could this be?
Well, we're talking about things like JSON or XML, or perhaps one we have
definitely
seen already.
And this is the YAML file format. WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
And this is the YAML file format.
So when we happen to be utilizing these particular file formats, we really are
utilizing data
serialization.
Take, for example, YAML, as we have already seen it, we know when we happen to
utilize YAML,
we're not just getting a big string blob.
We're actually getting data in a programmatic manner, meaning that if we want
to access
particular object, you know, so that means we can specify particular keys to
return very
particular values within the data sets.
And ultimately, what this is all about, it's about giving us the ability to
store this data
in a programmatic manner or even perhaps transmit the data over the wire. WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
in a programmatic manner or even perhaps transmit the data over the wire.
Safe example, you want to share this data over a network.
Then we would like that data to be serialized in one of these type of file
formats.
Now, the question that I had when I first heard about this is, why do we even
need to do
such a thing?
This makes no sense.
We have programming languages.
Safe example, if I happen to create a Python dictionary, well, this is
definitely program
logic data.
This data can be stored with any Python file.
Why use something different like YAML or JSON or XML? WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
Why use something different like YAML or JSON or XML?
This just seems like unnecessary information that I need to know about.
Ah, but it actually is not.
Let me show you why.
So let's imagine we have a little application over here.
And let's imagine that, oh, I don't know.
Let's say it's written in the Rust programming language.
And also, let's imagine we have another application all the way over here.
And let's imagine this one was written in Python.
So let's suppose I had some data that I wanted to share across the network and
be accessible WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
be accessible
or processed by a completely different application entirely.
This one over here.
Well, let's say I happen to store this data in a programmatic manner, utilizing
things
like Python dictionaries.
And then I send this over to this other application, which uses a completely
different programming
language.
Well, quite simply, the Rust programming language, if you had to show it a
Python dictionary,
it would just shrug its shoulders and say, who are you?
What are you?
Where did you come from?
What is this?
Rust has a completely different way of processing data.
The objects in Python do not make sense in Rust. WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
The objects in Python do not make sense in Rust.
It's almost kind of like this application here, store to information in German.
And it sent it over to this application here, the only spoke French.
How useful is the data that we have encoded in German?
If it's been sent only to a French reading application, not very useful as it's
.
But essentially, what we're looking for here is some type of neutrality.
So we can store our data in a manner that we don't have to worry about.
It being locked in to some type of programming language, whilst retaining the WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
It being locked in to some type of programming language, whilst retaining the
benefits of
programmability.
And we have a way to transmit that data across different code bases.
So now the transaction looks much more like this.
Here is our application.
Let's maybe say it's written in the Go programming language.
And the second application is over here.
Again, let's just say it's written in Python.
Now if this application stores its data, say for example, in JSON, this can be
freely transmitted
over the wire and ingested by the Go application.
And the data can effectively be reconstructed within Go.
And now the application can make sense of it. WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
And now the application can make sense of it.
This is the type of thing that we're talking about here.
Now, like I say, there are different implementations and different rules.
It's depending on the file format we use.
We can have like I say, JSON, XML, YAML, a whole bunch of others.
But the first one that I want to talk about is this one right here.
It is super, super popular.
And that one is JSON.
So let's talk about that in the very next video.