denote vs. dereference (ChatGPT)

denote vs. dereference (ChatGPT)#

Question

rdf 1.1, https://www.w3.org/TR/rdf11-concepts/ : “By design, IRIs have global scope. Thus, two different appearances of an IRI denote the same resource. Violating this principle constitutes an IRI collision [WEBARCH].” and it says: “The IRI owner can establish the intended referent by means of a specification or other document that explains what is denoted. For example, the Organization Ontology document [VOCAB-ORG] specifies the intended referents of various IRIs that start with http://www.w3.org/ns/org#. A good way of communicating the intended referent is to set up the IRI so that it dereferences [WEBARCH] to such a document.”

A#

You’re referencing key principles of RDF 1.1 Concepts regarding the semantics of IRIs (Internationalized Resource Identifiers). Here’s a breakdown of what the spec is emphasizing and why it matters:

Global Scope of IRIs#

IRIs are globally unique: In RDF, the same IRI used in different contexts must refer to the same resource.
This is crucial for interoperability on the Semantic Web.
Example:
```
<http://example.org/person#Alice> a foaf:Person.
```
Wherever this IRI appears, it must denote the same “Alice”.

IRI Collision#

An IRI collision occurs if:
- Two data sources use the same IRI to refer to different things.
- This violates RDF’s global naming assumption and breaks interoperability.
This is considered a design error.

IRI Ownership and Intended Referents#

The owner of an IRI namespace (usually the domain holder) has the responsibility and authority to define what that IRI denotes.
This is usually done through:
- A specification or
- A dereferenceable document that provides RDF or human-readable information.

Example from the spec:#

The Organization Ontology uses IRIs like:
```
http://www.w3.org/ns/org#Organization
```
- The document at that base URL explains what org:Organization means.
- This prevents misinterpretation and ensures shared understanding.

Dereferencing IRIs#

“Dereferencing” means that if you enter the IRI in a browser or HTTP client, you get a document describing the resource.
This follows the principle of Cool URIs and Linked Data:
- IRIs should be stable, resolvable, and informative.

Best Practice Summary:#

Use IRIs that you control or trust.
Ensure IRIs dereference to authoritative, explanatory documents.
Avoid reusing someone else’s IRI to mean something different.

Would you like an example of how to set up a dereferenceable IRI for your own RDF vocabulary?

Question

desrcibe the relationship between “denote” and “dereference”

Great question — the terms “denote” and “dereference” are related but fundamentally distinct in RDF and Web architecture. Here’s a precise explanation of their relationship:

Denote — Semantic Relationship#

Definition: To denote means that an IRI refers to or identifies a particular resource in the RDF data model.
This is a logical or semantic relationship.
It answers the question: What does this IRI mean?

Example: The IRI http://xmlns.com/foaf/0.1/Person denotes the concept of a “person” in the FOAF ontology.
Denotation is independent of access — it doesn’t require the IRI to be resolvable.

Dereference — Operational/Technical Action#

Definition: To dereference an IRI is to use a protocol (usually HTTP) to retrieve a representation of a resource from that IRI.
It’s a network operation, not a semantic act.
It answers the question: What information can I get when I look this IRI up?

Example: Accessing http://xmlns.com/foaf/0.1/Person in a browser may return an RDF document describing the concept “Person”.

How They Relate#

Aspect	Denote	Dereference
What it does	Assigns meaning	Retrieves a document
Layer	Semantic/Web of Data	Network/Web of Documents
Required?	Always in RDF	Optional but highly recommended
Who controls it	Anyone can use an IRI to denote	Only the IRI owner controls dereferencing
Can you denote without dereferencing?	✅ Yes
Can you dereference without denoting?	❌ Not meaningful in RDF

Dereferencing helps explain what is denoted, but the denotation exists independently.
The dereferenced document may describe what the IRI denotes — this is the mechanism of self-description on the Semantic Web.

Analogy#

Think of a name in a book (denotation), and then looking up that name in an encyclopedia entry (dereferencing). The name means something on its own, but the encyclopedia gives more information about it.

Would you like a visual diagram of this relationship?

Question

thus “denote” and “dereference” are sort of disjoint properties?

Yes — “denote” and “dereference” are indeed distinct (and in a sense disjoint) properties in RDF and Web architecture, though they can complement each other.

Key Differences#

