Download the Full Competency Index in English (using your browser’s Print function) or in Chinese (PDF)
The Competency Index for Linked Data (CI) is a set of topically arranged assertions of the knowledge, skills and habits of mind required for professional practice in the area of Linked Data. Its primary goal is to provide a means for mapping learning resource descriptions to the competencies those resources address to assist in finding, identifying, and selecting resources appropriate to specific learning needs.
Learn MoreThe structure of the CI is:
Topical Cluster » Topic » Competency » Benchmark
The The number following each node (e.g. “(4)”) indicates the number of learning resource descriptions mapped to that competency/benchmark.
For a published example of this same four-part topical/competency model being followed in the CI, see the Competency Index for the Library Field in the U.S. ASN-D2L triplestore. Click the expansion icon for a full view of the individual assertions on the left; click on a specific assertion to see the assertion’s metadata description on the right. Additional information on the project and its development can be found here on the Exploratorium website under Briefing Papers—see in particular LD4PE Overview.
- Fundamentals of Resource Description Framework (218)
- Identity in RDF (38)
- Knows that Uniform Resource Identifiers, or URIs (1994), include Uniform Resource Locators (URLs, which locate web pages) as well as location-independent identifiers for physical, conceptual, or web r (18)
- Knows that anything can be named with Uniform Resource Identifiers (URIs), such as agents, places, events, artifacts, and concepts. (17)
- Understands that a "real-world" thing may need to be named with a URI distinct from the URI for information about that thing. (8)
- Recognizes that URIs are "owned" by the owners of their respective Internet domains. (3)
- RDF data model (148)
- Understands the difference between literals and non-literal resources. (14)
- Knows the subject-predicate-object component structure of a triple. (46)
- Understands that URIs and literals denote things in the world ("resources") real, imagined, or conceptual. (28)
- Understands that resources are declared to be members (instances) of classes using the property rdf:type. (26)
- Understands the use of datatypes and language tags with literals. (15)
- Understands a named graph as one of the collection of graphs comprising an RDF dataset, with a graph name unique in the context of that dataset. (20)
- Understands blank nodes and their uses. (15)
- Understands that QNames define shorthand prefixes for long URIs. (13)
- Articulates differences between the RDF abstract data model and the XML and relational models. (35)
- Understands the RDF abstract data model as a directed labeled graph. (33)
- Knows graphic conventions for depicting RDF-based models. (10)
- Understands how a namespace, informally used in the RDF context for a namespace URI or RDF vocabulary, fundamentally differs from the namespace of data attributes and functions (methods) defined for a (8)
- Related data models (52)
- Grasps essential differences between schemas for syntactic validation (e.g., XML) and for inferencing (RDF Schema). (35)
- Differentiates hierarchical document models (eg, XML) and graph models (RDF). (24)
- Understands how an RDF class (named set of things) fundamentally differs from an object-oriented programming class, which defines a type of object bundling "state" (attributes with data values) and "b (6)
- RDF serialization (66)
- Identity in RDF (38)
- Fundamentals of Linked Data (135)
- Web technology (93)
- Knows the origins of the World Wide Web (1989) as a non-linear interactive system, or hypermedia, built on the Internet. (10)
- Understands that Linked Data (2006) extended the notion of a web of documents (the Web) to a notion of a web of finer-grained data (the Linked Data cloud). (69)
- Knows HyperText Markup Language, or HTML (1991+), as a language for "marking up" the content and multimedia components of Web pages. (25)
- Knows HTML5 (2014) as a version of HTML extended with support for complex web and mobile applications. (10)
- Knows Hypertext Transfer Protocol, or HTTP (1991+), as the basic technology for resolving hyperlinks and transferring data on the World Wide Web. (9)
- Knows Representational State Transfer, or REST (2000) as a software architectural style whereby browsers can exchange data with web servers, typically on the basis of well-known HTTP actions. (7)
- Linked Data principles (66)
- Knows Tim Berners-Lee's principles of Linked Data: use URIs to name things, use HTTP URIs that can be resolved to useful information, and create links to URIs of other things. (0)
- Knows the "five stars" of Open Data: put data on the Web, preferably in a structured and preferably non-proprietary format, using URIs to name things, and link to other data. (66)
- Linked Data policies and best practices (16)
- Non-RDF linked data (0)
- Web technology (93)
- RDF vocabularies and application profiles (181)
- Finding RDF-based vocabularies (16)
- Maintaining RDF vocabularies (0)
- Versioning RDF vocabularies (1)
- Publishing RDF vocabularies (33)
- Understands the typical publication formats for RDF vocabularies and their relative advantages (4)
- Understands the purpose of publishing RDF vocabularies in multiple formats using content negotiation. (16)
- Understands that to be "dereferencable", a URI should be usable to retrieve a representation of the resource it identifies. (21)
- Mapping RDF vocabularies (21)
- Recognizes that owl:sameAs, while popular as a mapping property, has strong formal semantics that can entail unintended inferences. (13)
- Understands that the properties of hierarchical subsumption within an RDF vocabulary — rdfs:subPropertyOf and rdfs:subClassOf — can also be used to express mappings between vocabularies. (7)
- Understands that owl:equivalentProperty and owl:equivalentClass may be used when equivalencies between properties or between classes are exact. (5)
- RDF application profiles (19)
- Designing RDF-based vocabularies (142)
- Uses RDF Schema to express semantic relationships within a vocabulary. (53)
- Knows the naming conventions for RDF properties and classes. (9)
- Reuses published properties and classes where available. (32)
- Coins namespace URIs, as needed, for any new properties and classes required. (14)
- Knows Web Ontology Language, or OWL (2004), as a RDF vocabulary of properties and classes that extend support for expressive data modeling and automated inferencing (reasoning). (35)
- Knows that the word "ontology" is ambiguous, referring to any RDF vocabulary, but more typically a set of OWL classes and properties designed to support inferencing in a specific domain. (36)
- Knows Simple Knowledge Organization System, or SKOS (2009), an RDF vocabulary for expressing concepts that are labeled in natural languages, organized into informal hierarchies, and aggregated into co (24)
- Knows SKOS eXtension for Labels, or SKOS-XL (2009), a small set of additional properties for describing and linking lexical labels as instances of the class Label. (4)
- Understands that in a formal sense, a SKOS concept is not an RDF class but an instance and, as such, is not formally associated with a set of instances ("class extension"). (8)
- Understands that SKOS can express a flexibly associative structure of concepts without enabling the more rigid and automatic inferences typically specified in a class-based OWL ontology. (9)
- Understands that in contrast to OWL sub-class chains, hierarchies of SKOS concepts are designed not to form transitive chains automatically because this is not how humans think or organize information (5)
- Creating and transforming Linked Data (82)
- Managing identifiers (URI) (19)
- Understands that to be "persistent", a URI must have a stable, well-documented meaning and be plausibly intended to identify a given resource in perpetuity. (11)
- Understands trade-offs between "opaque" URIs and URIs using version numbers, server names, dates, application-specific file extensions, query strings or other obsoletable context. (13)
- Recognizes the desirability of a published namespace policy describing an institution's commitment to the persistence and semantic stability of important URIs. (6)
- Creating RDF data (44)
- Generates RDF data from non-RDF sources. (13)
- Knows methods for generating RDF data from tabular data in formats such as Comma-Separated Values (CSV). (14)
- Knows methods such as Direct Mapping of Relational Data to RDF (2012) for transforming data from the relational model (keys, values, rows, columns, tables) into RDF graphs. (23)
- Versioning RDF data (0)
- RDF data provenance (0)
- Cleaning and reconciling RDF data (17)
- Mapping and enriching RDF data (32)
- Managing identifiers (URI) (19)
- Interacting with RDF data (368)
- Processing RDF data using programming languages. (86)
- Understands how components of the RDF data model (datasets, graphs, statements, and various types of node) are expressed in the RDF library of a given programming language by constructs such as object (70)
- Uses an RDF programming library to serialize RDF data in available syntaxes. (22)
- Uses RDF-specific programming methods to iterate over components of RDF data. (11)
- Uses RDF-library-specific convenience representations for common RDF vocabularies such as RDF, Dublin Core, and SKOS. (6)
- Programatically associates namespaces to prefixes for use in serializing RDF or when parsing SPARQL queries. (5)
- Uses RDF programming libraries to extract RDF data from CSV files, databases, or web pages. (10)
- Uses RDF programming libraries to persistently stores triples in memory, on disk, or to interact with triple stores. (30)
- Programatically infers triples using custom functions or methods. (8)
- Understands how the pattern matching of SPARQL queries can be expressed using functionally equivalent constructs in RDF programming libraries. (57)
- Uses RDF-specific programming methods to query RDF data and save the results for further processing. (23)
- Uses utilities and convenience functions the provide shortcuts for frequently used patterns, such as matching the multiple label properties used in real data. (6)
- Uses RDF libraries to process various types of SPARQL query result. (13)
- Understands how components of the RDF data model (datasets, graphs, statements, and various types of node) are expressed in the RDF library of a given programming language by constructs such as object (70)
- Querying RDF data (190)
- Understands the basic syntax of a SPARQL query. (24)
- Understands that a SPARQL query matches an RDF graph against a pattern of triples with fixed and variable values. (53)
- Demonstrates a working knowledge of the forms and uses of SPARQL result sets (SELECT, CONSTRUCT, DESCRIBE, and ASK). (63)
- Uses the SELECT clause to identify the variables to appear in a table of query results. (9)
- Uses the WHERE clause to provide the graph pattern to match against the graph data. (4)
- Uses variables in SELECT and WHERE clauses to yield a table of results. (24)
- Uses ASK for a True/False result test for a match to a query pattern. (3)
- Uses DESCRIBE to extract a single graph containing RDF data about resources. (2)
- Uses CONSTRUCT to extract and transform results into a single RDF graph specified by a graph template. (11)
- Uses FROM to formulate queries with URLs and local files. (2)
- Understands how to combine and filter graph patterns using operators such as UNION, OPTIONAL, FILTER, and MINUS. (58)
- Uses UNION to formulate queries with multiple possible graph patterns. (10)
- Uses OPTIONAL to formulate queries to return the values of optional variables when available. (8)
- Uses FILTER to formulates queries that eliminate solutions from a result set. (14)
- Uses NOT EXISTS to limit whether a given graph pattern exists in the data. (5)
- Uses MINUS to remove matches from a result based on the evaluation of two patterns. (2)
- Uses NOT IN to restrict a variable to not being in a given set of values. (0)
- Understands the major SPARQL result set modifiers, e.g., to limit or sort results, or to return distinct results only once. (28)
- Uses ORDER BY to define ordering conditions by variable, function call, or expression. (9)
- Uses DISTINCT to ensure solutions in the sequence are unique. (6)
- Uses OFFSET to control where the solutions processed start in the overall sequence of solutions. (2)
- Uses LIMIT to restrict the number of solutions processed for query results. (5)
- Uses projection to transform a solution sequence into one involving only a subset of the variables. (2)
- Understands the use of SPARQL functions and operators. (23)
- Uses the regular expression (regex()) function for string matching. (8)
- Uses aggregates to apply expressions over groups of solutions (GROUP BY, COUNT, SUM, AVG, MIN) for partitioning results, evaluating projections, and filtering. (11)
- Uses the lang() function to return the language tag of an RDF literal. (3)
- Uses the langMatches() function to match a language tag against a language range. (3)
- Uses the xsd:decimal(expn) function to convert an expression to an integer. (0)
- Uses the GROUP BY clause to transforms a result set so that only one row will appear for each unique set of grouping variables. (1)
- Uses the HAVING clause to apply a filter to the result set after grouping. (1)
- Differentiates between a Default Graph and a Named Graph, and formulates queries using the GRAPH clause. (30)
- Uses a temporary variable to extend a query. (3)
- Understands the role of Property Paths and how they are formed by combining predicates with regular expression-like operators. (11)
- Understands the concept of Federated Searches. (14)
- Converts/manipulates SPARQL query outputs (RDF-XML, JSON) to the exact format required by a third party tools and APIs. (10)
- Reads and understands high-level descriptions of the classes and properties of a dataset in order to write queries. (19)
- Uses available tools, servers, and endpoints to issue queries against a dataset. (69)
- Execute SPARQL queries using the Jena ARQ command-line utility. (3)
- Queries multiple local data files using ARQ. (1)
- Uses ARQ to evaluate queries on local data. (2)
- Uses Fuseki server to evaluate queries on a dataset. (5)
- Queries multiple data files using Fuseki. (3)
- Accesses DBPedia's SNORQL/SPARQL endpoint and issues simple queries. (12)
- Visualizing RDF data (31)
- Reasoning over RDF data (82)
- Understands the principles and practice of inferencing. (41)
- Understands the role of formally declared domains and ranges for inferencing. (39)
- Understands how reasoning can be used for integrating diverse datasets. (3)
- Knows that Web Ontology Language (OWL) is available in multiple "flavors" that are variously optimized for expressivity, performant reasoning, or for applications involving databases or business rules (19)
- Understands that OWL Full supports all available constructs and is most appropriately used when reasoning performance is not a concern. (4)
- Assessing RDF data quality (0)
- RDF data analytics (16)
- Finding RDF data (44)
- Manipulating RDF data (66)
- Knows the SPARQL 1.1 Update language for updating, creating, and removing RDF graphs in a Graph Store (32)
- Knows the SPARQL 1.1 Graph Store HTTP protocol for updating graphs on a web server (in "restful" style). (14)
- Uses GET to retrieve triples from a default graph or a named graph. (1)
- Uses PUT to insert set of triples into a new graph (or replace an existing graph). (1)
- Uses DELETE to remove a graph. (1)
- Uses proper syntax to request specific media types, such as Turtle. (0)
- Uses POST to add triples to an existing graph. (0)
- Understands the difference between SQL query language (which operates on database tables) and SPARQL (which operates on RDF graphs). (43)
- Processing RDF data using programming languages. (86)
- Creating Linked Data applications (0)