0:00
Now let's compared JSON and XML.
0:02
This is actually a hotly debated comparison right now.
0:05
There are signification overlap in
0:08
the usage of JSON and XML.
0:10
Both of them are very
0:12
good for putting semi-structured data
0:14
into a file format
0:16
and using it for data interchange.
0:18
And so because there's so
0:20
much overlap in what they're used
0:21
for, it's not surprising that there's significant debate.
0:24
I'm not gonna take sides.
0:26
I'm just going to try to give you a comparison.
0:28
Let's start by looking at the
0:29
verbosity of expressing data in the two languages.
0:33
So it is the case
0:34
that XML is in general,
0:36
a little more verbose than JSON.
0:38
So the same data expressed in
0:40
the 2 formats will tend to
0:41
have more characters in XML than JSON
0:43
and you can see that
0:44
in our examples because our big
0:47
Json example was actually pretty
0:48
much the same data that we used when we showed XML.
0:51
And the reason for
0:52
XML being a bit more
0:53
verbose largely has to
0:55
do actually with closing tags,
0:57
and some other features.
0:59
But I'll let you judge
1:01
for yourself whether the somewhat
1:03
longer expression of XML is a problem.
1:06
Second is complexity, and here,
1:08
too, most people would say
1:09
that XML is a bit more complex than JSON.
1:12
I'm not sure I entirely agree with that comparison.
1:16
If you look at the subset
1:18
of XML that people really
1:19
use, you've got attributes,
1:21
sub elements and text, and
1:23
that's more or less it.
1:24
If you look at Json, you got
1:25
your basic values and you've got your objects and your arrays.
1:28
I think the issue is that
1:30
XML has a lot of
1:31
extra stuff that goes along with it.
1:33
So if you read the entire XML specification.
1:36
It will take you a long time.
1:38
JSON, you can grasp the
1:40
entire specification a little bit more quickly.
1:43
Now let's turn to validity.
1:44
And by validity, I mean the
1:46
ability to specify constraints or
1:49
restriction or schema on
1:51
the structure of data
1:53
in one of these models, and
1:54
have it enforced by tools or by a system.
1:57
Specifically in XML we
1:59
have the notion of document type
2:00
descriptors, or DTDs, we also
2:03
have XML Schema which
2:05
gives us XSD's, XML Schema Descriptors.
2:08
And these are schema like
2:10
things that we can specify, and
2:12
we can have our data checked to
2:13
make sure it conforms to the
2:14
schema, and these are, I would say,
2:16
fairly widely used at this point for XML.
2:19
For JSON, there's something called JSON Schema.
2:21
And, you know, similar to
2:24
XML Schema, it's a way
2:26
to specify the structure and then
2:27
we can check that JSON conforms
2:29
that and we will see some of that in our demo.
2:33
The current status, February
2:35
2012 is that this is
2:37
not widely used this point.
2:39
But again, it could really just be evolution.
2:42
If we look back
2:44
at XML, as it was originally
2:46
proposed, probably we didn't
2:48
see a whole of lot of use
2:49
of DTDs, and in fact not
2:51
as XSDs for sure until later on.
2:53
So we'll just have to see whether JSON evolves in a similar way.
2:57
Now the programming interface is where JSON really shines.
3:01
The programming interface for XML can be fairly clunky.
3:05
The XML model, the attributes
3:08
and sub-elements and so on,
3:09
don't typically match the model
3:11
of data inside a programming language.
3:14
In fact, that's something called the impedance mismatch.
3:17
The impedance miss match
3:19
has been discussed in database
3:21
systems actually, for decades
3:23
because one of the original
3:25
criticisms of relational database
3:27
systems is that the data
3:28
structures used in the database,
3:30
specifically tables, didn't match
3:32
directly with the data structures and programming languages.
3:35
So there had to be some manipulation
3:35
at the interface between programming languages and the database system and that's the mismatch.
3:39
So that same impedance mismatch
3:43
is pretty much present
3:45
in XML wherein JSON is
3:48
really a more direct mapping
3:50
between many programming languages and the structures of JSON.
3:54
Finally, let's talk about querying.
3:56
I've already touched on this
3:57
a bit, but JSON does not
3:59
have any mature, widely
4:01
used query languages at this point.
4:04
for XML we do have
4:05
XPath, we have XQuery,
4:07
we have XSLT.
4:10
Maybe not all of
4:11
them are widely used but there's
4:13
no question that XPath at least and
4:15
XSL are used quiet a bit.
4:17
As far as Json goes there
4:19
is a proposal called Json path.
4:21
It looks actually quiet a lot
4:22
like XPath maybe he'll catch on.
4:25
There's something called JSON Query.
4:27
Doesn't look so much like
4:29
XML Query, I mean, XQuery.
4:32
and finally, there has been a
4:33
proposal called JAQL for the JSON query language, but
4:37
again as of February 2012
4:39
all of these are still very
4:40
early, so we just don't know what's going to catch on.
4:43
So now let's talk about the validity of JSON data.
4:46
So do JSON data that's
4:48
syntactically valid, simply needs
4:50
to adhere to the basic structural requirements.
4:53
As a reminder, that would be
4:54
that we have sets of label
4:56
value pairs, we have arrays
4:57
of values and our values
4:59
are from predefined types.
5:01
And again, these values here are defined recursively.
5:05
So we start with a JSON
5:06
file and we send
5:07
it to a the parser
5:09
may determine that the file
5:11
has syntactic errors or if
5:12
the file is syntactically correct then
5:15
it can parsed into objects in a programming language.
5:18
Now if we're interested in semantically
5:20
valid JSON; that is
5:22
JSON that conforms to
5:23
some constraints or a schema,
5:25
then in addition to checking the
5:26
basics structural requirements, we check
5:28
whether JSON conforms to the specified schema.
5:31
If we use a language like JSON
5:32
schema for example, we put
5:34
a specification in as a
5:36
separate file, and in
5:38
fact JSON schema is expressed in
5:40
JSON itself, as we'll see
5:41
in our demo, we send it
5:43
to a validator and that
5:44
validator might find that there
5:46
are some syntactic errors or
5:47
it may find that there are
5:48
some symantic errors so the
5:49
data could to be correct syntactically
5:52
but not conform to the schema.
5:54
If it's both syntactically and semantically
5:56
correct then it can move
5:57
on to the parser where
5:58
will be parsed again into
6:00
objects in a programming language.
6:02
So to summarize, JSON stands for Java Script Object Notation.
6:06
It's a standard for taking data
6:08
objects and serializing them into a format that's human readable.
6:12
It's also very useful for
6:13
exchanging data between programs,
6:16
and for representing and storing
6:18
semi-structured data in a flexible fashion.
6:21
In the next video we'll go
6:23
live with a demonstration of JSON.
6:25
We'll use a couple of JSON
6:26
editors, we'll take a
6:28
look at the structure of JSON
6:30
data, when it's syntactically correct.
6:32
We'll demonstrate how it's very
6:34
flexible when our data might
6:35
irregular, and we'll also
6:37
demonstrate schema checking using
6:40
an example of JSON's schema.