Aspect	Denote	Dereference
Nature	Semantic/logical	Operational/technical
Function	Assigns meaning in a data model	Retrieves data via a network protocol
Layer	RDF / Semantic Web	Web / HTTP architecture
Necessity in RDF	Required for RDF triples to make sense	Not required, but helpful
Owner Dependency	Anyone can use an IRI to denote something	Only the IRI owner controls dereferencing
Failure Impact	No effect if dereferencing fails	May hinder understanding but not denotation

Conceptual Relationship#

Denote is about what an IRI refers to.
Dereference is about how you can find more information about it.

They are not opposites, but they don’t imply each other:

You can denote without being able to dereference.
You can dereference a URI that provides no clear semantic information (or even doesn’t denote anything in RDF terms).

So, are they “disjoint”?#

In a formal sense, yes — they operate in different domains and one does not entail the other. But in best practice, they are often combined to strengthen the usefulness of RDF: by making dereferenceable IRIs that clarify what they denote.

Would you like to explore how this relates to the idea of “Linked Data” principles?

Question

yes

Great — the relationship between “denote” and “dereference” is central to the Linked Data principles, originally articulated by Tim Berners-Lee to guide how data should be published and connected on the Web. Here’s how it all connects:

Linked Data Principles (simplified)#

Use IRIs as names for things → This is about denotation: assigning global identifiers to people, places, concepts, etc.
Use HTTP IRIs so that people can look them up → This brings in dereferencing: making the IRIs resolvable over the Web.
When someone looks up an IRI, provide useful information → A dereference operation should return RDF (or other data) describing what the IRI denotes.
Include links to other IRIs so people can discover more things → Encourages creating a web of interconnected, dereferenceable, and semantically rich data.

How “Denote” and “Dereference” Work Together in Linked Data#

Linked Data Principle	Involves “Denote”?	Involves “Dereference”?	Explanation
1. Use IRIs as names	✅ Yes	❌ Not required	Just identifying resources semantically.
2. Use HTTP IRIs	✅ Implicitly	✅ Yes	Now the IRI can also be dereferenced.
3. Provide info on lookup	✅ Yes	✅ Yes	Information returned explains what the IRI denotes.
4. Link to other IRIs	✅ Yes	✅ Yes	Promotes richer graphs and easier exploration.

Why This Matters#

RDF needs “denote” for its logic.
The Web needs “dereference” for usability and discoverability.
Linked Data combines both: it builds a machine-readable Web of meaning.

When an IRI both denotes a concept and dereferences to a description of that concept, you get the full power of Linked Data: globally unambiguous meaning + navigable, extensible connections.

Question

Example: “””http://example.org/person#Alice a foaf:Person.””” : Explain denote and dereference

Absolutely! Let’s break down the example:

<http://example.org/person#Alice> a foaf:Person.

This is an RDF triple that says: The resource identified by <http://example.org/person#Alice> is a foaf:Person.

Denote#

