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 More- 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)