RDF Serialization

Turtle (Terse RDF Triple Language) is a widely adopted, human-readable text format for RDF. It provides a compact and intuitive syntax using prefix declarations and shorthand notations like ; and , to group triples with common subjects or predicates.

• Key Features: Supports all RDF 1.1 concepts, including blank nodes and collections. It is the primary authoring format for ontologies.
• Example: ex:Alice ex:knows ex:Bob .
• Use Case: The preferred format for manual ontology editing, documentation, and sharing due to its clarity.

RDF/XML is the original, XML-based serialization format standardized by the W3C. It represents RDF triples as nested XML elements and attributes, making it compatible with the vast ecosystem of XML tools.

• Key Features: The canonical format for RDF 1.0. It is verbose and can be challenging to read or write manually.
• Example: <rdf:Description rdf:about="http://example.com/Alice"><ex:knows rdf:resource="http://example.com/Bob"/></rdf:Description>
• Use Case: Legacy system integration and scenarios requiring strict XML validation or processing pipelines.

JSON-LD (JavaScript Object Notation for Linked Data) serializes RDF as JSON, providing a seamless bridge between Semantic Web data and modern web APIs and applications. Its core innovation is the @context object, which maps JSON terms to IRIs.

• Key Features: Can be processed as plain JSON or as a full RDF graph. Supports framing to shape the JSON output.
• Example: {"@context": {"ex": "http://example.com/", "knows": {"@id": "ex:knows"}}, "@id": "ex:Alice", "knows": {"@id": "ex:Bob"}}
• Use Case: Web API development, embedding structured data in web pages (via <script type="application/ld+json">), and integration with JavaScript applications.

N-Triples is a simple, line-based format where each line contains exactly one triple in fully expanded IRI form, terminated by a period. N-Quads extends N-Triples by adding an optional fourth element—the graph label or context—enabling the serialization of RDF Datasets.

• Key Features: Extremely simple to parse and generate programmatically. No abbreviations or shorthand syntax.
• Example (N-Triples): <http://example.com/Alice> <http://example.com/knows> <http://example.com/Bob> .
• Use Case: Ideal for large-scale data processing, streaming, and archival due to its simplicity and the ease of splitting files. N-Quads is the standard for serializing RDF datasets from systems like Apache Jena Fuseki.

RDFa (Resource Description Framework in Attributes) is a method for embedding RDF data within HTML and XHTML documents using existing attributes like href, src, and custom attributes (property, resource, typeof).

• Key Features: Enables graceful degradation; the embedded data is invisible to users but machine-readable. It directly connects the visible content with its semantic annotations.
• Example: <div resource="http://example.com/Alice" typeof="ex:Person"> <span property="ex:name">Alice</span> knows <a property="ex:knows" href="http://example.com/Bob">Bob</a>. </div>
• Use Case: Enhancing web pages for search engine optimization (SEO) via schema.org markup and enabling rich data extraction by crawlers.

TriG is a compact, textual format for serializing RDF Datasets (collections of named graphs). It extends the Turtle syntax with the ability to group triples into graphs labeled by an IRI or blank node. TriX (Triples in XML) is an XML-based format for RDF Datasets.

• Key Features (TriG): Provides Turtle's readability for multi-graph data. Uses GRAPH keyword to denote a named graph.
• Example (TriG): GRAPH ex:Graph1 { ex:Alice ex:knows ex:Bob . }
• Use Case: Exchanging or archiving provenance information, contextual metadata, or data from multi-tenant knowledge graph systems where data isolation by graph is required.

The Resource Description Framework (RDF) is the foundational, abstract data model for representing information as a directed graph of subject-predicate-object triples. It is not a specific file format but the underlying graph model that all RDF serializations (like Turtle or JSON-LD) express. This model forms the core of the Semantic Web and enterprise knowledge graphs.

• Triple: The atomic unit of data (e.g., :Person1 :hasName "Alice").
• Graph: A set of triples forms a labeled, directed graph.
• URI: Uniform Resource Identifiers are used to uniquely identify resources globally.

Turtle is a widely adopted, human-readable RDF serialization format. It provides a concise and readable syntax for writing RDF triples, making it a preferred choice for ontology authors and developers working directly with RDF data.

• Prefixes: Uses @prefix declarations to abbreviate URIs (e.g., ex: for http://example.com/).
• Abbreviations: Supports shorthand for lists, repeated subjects, and predicate-object groups.
• File Extension: Typically uses .ttl.
• Example: ex:Alice ex:worksFor ex:Inferensys .

JSON-LD is a lightweight RDF serialization format that expresses linked data using standard JSON. It is designed for easy integration with web APIs and existing JSON-based systems, making RDF consumable by mainstream developers.

• Context (@context): A key feature that maps JSON terms to IRIs, providing semantic meaning.
• Embedding: Can be seamlessly embedded in HTML as <script type="application/ld+json">.
• Framing: Allows shaping the JSON-LD output into a specific tree layout.
• Use Case: Ideal for publishing structured data on the web for search engines and knowledge graphs.

RDF/XML is the original, XML-based syntax for serializing RDF, standardized by the W3C. While verbose and complex for humans to read, it was crucial for the early adoption of RDF and is still supported by all major Semantic Web toolkits.

• XML Syntax: RDF triples are expressed as nested XML elements and attributes.
• Verbosity: Often more lengthy than Turtle or JSON-LD for the same graph.
• Legacy Support: Essential for interoperability with older systems and some government data portals.
• File Extension: Uses .rdf.

N-Triples and N-Quads are simple, line-based serialization formats where each line represents a single triple (or quad). They are designed for easy parsing, streaming, and large-scale dataset processing.

• N-Triples: One triple per line, fully expanded with absolute URIs. No abbreviations.
• N-Quads: Extends N-Triples by adding a fourth component—the graph context or named graph.
• Use Case: Ideal for dataset exchange, logging, and processing with line-oriented tools (e.g., grep, sort).
• Machine-Oriented: Prioritizes parsing simplicity over human readability.

SPARQL is the standard query language for RDF data. While not a serialization format itself, its query results are serialized in specific RDF-based formats, and it is the primary tool for retrieving data from an RDF graph stored in any serialization.

• Query Forms: SELECT (returns a table), CONSTRUCT (returns an RDF graph), ASK (returns boolean), DESCRIBE (returns an RDF description).
• Result Formats: Query results are serialized in formats like SPARQL JSON Results, SPARQL XML Results, or Turtle.
• Protocol: Defines a standard HTTP protocol for executing queries against a SPARQL endpoint.
• Core Function: Enables complex graph pattern matching across triplestores.