diff --git a/src/org/linkeddatafragments/datasource/AbstractRequestProcessorForTriplePatterns.java b/src/org/linkeddatafragments/datasource/AbstractRequestProcessorForTriplePatterns.java
index 9ba984a..debae47 100644
--- a/src/org/linkeddatafragments/datasource/AbstractRequestProcessorForTriplePatterns.java
+++ b/src/org/linkeddatafragments/datasource/AbstractRequestProcessorForTriplePatterns.java
@@ -13,40 +13,46 @@
  * Base class for implementations of {@link IFragmentRequestProcessor} that
  * process {@link TriplePatternFragmentRequest}s.
  *
- * @param <TermType> type for representing RDF terms in triple patterns 
- * @param <VarType> type for representing specific variables in triple patterns
+ * @param <CTT>
+ *          type for representing constants in triple patterns (i.e., URIs and
+ *          literals)
+ * @param <NVT>
+ *          type for representing named variables in triple patterns
+ * @param <AVT>
+ *          type for representing anonymous variables in triple patterns (i.e.,
+ *          variables denoted by a blank node)
  *
  * @author <a href="http://olafhartig.de">Olaf Hartig</a>
  */
 public abstract class
-    AbstractRequestProcessorForTriplePatterns<TermType,VarType>
+    AbstractRequestProcessorForTriplePatterns<CTT,NVT,AVT>
         extends AbstractRequestProcessor
 {
     @Override
-    protected final Worker<TermType,VarType> getWorker(
+    protected final Worker<CTT,NVT,AVT> getWorker(
             final LinkedDataFragmentRequest request )
                                                 throws IllegalArgumentException
     {
-        if ( request instanceof TriplePatternFragmentRequest<?,?> ) {
+        if ( request instanceof TriplePatternFragmentRequest<?,?,?> ) {
             @SuppressWarnings("unchecked")
-            final TriplePatternFragmentRequest<TermType,VarType> tpfRequest =
-                      (TriplePatternFragmentRequest<TermType,VarType>) request;
+            final TriplePatternFragmentRequest<CTT,NVT,AVT> tpfRequest =
+                      (TriplePatternFragmentRequest<CTT,NVT,AVT>) request;
             return getTPFSpecificWorker( tpfRequest );
         }
         else
             throw new IllegalArgumentException( request.getClass().getName() );
     }
 
-    abstract protected Worker<TermType,VarType> getTPFSpecificWorker(
-            final TriplePatternFragmentRequest<TermType,VarType> request )
+    abstract protected Worker<CTT,NVT,AVT> getTPFSpecificWorker(
+            final TriplePatternFragmentRequest<CTT,NVT,AVT> request )
                     throws IllegalArgumentException;
 
 
-    abstract static protected class Worker<TermType,VarType>
+    abstract static protected class Worker<CTT,NVT,AVT>
         extends AbstractRequestProcessor.Worker
     {        
         public Worker(
-                 final TriplePatternFragmentRequest<TermType,VarType> request )
+                 final TriplePatternFragmentRequest<CTT,NVT,AVT> request )
         {
             super( request );
         }
@@ -63,8 +69,8 @@ public LinkedDataFragment createRequestedFragment()
                 offset = 0L;
 
             @SuppressWarnings("unchecked")
-            final TriplePatternFragmentRequest<TermType,VarType> tpfRequest =
-                      (TriplePatternFragmentRequest<TermType,VarType>) request;
+            final TriplePatternFragmentRequest<CTT,NVT,AVT> tpfRequest =
+                      (TriplePatternFragmentRequest<CTT,NVT,AVT>) request;
 
             return createFragment( tpfRequest.getSubject(),
                                    tpfRequest.getPredicate(),
@@ -73,9 +79,9 @@ public LinkedDataFragment createRequestedFragment()
         }
 
         abstract protected LinkedDataFragment createFragment(
-                            final TriplePatternElement<TermType,VarType> subj,
-                            final TriplePatternElement<TermType,VarType> pred,
-                            final TriplePatternElement<TermType,VarType> obj,
+                            final TriplePatternElement<CTT,NVT,AVT> subj,
+                            final TriplePatternElement<CTT,NVT,AVT> pred,
+                            final TriplePatternElement<CTT,NVT,AVT> obj,
                             final long offset,
                             final long limit )
                                                throws IllegalArgumentException;
diff --git a/src/org/linkeddatafragments/datasource/hdt/HdtBasedRequestProcessorForTPFs.java b/src/org/linkeddatafragments/datasource/hdt/HdtBasedRequestProcessorForTPFs.java
index 3ed8dbe..be22e45 100644
--- a/src/org/linkeddatafragments/datasource/hdt/HdtBasedRequestProcessorForTPFs.java
+++ b/src/org/linkeddatafragments/datasource/hdt/HdtBasedRequestProcessorForTPFs.java
@@ -27,7 +27,7 @@
  * @author <a href="http://olafhartig.de">Olaf Hartig</a>
  */
 public class HdtBasedRequestProcessorForTPFs
-    extends AbstractRequestProcessorForTriplePatterns<RDFNode,String>
+    extends AbstractRequestProcessorForTriplePatterns<RDFNode,String,String>
 {
     protected final HDT datasource;
     protected final NodeDictionary dictionary;
@@ -46,7 +46,7 @@ public HdtBasedRequestProcessorForTPFs( String hdtFile ) throws IOException
 
     @Override
     protected Worker getTPFSpecificWorker(
-            final TriplePatternFragmentRequest<RDFNode,String> request )
+            final TriplePatternFragmentRequest<RDFNode,String,String> request )
                                                 throws IllegalArgumentException
     {
         return new Worker( request );
@@ -54,30 +54,32 @@ protected Worker getTPFSpecificWorker(
 
 
     protected class Worker
-       extends AbstractRequestProcessorForTriplePatterns.Worker<RDFNode,String>
+       extends AbstractRequestProcessorForTriplePatterns.Worker<RDFNode,String,String>
     {
-        public Worker( final TriplePatternFragmentRequest<RDFNode,String> req )
+        public Worker(
+                final TriplePatternFragmentRequest<RDFNode,String,String> req )
         {
             super( req );
         }
 
         @Override
         protected LinkedDataFragment createFragment(
-                          final TriplePatternElement<RDFNode,String> subject,
-                          final TriplePatternElement<RDFNode,String> predicate,
-                          final TriplePatternElement<RDFNode,String> object,
-                          final long offset,
-                          final long limit )
+                   final TriplePatternElement<RDFNode,String,String> subject,
+                   final TriplePatternElement<RDFNode,String,String> predicate,
+                   final TriplePatternElement<RDFNode,String,String> object,
+                   final long offset,
+                   final long limit )
         {
             // FIXME: The following algorithm is incorrect for cases in which
             //        the requested triple pattern contains a specific variable
-            //        multiple times (e.g., ?x foaf:knows ?x ).
+            //        multiple times;
+            //        e.g., (?x foaf:knows ?x ) or (_:bn foaf:knows _:bn)
             // see https://github.com/LinkedDataFragments/Server.Java/issues/23
 
             // look up the result from the HDT datasource)
-            int subjectId = subject.isVariable() ? 0 : dictionary.getIntID(subject.asTerm().asNode(), TripleComponentRole.SUBJECT);
-            int predicateId = predicate.isVariable() ? 0 : dictionary.getIntID(predicate.asTerm().asNode(), TripleComponentRole.PREDICATE);
-            int objectId = object.isVariable() ? 0 : dictionary.getIntID(object.asTerm().asNode(), TripleComponentRole.OBJECT);
+            int subjectId = subject.isVariable() ? 0 : dictionary.getIntID(subject.asConstantTerm().asNode(), TripleComponentRole.SUBJECT);
+            int predicateId = predicate.isVariable() ? 0 : dictionary.getIntID(predicate.asConstantTerm().asNode(), TripleComponentRole.PREDICATE);
+            int objectId = object.isVariable() ? 0 : dictionary.getIntID(object.asConstantTerm().asNode(), TripleComponentRole.OBJECT);
         
             if (subjectId < 0 || predicateId < 0 || objectId < 0) {
                 return createEmptyTriplePatternFragment();
diff --git a/src/org/linkeddatafragments/datasource/index/IndexRequestProcessorForTPFs.java b/src/org/linkeddatafragments/datasource/index/IndexRequestProcessorForTPFs.java
index 8e4c6d4..8b74ac6 100644
--- a/src/org/linkeddatafragments/datasource/index/IndexRequestProcessorForTPFs.java
+++ b/src/org/linkeddatafragments/datasource/index/IndexRequestProcessorForTPFs.java
@@ -28,7 +28,7 @@
  * @author <a href="http://olafhartig.de">Olaf Hartig</a>
  */
 public class IndexRequestProcessorForTPFs
-    extends AbstractRequestProcessorForTriplePatterns<RDFNode,String>
+    extends AbstractRequestProcessorForTriplePatterns<RDFNode,String,String>
 {
     final static String RDF = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
     final static String RDFS = "http://www.w3.org/2000/01/rdf-schema#";
@@ -58,7 +58,7 @@ public IndexRequestProcessorForTPFs(
 
     @Override
     protected Worker getTPFSpecificWorker(
-            final TriplePatternFragmentRequest<RDFNode,String> request )
+            final TriplePatternFragmentRequest<RDFNode,String,String> request )
                                                 throws IllegalArgumentException
     {
         return new Worker( request );
@@ -66,32 +66,34 @@ protected Worker getTPFSpecificWorker(
 
 
     protected class Worker
-       extends AbstractRequestProcessorForTriplePatterns.Worker<RDFNode,String>
+       extends AbstractRequestProcessorForTriplePatterns.Worker<RDFNode,String,String>
     {
-        public Worker( final TriplePatternFragmentRequest<RDFNode,String> req )
+        public Worker(
+                final TriplePatternFragmentRequest<RDFNode,String,String> req )
         {
             super( req );
         }
 
         @Override
         protected LinkedDataFragment createFragment(
-                                  final TriplePatternElement<RDFNode,String> s,
-                                  final TriplePatternElement<RDFNode,String> p,
-                                  final TriplePatternElement<RDFNode,String> o,
-                                  final long offset,
-                                  final long limit )
+                           final TriplePatternElement<RDFNode,String,String> s,
+                           final TriplePatternElement<RDFNode,String,String> p,
+                           final TriplePatternElement<RDFNode,String,String> o,
+                           final long offset,
+                           final long limit )
         {
             // FIXME: The following algorithm is incorrect for cases in which
             //        the requested triple pattern contains a specific variable
-            //        multiple times (e.g., ?x foaf:knows ?x ).
+            //        multiple times;
+            //        e.g., (?x foaf:knows ?x ) or (_:bn foaf:knows _:bn)
             // see https://github.com/LinkedDataFragments/Server.Java/issues/25
 
             final Resource subject   = s.isVariable() ? null
-                                                      : s.asTerm().asResource();
+                                                      : s.asConstantTerm().asResource();
             final Property predicate = p.isVariable() ? null
-                                                      : ResourceFactory.createProperty(p.asTerm().asResource().getURI());
+                                                      : ResourceFactory.createProperty(p.asConstantTerm().asResource().getURI());
             final RDFNode object     = o.isVariable() ? null
-                                                      : o.asTerm();
+                                                      : o.asConstantTerm();
 
             StmtIterator listStatements = model.listStatements(subject, predicate, object);
             Model result = ModelFactory.createDefaultModel();
diff --git a/src/org/linkeddatafragments/datasource/tdb/JenaTDBBasedRequestProcessorForTPFs.java b/src/org/linkeddatafragments/datasource/tdb/JenaTDBBasedRequestProcessorForTPFs.java
index 094183e..8a991d1 100644
--- a/src/org/linkeddatafragments/datasource/tdb/JenaTDBBasedRequestProcessorForTPFs.java
+++ b/src/org/linkeddatafragments/datasource/tdb/JenaTDBBasedRequestProcessorForTPFs.java
@@ -30,7 +30,7 @@
  * @author <a href="http://olafhartig.de">Olaf Hartig</a>
  */
 public class JenaTDBBasedRequestProcessorForTPFs
-    extends AbstractRequestProcessorForTriplePatterns<RDFNode,String>
+    extends AbstractRequestProcessorForTriplePatterns<RDFNode,String,String>
 {
     private final Dataset tdb;
     private final String sparql = "CONSTRUCT WHERE { ?s ?p ?o } " +
@@ -43,7 +43,7 @@ public class JenaTDBBasedRequestProcessorForTPFs
 
     @Override
     protected Worker getTPFSpecificWorker(
-            final TriplePatternFragmentRequest<RDFNode,String> request )
+            final TriplePatternFragmentRequest<RDFNode,String,String> request )
                                                 throws IllegalArgumentException
     {
         return new Worker( request );
@@ -51,36 +51,38 @@ protected Worker getTPFSpecificWorker(
 
 
     protected class Worker
-       extends AbstractRequestProcessorForTriplePatterns.Worker<RDFNode,String>
+       extends AbstractRequestProcessorForTriplePatterns.Worker<RDFNode,String,String>
     {
-        public Worker( final TriplePatternFragmentRequest<RDFNode,String> req )
+        public Worker(
+                final TriplePatternFragmentRequest<RDFNode,String,String> req )
         {
             super( req );
         }
 
         @Override
         protected LinkedDataFragment createFragment(
-                          final TriplePatternElement<RDFNode,String> subject,
-                          final TriplePatternElement<RDFNode,String> predicate,
-                          final TriplePatternElement<RDFNode,String> object,
-                          final long offset,
-                          final long limit )
+                   final TriplePatternElement<RDFNode,String,String> subject,
+                   final TriplePatternElement<RDFNode,String,String> predicate,
+                   final TriplePatternElement<RDFNode,String,String> object,
+                   final long offset,
+                   final long limit )
         {
             // FIXME: The following algorithm is incorrect for cases in which
             //        the requested triple pattern contains a specific variable
-            //        multiple times (e.g., ?x foaf:knows ?x ).
+            //        multiple times;
+            //        e.g., (?x foaf:knows ?x ) or (_:bn foaf:knows _:bn)
             // see https://github.com/LinkedDataFragments/Server.Java/issues/24
 
             Model model = tdb.getDefaultModel();
             QuerySolutionMap map = new QuerySolutionMap();
             if ( ! subject.isVariable() ) {
-                map.add("s", subject.asTerm());
+                map.add("s", subject.asConstantTerm());
             }
             if ( ! predicate.isVariable() ) {
-                map.add("p", predicate.asTerm());
+                map.add("p", predicate.asConstantTerm());
             }
             if ( ! object.isVariable() ) {
-                map.add("o", object.asTerm());
+                map.add("o", object.asConstantTerm());
             }
 
             query.setOffset(offset);
diff --git a/src/org/linkeddatafragments/fragments/tpf/TPFRequestParser.java b/src/org/linkeddatafragments/fragments/tpf/TPFRequestParser.java
index b03e7c8..def4e9a 100644
--- a/src/org/linkeddatafragments/fragments/tpf/TPFRequestParser.java
+++ b/src/org/linkeddatafragments/fragments/tpf/TPFRequestParser.java
@@ -16,13 +16,13 @@
  *
  * @author <a href="http://olafhartig.de">Olaf Hartig</a>
  */
-public class TPFRequestParser<TermType,VarType>
+public class TPFRequestParser<ConstantTermType,NamedVarType,AnonVarType>
     extends FragmentRequestParserBase
 {
-    public final TriplePatternElementParser<TermType,VarType> elmtParser;
+    public final TriplePatternElementParser<ConstantTermType,NamedVarType,AnonVarType> elmtParser;
 
     public TPFRequestParser(
-                final TriplePatternElementParser<TermType,VarType> elmtParser )
+                final TriplePatternElementParser<ConstantTermType,NamedVarType,AnonVarType> elmtParser )
     {
         this.elmtParser = elmtParser;
     }
@@ -47,7 +47,7 @@ public Worker( final HttpServletRequest request,
         public LinkedDataFragmentRequest createFragmentRequest()
                                                throws IllegalArgumentException
         {
-            return new TriplePatternFragmentRequestImpl<TermType,VarType>(
+            return new TriplePatternFragmentRequestImpl<ConstantTermType,NamedVarType,AnonVarType>(
                                                          getFragmentURL(),
                                                          getDatasetURL(),
                                                          pageNumberWasRequested,
@@ -57,22 +57,22 @@ public LinkedDataFragmentRequest createFragmentRequest()
                                                          getObject() );
         }
 
-        public TriplePatternElement<TermType,VarType> getSubject() {
+        public TriplePatternElement<ConstantTermType,NamedVarType,AnonVarType> getSubject() {
             return getParameterAsTriplePatternElement(
                     TriplePatternFragmentRequest.PARAMETERNAME_SUBJ );
         }
 
-        public TriplePatternElement<TermType,VarType> getPredicate() {
+        public TriplePatternElement<ConstantTermType,NamedVarType,AnonVarType> getPredicate() {
             return getParameterAsTriplePatternElement(
                     TriplePatternFragmentRequest.PARAMETERNAME_PRED );
         }
 
-        public TriplePatternElement<TermType,VarType> getObject() {
+        public TriplePatternElement<ConstantTermType,NamedVarType,AnonVarType> getObject() {
             return getParameterAsTriplePatternElement(
                     TriplePatternFragmentRequest.PARAMETERNAME_OBJ );
         }
 
-        public TriplePatternElement<TermType,VarType>
+        public TriplePatternElement<ConstantTermType,NamedVarType,AnonVarType>
                    getParameterAsTriplePatternElement( final String paramName )
         {
             final String parameter = request.getParameter( paramName );
diff --git a/src/org/linkeddatafragments/fragments/tpf/TPFRequestParserForJenaBackends.java b/src/org/linkeddatafragments/fragments/tpf/TPFRequestParserForJenaBackends.java
index ee5f707..8eb9c56 100644
--- a/src/org/linkeddatafragments/fragments/tpf/TPFRequestParserForJenaBackends.java
+++ b/src/org/linkeddatafragments/fragments/tpf/TPFRequestParserForJenaBackends.java
@@ -10,7 +10,7 @@
  * @author <a href="http://olafhartig.de">Olaf Hartig</a>
  */
 public class TPFRequestParserForJenaBackends
-    extends TPFRequestParser<RDFNode,String>
+    extends TPFRequestParser<RDFNode,String,String>
 {
     private static TPFRequestParserForJenaBackends instance = null;
 
diff --git a/src/org/linkeddatafragments/fragments/tpf/TriplePatternElement.java b/src/org/linkeddatafragments/fragments/tpf/TriplePatternElement.java
index 55f0163..fe2c743 100644
--- a/src/org/linkeddatafragments/fragments/tpf/TriplePatternElement.java
+++ b/src/org/linkeddatafragments/fragments/tpf/TriplePatternElement.java
@@ -3,47 +3,80 @@
 /**
  * Represents an element of a triple pattern (i.e., subject, predicate, object). 
  *
- * @param <TermType> type for representing RDF terms in triple patterns 
- * @param <VarType> type for representing specific variables in triple patterns
+ * @param <ConstantTermType> type for representing constants in triple patterns
+ *                           (i.e., URIs and literals)
+ * @param <NamedVarType> type for representing named variables in triple patterns
+ * @param <AnonVarType> type for representing anonymous variables in triple
+ *                      patterns (i.e., variables denoted by a blank node)
  *
  * @author <a href="http://olafhartig.de">Olaf Hartig</a>
  */
-public interface TriplePatternElement<TermType,VarType>
+public interface TriplePatternElement<ConstantTermType,NamedVarType,AnonVarType>
 {
     /**
-     * Returns true if this element is a variable (named or unnamed).
+     * Returns true if this element is a variable (specific or unspecified).
      */
     boolean isVariable();
 
     /**
      * Returns true if this element is a specific variable, and false if either
-     * it is not a variable but an RDF term or it is some variable that is not
-     * specified. The latter (unspecified variables) is possible because when
-     * a client requests a triple pattern fragment, it may omit triple pattern
-     * related parameters.
-     *
-     * If this element is a specific variable (that is, this method returns
-     * true), this specific variable can be obtained by {@link #asVariable()}.
+     * it is not a variable (but a URI or literal) or it is some variable that
+     * is not specified. The latter (unspecified variables) is possible because
+     * when a client requests a triple pattern fragment, it may omit triple
+     * pattern related parameters.
      */
     boolean isSpecificVariable();
 
     /**
-     * Returns a representation of this element as a specific variable (assuming
-     * it is a specific variable).
+     * Returns true if this element is a specific variable that has a name
+     * (i.e., it is denoted by a string that begins with a question mark),
+     * and false if either it is not a specific variable or it is a specific
+     * variable that is denoted by a blank node.
+     *
+     * If this element is a specific variable that has a name (that is, this
+     * method returns true), the named variable can be obtained by the method
+     * {@link #asNamedVariable()}.
+     */
+    boolean isNamedVariable();
+
+    /**
+     * Returns a representation of this element as a named variable (assuming
+     * it is a specific variable that has a name).
+     *
+     * @throws UnsupportedOperationException
+     *         If this element is not a specific variable that has a name
+     *         (i.e., if {@link #isNamedVariable()} returns false).
+     */
+    NamedVarType asNamedVariable() throws UnsupportedOperationException;
+
+    /**
+     * Returns true if this element is a specific variable that does not have
+     * a name (i.e., it is denoted by a blank node), and false if either it is
+     * not a specific variable or it is a specific variable that has a name.
+     *
+     * If this element is a specific variable denoted by a blank node (that is,
+     * this method returns true), the blank node can be obtained by the method
+     * {@link #asAnonymousVariable()}.
+     */
+    boolean isAnonymousVariable();
+
+    /**
+     * Returns a representation of this element as a blank node (assuming
+     * it is a specific, but non-named variable).
      *
      * @throws UnsupportedOperationException
-     *         If this element is not a specific variable (i.e.,
-     *         if {@link #isSpecificVariable()} returns false).
+     *         If this element is not a specific anonymous variable (i.e.,
+     *         if {@link #isAnonymousVariable()} returns false).
      */
-    VarType asVariable() throws UnsupportedOperationException;
+    AnonVarType asAnonymousVariable() throws UnsupportedOperationException;
 
     /**
-     * Returns a representation of this element as an RDF term (assuming it is
-     * an RDF term and not a variable).
+     * Returns a representation of this element as a constant RDF term (i.e.,
+     * a URI or a literal).
      *
      * @throws UnsupportedOperationException
-     *         If this element is not an RDF term but a variable
+     *         If this element is not a constant RDF term but a variable
      *         (i.e., if {@link #isVariable()} returns true).
      */
-    TermType asTerm() throws UnsupportedOperationException;
+    ConstantTermType asConstantTerm() throws UnsupportedOperationException;
 }
diff --git a/src/org/linkeddatafragments/fragments/tpf/TriplePatternElementFactory.java b/src/org/linkeddatafragments/fragments/tpf/TriplePatternElementFactory.java
index aff548c..fdd4537 100644
--- a/src/org/linkeddatafragments/fragments/tpf/TriplePatternElementFactory.java
+++ b/src/org/linkeddatafragments/fragments/tpf/TriplePatternElementFactory.java
@@ -1,63 +1,132 @@
 package org.linkeddatafragments.fragments.tpf;
 
 /**
- * A factory for {@link TriplePatternElement}s. 
+ * A factory for {@link TriplePatternElement}s.
  *
- * @param <TermType> type for representing RDF terms in triple patterns 
- * @param <VarType> type for representing specific variables in triple patterns
+ * @param <CTT>
+ *          type for representing constants in triple patterns (i.e., URIs and
+ *          literals)
+ * @param <NVT>
+ *          type for representing named variables in triple patterns
+ * @param <AVT>
+ *          type for representing anonymous variables in triple patterns (i.e.,
+ *          variables denoted by a blank node)
  *
  * @author <a href="http://olafhartig.de">Olaf Hartig</a>
  */
-public class TriplePatternElementFactory<TermType,VarType>
+public class TriplePatternElementFactory<CTT,NVT,AVT>
 {
-    public TriplePatternElement<TermType,VarType> createUnspecifiedVariable() {
-        return new UnspecifiedVariable<TermType,VarType>();
+    public TriplePatternElement<CTT,NVT,AVT> createUnspecifiedVariable()
+    {
+        return new UnspecifiedVariable<CTT,NVT,AVT>();
     }
 
-    public TriplePatternElement<TermType,VarType> createSpecificVariable(
-            final VarType variable ) {
-        return new SpecificVariable<TermType,VarType>( variable );
+    public TriplePatternElement<CTT,NVT,AVT> createNamedVariable( final NVT v )
+    {
+        return new NamedVariable<CTT,NVT,AVT>( v );
     }
-    public TriplePatternElement<TermType,VarType> createRDFTerm(
-            final TermType term ) {
-        return new RDFTerm<TermType,VarType>( term );
+
+    public TriplePatternElement<CTT,NVT,AVT> createAnonymousVariable(
+                                                              final AVT bnode )
+    {
+        return new AnonymousVariable<CTT,NVT,AVT>( bnode );
+    }
+
+    public TriplePatternElement<CTT,NVT,AVT> createConstantRDFTerm(
+                                                               final CTT term )
+    {
+        return new ConstantRDFTerm<CTT,NVT,AVT>( term );
     }
 
-    static abstract public class Variable<TermType,VarType>
-        implements TriplePatternElement<TermType,VarType>
+
+    static abstract public class Variable<CTT,NVT,AVT>
+        implements TriplePatternElement<CTT,NVT,AVT>
     {
+        @Override
         public boolean isVariable() { return true; }
-        public TermType asTerm() { throw new UnsupportedOperationException(); }
+        @Override
+        public CTT asConstantTerm() { throw new UnsupportedOperationException(); }
     }
 
-    static public class UnspecifiedVariable<TermType,VarType>
-        extends Variable<TermType,VarType>
+    static public class UnspecifiedVariable<CTT,NVT,AVT>
+        extends Variable<CTT,NVT,AVT>
     {
+        @Override
         public boolean isSpecificVariable() { return false; }
-        public VarType asVariable() { throw new UnsupportedOperationException(); }
+        @Override
+        public boolean isNamedVariable() { return false; }
+        @Override
+        public NVT asNamedVariable() { throw new UnsupportedOperationException(); }
+        @Override
+        public boolean isAnonymousVariable() { return false; }
+        @Override
+        public AVT asAnonymousVariable() { throw new UnsupportedOperationException(); }
+        @Override
         public String toString() { return "UnspecifiedVariable"; }
     }
 
-    static public class SpecificVariable<TermType,VarType>
-        extends Variable<TermType,VarType>
+    static abstract public class SpecificVariable<CTT,NVT,AVT>
+        extends Variable<CTT,NVT,AVT>
     {
-        protected final VarType v;
-        public SpecificVariable( final VarType variable ) { v = variable; }
+        @Override
         public boolean isSpecificVariable() { return true; }
-        public VarType asVariable() { return v; }
-        public String toString() { return "SpecificVariable(" + v.toString() + ")"; }
     }
 
-    static public class RDFTerm<TermType,VarType>
-        implements TriplePatternElement<TermType,VarType>
+    static public class NamedVariable<CTT,NVT,AVT>
+        extends SpecificVariable<CTT,NVT,AVT>
+    {
+        protected final NVT v;
+        public NamedVariable( final NVT variable ) { v = variable; }
+        @Override
+        public boolean isNamedVariable() { return true; }
+        @Override
+        public NVT asNamedVariable() { return v; }
+        @Override
+        public boolean isAnonymousVariable() { return false; }
+        @Override
+        public AVT asAnonymousVariable() { throw new UnsupportedOperationException(); }
+        @Override
+        public String toString() { return "NamedVariable(" + v.toString() + ")"; }
+    }
+
+    static public class AnonymousVariable<CTT,NVT,AVT>
+        extends SpecificVariable<CTT,NVT,AVT>
+    {
+        protected final AVT bn;
+        public AnonymousVariable( final AVT bnode ) { bn = bnode; }
+        @Override
+        public boolean isNamedVariable() { return false; }
+        @Override
+        public NVT asNamedVariable() { throw new UnsupportedOperationException(); }
+        @Override
+        public boolean isAnonymousVariable() { return true; }
+        @Override
+        public AVT asAnonymousVariable() { return bn; }
+        @Override
+        public String toString() { return "AnonymousVariable(" + bn.toString() + ")"; }
+    }
+
+    static public class ConstantRDFTerm<CTT,NVT,AVT>
+        implements TriplePatternElement<CTT,NVT,AVT>
     {
-        protected final TermType t;
-        public RDFTerm( final TermType term ) { t = term; }
+        protected final CTT t;
+        public ConstantRDFTerm( final CTT term ) { t = term; }
+        @Override
         public boolean isVariable() { return false; }
+        @Override
         public boolean isSpecificVariable() { return false; }
-        public VarType asVariable() { throw new UnsupportedOperationException(); }
-        public TermType asTerm() { return t; }
-        public String toString() { return "RDFTerm(" + t.toString() + ")(type: " + t.getClass().getSimpleName() + ")"; }
+        @Override
+        public boolean isNamedVariable() { return false; }
+        @Override
+        public NVT asNamedVariable() { throw new UnsupportedOperationException(); }
+        @Override
+        public boolean isAnonymousVariable() { return false; }
+        @Override
+        public AVT asAnonymousVariable() { throw new UnsupportedOperationException(); }
+        @Override
+        public CTT asConstantTerm() { return t; }
+        @Override
+        public String toString() { return "ConstantRDFTerm(" + t.toString() + ")(type: " + t.getClass().getSimpleName() + ")"; }
     }
 
 }
diff --git a/src/org/linkeddatafragments/fragments/tpf/TriplePatternFragmentRequest.java b/src/org/linkeddatafragments/fragments/tpf/TriplePatternFragmentRequest.java
index 85154f7..35b9a98 100644
--- a/src/org/linkeddatafragments/fragments/tpf/TriplePatternFragmentRequest.java
+++ b/src/org/linkeddatafragments/fragments/tpf/TriplePatternFragmentRequest.java
@@ -5,12 +5,15 @@
 /**
  * Represents a request of a Triple Pattern Fragment (TPF).
  *
- * @param <TermType> type for representing RDF terms in triple patterns 
- * @param <VarType> type for representing specific variables in triple patterns
+ * @param <ConstantTermType> type for representing constants in triple patterns
+ *                           (i.e., URIs and literals)
+ * @param <NamedVarType> type for representing named variables in triple patterns
+ * @param <AnonVarType> type for representing anonymous variables in triple
+ *                      patterns (i.e., variables denoted by a blank node)
  *
  * @author <a href="http://olafhartig.de">Olaf Hartig</a>
  */
-public interface TriplePatternFragmentRequest<TermType,VarType>
+public interface TriplePatternFragmentRequest<ConstantTermType,NamedVarType,AnonVarType>
     extends LinkedDataFragmentRequest
 {
     public final static String PARAMETERNAME_SUBJ = "subject";
@@ -20,15 +23,15 @@ public interface TriplePatternFragmentRequest<TermType,VarType>
     /**
      * Returns the subject position of the requested triple pattern.
      */
-    TriplePatternElement<TermType,VarType> getSubject();
+    TriplePatternElement<ConstantTermType,NamedVarType,AnonVarType> getSubject();
 
     /**
      * Returns the predicate position of the requested triple pattern.
      */
-    TriplePatternElement<TermType,VarType> getPredicate();
+    TriplePatternElement<ConstantTermType,NamedVarType,AnonVarType> getPredicate();
 
     /**
      * Returns the object position of the requested triple pattern.
      */
-    TriplePatternElement<TermType,VarType> getObject();
+    TriplePatternElement<ConstantTermType,NamedVarType,AnonVarType> getObject();
 }
diff --git a/src/org/linkeddatafragments/fragments/tpf/TriplePatternFragmentRequestImpl.java b/src/org/linkeddatafragments/fragments/tpf/TriplePatternFragmentRequestImpl.java
index c968212..abec2ef 100644
--- a/src/org/linkeddatafragments/fragments/tpf/TriplePatternFragmentRequestImpl.java
+++ b/src/org/linkeddatafragments/fragments/tpf/TriplePatternFragmentRequestImpl.java
@@ -7,21 +7,21 @@
  *
  * @author <a href="http://olafhartig.de">Olaf Hartig</a>
  */
-public class TriplePatternFragmentRequestImpl<TermType,VarType>
+public class TriplePatternFragmentRequestImpl<CTT,NVT,AVT>
     extends LinkedDataFragmentRequestBase
-    implements TriplePatternFragmentRequest<TermType,VarType>
+    implements TriplePatternFragmentRequest<CTT,NVT,AVT>
 {
-    public final TriplePatternElement<TermType,VarType> subject;
-    public final TriplePatternElement<TermType,VarType> predicate;
-    public final TriplePatternElement<TermType,VarType> object;
+    public final TriplePatternElement<CTT,NVT,AVT> subject;
+    public final TriplePatternElement<CTT,NVT,AVT> predicate;
+    public final TriplePatternElement<CTT,NVT,AVT> object;
 
     public TriplePatternFragmentRequestImpl( final String fragmentURL,
                                              final String datasetURL,
                                              final boolean pageNumberWasRequested,
                                              final long pageNumber,
-                                             final TriplePatternElement<TermType,VarType> subject,
-                                             final TriplePatternElement<TermType,VarType> predicate,
-                                             final TriplePatternElement<TermType,VarType> object )
+                                             final TriplePatternElement<CTT,NVT,AVT> subject,
+                                             final TriplePatternElement<CTT,NVT,AVT> predicate,
+                                             final TriplePatternElement<CTT,NVT,AVT> object )
     {
         super( fragmentURL, datasetURL, pageNumberWasRequested, pageNumber );
 
@@ -40,17 +40,17 @@ public TriplePatternFragmentRequestImpl( final String fragmentURL,
     }
 
     @Override
-    public TriplePatternElement<TermType,VarType> getSubject() {
+    public TriplePatternElement<CTT,NVT,AVT> getSubject() {
         return subject;
     }
 
     @Override
-    public TriplePatternElement<TermType,VarType> getPredicate() {
+    public TriplePatternElement<CTT,NVT,AVT> getPredicate() {
         return predicate;
     }
 
     @Override
-    public TriplePatternElement<TermType,VarType> getObject() {
+    public TriplePatternElement<CTT,NVT,AVT> getObject() {
         return object;
     }
 
diff --git a/src/org/linkeddatafragments/util/TriplePatternElementParser.java b/src/org/linkeddatafragments/util/TriplePatternElementParser.java
index ecbb2e3..8b16889 100644
--- a/src/org/linkeddatafragments/util/TriplePatternElementParser.java
+++ b/src/org/linkeddatafragments/util/TriplePatternElementParser.java
@@ -5,21 +5,25 @@
 
 /**
  * Parses strings (as obtained from HTTP request parameters) into
- * {@link TriplePatternElement}s. 
+ * {@link TriplePatternElement}s.
  *
- * @param <TermType> type for representing RDF terms
- * @param <VarType> type for representing specific variables
+ * @param <ConstantTermType> type for representing constants in triple patterns
+ *                           (i.e., URIs and literals)
+ * @param <NamedVarType> type for representing named variables in triple patterns
+ * @param <AnonVarType> type for representing anonymous variables in triple
+ *                      patterns (i.e., variables denoted by a blank node)
  *
  * @author <a href="http://olafhartig.de">Olaf Hartig</a>
  * @author Ruben Verborgh
  */
-abstract public class TriplePatternElementParser<TermType,VarType>
-    extends RDFTermParser<TermType>
+abstract public
+    class TriplePatternElementParser<ConstantTermType,NamedVarType,AnonVarType>
+        extends RDFTermParser<ConstantTermType>
 {
-    public final TriplePatternElementFactory<TermType,VarType> factory =
-            new TriplePatternElementFactory<TermType,VarType>();
+    public final TriplePatternElementFactory<ConstantTermType,NamedVarType,AnonVarType>
+        factory = new TriplePatternElementFactory<ConstantTermType,NamedVarType,AnonVarType>();
 
-    public TriplePatternElement<TermType,VarType>
+    public TriplePatternElement<ConstantTermType,NamedVarType,AnonVarType>
                             parseIntoTriplePatternElement( final String param )
     {
         // nothing or empty indicates an unspecified variable
@@ -30,25 +34,28 @@ abstract public class TriplePatternElementParser<TermType,VarType>
         char firstChar = param.charAt(0);
         switch ( firstChar )
         {
-            // specific variable
+            // specific variable that has a name
             case '?':
             {
                 final String varName = param.substring(1);
-                final VarType var = createSpecificVariable( varName );
-                return factory.createSpecificVariable( var );
+                final NamedVarType var = createNamedVariable( varName );
+                return factory.createNamedVariable( var );
             }
 
-            // blank node indicates an unspecified variable
+            // specific variable that is denoted by a blank node
             case '_':
             {
-                return factory.createUnspecifiedVariable();
+                final AnonVarType var = createAnonymousVariable( param );
+                return factory.createAnonymousVariable( var );
             }
 
             // assume it is an RDF term
             default:
-                return factory.createRDFTerm( parseIntoRDFNode(param) );
+                return factory.createConstantRDFTerm( parseIntoRDFNode(param) );
         }
     }
 
-    abstract public VarType createSpecificVariable( final String varName );
+    abstract public NamedVarType createNamedVariable( final String varName );
+
+    abstract public AnonVarType createAnonymousVariable( final String label );
 }
diff --git a/src/org/linkeddatafragments/util/TriplePatternElementParserForJena.java b/src/org/linkeddatafragments/util/TriplePatternElementParserForJena.java
index 41dd83c..029c512 100644
--- a/src/org/linkeddatafragments/util/TriplePatternElementParserForJena.java
+++ b/src/org/linkeddatafragments/util/TriplePatternElementParserForJena.java
@@ -11,7 +11,7 @@
  * @author <a href="http://olafhartig.de">Olaf Hartig</a>
  */
 public class TriplePatternElementParserForJena
-    extends TriplePatternElementParser<RDFNode,String>
+    extends TriplePatternElementParser<RDFNode,String,String>
 {
     private static TriplePatternElementParserForJena instance = null;
 
@@ -26,11 +26,17 @@ public static TriplePatternElementParserForJena getInstance()
     protected TriplePatternElementParserForJena() {}
 
     @Override
-    public String createSpecificVariable( final String varName )
+    public String createNamedVariable( final String varName )
     {
         return varName;
     }
 
+    @Override
+    public String createAnonymousVariable( final String label )
+    {
+        return label;
+    }
+
     @Override
     public RDFNode createBlankNode( final String label )
     {
diff --git a/src/test/java/org/linkeddatafragments/datasource/DataSourceTest.java b/src/test/java/org/linkeddatafragments/datasource/DataSourceTest.java
index 81c3589..937dcaa 100644
--- a/src/test/java/org/linkeddatafragments/datasource/DataSourceTest.java
+++ b/src/test/java/org/linkeddatafragments/datasource/DataSourceTest.java
@@ -26,7 +26,8 @@
  *
  * @author Bart Hanssens <bart.hanssens@fedict.be>
  */
-public abstract class DataSourceTest<TermType,VarType> {
+public abstract class DataSourceTest<ConstantTermType,NamedVarType,AnonVarType>
+{
     private static IDataSource ds;
     
     /**
@@ -47,7 +48,7 @@ public static void setDatasource(IDataSource ds) {
         DataSourceTest.ds = ds;
     }
 
-    protected abstract TriplePatternElementParser<TermType,VarType>
+    protected abstract TriplePatternElementParser<ConstantTermType,NamedVarType,AnonVarType>
                                                getTriplePatternElementParser();
         
     /**
@@ -90,11 +91,11 @@ public static JsonObject createConfig(String title, String desc, String type) {
      */
     @Test
     public void testEmpty() {        
-        final TriplePatternElementParser<TermType,VarType> tpeParser =
+        final TriplePatternElementParser<ConstantTermType,NamedVarType,AnonVarType> tpeParser =
                                                getTriplePatternElementParser();
 
-        final TriplePatternFragmentRequest<TermType,VarType> request =
-                new TriplePatternFragmentRequestImpl<TermType,VarType>(
+        final TriplePatternFragmentRequest<ConstantTermType,NamedVarType,AnonVarType> request =
+                new TriplePatternFragmentRequestImpl<ConstantTermType,NamedVarType,AnonVarType>(
                         "http://example.org/f", // fragmentURL
                         "http://example.org/",  // datasetURL,
                         true, // pageNumberWasRequested,
@@ -118,23 +119,23 @@ public void testEmpty() {
      */
     @Test
     public void testEstimate() {
-        final TriplePatternElementParser<TermType,VarType> tpeParser =
+        final TriplePatternElementParser<ConstantTermType,NamedVarType,AnonVarType> tpeParser =
                                                getTriplePatternElementParser();
 
-        final TriplePatternFragmentRequest<TermType,VarType> request =
-          new TriplePatternFragmentRequest<TermType,VarType>() {
+        final TriplePatternFragmentRequest<ConstantTermType,NamedVarType,AnonVarType> request =
+          new TriplePatternFragmentRequest<ConstantTermType,NamedVarType,AnonVarType>() {
             public boolean isPageRequest() { return true; }
             public long getPageNumber() { return 1L; }
             public String getFragmentURL() { return "http://example.org/f"; }
             public String getDatasetURL() { return "http://example.org/"; }
 
-            public TriplePatternElement<TermType,VarType> getSubject() {
+            public TriplePatternElement<ConstantTermType,NamedVarType,AnonVarType> getSubject() {
                 return tpeParser.parseIntoTriplePatternElement("http://data.gov.be/catalog/ckanvl");
             }
-            public TriplePatternElement<TermType,VarType> getPredicate() {
+            public TriplePatternElement<ConstantTermType,NamedVarType,AnonVarType> getPredicate() {
                 return tpeParser.parseIntoTriplePatternElement(null);
             }
-            public TriplePatternElement<TermType,VarType> getObject() {
+            public TriplePatternElement<ConstantTermType,NamedVarType,AnonVarType> getObject() {
                 return tpeParser.parseIntoTriplePatternElement(null);
             }
         };
diff --git a/src/test/java/org/linkeddatafragments/datasource/HdtDataSourceTest.java b/src/test/java/org/linkeddatafragments/datasource/HdtDataSourceTest.java
index 09e5e2c..712a2a9 100644
--- a/src/test/java/org/linkeddatafragments/datasource/HdtDataSourceTest.java
+++ b/src/test/java/org/linkeddatafragments/datasource/HdtDataSourceTest.java
@@ -22,12 +22,12 @@
  *
  * @author Bart Hanssens <bart.hanssens@fedict.be>
  */
-public class HdtDataSourceTest extends DataSourceTest<RDFNode,String> {
+public class HdtDataSourceTest extends DataSourceTest<RDFNode,String,String> {
 
     private static File hdtfile;
 
     @Override
-    protected TriplePatternElementParser<RDFNode,String>
+    protected TriplePatternElementParser<RDFNode,String,String>
                                                getTriplePatternElementParser()
     {
         return TriplePatternElementParserForJena.getInstance();
diff --git a/src/test/java/org/linkeddatafragments/datasource/JenaTDBDataSourceTest.java b/src/test/java/org/linkeddatafragments/datasource/JenaTDBDataSourceTest.java
index 9ee6935..7ea7d42 100644
--- a/src/test/java/org/linkeddatafragments/datasource/JenaTDBDataSourceTest.java
+++ b/src/test/java/org/linkeddatafragments/datasource/JenaTDBDataSourceTest.java
@@ -29,12 +29,13 @@
  *
  * @author Bart Hanssens <bart.hanssens@fedict.be>
  */
-public class JenaTDBDataSourceTest extends DataSourceTest<RDFNode,String> {
+public class JenaTDBDataSourceTest extends DataSourceTest<RDFNode,String,String>
+{
     private static File jena;
     private static Dataset dataset;
 
     @Override
-    protected TriplePatternElementParser<RDFNode,String>
+    protected TriplePatternElementParser<RDFNode,String,String>
                                                getTriplePatternElementParser()
     {
         return TriplePatternElementParserForJena.getInstance();