XML Basics and Structure

One Person, Two Formats

When two programs share information, they need a common format. XML and JSON can both represent the same information, but they organize it differently. XML uses nested tags and attributes, while JSON uses curly braces and key-value pairs. The important difference is not merely how the formats look: JSON is designed around data structures that programs already use, which makes it especially convenient for communication between programs.

XML's Nested Elements

XML structures information with nested tags. Each piece of information lives inside an element, represented by an opening tag and a closing tag. A person element can contain child elements such as name, phone, and email. This creates a hierarchy: person contains the other elements, and those elements contain their values.

<person>
  <name>Riya</name>
  <phone intl="true">555-0100</phone>
  <email>riya@example.test</email>
</person>

In this example, person is the outer element. The name, phone, and email elements are nested inside it. The value true is not the main content of phone; it is metadata attached to phone through the intl attribute in the opening tag. This separation between an element's main content and its attributes is a central part of XML's design.

The Same Data in JSON

{
  "name": "Riya",
  "phone": "555-0100",
  "phone_intl": true,
  "email": "riya@example.test"
}

The XML person tag is not given a separate JSON tag. Instead, the outer curly braces represent the object as a whole. The intl attribute is also not kept as a special kind of property attached to phone. It becomes phone_intl, an ordinary key at the same level as phone. This is a deliberate simplification: JSON treats the information as key-value pairs rather than separating element content from attributes.

Why JSON Maps Easily to Programs

JSON's main structures are objects and arrays. These correspond closely to data structures found in programming languages: dictionaries, hash maps, objects, or associative arrays for key-value data, and lists or arrays for ordered collections. Nearly all programming languages have equivalents of dictionaries and lists, so JSON can act as a shared bridge between programs.

When a program receives JSON, it can parse the data into structures that are already familiar to the language. The source explains that a Python program can receive JSON as a Python dictionary, while a JavaScript program can parse it into a JavaScript object. This direct mapping avoids the need to build a custom object model before the program can work with the data.

From One Program to Another

Suppose Program A creates data using its native dictionary-like structure. It can serialize that data into JSON and send the JSON to Program B over a network. Program B can parse the JSON into its own native object-like structure. Because both programs understand the shared JSON format, they can exchange the data even when they are written in different languages.

Mistakes Beginners Make

• Treating an XML attribute as if it were a nested child element.

  XML distinguishes the main content of an element from metadata attached as an attribute.

  Fix: Look inside the opening tag for attributes, and look between opening and closing tags for the element's main content.

• Looking for a separate attribute category in JSON.

  JSON deliberately removes the separate tag-and-attribute model.

  Fix: Represent the extra information as an ordinary key-value pair.

• Assuming XML and JSON have the same structural vocabulary.

  Curly braces define a JSON object, while XML uses opening and closing tags to define elements.

  Fix: Use the vocabulary of the format: elements, tags, and attributes for XML; objects, arrays, keys, and values for JSON.

• Choosing XML or JSON only because one looks familiar.

  The choice should reflect the data and the systems exchanging it.

  Fix: Prefer JSON when direct mapping to common programming structures and simple exchange are the main goals; use XML when an existing system or advanced metadata needs calls for it.

Check Your Understanding

The Practical Rule

XML and JSON can carry the same information, but they express structure differently. XML uses a hierarchy of nested elements and distinguishes element content from attributes. JSON uses objects, arrays, and key-value pairs, turning attributes into ordinary keys. Because those structures resemble dictionaries, objects, lists, and arrays found in nearly all programming languages, JSON usually requires less translation when programs exchange data.