XML Beginner Level Course

Lesson 1 • Setting Up Your XML Environment

Guides students through selecting and configuring tools to write and view XML. Ensures every student has a working environment before writing any code.

Lesson 2 • History and Design Goals of XML

Traces XML's origin from SGML and the goals set by its designers. Provides context for understanding why XML rules are structured as they are.

Lesson 3 • What XML Is and Why It Matters

Defines XML as a markup language for structured data storage and transport. Grounds the chapter by contrasting XML with plain text and binary formats.

Lesson 1 • Elements, Tags, and Nesting Rules

Covers start tags, end tags, empty elements, and proper nesting hierarchy. Students practise building valid element trees without crossing or unclosed tags.

Lesson 2 • The XML Declaration and Prolog

Explains the optional XML declaration, version, encoding, and standalone attributes. Sets the foundation for every XML document students will write.

Lesson 3 • Text Content and Special Characters

Addresses how text nodes work inside elements and how reserved characters must be escaped. Prevents common syntax errors caused by unescaped symbols.

Lesson 4 • Attributes: Syntax and Best Practices

Teaches how to add attributes to elements, including quoting rules and uniqueness constraints. Distinguishes when to use attributes versus child elements.

Lesson 1 • Introduction to XML Schema (XSD)

Surveys XSD as the primary modern validation language for XML. Students read a simple XSD and match it to a corresponding XML instance.

Lesson 2 • Document Type Definitions Overview

Introduces DTD syntax for declaring elements and attributes. Provides a historical baseline before students move to modern schema languages.

Lesson 3 • Introduction to XML Validation

Explains the concept of validating XML against a schema or grammar. Motivates validation as a quality gate in data exchange workflows.

Lesson 1 • Declaring and Using Namespaces

Covers the xmlns attribute, default namespaces, and prefixed namespaces. Students annotate elements and attributes with correct namespace declarations.

Lesson 2 • Practical Namespace Patterns

Presents common namespace patterns found in real XML standards. Students recognise and replicate these patterns in their own documents.

Lesson 3 • The Problem Namespaces Solve

Demonstrates name collision scenarios that arise when combining XML vocabularies. Motivates namespace syntax as the standard solution to this problem.

Lesson 1 • Predicates and Filtering Nodes

Introduces predicates in square brackets to filter node sets by position or condition. Students narrow query results to exactly the nodes they need.

Lesson 2 • XPath Data Model and Nodes

Explains the tree of nodes XPath operates on, including element, attribute, and text nodes. Builds the mental model needed before writing any expressions.

Lesson 3 • Location Paths and Axes

Teaches absolute and relative location paths and the axis specifiers that navigate the tree. Students write paths to reach any node in a sample document.

Lesson 4 • XPath Functions and Operators

Covers built-in string, numeric, and boolean functions used in XPath expressions. Enables students to write expressive queries beyond simple path navigation.

Lesson 1 • XSD Document Anatomy

Breaks down the xs:schema root element, namespace declarations, and top-level components. Students recognise and replicate the skeleton of any XSD file.

Lesson 2 • Complex Types and Content Models

Teaches xs:complexType with sequence, choice, and all compositors. Students model real-world data structures with optional and repeating child elements.

Lesson 3 • Built-in Simple Types and Restrictions

Surveys XSD built-in types and shows how facets restrict their value space. Students constrain string length, numeric ranges, and date formats precisely.

Lesson 4 • Reuse Through Named Types and Groups

Demonstrates named complex types, element groups, and type extension for schema reuse. Students refactor redundant schema sections into shared, referenced components.

Lesson 1 • Outputting Content and Formatting

Teaches xsl:value-of, xsl:element, xsl:attribute, and xsl:output for controlling result content. Students generate well-structured HTML from an XML source.

Lesson 2 • XSLT Architecture and Processing Model

Explains how an XSLT processor merges a source tree with a stylesheet to produce a result tree. Establishes the conceptual framework before any template writing.

Lesson 3 • Templates and Pattern Matching

Covers xsl:template, match patterns, and how the processor selects templates. Students write templates that fire on specific elements and produce output.

Lesson 4 • Conditional Logic and Loops in XSLT

Introduces xsl:if, xsl:choose, and xsl:for-each for dynamic output generation. Students produce output that varies based on data values in the source XML.

Lesson 1 • StAX: Pull-Based XML Parsing

Presents StAX as a cursor-based pull parser that gives developers control over iteration. Students write loops that advance the cursor and process only needed events.

Lesson 2 • DOM Parsing: Loading and Navigating

Explains the Document Object Model tree loaded into memory by a DOM parser. Students traverse nodes, read element content, and access attribute values in code.

Lesson 3 • Writing XML Programmatically

Demonstrates generating well-formed XML output from code using writer APIs. Students produce XML files from structured data without manual string concatenation.

Lesson 4 • SAX Parsing: Event-Driven Processing

Introduces SAX as a streaming, event-driven alternative to DOM for large files. Students implement handler methods that react to start element, end element, and character events.