You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@datafu.apache.org by mh...@apache.org on 2020/03/31 19:22:26 UTC

[datafu] branch master updated: Update website instructions and update for 1.6.0 release

This is an automated email from the ASF dual-hosted git repository.

mhayes pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/datafu.git


The following commit(s) were added to refs/heads/master by this push:
     new 75509a1  Update website instructions and update for 1.6.0 release
75509a1 is described below

commit 75509a1ddeb02b4fb532b9ad9146844c358db2d6
Author: Matthew Hayes <mh...@apache.org>
AuthorDate: Tue Mar 31 12:22:18 2020 -0700

    Update website instructions and update for 1.6.0 release
---
 .../evaluation/ExtremalTupleByNthField.java        | 82 ++++++++----------
 .../java/datafu/pig/bags/CountDistinctUpTo.java    | 96 +++++++++++++---------
 .../src/main/java/datafu/pig/hash/Hasher.java      | 29 ++++---
 .../src/main/java/datafu/pig/hash/HasherRand.java  | 18 ++--
 site/README.md                                     | 28 ++++---
 .../docs/spark/getting-started.html.markdown.erb   |  8 +-
 site/source/layouts/_docs_nav.erb                  |  5 +-
 7 files changed, 144 insertions(+), 122 deletions(-)

diff --git a/datafu-pig/src/main/java/datafu/org/apache/pig/piggybank/evaluation/ExtremalTupleByNthField.java b/datafu-pig/src/main/java/datafu/org/apache/pig/piggybank/evaluation/ExtremalTupleByNthField.java
index e425417..8e0aad2 100644
--- a/datafu-pig/src/main/java/datafu/org/apache/pig/piggybank/evaluation/ExtremalTupleByNthField.java
+++ b/datafu-pig/src/main/java/datafu/org/apache/pig/piggybank/evaluation/ExtremalTupleByNthField.java
@@ -35,101 +35,89 @@ import org.apache.pig.impl.logicalLayer.schema.Schema;
 
 /**
  * This class is a copy of org.apache.pig.piggybank.evaluation.ExtremalTupleByNthField
- * 
+ *
  * https://github.com/apache/pig/blob/trunk/contrib/piggybank/java/src/main/java/org/apache/pig/piggybank/evaluation/ExtremalTupleByNthField.java
  */
 public class ExtremalTupleByNthField extends EvalFunc<Tuple> implements Algebraic, Accumulator<Tuple> {
-	
+
 	/**
 	 * Indicates once for how many items progress heart beat should be sent.
 	 * This number has been increased from 10 to reduce verbosity.
 	 */
 	private static final int PROGRESS_FREQUENCY = 10000;
-	
+
 	int fieldIndex;
 	int sign;
-	
-	/**
-	 * 
-	 * 
-	 * 
-	 * 
-	 * 
-	 * Constructors
-	 * 
-	 * @throws ExecException
-	 * 
-	 */
-	
+
 	// defaults to max by first field
 	public ExtremalTupleByNthField() throws ExecException {
 		this("1", "max");
 	}
-	
+
 	// defaults to max
 	public ExtremalTupleByNthField(String fieldIndexString)
 			throws ExecException {
 		this(fieldIndexString, "max");
 	}
-	
+
 	public ExtremalTupleByNthField(String fieldIndexString, String order)
 			throws ExecException {
 		super();
 		this.fieldIndex = parseFieldIndex(fieldIndexString);
 		this.sign = parseOrdering(order);
 	}
-	
+
 	/**
-	 * 
-	 * 
-	 * 
-	 * 
-	 * 
+	 *
+	 *
+	 *
+	 *
+	 *
 	 * The EvalFunc interface
 	 */
 	@Override
 	public Tuple exec(Tuple input) throws IOException {
 		return extreme(fieldIndex, sign, input, reporter);
 	}
-	
+
 	@Override
 	public Type getReturnType() {
 		return Tuple.class;
 	}
-	
+
 	public Schema outputSchema(Schema input) {
 		return input;
 	}
-	
+
 	/**
-	 * 
-	 * 
-	 * 
-	 * 
-	 * 
+	 *
+	 *
+	 *
+	 *
+	 *
 	 * Algebraic interface
 	 */
 	@Override
 	public String getInitial() {
 		return HelperClass.class.getName();
 	}
-	
+
 	@Override
 	public String getIntermed() {
 		return HelperClass.class.getName();
 	}
-	
+
 	@Override
 	public String getFinal() {
 		return HelperClass.class.getName();
 	}
-	
+
 	/**
-	 * 
-	 * 
-	 * 
-	 * 
-	 * 
+	 *
+	 *
+	 *
+	 *
+	 *
 	 * The Accumulator interface
 	 */
 	Tuple intermediate = null;
@@ -178,12 +166,12 @@ public class ExtremalTupleByNthField extends EvalFunc<Tuple> implements Algebrai
 	}
 
 	/**
-	 * 
-	 * 
-	 * 
-	 * 
+	 *
+	 *
+	 *
+	 *
 	 * Utility classes and methods
-	 * 
+	 *
 	 */
 	public static final class HelperClass extends EvalFunc<Tuple> {
 		int fieldIndex, sign;
@@ -250,10 +238,10 @@ public class ExtremalTupleByNthField extends EvalFunc<Tuple> implements Algebrai
 					 * <pre>
 					 * c > 0 iff ((sign==1 && d>curMax) || (sign==-1 && d<curMax))
 					 * </pre>
-					 * 
+					 *
 					 * In both case we want to replace curMax/curMaxTuple by the
 					 * new values
-					 * 
+					 *
 					 **/
 					int c = psign * d.compareTo(curMax);
 					if (c > 0) {
diff --git a/datafu-pig/src/main/java/datafu/pig/bags/CountDistinctUpTo.java b/datafu-pig/src/main/java/datafu/pig/bags/CountDistinctUpTo.java
index d707cd6..943739e 100644
--- a/datafu-pig/src/main/java/datafu/pig/bags/CountDistinctUpTo.java
+++ b/datafu-pig/src/main/java/datafu/pig/bags/CountDistinctUpTo.java
@@ -39,9 +39,9 @@ import org.apache.pig.impl.logicalLayer.schema.Schema.FieldSchema;
 
 /**
  * Generates a count of the number of distinct tuples in a bag, up to a preset limit.
- * 
+ *
  * If the number of distinct tuples is small, performance is comparable to using Pig's DISTINCT and COUNT in a nested foreach.
- * 
+ *
  * Use this UDF when your threshold is low, and some records have a distinct count that is much higher. In such cases this UDF will prevent memory problems
  * and perform an order of magnitude faster than using pure Pig.
  *
@@ -50,19 +50,19 @@ import org.apache.pig.impl.logicalLayer.schema.Schema.FieldSchema;
  * {@code
  * DEFINE CountDistinctUpTo10 datafu.pig.bags.CountDistinctUpTo('10');
  * DEFINE CountDistinctUpTo3 datafu.pig.bags.CountDistinctUpTo('3');
- * 
- * -- input: 
+ *
+ * -- input:
  * -- {(A),(B),(D),(A),(C),(E),(A),(B),(A),(B)}
  * input = LOAD 'input' AS (B: bag {T: tuple(alpha:CHARARRAY)});
- * 
- * -- output: 
+ *
+ * -- output:
  * -- (5)
- * output = FOREACH input GENERATE CountDistinctUpTo10(B); 
+ * output = FOREACH input GENERATE CountDistinctUpTo10(B);
  *
- * -- output2: 
+ * -- output2:
  * -- (3)
- * output2 = FOREACH input GENERATE CountDistinctUpTo3(B); 
- * } 
+ * output2 = FOREACH input GENERATE CountDistinctUpTo3(B);
+ * }
  * </pre>
  */
 public class CountDistinctUpTo extends AccumulatorEvalFunc<Integer> implements Algebraic{
@@ -73,12 +73,12 @@ public class CountDistinctUpTo extends AccumulatorEvalFunc<Integer> implements A
 	// for accumulator implementation
 	private Set<Tuple> set;
 	private final int max;
-	
+
 	public CountDistinctUpTo(String maxAmount) {
 		max = Integer.valueOf(maxAmount);
 		set = new HashSet<Tuple>(max);
 	}
-	
+
 	@Override
 	public void accumulate(Tuple tuple) throws IOException {
 		count(set, tuple, max, log);
@@ -86,7 +86,7 @@ public class CountDistinctUpTo extends AccumulatorEvalFunc<Integer> implements A
 
 	/**
 	 * Counts tuples with a single level of embedding (input contains a bag containing tuples with the original schema)
-	 * 
+	 *
 	 * Used by both accumulator and algebraic implementations
 	 */
 	private static void count(Set<Tuple> set, Tuple input, int max, Log log) throws ExecException {
@@ -113,23 +113,23 @@ public class CountDistinctUpTo extends AccumulatorEvalFunc<Integer> implements A
 
 	/**
 	 * Counts tuples with two levels of embedding (input contains a bag containing bags of tuples with the original schema)
-	 * 
+	 *
 	 * Used by the algebraic implementation. Returns null if the maximum was reached
 	 */
 	private static Set<Tuple> makeDistinctSet(Tuple input, int max, Log log) throws ExecException {
 		Set<Tuple> set = new HashSet<Tuple>(max);
 
 		DataBag bag = (DataBag) input.get(0);
-		
+
 		for (Tuple t : bag) {
-			
+
 			// we've encountered a null value from the combiner, therefore the max has already been reached (obviously, not used in the combiner itself)
 			if (t.get(0) == null) {
 				return null;
 			}
-			
+
 			count(set, t, max, log);
-			
+
 			// we've just now reached the maximum
 			if (set.size() == max) {
 				return null;
@@ -138,7 +138,7 @@ public class CountDistinctUpTo extends AccumulatorEvalFunc<Integer> implements A
 
 		return set;
 	}
-	
+
 	@Override
 	public void cleanup() {
 		set.clear();
@@ -166,14 +166,18 @@ public class CountDistinctUpTo extends AccumulatorEvalFunc<Integer> implements A
 
 	/**
 	 * Outputs a tuple containing a DataBag containing a single tuple T (the original schema) or an empty bag
-	 * 
+	 *
+	 * <pre>
+     * {@code
 	 *  T -> ({T})
+	 * }
+	 * </pre>
 	 */
 	public static class Initial extends EvalFunc<Tuple> {
 
 		public Initial() {}
 		public Initial(String maxAmount) {}
-			
+
 		@Override
 		public Tuple exec(Tuple input) throws IOException {
 			DataBag inputBag = (DataBag) input.get(0);
@@ -186,17 +190,29 @@ public class CountDistinctUpTo extends AccumulatorEvalFunc<Integer> implements A
 					outputBag.add(t);
 				}
 			}
-			
+
 			return tupleFactory.newTuple(outputBag);
 		}
 	}
 
 	/**
 	 * Receives a bag of bags, each containing a single tuple with the original input schema T
-	 * 
-	 * Outputs a bag of distinct tuples each with the original schema T: {({T}),({T}),({T})} -> ({T, T, T}) 
-	 * 
-	 * or if the maximum is reached, null: {({T}),({T}),({T}) ..} -> (null) 
+	 *
+	 * Outputs a bag of distinct tuples each with the original schema T:
+
+	 * <pre>
+     * {@code
+	 * {({T}),({T}),({T})} -> ({T, T, T})
+	 * }
+	 * </pre>
+	 *
+	 * or if the maximum is reached, null:
+	 *
+	 * <pre>
+     * {@code
+	 * {({T}),({T}),({T}) ..} -> (null)
+	 * }
+	 * </pre>
 	 */
 	public static class Intermediate extends EvalFunc<Tuple> {
 
@@ -205,7 +221,7 @@ public class CountDistinctUpTo extends AccumulatorEvalFunc<Integer> implements A
 		public Intermediate() {
 			this("0");
 		}
-		
+
 		public Intermediate(String maxAmount) {
 			max = Integer.valueOf(maxAmount);
 		}
@@ -219,10 +235,10 @@ public class CountDistinctUpTo extends AccumulatorEvalFunc<Integer> implements A
 				Tuple result = tupleFactory.newTuple(1);
 				result.set(0, null);
 				return result;
-			} 
-			
+			}
+
 			DataBag outputBag = bagFactory.newDefaultBag();
-	
+
 			for (Tuple t : set) {
 				outputBag.add(t);
 			}
@@ -233,14 +249,18 @@ public class CountDistinctUpTo extends AccumulatorEvalFunc<Integer> implements A
 
 	/**
 	 * Receives output either from initial results or intermediate
-	 * 
-	 * Outputs an integer with the number of distinct tuples, up to the maximum desired. 
-	 * 
+	 *
+	 * Outputs an integer with the number of distinct tuples, up to the maximum desired.
+	 *
+	 * <pre>
+     * {@code
 	 * {({T}),({T,T,T})} -> (3)
-	 * 
+	 *
 	 * or
-	 * 
+	 *
 	 * {({T}),({T,T,T}),(null)} -> (MAX)
+	 * }
+	 * </pre>
 	 */
 	public static class Final extends EvalFunc<Integer> {
 
@@ -249,7 +269,7 @@ public class CountDistinctUpTo extends AccumulatorEvalFunc<Integer> implements A
 		public Final() {
 			this("0");
 		}
-		
+
 		public Final(String maxAmount) {
 			max = Integer.valueOf(maxAmount);
 		}
@@ -257,11 +277,11 @@ public class CountDistinctUpTo extends AccumulatorEvalFunc<Integer> implements A
 		@Override
 		public Integer exec(Tuple input) throws IOException {
 			Set<Tuple> set = makeDistinctSet(input, max, log);
-			
+
 			if (set == null) {
 				return max;
 			}
-			
+
 			return set.size();
 		}
 	}
diff --git a/datafu-pig/src/main/java/datafu/pig/hash/Hasher.java b/datafu-pig/src/main/java/datafu/pig/hash/Hasher.java
index 36accc8..c2afd1c 100644
--- a/datafu-pig/src/main/java/datafu/pig/hash/Hasher.java
+++ b/datafu-pig/src/main/java/datafu/pig/hash/Hasher.java
@@ -83,7 +83,8 @@ public class Hasher extends SimpleEvalFunc<String>
    * Generates hash values according to murmur3-32, a non-cryptographic-strength
    * hash function with good mixing.
    *
-   * @throws IllegalArgumentException, RuntimeException
+   * @throws IllegalArgumentException for an internal error
+   * @throws RuntimeException for an internal error
    */
   public Hasher() throws IllegalArgumentException, RuntimeException
   {
@@ -95,8 +96,9 @@ public class Hasher extends SimpleEvalFunc<String>
    *
    * See the Hasher class docs for a list of algorithms and guidance on selection.
    *
-   * @param algorithm
-   * @throws IllegalArgumentException, RuntimeException
+   * @param algorithm the hash algorithm to use
+   * @throws IllegalArgumentException for an invalid algorithm
+   * @throws RuntimeException for an internal error
    * @see    Hasher#makeHashFunc(String algorithm)
    *
    */
@@ -111,9 +113,10 @@ public class Hasher extends SimpleEvalFunc<String>
    *
    * See the Hasher class docs for a list of algorithms and guidance on selection.
    *
-   * @param  algorithm
-   * @param  seed
-   * @throws IllegalArgumentException, RuntimeException
+   * @param  algorithm the hash algorithm to use
+   * @param  seed the initial seed to use
+   * @throws IllegalArgumentException for an invalid algorithm or seed
+   * @throws RuntimeException when the seed cannot be parsed or other internal error
    * @see    Hasher#makeHashFunc(String algorithm, String seed)
    *
    */
@@ -127,14 +130,15 @@ public class Hasher extends SimpleEvalFunc<String>
    *
    * See the Hasher class docs for a list of algorithms and guidance on selection.
    *
-   * @param algorithm
-   * @throws IllegalArgumentException, RuntimeException
+   * @param algorithm the hash algorithm to use
+   * @throws IllegalArgumentException for an invalid seed given the algorithm
+   * @throws RuntimeException when the seed cannot be parsed
    */
   private void makeHashFunc(String algorithm) throws IllegalArgumentException, RuntimeException
   {
     if (hash_func != null) { throw new RuntimeException("The hash function should only be set once per instance"); }
 
-    if      (algorithm.startsWith("good-")) {
+    if (algorithm.startsWith("good-")) {
       int bits = Integer.parseInt(algorithm.substring(5));
       hash_func = Hashing.goodFastHash(bits);
     }
@@ -165,9 +169,10 @@ public class Hasher extends SimpleEvalFunc<String>
    *   32 hexadecimal digits.</li>
    * </ul>
    *
-   * @param algorithm
-   * @param seed
-   * @throws IllegalArgumentException, RuntimeException
+   * @param algorithm the hash algorithm to use
+   * @param seed the initial seed to use
+   * @throws IllegalArgumentException for an invalid seed given the algorithm
+   * @throws RuntimeException when the seed cannot be parsed
    */
   protected void makeHashFunc(String algorithm, String seed) throws IllegalArgumentException, RuntimeException
   {
diff --git a/datafu-pig/src/main/java/datafu/pig/hash/HasherRand.java b/datafu-pig/src/main/java/datafu/pig/hash/HasherRand.java
index c5707fd..02f5cf4 100644
--- a/datafu-pig/src/main/java/datafu/pig/hash/HasherRand.java
+++ b/datafu-pig/src/main/java/datafu/pig/hash/HasherRand.java
@@ -50,26 +50,28 @@ public class HasherRand extends Hasher
   * Generates hash values according to murmur3-32, a non-cryptographic-strength
   * hash function with good mixing.
   *
-  * @throws IllegalArgumentException, RuntimeException
-  * @see    #HasherRand(String alg)
+  * @see #HasherRand(String alg)
   */
- public HasherRand() throws IllegalArgumentException, RuntimeException
+ public HasherRand()
  {
    this("murmur3-32");
  }
 
   /**
-   * @param  alg
-   * @throws IllegalArgumentException, RuntimeException
-   * @see    #HasherRand()
+   * Generates hash values according to the given hash algorithm.
+   *
+   * @param alg the hash algorithm to use
+   * @see #HasherRand()
    */
-  public HasherRand(String alg) throws IllegalArgumentException, RuntimeException
+  public HasherRand(String alg)
   {
     algorithm = alg;
   }
 
   /**
-   * @param  val the single string to hash
+   * Generates the hash for a string value.
+   *
+   * @param val the single string to hash
    * @return val, hashed according to the algorithm specified at instantiation
    */
   @Override
diff --git a/site/README.md b/site/README.md
index 7e0722c..731198c 100644
--- a/site/README.md
+++ b/site/README.md
@@ -41,7 +41,22 @@ The static website content is located in another repo:
 
     svn co https://svn.apache.org/repos/asf/datafu apache-datafu-website
 
-## Commit the changes
+## Build and commit docs
+
+To generate the docs, run the commands below.  If you are in a release branch or building from a source release then the version should not include SNAPSHOT in the name.  Confirm this is the case by opening the docs after they are built.
+
+    ./gradlew clean
+    ./gradlew :datafu-spark:scaladoc :datafu-pig:javadoc :datafu-hourglass:javadoc
+
+Assuming current version is `x.y.z`, copy the docs to the site repo into new version directories:
+
+    cp -r ~/Projects/datafu/datafu-pig/build/docs/javadoc ~/Projects/apache-datafu-website/site/docs/datafu/x.y.z
+    cp -r ~/Projects/datafu/datafu-hourglass/build/docs/javadoc ~/Projects/apache-datafu-website/site/docs/hourglass/x.y.z
+    cp -r ~/Projects/datafu/datafu-spark/build/docs/scaladoc ~/Projects/apache-datafu-website/site/docs/spark/x.y.z
+
+Add and commit the changes.
+
+## Commit the website changes
 
 In the `apache-datafu-website` folder, delete the old content, which we will be replacing
 with new content:
@@ -55,18 +70,9 @@ Now copy the built content to the `apache-datafu-website` folder, replacing the
 
 This procedure unfortunately removes the javadocs too, which we want to keep and are not stored in the git repo.  We should add a script to make this easier.  In the meantime you can revert the deleted javadoc files with something resembling the commands below.  Check the `revert_list.txt` file before proceeding.
 
-    svn status | grep "\!" | cut -c 9- | grep -E "(datafu|hourglass)/\d\.\d\.\d/" > revert_list.txt
+    svn status | grep "\!" | cut -c 9- | grep -E "(datafu|hourglass|spark)/\d\.\d\.\d/" > revert_list.txt
     svn revert --targets revert_list.txt
 
-If this is a new release, make sure you have built the javadocs first.  If you are in the release branch for the repo, you can run `gradle assemble -Prelease=true` to generate the javadocs.  The `release=true` flag ensure SNAPSHOT does not appear in the name.  If you are building from the source release this isn't necessary and `gradle assemble` is fine.  Copy the new javadocs from the release into the site.
-
-    cp -r ~/Projects/datafu/datafu-pig/build/docs/javadoc site/docs/datafu/x.y.z
-    cp -r ~/Projects/datafu/datafu-hourglass/build/docs/javadoc site/docs/hourglass/x.y.z
-    svn add site/docs/datafu/x.y.z
-    svn add site/docs/hourglass/x.y.z
-
-Open the new javadocs and confirm they are correct before checking them in.  For example, make sure that the version is correct and the version does not have SNAPSHOT in the name.
-
 Check what has changed:
 
     svn status
diff --git a/site/source/docs/spark/getting-started.html.markdown.erb b/site/source/docs/spark/getting-started.html.markdown.erb
index 4b7dfb1..1512a0e 100644
--- a/site/source/docs/spark/getting-started.html.markdown.erb
+++ b/site/source/docs/spark/getting-started.html.markdown.erb
@@ -25,13 +25,13 @@ Apache DataFu Spark is a collection of utils and user-defined functions for work
 
 A list of some of the things you can do with DataFu Spark is given below:
 
-* ["Dedup" a table](https://github.com/apache/datafu/blob/spark-tmp/datafu-spark/src/main/scala/datafu/spark/SparkDFUtils.scala#L139) - remove duplicates based on a key and ordering (typically a date updated field, to get only the mostly recently updated record).
+* ["Dedup" a table](https://github.com/apache/datafu/blob/master/datafu-spark/src/main/scala/datafu/spark/SparkDFUtils.scala#L139) - remove duplicates based on a key and ordering (typically a date updated field, to get only the mostly recently updated record).
 
-* [Join a table with a numeric field with a table with a range](https://github.com/apache/datafu/blob/spark-tmp/datafu-spark/src/main/scala/datafu/spark/SparkDFUtils.scala#L361)
+* [Join a table with a numeric field with a table with a range](https://github.com/apache/datafu/blob/master/datafu-spark/src/main/scala/datafu/spark/SparkDFUtils.scala#L361)
 
-* [Do a skewed join between tables](https://github.com/apache/datafu/blob/spark-tmp/datafu-spark/src/main/scala/datafu/spark/SparkDFUtils.scala#L274) (where the small table is still too big to fit in memory)
+* [Do a skewed join between tables](https://github.com/apache/datafu/blob/master/datafu-spark/src/main/scala/datafu/spark/SparkDFUtils.scala#L274) (where the small table is still too big to fit in memory)
 
-* [Count distinct up to](https://github.com/apache/datafu/blob/spark-tmp/datafu-spark/src/main/scala/datafu/spark/SparkUDAFs.scala#L224) - an efficient implementation when you just want to verify that a certain minimum of distinct rows appear in a table
+* [Count distinct up to](https://github.com/apache/datafu/blob/master/datafu-spark/src/main/scala/datafu/spark/SparkUDAFs.scala#L224) - an efficient implementation when you just want to verify that a certain minimum of distinct rows appear in a table
 
 * Call Python code from Spark Scala, or Scala code from PySpark
 
diff --git a/site/source/layouts/_docs_nav.erb b/site/source/layouts/_docs_nav.erb
index 3c3d4ab..21445fd 100644
--- a/site/source/layouts/_docs_nav.erb
+++ b/site/source/layouts/_docs_nav.erb
@@ -29,20 +29,21 @@
 <ul class="nav nav-pills nav-stacked">
 
   <li><a href="/docs/spark/guide.html">Guide</a></li>
+  <li><a href="https://datafu.apache.org/docs/spark/1.6.0/">Scaladocs</a></li>
 </ul>
 
 <h4>DataFu Pig Docs</h4>
 <ul class="nav nav-pills nav-stacked">
 
   <li><a href="/docs/datafu/guide.html">Guide</a></li>
-  <li><a href="https://datafu.apache.org/docs/datafu/1.5.0/">Javadocs</a></li>
+  <li><a href="https://datafu.apache.org/docs/datafu/1.6.0/">Javadocs</a></li>
 </ul>
 
 <h4>DataFu Hourglass Docs</h4>
 <ul class="nav nav-pills nav-stacked">
 
   <li><a href="/docs/hourglass/concepts.html">Concepts</a></li>
-  <li><a href="https://datafu.apache.org/docs/hourglass/1.5.0/">Javadocs</a></li>
+  <li><a href="https://datafu.apache.org/docs/hourglass/1.6.0/">Javadocs</a></li>
 </ul>
 
 <h4>Community</h4>