The IRI <http://example.org/person#Alice> denotes a specific person — “Alice”.
In the RDF data model, denotation is semantic:
- The triple does not say where to find more info about Alice.
- It just says: “This IRI stands for a person named Alice.”
Likewise, foaf:Person (which expands to http://xmlns.com/foaf/0.1/Person) denotes the class “Person” from the FOAF vocabulary.

So, this RDF triple has two IRIs, both denoting things:

<http://example.org/person#Alice> → A specific person.
foaf:Person → A category of people (in the FOAF ontology).

Dereference#

Now, suppose you dereference <http://example.org/person#Alice>:
- You type it into a browser or send an HTTP GET request.
- The server at example.org could return an RDF document describing Alice:
```
@prefix foaf: <http://xmlns.com/foaf/0.1/> .

<#Alice>
  a foaf:Person ;
  foaf:name "Alice Example" ;
  foaf:mbox <mailto:alice@example.org> .
```
- This document helps a client understand what is denoted by the IRI.
If dereferencing fails (e.g., 404 Not Found), the IRI still denotes Alice, but clients can’t learn more unless they have out-of-band knowledge.

Summary#

Concept	`<http://example.org/person#Alice>`
Denotes	A person named Alice (semantic)
Dereference	Returns RDF data about Alice (optional but helpful)

So, denote answers “What does this IRI mean?” While dereference answers “Can I fetch more information about it from the Web?”

Would you like an example where dereferencing returns non-RDF (e.g., HTML) content, and how content negotiation fits in?

Question

yes

Great — let’s expand the example by showing how dereferencing can return non-RDF content (e.g., HTML) and how HTTP content negotiation helps machines and humans get appropriate representations from the same IRI.

Starting Point#

You have this IRI in RDF:

<http://example.org/person#Alice> a foaf:Person.

Denotation:#

This IRI denotes a specific person named Alice.

Dereferencing (with Content Negotiation)#

When you dereference http://example.org/person#Alice, the server can return different content types, depending on who’s asking:

1. A Human (Web Browser):#

The browser sends an Accept: text/html header.
The server responds with HTML:

<!DOCTYPE html>
<html>
  <head><title>Alice Example</title></head>
  <body>
    <h1>Alice Example</h1>
    <p>Alice is a researcher in Semantic Web technologies.</p>
    <p>Email: alice@example.org</p>
  </body>
</html>

Caution

wrong example: There should be an id identifier in the html document to identify the Alice XML fragment! … c.f. below, “rethink html document”

This version is readable by humans.

2. A Machine (RDF Client or Crawler):#

The client sends Accept: application/rdf+xml or Accept: text/turtle.
The server responds with RDF, e.g.:

@prefix foaf: <http://xmlns.com/foaf/0.1/> .

<http://example.org/person#Alice>
  a foaf:Person ;
  foaf:name "Alice Example" ;
  foaf:mbox <mailto:alice@example.org> ;
  foaf:homepage <http://example.org/~alice> .

This is structured data a machine can process semantically.

How This Works: HTTP 303 and Content Negotiation#

Problem:#

An IRI like http://example.org/person#Alice denotes a person, not a web page. But dereferencing it returns a document about the person. That’s a different thing.

Solution (per Cool URIs):#

When the IRI is dereferenced, the server responds with:
- HTTP 303 See Other (redirect)
- Redirects to a document describing the person:
  - e.g., http://example.org/person/alice.ttl or alice.html
These documents do not denote Alice directly — they describe her.

This preserves the distinction between:

The person (Alice) ← denoted by the IRI
The documents ← returned via dereference

Summary#

Operation	Result
Denotation	IRI denotes Alice (a person)
Dereference (HTML)	Returns human-readable profile
Dereference (RDF)	Returns machine-readable metadata
HTTP 303 Redirect	Keeps person ≠ document clear

Would you like an example of the actual HTTP request/response headers for these operations?

Question

yes

Great! Let’s walk through actual HTTP request/response headers to illustrate how content negotiation and HTTP 303 redirects work in dereferencing an RDF IRI that denotes a person (not a document).

We’ll use the example:

http://example.org/person#Alice

which denotes a person named Alice.

1. Machine (RDF client) Requests RDF#

HTTP Request:#

GET /person HTTP/1.1
Host: example.org
Accept: text/turtle, application/rdf+xml;q=0.9, */*;q=0.1

Server Response (redirect):#

HTTP/1.1 303 See Other
Location: http://example.org/data/person.ttl

Follow-up Request:#

GET /data/person.ttl HTTP/1.1
Host: example.org
Accept: text/turtle

Response:#

HTTP/1.1 200 OK
Content-Type: text/turtle

@prefix foaf: <http://xmlns.com/foaf/0.1/> .

<http://example.org/person#Alice>
  a foaf:Person ;
  foaf:name "Alice Example" ;
  foaf:mbox <mailto:alice@example.org> .

👉 The IRI denotes a person, but you get an RDF document about that person.

2. Human (Browser) Requests HTML#

HTTP Request:#

GET /person HTTP/1.1
Host: example.org
Accept: text/html

Server Response (redirect):#

HTTP/1.1 303 See Other
Location: http://example.org/page/person.html

Follow-up Request:#

GET /page/person.html HTTP/1.1
Host: example.org
Accept: text/html

Response:#

HTTP/1.1 200 OK
Content-Type: text/html

<!DOCTYPE html>
<html>
<head><title>Alice Example</title></head>
<body>
  <h1>Alice Example</h1>
  <p>Alice is a semantic web researcher. Email: alice@example.org</p>
</body>
</html>

Summary of Flow#

Client Type	Accept Header	Response	Redirect To	Content Type Returned
Machine	RDF (Turtle/XML)	303	`/data/person.ttl`	`text/turtle`
Human	HTML	303	`/page/person.html`	`text/html`

This approach:

Keeps IRIs unambiguous (they denote resources, not documents).
Returns appropriate representations via dereferencing and content negotiation.
Follows best practices from Cool URIs and Linked Data.

Would you like a reusable template for setting up this behavior on your own domain (e.g., using Apache or NGINX)?

Question

rethink html document: shouldn’t there be an html id in order to define a fragment?

Excellent observation — and yes, you’re absolutely right: If an RDF IRI includes a fragment identifier (like #Alice), then dereferencing the base IRI (e.g., http://example.org/person) should return an HTML document that includes an element with an ID matching the fragment — for proper semantic alignment and linking.

Why the Fragment Matters#

The IRI:
```
http://example.org/person#Alice
```
means:
- “The resource identified by the fragment Alice within the representation at http://example.org/person.”
If dereferenced to HTML, then:
- #Alice refers to the HTML element with id="Alice" in the returned page.
- This is defined by HTML’s fragment identifier semantics.

Corrected HTML Example#

If your RDF IRI is:

<http://example.org/person#Alice> a foaf:Person .

Then dereferencing http://example.org/person should return an HTML page like:

<!DOCTYPE html>
<html>
  <head>
    <title>Alice Example</title>
  </head>
  <body>
    <section id="Alice">
      <h1>Alice Example</h1>
      <p>Alice is a semantic web researcher.</p>
      <p>Email: alice@example.org</p>
    </section>
  </body>
</html>

Now:

http://example.org/person#Alice dereferences to this document.
The fragment #Alice correctly identifies the <section id="Alice">.

This ensures:

Conformance to Web architecture
Correct linking behavior from browsers and RDF-aware tools
Semantic and operational alignment between RDF and HTML

Additional Note for RDF:#

When serving RDF via content negotiation, the #Alice fragment refers to a subject in RDF, not an HTML element — but it’s the same IRI. This is what makes the web of documents and data interoperable.

Would you like a dual-version HTML+RDFa template to represent this person directly in HTML with embedded semantics?

Question

yes

Great! Here’s a dual-version HTML+RDFa template that:

Is human-readable in HTML.
Is machine-readable using RDFa.
Aligns with the IRI: http://example.org/person#Alice.

RDFa-annotated HTML Template#

<!DOCTYPE html>
<html lang="en" prefix="foaf: http://xmlns.com/foaf/0.1/">
<head>
  <meta charset="UTF-8">
  <title>Alice Example</title>
</head>
<body vocab="http://xmlns.com/foaf/0.1/" typeof="Person" resource="#Alice">

  <section id="Alice">
    <h1 property="name">Alice Example</h1>
    <p>Alice is a semantic web researcher.</p>
    <p>
      Email: <a property="mbox" href="mailto:alice@example.org">alice@example.org</a><br>
      Homepage: <a property="homepage" href="http://example.org/~alice">http://example.org/~alice</a>
    </p>
  </section>

</body>
</html>

How It Works#

resource="#Alice" defines that the main resource described is http://example.org/person#Alice.
RDFa attributes like property="name" embed RDF triples into the HTML.

A machine parsing this will extract:

<http://example.org/person#Alice>
    a foaf:Person ;
    foaf:name "Alice Example" ;
    foaf:mbox <mailto:alice@example.org> ;
    foaf:homepage <http://example.org/~alice> .

Benefits#

One document serves both humans and machines.
No need for content negotiation if using RDFa everywhere.
Follows Linked Data and Cool URI principles.

Would you like a version of this that uses JSON-LD instead of RDFa in the <script> block?

Question

yes

Perfect! Here’s a version of the same page using JSON-LD, a lightweight RDF serialization format that fits naturally into HTML via a <script> block.

JSON-LD Embedded in HTML#

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Alice Example</title>

  <!-- JSON-LD block describing Alice -->
  <script type="application/ld+json">
  {
    "@context": {
      "foaf": "http://xmlns.com/foaf/0.1/"
    },
    "@id": "http://example.org/person#Alice",
    "@type": "foaf:Person",
    "foaf:name": "Alice Example",
    "foaf:mbox": "mailto:alice@example.org",
    "foaf:homepage": "http://example.org/~alice"
  }
  </script>
</head>
<body>
  <section id="Alice">
    <h1>Alice Example</h1>
    <p>Alice is a semantic web researcher.</p>
    <p>
      Email: <a href="mailto:alice@example.org">alice@example.org</a><br>
      Homepage: <a href="http://example.org/~alice">http://example.org/~alice</a>
    </p>
  </section>
</body>
</html>

Breakdown#

The @id value matches the IRI: http://example.org/person#Alice.
The JSON-LD block contains machine-readable RDF, while the HTML is human-readable.
No need for content negotiation — both audiences get what they need in a single file.

When to Use JSON-LD vs RDFa#

Use Case	RDFa	JSON-LD
Semantic HTML with inline annotations	✅ Best fit	❌ Less integrated
Clean HTML separation	🤷‍♂️ Can clutter structure	✅ Keeps RDF separate in `<script>`
Popular in schema.org & SEO	❌ Not common	✅ Widely used by Google, etc.
Fine-grained linking to HTML elements	✅ Easy via `property`	❌ Not inherently supported

Would you like to see how this JSON-LD looks when converted to Turtle RDF?

Question

yes

Sure! Here’s how the JSON-LD data from the HTML document can be expressed in Turtle (a common RDF serialization format):

JSON-LD Example#

Here’s the JSON-LD you saw earlier:

{
  "@context": {
    "foaf": "http://xmlns.com/foaf/0.1/"
  },
  "@id": "http://example.org/person#Alice",
  "@type": "foaf:Person",
  "foaf:name": "Alice Example",
  "foaf:mbox": "mailto:alice@example.org",
  "foaf:homepage": "http://example.org/~alice"
}

Turtle Representation#

Converting the JSON-LD above to Turtle would give:

@prefix foaf: <http://xmlns.com/foaf/0.1/> .

<http://example.org/person#Alice>
  a foaf:Person ;
  foaf:name "Alice Example" ;
  foaf:mbox <mailto:alice@example.org> ;
  foaf:homepage <http://example.org/~alice> .

Explanation:#

The @id field in JSON-LD becomes the subject in the RDF triple: <http://example.org/person#Alice>.
The @type field (which defines the RDF class) becomes the a (type) predicate in Turtle: a foaf:Person.
The properties like "foaf:name", "foaf:mbox", and "foaf:homepage" become predicates in RDF:
- foaf:name → "Alice Example"
- foaf:mbox → <mailto:alice@example.org>
- foaf:homepage → <http://example.org/~alice>

This is semantically equivalent to the original JSON-LD.

Key Takeaway:#

JSON-LD allows data to be embedded into HTML in a way that is easy to extract and process.
Turtle is another representation of the same data, commonly used in RDF stores or linked data environments.
Both formats serve the same purpose: to represent structured data that machines can understand and link across the Web.

Would you like to see how this Turtle data fits into a broader Linked Data graph or how to query it with SPARQL?

Question

yes

Great! Let’s dive into how this Turtle data can be used in a Linked Data graph and how to query it using SPARQL.

Example Linked Data Graph#

The Turtle data you’ve seen could be part of a larger RDF graph. Imagine we have several resources (e.g., different people, organizations, and websites) linked together.

Here’s how it might look in a larger context:

@prefix foaf: <http://xmlns.com/foaf/0.1/> .
@prefix ex: <http://example.org/> .

<http://example.org/person#Alice>
  a foaf:Person ;
  foaf:name "Alice Example" ;
  foaf:mbox <mailto:alice@example.org> ;
  foaf:homepage <http://example.org/~alice> .

<http://example.org/person#Bob>
  a foaf:Person ;
  foaf:name "Bob Builder" ;
  foaf:mbox <mailto:bob@builder.com> ;
  foaf:homepage <http://example.org/~bob> .

<http://example.org/organization#ExampleOrg>
  a foaf:Organization ;
  foaf:name "Example Organization" ;
  foaf:homepage <http://example.org/> ;
  foaf:member <http://example.org/person#Alice> , <http://example.org/person#Bob> .

In this graph, we have:

Two Person nodes (Alice and Bob).
One Organization node (ExampleOrg).
Relationships like foaf:member, foaf:name, foaf:mbox, and foaf:homepage.

Visualizing the Graph#

It might look like this in a graph (simplified):

(Alice) --foaf:name--> "Alice Example"
  |                         |
foaf:mbox                    |
  |                         |
<mailto:alice@example.org>  |
                           foaf:homepage
                             |
                   <http://example.org/~alice>

Similar for Bob and ExampleOrg.

SPARQL Queries#

Now, let’s say you want to query this RDF graph using SPARQL. Here are a few examples:

1. Query to Get All People’s Names#

This query will return all the names of people (i.e., all foaf:Person entities in the graph).

PREFIX foaf: <http://xmlns.com/foaf/0.1/>

SELECT ?person ?name
WHERE {
  ?person a foaf:Person ;
          foaf:name ?name .
}

Expected Results:#

person	name
`<http://example.org/person#Alice>`	Alice Example
`<http://example.org/person#Bob>`	Bob Builder

2. Query to Get Members of “Example Organization”#

This query finds the members of the organization ExampleOrg.

PREFIX foaf: <http://xmlns.com/foaf/0.1/>
PREFIX ex: <http://example.org/>

SELECT ?member ?name
WHERE {
  ex:ExampleOrg foaf:member ?member .
  ?member foaf:name ?name .
}

Expected Results:#

member	name
`<http://example.org/person#Alice>`	Alice Example
`<http://example.org/person#Bob>`	Bob Builder

3. Query to Find People’s Emails and Homepages#

This query fetches the mbox and homepage for all persons in the dataset.

PREFIX foaf: <http://xmlns.com/foaf/0.1/>

SELECT ?person ?email ?homepage
WHERE {
  ?person a foaf:Person ;
          foaf:mbox ?email ;
          foaf:homepage ?homepage .
}

Expected Results:#

person	email	homepage
`<http://example.org/person#Alice>`	mailto:alice@example.org	http://example.org/~alice
`<http://example.org/person#Bob>`	mailto:bob@builder.com	http://example.org/~bob

Key Takeaways:#

Linked Data Graph: RDF graphs connect diverse data, like people, organizations, and other entities, and link them together via predicates (such as foaf:name, foaf:member).
SPARQL Queries: SPARQL is a powerful query language used to extract specific data from RDF graphs. It allows you to ask questions like “Who are the members of this organization?” or “What are the emails of all persons?”
Interoperability: RDF data is globally linked, and by following standards like Linked Data, you can query, merge, and explore information from different domains or datasets.

Next Steps#

Would you like to run these SPARQL queries on an actual dataset?
Do you need help setting up a SPARQL endpoint to store and query RDF data?
I could also show how to store this RDF data in a graph database like Apache Jena or Virtuoso.

Let me know how you’d like to proceed!

denote vs. dereference (ChatGPT)

Contents

denote vs. dereference (ChatGPT)#

A#

Global Scope of IRIs#

IRI Collision#

IRI Ownership and Intended Referents#

Example from the spec:#

Dereferencing IRIs#

Best Practice Summary:#

Denote — Semantic Relationship#

Dereference — Operational/Technical Action#

How They Relate#

Analogy#

Key Differences#

Conceptual Relationship#

So, are they “disjoint”?#

Linked Data Principles (simplified)#

How “Denote” and “Dereference” Work Together in Linked Data#

Why This Matters#

Denote#

Dereference#

Summary#

Starting Point#

Denotation:#

Dereferencing (with Content Negotiation)#

1. A Human (Web Browser):#

2. A Machine (RDF Client or Crawler):#

How This Works: HTTP 303 and Content Negotiation#

Problem:#

Solution (per Cool URIs):#

Summary#

1. Machine (RDF client) Requests RDF#

HTTP Request:#

Server Response (redirect):#

Follow-up Request:#

Response:#

2. Human (Browser) Requests HTML#

HTTP Request:#

Server Response (redirect):#

Follow-up Request:#

Response:#

Summary of Flow#

Why the Fragment Matters#

Corrected HTML Example#

Additional Note for RDF:#

RDFa-annotated HTML Template#

How It Works#

Benefits#

JSON-LD Embedded in HTML#

Breakdown#

When to Use JSON-LD vs RDFa#

JSON-LD Example#

Turtle Representation#

Explanation:#

Key Takeaway:#

Example Linked Data Graph#

Visualizing the Graph#

SPARQL Queries#

1. Query to Get All People’s Names#

Expected Results:#

2. Query to Get Members of “Example Organization”#

Expected Results:#

3. Query to Find People’s Emails and Homepages#

Expected Results:#

Key Takeaways:#

Next Steps#