fluo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ktur...@apache.org
Subject incubator-fluo-website git commit: Jekyll build from gh-pages:e31d7c8
Date Thu, 10 Nov 2016 20:44:59 GMT
Repository: incubator-fluo-website
Updated Branches:
  refs/heads/asf-site bc5bfd431 -> ecf039705


Jekyll build from gh-pages:e31d7c8

Blog post about immutable bytes


Project: http://git-wip-us.apache.org/repos/asf/incubator-fluo-website/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-fluo-website/commit/ecf03970
Tree: http://git-wip-us.apache.org/repos/asf/incubator-fluo-website/tree/ecf03970
Diff: http://git-wip-us.apache.org/repos/asf/incubator-fluo-website/diff/ecf03970

Branch: refs/heads/asf-site
Commit: ecf039705ad98d56b5eb547a9433b7bb23ea23d4
Parents: bc5bfd4
Author: Keith Turner <keith@deenlo.com>
Authored: Thu Nov 10 15:43:36 2016 -0500
Committer: Keith Turner <keith@deenlo.com>
Committed: Thu Nov 10 15:43:36 2016 -0500

----------------------------------------------------------------------
 blog/2014/12/30/stress-test-long-run/index.html |   8 +-
 .../22/fluo-talk-at-accumulo-summit/index.html  |   8 +-
 .../beta-2-pre-release-stress-test/index.html   |   8 +-
 blog/2016/01/11/webindex-long-run/index.html    |   8 +-
 blog/2016/05/17/webindex-long-run-2/index.html  |   8 +-
 .../2016/06/02/fluo-moving-to-apache/index.html |   8 +-
 blog/2016/11/10/immutable-bytes/index.html      | 322 +++++++++++++++++
 feed.xml                                        | 351 +++++++++++--------
 index.html                                      |  10 +-
 news/index.html                                 |   8 +
 10 files changed, 571 insertions(+), 168 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-fluo-website/blob/ecf03970/blog/2014/12/30/stress-test-long-run/index.html
----------------------------------------------------------------------
diff --git a/blog/2014/12/30/stress-test-long-run/index.html b/blog/2014/12/30/stress-test-long-run/index.html
index e929971..c975d2b 100644
--- a/blog/2014/12/30/stress-test-long-run/index.html
+++ b/blog/2014/12/30/stress-test-long-run/index.html
@@ -104,8 +104,12 @@
       <div class="row">
           <div class="col-sm-12">
             <div id="post-header">
-  <h2>First long stress test run on Fluo</h2>
-  <p class="text-muted">30 Dec 2014</p>
+  <h1>First long stress test run on Fluo</h1>
+  <p class="text-muted">
+     
+    
+    30 Dec 2014
+  </p> 
   <p><a class="twitter-share-button" href="https://twitter.com/intent/tweet?text=First long stress test run on Fluo&url=https://fluo.apache.org//blog/2014/12/30/stress-test-long-run/&via=ApacheFluo&related=ApacheFluo" rel="nofollow" target="_blank" title="Share on Twitter">Twitter</a></p>
 </div>
 <div id="post-content">

http://git-wip-us.apache.org/repos/asf/incubator-fluo-website/blob/ecf03970/blog/2015/05/22/fluo-talk-at-accumulo-summit/index.html
----------------------------------------------------------------------
diff --git a/blog/2015/05/22/fluo-talk-at-accumulo-summit/index.html b/blog/2015/05/22/fluo-talk-at-accumulo-summit/index.html
index fc08031..b89b08a 100644
--- a/blog/2015/05/22/fluo-talk-at-accumulo-summit/index.html
+++ b/blog/2015/05/22/fluo-talk-at-accumulo-summit/index.html
@@ -104,8 +104,12 @@
       <div class="row">
           <div class="col-sm-12">
             <div id="post-header">
-  <h2>Fluo talk at Accumulo Summit</h2>
-  <p class="text-muted">22 May 2015</p>
+  <h1>Fluo talk at Accumulo Summit</h1>
+  <p class="text-muted">
+     
+    
+    22 May 2015
+  </p> 
   <p><a class="twitter-share-button" href="https://twitter.com/intent/tweet?text=Fluo talk at Accumulo Summit&url=https://fluo.apache.org//blog/2015/05/22/fluo-talk-at-accumulo-summit/&via=ApacheFluo&related=ApacheFluo" rel="nofollow" target="_blank" title="Share on Twitter">Twitter</a></p>
 </div>
 <div id="post-content">

http://git-wip-us.apache.org/repos/asf/incubator-fluo-website/blob/ecf03970/blog/2015/12/22/beta-2-pre-release-stress-test/index.html
----------------------------------------------------------------------
diff --git a/blog/2015/12/22/beta-2-pre-release-stress-test/index.html b/blog/2015/12/22/beta-2-pre-release-stress-test/index.html
index c19d059..224176e 100644
--- a/blog/2015/12/22/beta-2-pre-release-stress-test/index.html
+++ b/blog/2015/12/22/beta-2-pre-release-stress-test/index.html
@@ -104,8 +104,12 @@
       <div class="row">
           <div class="col-sm-12">
             <div id="post-header">
-  <h2>Beta 2 pre-release stress test</h2>
-  <p class="text-muted">22 Dec 2015</p>
+  <h1>Beta 2 pre-release stress test</h1>
+  <p class="text-muted">
+     
+    
+    22 Dec 2015
+  </p> 
   <p><a class="twitter-share-button" href="https://twitter.com/intent/tweet?text=Beta 2 pre-release stress test&url=https://fluo.apache.org//blog/2015/12/22/beta-2-pre-release-stress-test/&via=ApacheFluo&related=ApacheFluo" rel="nofollow" target="_blank" title="Share on Twitter">Twitter</a></p>
 </div>
 <div id="post-content">

http://git-wip-us.apache.org/repos/asf/incubator-fluo-website/blob/ecf03970/blog/2016/01/11/webindex-long-run/index.html
----------------------------------------------------------------------
diff --git a/blog/2016/01/11/webindex-long-run/index.html b/blog/2016/01/11/webindex-long-run/index.html
index 8cefdf9..efeee26 100644
--- a/blog/2016/01/11/webindex-long-run/index.html
+++ b/blog/2016/01/11/webindex-long-run/index.html
@@ -104,8 +104,12 @@
       <div class="row">
           <div class="col-sm-12">
             <div id="post-header">
-  <h2>Running Webindex for 3 days on EC2</h2>
-  <p class="text-muted">11 Jan 2016</p>
+  <h1>Running Webindex for 3 days on EC2</h1>
+  <p class="text-muted">
+     
+    
+    11 Jan 2016
+  </p> 
   <p><a class="twitter-share-button" href="https://twitter.com/intent/tweet?text=Running Webindex for 3 days on EC2&url=https://fluo.apache.org//blog/2016/01/11/webindex-long-run/&via=ApacheFluo&related=ApacheFluo" rel="nofollow" target="_blank" title="Share on Twitter">Twitter</a></p>
 </div>
 <div id="post-content">

http://git-wip-us.apache.org/repos/asf/incubator-fluo-website/blob/ecf03970/blog/2016/05/17/webindex-long-run-2/index.html
----------------------------------------------------------------------
diff --git a/blog/2016/05/17/webindex-long-run-2/index.html b/blog/2016/05/17/webindex-long-run-2/index.html
index 2796d84..e184f24 100644
--- a/blog/2016/05/17/webindex-long-run-2/index.html
+++ b/blog/2016/05/17/webindex-long-run-2/index.html
@@ -104,8 +104,12 @@
       <div class="row">
           <div class="col-sm-12">
             <div id="post-header">
-  <h2>Running Webindex for 3 days on EC2 Again</h2>
-  <p class="text-muted">17 May 2016</p>
+  <h1>Running Webindex for 3 days on EC2 Again</h1>
+  <p class="text-muted">
+     
+    
+    17 May 2016
+  </p> 
   <p><a class="twitter-share-button" href="https://twitter.com/intent/tweet?text=Running Webindex for 3 days on EC2 Again&url=https://fluo.apache.org//blog/2016/05/17/webindex-long-run-2/&via=ApacheFluo&related=ApacheFluo" rel="nofollow" target="_blank" title="Share on Twitter">Twitter</a></p>
 </div>
 <div id="post-content">

http://git-wip-us.apache.org/repos/asf/incubator-fluo-website/blob/ecf03970/blog/2016/06/02/fluo-moving-to-apache/index.html
----------------------------------------------------------------------
diff --git a/blog/2016/06/02/fluo-moving-to-apache/index.html b/blog/2016/06/02/fluo-moving-to-apache/index.html
index c1720d1..f8e9f43 100644
--- a/blog/2016/06/02/fluo-moving-to-apache/index.html
+++ b/blog/2016/06/02/fluo-moving-to-apache/index.html
@@ -104,8 +104,12 @@
       <div class="row">
           <div class="col-sm-12">
             <div id="post-header">
-  <h2>Fluo is moving to Apache</h2>
-  <p class="text-muted">02 Jun 2016</p>
+  <h1>Fluo is moving to Apache</h1>
+  <p class="text-muted">
+     
+    
+    02 Jun 2016
+  </p> 
   <p><a class="twitter-share-button" href="https://twitter.com/intent/tweet?text=Fluo is moving to Apache&url=https://fluo.apache.org//blog/2016/06/02/fluo-moving-to-apache/&via=ApacheFluo&related=ApacheFluo" rel="nofollow" target="_blank" title="Share on Twitter">Twitter</a></p>
 </div>
 <div id="post-content">

http://git-wip-us.apache.org/repos/asf/incubator-fluo-website/blob/ecf03970/blog/2016/11/10/immutable-bytes/index.html
----------------------------------------------------------------------
diff --git a/blog/2016/11/10/immutable-bytes/index.html b/blog/2016/11/10/immutable-bytes/index.html
new file mode 100644
index 0000000..80a0624
--- /dev/null
+++ b/blog/2016/11/10/immutable-bytes/index.html
@@ -0,0 +1,322 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+
+    <link href="https://maxcdn.bootstrapcdn.com/bootswatch/3.3.7/cosmo/bootstrap.min.css" rel="stylesheet" integrity="sha384-h21C2fcDk/eFsW9sC9h0dhokq5pDinLNklTKoxIZRUn3+hvmgQSffLLQ4G4l2eEr" crossorigin="anonymous">
+    <link href="https://maxcdn.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css" rel="stylesheet" integrity="sha384-wvfXpqpZZVQGK6TAh5PVlGOfQNHSoD2xbE+QkPxCAFlNEevoEH3Sl0sibVcOQVnN" crossorigin="anonymous">
+    <link rel="stylesheet" href="/css/fluo.css">
+    <link rel="canonical" href="https://fluo.apache.org//blog/2016/11/10/immutable-bytes/">
+    <link rel="icon" type="image/png" href="/resources/favicon.png">
+    
+    <title>Java needs an immutable byte string | Apache Fluo</title>
+
+    <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.1.1/jquery.min.js"></script>
+    <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js" integrity="sha384-Tc5IQib027qvyjSMfHjOMaLkfuWVxZxUPnCJA7l2mCWNIpG9mGCD8wGNIcPD7Txa" crossorigin="anonymous"></script>
+    <!-- Place your <script> tags here. -->
+
+<!-- Google Analytics -->
+<script>
+  (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
+  (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
+  m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
+  })(window,document,'script','https://www.google-analytics.com/analytics.js','ga');
+
+  ga('create', 'UA-55360307-1', 'auto');
+  ga('send', 'pageview');
+
+</script>
+
+<script>window.twttr = (function(d, s, id) {
+  var js, fjs = d.getElementsByTagName(s)[0],
+    t = window.twttr || {};
+  if (d.getElementById(id)) return t;
+  js = d.createElement(s);
+  js.id = id;
+  js.src = "https://platform.twitter.com/widgets.js";
+  fjs.parentNode.insertBefore(js, fjs);
+
+  t._e = [];
+  t.ready = function(f) {
+    t._e.push(f);
+  };
+
+  return t;
+}(document, "script", "twitter-wjs"));</script>
+
+  </head>
+  <body style="padding-top: 100px">
+    <nav id="fluo-nav" class="navbar navbar-default navbar-fixed-top">
+      <div class="container">
+        <div class="navbar-header">
+          <div class="navbar-toggle-wrapper visible-xs">
+            <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".js-navbar-collapse">
+              <span class="icon-bar"></span>
+              <span class="icon-bar"></span>
+              <span class="icon-bar"></span>
+            </button>
+          </div>
+          <a href="/" class="navbar-brand"><img id="fluo-img" height="40px" src="/resources/fluo-logo-dark.png" alt="Apache Fluo"></a>
+        </div>
+        <div class="collapse navbar-collapse js-navbar-collapse" style="margin-top: 20px">
+          <ul class="navbar-nav nav">
+            <li><a href="/release/">Releases</a></li>
+            <li><a href="/tour/">Tour</a></li>
+            <li><a href="/docs/">Docs</a></li>
+            <li><a href="/api/">API</a></li>
+            <li class="dropdown">
+              <a class="dropdown-toggle" data-toggle="dropdown" href="#">Community<span class="caret"></span></a>
+              <ul class="dropdown-menu">
+                <li><a href="/getinvolved/">Get Involved</a></li>
+                <li><a href="/news/">News Archive</a></li>
+                <li><a href="/people/">People</a></li>
+                <li><a href="/related-projects/">Related Projects</a></li>
+                <li><a href="/poweredby/">Powered By</a></li>
+              </ul>
+            </li>
+            <li class="dropdown">
+              <a class="dropdown-toggle" data-toggle="dropdown" href="#">Contributing<span class="caret"></span></a>
+              <ul class="dropdown-menu">
+                <li><a href="/how-to-contribute/">How To Contribute</a></li>
+                <li><a href="/release-process/">Release Process</a></li>
+              </ul>
+            </li>
+          </ul>
+          <ul class="navbar-nav nav navbar-right">
+            <li class="dropdown">
+              <a class="dropdown-toggle" data-toggle="dropdown" href="#">Apache Software Foundation<span class="caret"></span></a>
+              <ul class="dropdown-menu">
+                <li><a href="https://www.apache.org">Apache Homepage</a></li>
+                <li><a href="https://www.apache.org/licenses/LICENSE-2.0">License</a></li>
+                <li><a href="https://www.apache.org/foundation/sponsorship">Sponsorship</i></a></li>
+                <li><a href="https://www.apache.org/security">Security</a></li>
+                <li><a href="https://www.apache.org/foundation/thanks">Thanks</a></li>
+                <li><a href="https://www.apache.org/foundation/policies/conduct">Code of Conduct</a></li>
+              </ul>
+            </li>
+          </ul>
+        </div>
+      </div>
+    </nav>
+    <div class="container">
+      <div class="row">
+          <div class="col-sm-12">
+            <div id="post-header">
+  <h1>Java needs an immutable byte string</h1>
+  <p class="text-muted">
+     Author : Keith Turner <br>  
+     Reviewer(s) : Christopher Tubbs, Mike Walch <br> 
+    10 Nov 2016
+  </p> 
+  <p><a class="twitter-share-button" href="https://twitter.com/intent/tweet?text=Java needs an immutable byte string&url=https://fluo.apache.org//blog/2016/11/10/immutable-bytes/&via=ApacheFluo&related=ApacheFluo" rel="nofollow" target="_blank" title="Share on Twitter">Twitter</a></p>
+</div>
+<div id="post-content">
+  <h2 id="fluo-data-model-and-transactions">Fluo Data Model and Transactions</h2>
+
+<p>Fluo uses a <a href="/tour/data-model/">data model</a> composed of key/values.  Each key has four fields :
+<em>row</em>,<em>family</em>,<em>qualifier</em>,<em>visibility</em>.  Each of these key fields is a sequence of bytes.  Fluo
+transactions read key/values from a snapshot of a table.  Any changes a transaction makes is
+buffered until commit.  At the time of commit the changes are only made if no other transaction
+modified any of the key values.</p>
+
+<p>While designing the Fluo API we were uncertain about making Fluo’s basic <a href="/tour/data-pojos/">POJOs</a> mutable or
+immutable.  In the end we decided to go with immutable types to make writing correct Fluo code
+easier.  One of the POJOs we created was <a href="https://static.javadoc.io/org.apache.fluo/fluo-api/1.0.0-incubating/org/apache/fluo/api/data/Bytes.html">Bytes</a>,  an immutable wrapper around a byte array.  We
+also created <a href="https://static.javadoc.io/org.apache.fluo/fluo-api/1.0.0-incubating/org/apache/fluo/api/data/Bytes.BytesBuilder.html">BytesBuilder</a>, which is analagous to StringBuilder, and makes it easy and efficient
+to construct Bytes.</p>
+
+<h3 id="what-about-the-copies">What about the copies?</h3>
+
+<p>Bytes requires a defensive copy at creation time.  When we were designing Fluo’s API we were worried
+about this at first.  However a simple truth became apparent.  If the API took a mutable type, then
+all boundary points between the user and Fluo would require defensive copies.  For example assume
+Fluo’s API took byte arrays and consider the following code.</p>
+
+<div class="language-java highlighter-rouge"><pre class="highlight"><code><span class="c1">//A Fluo transaction</span>
+<span class="n">Transaction</span> <span class="n">tx</span> <span class="o">=</span> <span class="o">...</span>
+<span class="kt">byte</span><span class="o">[]</span> <span class="n">row</span> <span class="o">=</span> <span class="o">...</span>
+
+<span class="n">tx</span><span class="o">.</span><span class="na">set</span><span class="o">(</span><span class="n">row</span><span class="o">,</span> <span class="n">column1</span><span class="o">,</span> <span class="n">value1</span><span class="o">);</span>
+<span class="n">tx</span><span class="o">.</span><span class="na">set</span><span class="o">(</span><span class="n">row</span><span class="o">,</span> <span class="n">column2</span><span class="o">,</span> <span class="n">value2</span><span class="o">);</span>
+<span class="n">tx</span><span class="o">.</span><span class="na">set</span><span class="o">(</span><span class="n">row</span><span class="o">,</span> <span class="n">column3</span><span class="o">,</span> <span class="n">value3</span><span class="o">);</span>
+</code></pre>
+</div>
+
+<p>Fluo will buffer changes until a transaction is committed.  In the example above since Fluo accepts
+a mutable row, it would be prudent to do a defensive copy each time <code class="highlighter-rouge">set()</code> is called above.</p>
+
+<p>In the code below where an immutable byte array wrapper is used, the calls to <code class="highlighter-rouge">set()</code> do not need to
+do a defensive copy.  So when comparing the two examples, the immutable byte wrapper results in less
+defensive copies.</p>
+
+<div class="language-java highlighter-rouge"><pre class="highlight"><code><span class="c1">//A Fluo transaction</span>
+<span class="n">Transaction</span> <span class="n">tx</span> <span class="o">=</span> <span class="o">...</span>
+<span class="n">Bytes</span> <span class="n">row</span> <span class="o">=</span> <span class="o">...</span>
+
+<span class="n">tx</span><span class="o">.</span><span class="na">set</span><span class="o">(</span><span class="n">row</span><span class="o">,</span> <span class="n">column1</span><span class="o">,</span> <span class="n">value1</span><span class="o">);</span>
+<span class="n">tx</span><span class="o">.</span><span class="na">set</span><span class="o">(</span><span class="n">row</span><span class="o">,</span> <span class="n">column2</span><span class="o">,</span> <span class="n">value2</span><span class="o">);</span>
+<span class="n">tx</span><span class="o">.</span><span class="na">set</span><span class="o">(</span><span class="n">row</span><span class="o">,</span> <span class="n">column3</span><span class="o">,</span> <span class="n">value3</span><span class="o">);</span>
+</code></pre>
+</div>
+
+<p>We really did not want to create Bytes and BytesBuilder types, however we could not find what we
+needed in Java’s standard libraries.  The following sections discuss some of the options we
+considered.</p>
+
+<h2 id="why-not-use-string">Why not use String?</h2>
+
+<p>Java’s String type is an immutable wrapper around a char array.  In order to store a byte array in a
+String, Java must decode the byte array using a character set.  Some sequences of bytes do not map
+in some characters sets.  Therefore, trying to stuff arbitrary binary data in a String can corrupt
+the data.  The following little program shows this, it will print <code class="highlighter-rouge">false</code>.</p>
+
+<div class="language-java highlighter-rouge"><pre class="highlight"><code>    <span class="kt">byte</span> <span class="n">bytes1</span><span class="o">[]</span> <span class="o">=</span> <span class="k">new</span> <span class="kt">byte</span><span class="o">[</span><span class="mi">256</span><span class="o">];</span>
+    <span class="k">for</span><span class="o">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">i</span><span class="o">&lt;</span><span class="mi">255</span><span class="o">;</span> <span class="n">i</span><span class="o">++)</span>
+      <span class="n">bytes1</span><span class="o">[</span><span class="n">i</span><span class="o">]</span> <span class="o">=</span> <span class="o">(</span><span class="kt">byte</span><span class="o">)</span><span class="n">i</span><span class="o">;</span>
+
+    <span class="kt">byte</span> <span class="n">bytes2</span><span class="o">[]</span> <span class="o">=</span> <span class="k">new</span> <span class="n">String</span><span class="o">(</span><span class="n">bytes1</span><span class="o">).</span><span class="na">getBytes</span><span class="o">();</span>
+
+    <span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">Arrays</span><span class="o">.</span><span class="na">equals</span><span class="o">(</span><span class="n">bytes1</span><span class="o">,</span> <span class="n">bytes2</span><span class="o">));</span>
+</code></pre>
+</div>
+
+<p>String can be made to work by specifying an appropriate character set. The following program will
+print <code class="highlighter-rouge">true</code>.  However, this is error prone and inefficient.  It’s error prone in the case where the
+character set is wrong or omitted.  It’s inefficient because it results in copying from byte arrays
+to char arrays and visa versa.  Also, char arrays use twice as much memory.</p>
+
+<div class="language-java highlighter-rouge"><pre class="highlight"><code>    <span class="kt">byte</span> <span class="n">bytes1</span><span class="o">[]</span> <span class="o">=</span> <span class="k">new</span> <span class="kt">byte</span><span class="o">[</span><span class="mi">256</span><span class="o">];</span>
+    <span class="k">for</span><span class="o">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">i</span><span class="o">&lt;</span><span class="mi">255</span><span class="o">;</span> <span class="n">i</span><span class="o">++)</span>
+      <span class="n">bytes1</span><span class="o">[</span><span class="n">i</span><span class="o">]</span> <span class="o">=</span> <span class="o">(</span><span class="kt">byte</span><span class="o">)</span><span class="n">i</span><span class="o">;</span>
+
+    <span class="n">String</span> <span class="n">str</span> <span class="o">=</span> <span class="k">new</span> <span class="n">String</span><span class="o">(</span><span class="n">bytes1</span><span class="o">,</span> <span class="n">StandardCharsets</span><span class="o">.</span><span class="na">ISO_8859_1</span><span class="o">);</span>
+    <span class="kt">byte</span> <span class="n">bytes2</span><span class="o">[]</span> <span class="o">=</span> <span class="n">str</span><span class="o">.</span><span class="na">getBytes</span><span class="o">(</span><span class="n">StandardCharsets</span><span class="o">.</span><span class="na">ISO_8859_1</span><span class="o">);</span>
+
+    <span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">Arrays</span><span class="o">.</span><span class="na">equals</span><span class="o">(</span><span class="n">bytes1</span><span class="o">,</span> <span class="n">bytes2</span><span class="o">));</span>
+</code></pre>
+</div>
+
+<h2 id="why-not-use-bytebuffer">Why not use ByteBuffer?</h2>
+
+<p>A read only ByteBuffer might seem like it would fit the bill of an immutable byte array wrapper.
+However, the following program shows two ways that ByteBuffer falls short.  ByteBuffers are great
+for I/O, but it would not be prudent to use them when immutability is desired.</p>
+
+<div class="language-java highlighter-rouge"><pre class="highlight"><code>    <span class="kt">byte</span><span class="o">[]</span> <span class="n">bytes1</span> <span class="o">=</span> <span class="k">new</span> <span class="kt">byte</span><span class="o">[]</span> <span class="o">{</span><span class="mi">1</span><span class="o">,</span><span class="mi">2</span><span class="o">,</span><span class="mi">3</span><span class="o">,(</span><span class="kt">byte</span><span class="o">)</span><span class="mi">250</span><span class="o">};</span>
+    <span class="n">ByteBuffer</span> <span class="n">bb1</span> <span class="o">=</span> <span class="n">ByteBuffer</span><span class="o">.</span><span class="na">wrap</span><span class="o">(</span><span class="n">bytes1</span><span class="o">).</span><span class="na">asReadOnlyBuffer</span><span class="o">();</span>
+
+    <span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">bb1</span><span class="o">.</span><span class="na">hashCode</span><span class="o">());</span>
+    <span class="n">bytes1</span><span class="o">[</span><span class="mi">2</span><span class="o">]=</span><span class="mi">89</span><span class="o">;</span>
+    <span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">bb1</span><span class="o">.</span><span class="na">hashCode</span><span class="o">());</span>
+    <span class="n">bb1</span><span class="o">.</span><span class="na">get</span><span class="o">();</span>
+    <span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">bb1</span><span class="o">.</span><span class="na">hashCode</span><span class="o">());</span>
+</code></pre>
+</div>
+
+<p>The program above prints the following, which is less than ideal :</p>
+
+<div class="highlighter-rouge"><pre class="highlight"><code>747721
+830367
+26786
+</code></pre>
+</div>
+
+<p>This little program shows two things.  First, the only guarantee we are getting from
+<code class="highlighter-rouge">asReadOnlyBuffer()</code> is that <code class="highlighter-rouge">bb1</code> can not be used to modify <code class="highlighter-rouge">bytes1</code>.  However, the originator of
+the read only buffer can still modify the wrapped byte array.   Java’s String and Fluo’s Bytes avoid
+this by always copying data into an internal private array that never escapes.</p>
+
+<p>The second issue is that <code class="highlighter-rouge">bb1</code> has a position and calling <code class="highlighter-rouge">bb1.get()</code> changes this position.
+Changing the position conceptually changes the contents of the ByteBuffer.  This is why <code class="highlighter-rouge">hashCode()</code>
+returns something different after <code class="highlighter-rouge">bb1.get()</code> is called.  So even though <code class="highlighter-rouge">bb1</code> does not enable
+mutating <code class="highlighter-rouge">bytes1</code>, <code class="highlighter-rouge">bb1</code> is itself mutable.</p>
+
+<h2 id="why-not-use-protobufs-bytestring">Why not use Protobuf’s ByteString?</h2>
+
+<p><a href="https://developers.google.com/protocol-buffers/">Protocol Buffers</a> has a beautiful implementation of an immutable byte array wrapper called
+<a href="https://developers.google.com/protocol-buffers/docs/reference/java/com/google/protobuf/ByteString">ByteString</a>.  I would encourage its use when possible.  I discovered this jewel after Bytes was
+implemented in Fluo.  Using it was considered, however in Fluo’s case its not really appropriate to
+use for two reasons.  First, any library designer should try to minimize what transitive dependencies
+they force on users.  Internally Fluo does not currently use Protocol Buffers in its implementation,
+so this would be a new dependency for Fluo users.  The second reason is going to require some
+background to explain.</p>
+
+<p>Technologies like <a href="https://www.osgi.org">OSGI</a> and <a href="http://openjdk.java.net/projects/jigsaw/">Jigsaw</a> seek to modularize Java libraries and provide dependency
+isolation.  Dependency isolation allows a user to use a library without having to share a libraries
+dependencies.  For example, consider the following hypothetical scenario.</p>
+
+<ul>
+  <li>Fluo’s implementation uses Protobuf version 2.5</li>
+  <li>Fluo user code uses Protobuf version 1.8</li>
+</ul>
+
+<p>Without dependency isolation, the user must converge dependencies and make their application and
+Fluo use the same version of Protobuf.  Sometimes this works without issue, but sometimes things
+will break because Protobuf dropped, changed, or added a method.</p>
+
+<p>With dependency isolation, Fluo’s implementation and Fluo user code can easily use different versions
+of Protobuf.  This is only true as long as Fluo’s API does not use Protobuf.  So, this is the second
+reason that Fluo should not use classes from Protobuf in its API.  If Fluo used Protobuf in its API
+then it forces the user to have to converge dependencies, even if they are using OSGI or Jigsaw.</p>
+
+<h2 id="java-should-have-an-immutable-byte-array-wrapper">Java should have an immutable byte array wrapper</h2>
+
+<p>So far, the following arguments have been presented:</p>
+
+<ul>
+  <li>An immutable byte array wrapper is useful and needed.</li>
+  <li>Java does not provide a good immutable byte array wrapper.</li>
+  <li>Using an immutable byte array wrapper from library X in library Y’s API may be problematic.</li>
+</ul>
+
+<p>These arguments all point to the need for an immutable byte array wrapper to exist in Java. This
+need could also be satisfied by a library outside of Java with some restrictions. Assume a new
+library called Lib Immutable Byte Array Wrapper (libibaw) was created.  In order for libibaw to be
+used in other libraries APIs, it would need to promise the following.</p>
+
+<ul>
+  <li>No dependencies other than Java.</li>
+  <li>Backwards compatibility.</li>
+</ul>
+
+<p>The reason backwards compatibility is important is that it would make dependency convergence super
+easy.  The following situation shows this.</p>
+
+<ul>
+  <li>Fluo uses libibaw 1.2 in its API</li>
+  <li>Fluo user code uses libibaw 1.1.</li>
+</ul>
+
+<p>If libibaw promises backward compatibility, then all the user needs to do is use version 1.2 of
+libibaw.  With the promise of backwards compatibility, using version 1.2 will not break the users
+code.</p>
+
+<p>Having a library would be nice, but having something in Java would minimize copies.  Outside
+of Java there will inevitably be multiple implementations and going between them will require a
+copy.  For example if a user uses Fluo and Protobuf they may be forced to copy Fluo’s Bytes to
+Protobuf’s ByteString. If Protobuf and Fluo both used an immutable byte sequence type from Java, this
+would not be needed.</p>
+
+
+</div>
+
+<div>
+  <p class="text-muted">View all posts in the <a href="/news/">news archive</a></p>
+</div>
+
+          </div>
+      </div>
+      <hr>
+      <div class="row footer">
+        <div class="col-sm-12 text-center">
+          <div class="center-block">
+          <a href="https://apache.org"><img src="/resources/feather.png" alt="Apache"></a>
+          Copyright &copy; 2016 The Apache Software Foundation. Licensed under the <a href="https://www.apache.org/licenses/LICENSE-2.0">Apache&nbsp;License,&nbsp;Version&nbsp;2.0</a>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>

http://git-wip-us.apache.org/repos/asf/incubator-fluo-website/blob/ecf03970/feed.xml
----------------------------------------------------------------------
diff --git a/feed.xml b/feed.xml
index 734d926..0c5ee97 100644
--- a/feed.xml
+++ b/feed.xml
@@ -5,11 +5,209 @@
     <description></description>
     <link>https://fluo.apache.org//</link>
     <atom:link href="https://fluo.apache.org//feed.xml" rel="self" type="application/rss+xml" />
-    <pubDate>Tue, 08 Nov 2016 17:16:42 +0000</pubDate>
-    <lastBuildDate>Tue, 08 Nov 2016 17:16:42 +0000</lastBuildDate>
+    <pubDate>Thu, 10 Nov 2016 20:43:33 +0000</pubDate>
+    <lastBuildDate>Thu, 10 Nov 2016 20:43:33 +0000</lastBuildDate>
     <generator>Jekyll v3.2.1</generator>
     
       <item>
+        <title>Java needs an immutable byte string</title>
+        <description>&lt;h2 id=&quot;fluo-data-model-and-transactions&quot;&gt;Fluo Data Model and Transactions&lt;/h2&gt;
+
+&lt;p&gt;Fluo uses a &lt;a href=&quot;/tour/data-model/&quot;&gt;data model&lt;/a&gt; composed of key/values.  Each key has four fields :
+&lt;em&gt;row&lt;/em&gt;,&lt;em&gt;family&lt;/em&gt;,&lt;em&gt;qualifier&lt;/em&gt;,&lt;em&gt;visibility&lt;/em&gt;.  Each of these key fields is a sequence of bytes.  Fluo
+transactions read key/values from a snapshot of a table.  Any changes a transaction makes is
+buffered until commit.  At the time of commit the changes are only made if no other transaction
+modified any of the key values.&lt;/p&gt;
+
+&lt;p&gt;While designing the Fluo API we were uncertain about making Fluo’s basic &lt;a href=&quot;/tour/data-pojos/&quot;&gt;POJOs&lt;/a&gt; mutable or
+immutable.  In the end we decided to go with immutable types to make writing correct Fluo code
+easier.  One of the POJOs we created was &lt;a href=&quot;https://static.javadoc.io/org.apache.fluo/fluo-api/1.0.0-incubating/org/apache/fluo/api/data/Bytes.html&quot;&gt;Bytes&lt;/a&gt;,  an immutable wrapper around a byte array.  We
+also created &lt;a href=&quot;https://static.javadoc.io/org.apache.fluo/fluo-api/1.0.0-incubating/org/apache/fluo/api/data/Bytes.BytesBuilder.html&quot;&gt;BytesBuilder&lt;/a&gt;, which is analagous to StringBuilder, and makes it easy and efficient
+to construct Bytes.&lt;/p&gt;
+
+&lt;h3 id=&quot;what-about-the-copies&quot;&gt;What about the copies?&lt;/h3&gt;
+
+&lt;p&gt;Bytes requires a defensive copy at creation time.  When we were designing Fluo’s API we were worried
+about this at first.  However a simple truth became apparent.  If the API took a mutable type, then
+all boundary points between the user and Fluo would require defensive copies.  For example assume
+Fluo’s API took byte arrays and consider the following code.&lt;/p&gt;
+
+&lt;div class=&quot;language-java highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;c1&quot;&gt;//A Fluo transaction&lt;/span&gt;
+&lt;span class=&quot;n&quot;&gt;Transaction&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;tx&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;...&lt;/span&gt;
+&lt;span class=&quot;kt&quot;&gt;byte&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;[]&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;row&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;...&lt;/span&gt;
+
+&lt;span class=&quot;n&quot;&gt;tx&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;set&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;row&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;column1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;value1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
+&lt;span class=&quot;n&quot;&gt;tx&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;set&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;row&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;column2&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;value2&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
+&lt;span class=&quot;n&quot;&gt;tx&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;set&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;row&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;column3&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;value3&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
+&lt;/code&gt;&lt;/pre&gt;
+&lt;/div&gt;
+
+&lt;p&gt;Fluo will buffer changes until a transaction is committed.  In the example above since Fluo accepts
+a mutable row, it would be prudent to do a defensive copy each time &lt;code class=&quot;highlighter-rouge&quot;&gt;set()&lt;/code&gt; is called above.&lt;/p&gt;
+
+&lt;p&gt;In the code below where an immutable byte array wrapper is used, the calls to &lt;code class=&quot;highlighter-rouge&quot;&gt;set()&lt;/code&gt; do not need to
+do a defensive copy.  So when comparing the two examples, the immutable byte wrapper results in less
+defensive copies.&lt;/p&gt;
+
+&lt;div class=&quot;language-java highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;c1&quot;&gt;//A Fluo transaction&lt;/span&gt;
+&lt;span class=&quot;n&quot;&gt;Transaction&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;tx&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;...&lt;/span&gt;
+&lt;span class=&quot;n&quot;&gt;Bytes&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;row&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;...&lt;/span&gt;
+
+&lt;span class=&quot;n&quot;&gt;tx&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;set&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;row&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;column1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;value1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
+&lt;span class=&quot;n&quot;&gt;tx&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;set&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;row&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;column2&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;value2&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
+&lt;span class=&quot;n&quot;&gt;tx&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;set&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;row&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;column3&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;value3&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
+&lt;/code&gt;&lt;/pre&gt;
+&lt;/div&gt;
+
+&lt;p&gt;We really did not want to create Bytes and BytesBuilder types, however we could not find what we
+needed in Java’s standard libraries.  The following sections discuss some of the options we
+considered.&lt;/p&gt;
+
+&lt;h2 id=&quot;why-not-use-string&quot;&gt;Why not use String?&lt;/h2&gt;
+
+&lt;p&gt;Java’s String type is an immutable wrapper around a char array.  In order to store a byte array in a
+String, Java must decode the byte array using a character set.  Some sequences of bytes do not map
+in some characters sets.  Therefore, trying to stuff arbitrary binary data in a String can corrupt
+the data.  The following little program shows this, it will print &lt;code class=&quot;highlighter-rouge&quot;&gt;false&lt;/code&gt;.&lt;/p&gt;
+
+&lt;div class=&quot;language-java highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;    &lt;span class=&quot;kt&quot;&gt;byte&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;bytes1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;[]&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;byte&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;256&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;];&lt;/span&gt;
+    &lt;span class=&quot;k&quot;&gt;for&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;i&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;255&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;++)&lt;/span&gt;
+      &lt;span class=&quot;n&quot;&gt;bytes1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;]&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;byte&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;
+
+    &lt;span class=&quot;kt&quot;&gt;byte&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;bytes2&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;[]&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;String&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;bytes1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;).&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;getBytes&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;();&lt;/span&gt;
+
+    &lt;span class=&quot;n&quot;&gt;System&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;out&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;println&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Arrays&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;equals&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;bytes1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;bytes2&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;));&lt;/span&gt;
+&lt;/code&gt;&lt;/pre&gt;
+&lt;/div&gt;
+
+&lt;p&gt;String can be made to work by specifying an appropriate character set. The following program will
+print &lt;code class=&quot;highlighter-rouge&quot;&gt;true&lt;/code&gt;.  However, this is error prone and inefficient.  It’s error prone in the case where the
+character set is wrong or omitted.  It’s inefficient because it results in copying from byte arrays
+to char arrays and visa versa.  Also, char arrays use twice as much memory.&lt;/p&gt;
+
+&lt;div class=&quot;language-java highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;    &lt;span class=&quot;kt&quot;&gt;byte&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;bytes1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;[]&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;byte&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;256&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;];&lt;/span&gt;
+    &lt;span class=&quot;k&quot;&gt;for&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;i&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;mi&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;255&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;++)&lt;/span&gt;
+      &lt;span class=&quot;n&quot;&gt;bytes1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;]&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;byte&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;i&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;
+
+    &lt;span class=&quot;n&quot;&gt;String&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;str&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;String&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;bytes1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;StandardCharsets&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;ISO_8859_1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
+    &lt;span class=&quot;kt&quot;&gt;byte&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;bytes2&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;[]&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;str&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;getBytes&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;StandardCharsets&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;ISO_8859_1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
+
+    &lt;span class=&quot;n&quot;&gt;System&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;out&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;println&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Arrays&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;equals&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;bytes1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;bytes2&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;));&lt;/span&gt;
+&lt;/code&gt;&lt;/pre&gt;
+&lt;/div&gt;
+
+&lt;h2 id=&quot;why-not-use-bytebuffer&quot;&gt;Why not use ByteBuffer?&lt;/h2&gt;
+
+&lt;p&gt;A read only ByteBuffer might seem like it would fit the bill of an immutable byte array wrapper.
+However, the following program shows two ways that ByteBuffer falls short.  ByteBuffers are great
+for I/O, but it would not be prudent to use them when immutability is desired.&lt;/p&gt;
+
+&lt;div class=&quot;language-java highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;    &lt;span class=&quot;kt&quot;&gt;byte&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;[]&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;bytes1&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;byte&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;[]&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;2&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;3&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;,(&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;byte&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;250&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;};&lt;/span&gt;
+    &lt;span class=&quot;n&quot;&gt;ByteBuffer&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;bb1&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;ByteBuffer&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;wrap&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;bytes1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;).&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;asReadOnlyBuffer&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;();&lt;/span&gt;
+
+    &lt;span class=&quot;n&quot;&gt;System&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;out&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;println&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;bb1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;hashCode&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;());&lt;/span&gt;
+    &lt;span class=&quot;n&quot;&gt;bytes1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;2&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;]=&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;89&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;
+    &lt;span class=&quot;n&quot;&gt;System&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;out&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;println&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;bb1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;hashCode&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;());&lt;/span&gt;
+    &lt;span class=&quot;n&quot;&gt;bb1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;get&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;();&lt;/span&gt;
+    &lt;span class=&quot;n&quot;&gt;System&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;out&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;println&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;bb1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;hashCode&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;());&lt;/span&gt;
+&lt;/code&gt;&lt;/pre&gt;
+&lt;/div&gt;
+
+&lt;p&gt;The program above prints the following, which is less than ideal :&lt;/p&gt;
+
+&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;747721
+830367
+26786
+&lt;/code&gt;&lt;/pre&gt;
+&lt;/div&gt;
+
+&lt;p&gt;This little program shows two things.  First, the only guarantee we are getting from
+&lt;code class=&quot;highlighter-rouge&quot;&gt;asReadOnlyBuffer()&lt;/code&gt; is that &lt;code class=&quot;highlighter-rouge&quot;&gt;bb1&lt;/code&gt; can not be used to modify &lt;code class=&quot;highlighter-rouge&quot;&gt;bytes1&lt;/code&gt;.  However, the originator of
+the read only buffer can still modify the wrapped byte array.   Java’s String and Fluo’s Bytes avoid
+this by always copying data into an internal private array that never escapes.&lt;/p&gt;
+
+&lt;p&gt;The second issue is that &lt;code class=&quot;highlighter-rouge&quot;&gt;bb1&lt;/code&gt; has a position and calling &lt;code class=&quot;highlighter-rouge&quot;&gt;bb1.get()&lt;/code&gt; changes this position.
+Changing the position conceptually changes the contents of the ByteBuffer.  This is why &lt;code class=&quot;highlighter-rouge&quot;&gt;hashCode()&lt;/code&gt;
+returns something different after &lt;code class=&quot;highlighter-rouge&quot;&gt;bb1.get()&lt;/code&gt; is called.  So even though &lt;code class=&quot;highlighter-rouge&quot;&gt;bb1&lt;/code&gt; does not enable
+mutating &lt;code class=&quot;highlighter-rouge&quot;&gt;bytes1&lt;/code&gt;, &lt;code class=&quot;highlighter-rouge&quot;&gt;bb1&lt;/code&gt; is itself mutable.&lt;/p&gt;
+
+&lt;h2 id=&quot;why-not-use-protobufs-bytestring&quot;&gt;Why not use Protobuf’s ByteString?&lt;/h2&gt;
+
+&lt;p&gt;&lt;a href=&quot;https://developers.google.com/protocol-buffers/&quot;&gt;Protocol Buffers&lt;/a&gt; has a beautiful implementation of an immutable byte array wrapper called
+&lt;a href=&quot;https://developers.google.com/protocol-buffers/docs/reference/java/com/google/protobuf/ByteString&quot;&gt;ByteString&lt;/a&gt;.  I would encourage its use when possible.  I discovered this jewel after Bytes was
+implemented in Fluo.  Using it was considered, however in Fluo’s case its not really appropriate to
+use for two reasons.  First, any library designer should try to minimize what transitive dependencies
+they force on users.  Internally Fluo does not currently use Protocol Buffers in its implementation,
+so this would be a new dependency for Fluo users.  The second reason is going to require some
+background to explain.&lt;/p&gt;
+
+&lt;p&gt;Technologies like &lt;a href=&quot;https://www.osgi.org&quot;&gt;OSGI&lt;/a&gt; and &lt;a href=&quot;http://openjdk.java.net/projects/jigsaw/&quot;&gt;Jigsaw&lt;/a&gt; seek to modularize Java libraries and provide dependency
+isolation.  Dependency isolation allows a user to use a library without having to share a libraries
+dependencies.  For example, consider the following hypothetical scenario.&lt;/p&gt;
+
+&lt;ul&gt;
+  &lt;li&gt;Fluo’s implementation uses Protobuf version 2.5&lt;/li&gt;
+  &lt;li&gt;Fluo user code uses Protobuf version 1.8&lt;/li&gt;
+&lt;/ul&gt;
+
+&lt;p&gt;Without dependency isolation, the user must converge dependencies and make their application and
+Fluo use the same version of Protobuf.  Sometimes this works without issue, but sometimes things
+will break because Protobuf dropped, changed, or added a method.&lt;/p&gt;
+
+&lt;p&gt;With dependency isolation, Fluo’s implementation and Fluo user code can easily use different versions
+of Protobuf.  This is only true as long as Fluo’s API does not use Protobuf.  So, this is the second
+reason that Fluo should not use classes from Protobuf in its API.  If Fluo used Protobuf in its API
+then it forces the user to have to converge dependencies, even if they are using OSGI or Jigsaw.&lt;/p&gt;
+
+&lt;h2 id=&quot;java-should-have-an-immutable-byte-array-wrapper&quot;&gt;Java should have an immutable byte array wrapper&lt;/h2&gt;
+
+&lt;p&gt;So far, the following arguments have been presented:&lt;/p&gt;
+
+&lt;ul&gt;
+  &lt;li&gt;An immutable byte array wrapper is useful and needed.&lt;/li&gt;
+  &lt;li&gt;Java does not provide a good immutable byte array wrapper.&lt;/li&gt;
+  &lt;li&gt;Using an immutable byte array wrapper from library X in library Y’s API may be problematic.&lt;/li&gt;
+&lt;/ul&gt;
+
+&lt;p&gt;These arguments all point to the need for an immutable byte array wrapper to exist in Java. This
+need could also be satisfied by a library outside of Java with some restrictions. Assume a new
+library called Lib Immutable Byte Array Wrapper (libibaw) was created.  In order for libibaw to be
+used in other libraries APIs, it would need to promise the following.&lt;/p&gt;
+
+&lt;ul&gt;
+  &lt;li&gt;No dependencies other than Java.&lt;/li&gt;
+  &lt;li&gt;Backwards compatibility.&lt;/li&gt;
+&lt;/ul&gt;
+
+&lt;p&gt;The reason backwards compatibility is important is that it would make dependency convergence super
+easy.  The following situation shows this.&lt;/p&gt;
+
+&lt;ul&gt;
+  &lt;li&gt;Fluo uses libibaw 1.2 in its API&lt;/li&gt;
+  &lt;li&gt;Fluo user code uses libibaw 1.1.&lt;/li&gt;
+&lt;/ul&gt;
+
+&lt;p&gt;If libibaw promises backward compatibility, then all the user needs to do is use version 1.2 of
+libibaw.  With the promise of backwards compatibility, using version 1.2 will not break the users
+code.&lt;/p&gt;
+
+&lt;p&gt;Having a library would be nice, but having something in Java would minimize copies.  Outside
+of Java there will inevitably be multiple implementations and going between them will require a
+copy.  For example if a user uses Fluo and Protobuf they may be forced to copy Fluo’s Bytes to
+Protobuf’s ByteString. If Protobuf and Fluo both used an immutable byte sequence type from Java, this
+would not be needed.&lt;/p&gt;
+
+</description>
+        <pubDate>Thu, 10 Nov 2016 11:43:00 +0000</pubDate>
+        <link>https://fluo.apache.org//blog/2016/11/10/immutable-bytes/</link>
+        <guid isPermaLink="true">https://fluo.apache.org//blog/2016/11/10/immutable-bytes/</guid>
+        
+        
+        <category>blog</category>
+        
+      </item>
+    
+      <item>
         <title>Apache Fluo Recipes 1.0.0-incubating released</title>
         <description>&lt;p&gt;Apache Fluo Recipes builds on the Apache Fluo API to provide libraries of common code for Fluo developers.&lt;/p&gt;
 
@@ -984,154 +1182,5 @@ done with an empty table.&lt;/p&gt;
         
       </item>
     
-      <item>
-        <title>Fluo 1.0.0-beta-1 released</title>
-        <description>&lt;p&gt;Fluo 1.0.0-beta-1 is the second official release of Fluo. Fluo is an implementation of Google’s &lt;a href=&quot;http://research.google.com/pubs/pub36726.html&quot;&gt;percolator paper&lt;/a&gt;, which adds large-scale incremental 
-processing of data using distributed transactions and notifications. It runs on &lt;a href=&quot;http://hadoop.apache.org/docs/r2.5.1/hadoop-yarn/hadoop-yarn-site/YARN.html&quot;&gt;YARN&lt;/a&gt; and stores its data in &lt;a href=&quot;https://accumulo.apache.org/&quot;&gt;Accumulo&lt;/a&gt;.&lt;/p&gt;
-
-&lt;p&gt;Below are resources for this release:&lt;/p&gt;
-
-&lt;ul&gt;
-  &lt;li&gt;Download the &lt;a href=&quot;https://github.com/fluo-io/fluo/releases/tag/1.0.0-beta-1&quot;&gt;Fluo binary tarball&lt;/a&gt; for 1.0.0-beta-1 from GitHub.&lt;/li&gt;
-  &lt;li&gt;View the &lt;a href=&quot;/docs/fluo/1.0.0-beta-1/&quot;&gt;documentation&lt;/a&gt; for help getting started with Fluo.&lt;/li&gt;
-  &lt;li&gt;&lt;a href=&quot;https://javadoc.io/doc/io.fluo/fluo-api/1.0.0-beta-1/&quot;&gt;Javadocs&lt;/a&gt; are available for this release.&lt;/li&gt;
-  &lt;li&gt;A &lt;a href=&quot;https://github.com/fluo-io/fluo/tree/1.0.0-beta-1&quot;&gt;tag&lt;/a&gt; of Fluo codebase for 1.0.0-beta-1 is available.&lt;/li&gt;
-  &lt;li&gt;Fluo &lt;a href=&quot;http://search.maven.org/#search%7Cga%7C1%7Cfluo&quot;&gt;jars&lt;/a&gt; have been deployed to Maven Central.&lt;/li&gt;
-  &lt;li&gt;The &lt;a href=&quot;https://github.com/fluo-io/fluo-quickstart&quot;&gt;Quickstart&lt;/a&gt; and &lt;a href=&quot;https://github.com/fluo-io/phrasecount&quot;&gt;Phrasecount&lt;/a&gt; applications were updated to work with this release.&lt;/li&gt;
-&lt;/ul&gt;
-
-&lt;p&gt;This release closed &lt;a href=&quot;https://github.com/fluo-io/fluo/issues?q=milestone%3A1.0.0-beta-1+is%3Aclosed&quot;&gt;133 tickets&lt;/a&gt;. This release is not recommended for production use.
-There is no upgrade path from 1.0.0-alpha-1 to 1.0.0-beta-1.&lt;/p&gt;
-
-&lt;h2 id=&quot;significant-features&quot;&gt;Significant features&lt;/h2&gt;
-
-&lt;p&gt;This release contains many new features that makes it easier to run, develop, and monitor Fluo applications.&lt;/p&gt;
-
-&lt;h4 id=&quot;simplified-fluo-administration-on-a-local-machine-or-ec2-cluster&quot;&gt;Simplified Fluo administration on a local machine or EC2 cluster&lt;/h4&gt;
-
-&lt;p&gt;Developers can now run Fluo and its dependencies on their local machine (&lt;a href=&quot;https://github.com/fluo-io/fluo/issues/92&quot;&gt;#92&lt;/a&gt;) or an AWS EC2 cluster (&lt;a href=&quot;https://github.com/fluo-io/fluo/issues/356&quot;&gt;#356&lt;/a&gt;) using a few simple commands.
-This was done by creating two administration tools called &lt;a href=&quot;https://github.com/fluo-io/fluo-dev&quot;&gt;Fluo-dev&lt;/a&gt; and &lt;a href=&quot;https://github.com/fluo-io/fluo-deploy&quot;&gt;Fluo-deploy&lt;/a&gt; whose scripts and configuration reside in repos
-separate from the Fluo code base.  These tools allow developers to collaborate and share configuration for running Fluo.&lt;/p&gt;
-
-&lt;h4 id=&quot;transaction-metrics-are-viewable-using-common-monitoring-tools&quot;&gt;Transaction metrics are viewable using common monitoring tools&lt;/h4&gt;
-
-&lt;p&gt;Fluo now publishes metrics (&lt;a href=&quot;https://github.com/fluo-io/fluo/issues/20&quot;&gt;#20&lt;/a&gt;) about transactions, collisions, and timestamps using &lt;a href=&quot;https://dropwizard.github.io/metrics/3.1.0/&quot;&gt;Dropwizard metrics&lt;/a&gt;.  These metrics are by default published 
-using JMX and are viewable using JConsole or JVisualVM.  Fluo can also be configured to publish metrics to Graphite or Ganglia.  View the &lt;a href=&quot;https://github.com/fluo-io/fluo/blob/1.0.0-beta-1/docs/metrics.md&quot;&gt;metrics documentation&lt;/a&gt;
-for more information.&lt;/p&gt;
-
-&lt;h4 id=&quot;improved-processing-of-notifications-in-fluo-workers&quot;&gt;Improved processing of notifications in Fluo workers&lt;/h4&gt;
-
-&lt;p&gt;Fluo workers were refactored to separate the code used for finding and executing work.  Each worker uses a single thread for finding 
-work (&lt;a href=&quot;https://github.com/fluo-io/fluo/issues/19&quot;&gt;#19&lt;/a&gt;).  A new method was introduced to partition work among workers using a hash+mod of notifications (&lt;a href=&quot;https://github.com/fluo-io/fluo/issues/282&quot;&gt;#282&lt;/a&gt;).
-The commit message for &lt;a href=&quot;https://github.com/fluo-io/fluo/commit/4100e236b8438350e30eda924a6360e2c722ae37&quot;&gt;4100e23&lt;/a&gt; contains a good description of some of the benefits and drawback of the current
-hashing approach.&lt;/p&gt;
-
-&lt;h4 id=&quot;improved-the-deletion-of-observer-notifications&quot;&gt;Improved the deletion of observer notifications&lt;/h4&gt;
-
-&lt;p&gt;When a cell is deleted in Accumulo, a delete marker is inserted.  Delete markers stay around until
-all files in a tablet are compacted.  For Fluo this could cause a lot of notification delete markers
-to build up over time.  To avoid this buildup, the way Fluo deletes notifications was changed in
-(&lt;a href=&quot;https://github.com/fluo-io/fluo/issues/457&quot;&gt;#457&lt;/a&gt;).  Accumulo delete markers are no longer used, Fluo now uses a custom delete marker for
-notifications.  The custom deleter marker allows Fluo to do analysis when Accumulo flushes memory to
-disk and avoid writing many delete markers to persistent storage.&lt;/p&gt;
-
-&lt;h4 id=&quot;easier-management-of-fluo-from-the-command-line&quot;&gt;Easier management of Fluo from the command line&lt;/h4&gt;
-
-&lt;p&gt;Fluo now provides different scripts (&lt;strong&gt;fluo&lt;/strong&gt;, &lt;strong&gt;mini-fluo&lt;/strong&gt;, &amp;amp; &lt;strong&gt;local-fluo&lt;/strong&gt;) for managing Fluo using a YARN cluster, MiniFluo, or local processes.  Several commands
-were created for these scripts.  A &lt;strong&gt;scan&lt;/strong&gt; command allows users to print a snapshot of a Fluo table (&lt;a href=&quot;https://github.com/fluo-io/fluo/issues/319&quot;&gt;#319&lt;/a&gt;).  A &lt;strong&gt;info&lt;/strong&gt; command shows locations of containers
-when running Fluo in YARN (&lt;a href=&quot;https://github.com/fluo-io/fluo/issues/297&quot;&gt;#297&lt;/a&gt;).  A &lt;strong&gt;classpath&lt;/strong&gt; command gives users a list of jars needed to execute Fluo client code (&lt;a href=&quot;https://github.com/fluo-io/fluo/issues/436&quot;&gt;#436&lt;/a&gt;).  A &lt;strong&gt;wait&lt;/strong&gt; command will
-sleep until all notifications are processed (&lt;a href=&quot;https://github.com/fluo-io/fluo/issues/434&quot;&gt;#434&lt;/a&gt;).&lt;/p&gt;
-
-&lt;h4 id=&quot;support-for-running-multiple-fluo-applications-on-a-single-cluster&quot;&gt;Support for running multiple Fluo applications on a single cluster&lt;/h4&gt;
-
-&lt;p&gt;Users can now run multiple Fluo applications using a single cluster (&lt;a href=&quot;https://github.com/fluo-io/fluo/issues/454&quot;&gt;#454&lt;/a&gt;).  This enables different Fluo users to share the same cluster.  Fluo applications
-can be started and stopped independently.  Each application has its own configuration.&lt;/p&gt;
-
-&lt;h4 id=&quot;fluo-build-improvements&quot;&gt;Fluo build improvements&lt;/h4&gt;
-
-&lt;p&gt;On each build, all Java code is automatically formatted based on Google Java Style (&lt;a href=&quot;https://github.com/fluo-io/fluo/issues/479&quot;&gt;#479&lt;/a&gt;).  Also, checkstyle and findbugs will fail the build if certain
-standards are not reached (&lt;a href=&quot;https://github.com/fluo-io/fluo/issues/185&quot;&gt;#185&lt;/a&gt;).  The POM is also sorted (&lt;a href=&quot;https://github.com/fluo-io/fluo/issues/493&quot;&gt;#493&lt;/a&gt;).&lt;/p&gt;
-
-&lt;h4 id=&quot;organized-fluo-code-base&quot;&gt;Organized Fluo code base&lt;/h4&gt;
-
-&lt;p&gt;The Fluo stress test was moved to its own &lt;a href=&quot;https://github.com/fluo-io/fluo-stress&quot;&gt;repo&lt;/a&gt; and is no longer a sub-module (&lt;a href=&quot;https://github.com/fluo-io/fluo/issues/385&quot;&gt;#385&lt;/a&gt;).  MiniFluo was moved from fluo-core to the fluo-mini 
-module/jar (&lt;a href=&quot;https://github.com/fluo-io/fluo/issues/439&quot;&gt;#439&lt;/a&gt;).  This reduced the number of dependencies in fluo-core.  However, developers will now need to include the fluo-mini jar in their Maven
-POM if they start MiniFluo.&lt;/p&gt;
-
-&lt;h4 id=&quot;fluo-testing-improvements&quot;&gt;Fluo testing improvements&lt;/h4&gt;
-
-&lt;p&gt;Integration tests can now be run from Eclipse (&lt;a href=&quot;https://github.com/fluo-io/fluo/issues/322&quot;&gt;#322&lt;/a&gt;).  Several new &lt;a href=&quot;https://github.com/fluo-io/fluo/issues?utf8=%E2%9C%93&amp;amp;q=milestone%3A1.0.0-beta-1+is%3Aclosed+%22unit+test%22&quot;&gt;unit tests&lt;/a&gt; were created.&lt;/p&gt;
-
-&lt;h4 id=&quot;other-important-improvements-and-bug-fixes&quot;&gt;Other important improvements and bug fixes&lt;/h4&gt;
-
-&lt;ul&gt;
-  &lt;li&gt;&lt;a href=&quot;https://github.com/fluo-io/fluo/issues/470&quot;&gt;#470&lt;/a&gt; - Replaced FluoFileOutputFormat with an Accumulo Key/Value generator&lt;/li&gt;
-  &lt;li&gt;&lt;a href=&quot;https://github.com/fluo-io/fluo/issues/460&quot;&gt;#460&lt;/a&gt; - Reduced Fluo API module dependencies&lt;/li&gt;
-  &lt;li&gt;&lt;a href=&quot;https://github.com/fluo-io/fluo/issues/456&quot;&gt;#456&lt;/a&gt; - Fixed bug with notifications being lost when processes died&lt;/li&gt;
-  &lt;li&gt;&lt;a href=&quot;https://github.com/fluo-io/fluo/issues/446&quot;&gt;#446&lt;/a&gt; - Simplified log configuration and configure rolling log files in YARN&lt;/li&gt;
-  &lt;li&gt;&lt;a href=&quot;https://github.com/fluo-io/fluo/issues/442&quot;&gt;#442&lt;/a&gt; - Reduced the number of curator clients in FluoAdmin&lt;/li&gt;
-  &lt;li&gt;&lt;a href=&quot;https://github.com/fluo-io/fluo/issues/383&quot;&gt;#383&lt;/a&gt; - Improved transaction logging to help users debug collisions. See &lt;a href=&quot;https://github.com/fluo-io/fluo/blob/1.0.0-beta-1/docs/applications.md#debugging-applications&quot;&gt;debugging documentation&lt;/a&gt;.&lt;/li&gt;
-  &lt;li&gt;&lt;a href=&quot;https://github.com/fluo-io/fluo/issues/365&quot;&gt;#365&lt;/a&gt; - Analyze Fluo code to see what non-public Accumulo APIs are used&lt;/li&gt;
-  &lt;li&gt;&lt;a href=&quot;https://github.com/fluo-io/fluo/issues/362&quot;&gt;#362&lt;/a&gt; - Made API data objects immutable&lt;/li&gt;
-  &lt;li&gt;&lt;a href=&quot;https://github.com/fluo-io/fluo/issues/349&quot;&gt;#349&lt;/a&gt; - Support application level configuration in fluo.properties&lt;/li&gt;
-  &lt;li&gt;&lt;a href=&quot;https://github.com/fluo-io/fluo/issues/342&quot;&gt;#342&lt;/a&gt; - Add a configurable retry timeout to Fluo clients&lt;/li&gt;
-  &lt;li&gt;&lt;a href=&quot;https://github.com/fluo-io/fluo/issues/294&quot;&gt;#294&lt;/a&gt; - Fluo now uses chroot suffix in its Zookeeper connection.&lt;/li&gt;
-  &lt;li&gt;&lt;a href=&quot;https://github.com/fluo-io/fluo/issues/293&quot;&gt;#293&lt;/a&gt; - Add argument checking to FluoConfiguration&lt;/li&gt;
-  &lt;li&gt;&lt;a href=&quot;https://github.com/fluo-io/fluo/issues/244&quot;&gt;#244&lt;/a&gt; - Make re-initialization easier for user&lt;/li&gt;
-&lt;/ul&gt;
-
-&lt;h2 id=&quot;testing&quot;&gt;Testing&lt;/h2&gt;
-
-&lt;p&gt;A successful long stress test run was conducted using Fluo built from commit
-&lt;a href=&quot;https://github.com/fluo-io/fluo/commit/fb647dd6a470e8015654f8ed99b9196f5f49582a&quot;&gt;fb647dd&lt;/a&gt;.  The test ran very well and never fell behind like a
-&lt;a href=&quot;/blog/2014/12/30/stress-test-long-run/&quot;&gt;previous long run&lt;/a&gt; of stress did.  The test had the following
-properties.&lt;/p&gt;
-
-&lt;ul&gt;
-  &lt;li&gt;Initialized stress test using 1 billion random integers.&lt;/li&gt;
-  &lt;li&gt;Ran 150 incremental loads of 100 thousand integers.  Slept 3 minutes between loads.&lt;/li&gt;
-  &lt;li&gt;Used 19 m3.xlarge nodes on EC2.  16 workers and 3 masters&lt;/li&gt;
-  &lt;li&gt;Configuration for the test committed and tagged in git : &lt;a href=&quot;https://github.com/keith-turner/fluo-deploy/tree/beta-long-test-1&quot;&gt;fluo-deploy tag&lt;/a&gt; and &lt;a href=&quot;https://github.com/keith-turner/fluo-stress/tree/beta-long-test-1&quot;&gt;fluo-stress tag&lt;/a&gt;&lt;/li&gt;
-  &lt;li&gt;Opened two issues as a result of test &lt;a href=&quot;https://github.com/fluo-io/fluo/issues/499&quot;&gt;#499&lt;/a&gt; and &lt;a href=&quot;https://github.com/fluo-io/fluo-stress/issues/30&quot;&gt;fluo-stress#30&lt;/a&gt;&lt;/li&gt;
-&lt;/ul&gt;
-
-&lt;p&gt;Below is the trailing output from running the test.&lt;/p&gt;
-
-&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;*****Generating and loading incremental data set 148*****
-*****Generating and loading incremental data set 149*****
-*****Generating and loading incremental data set 150*****
-*****Calculating # of unique integers using MapReduce*****
-                UNIQUE=1014486419
-*****Wait for Fluo to finish processing*****
-05:33:40.158 [main] INFO  io.fluo.cluster.runner.AppRunner - The wait command will exit when all notifications are processed
-05:33:40.417 [Thread-3] INFO  io.fluo.core.oracle.OracleClient - Connected to oracle at worker4:9913
-05:33:41.308 [main] INFO  io.fluo.cluster.runner.AppRunner - All processing has finished!
-*****Printing # of unique integers calculated by Fluo*****
-Total at root : 1014486419
-Nodes Scanned : 59605
-*****Verifying Fluo &amp;amp; MapReduce results match*****
-Success! Fluo &amp;amp; MapReduce both calculated 1014486419 unique integers
-&lt;/code&gt;&lt;/pre&gt;
-&lt;/div&gt;
-
-&lt;p&gt;The test ran for a little over 12 hours.  Below are two plots pulled from
-graphite showing the number of notifications queued and transaction rate over
-the entire test run.  Load transactions are not included in the rate.  The rate
-is transactions per second.  The accuracy of these plots is uncertain because
-no graphite configuration changes were made.  The plots do seem within the
-ballpark.&lt;/p&gt;
-
-&lt;p&gt;&lt;img src=&quot;/resources/release/1.0.0-beta-1/queued.png&quot; alt=&quot;Notifications Queued&quot; title=&quot;Notifications Queued&quot; /&gt; &lt;img src=&quot;/resources/release/1.0.0-beta-1/rate.png&quot; alt=&quot;Transaction rate&quot; title=&quot;Transaction Rate&quot; /&gt;&lt;/p&gt;
-
-</description>
-        <pubDate>Tue, 09 Jun 2015 18:30:00 +0000</pubDate>
-        <link>https://fluo.apache.org//release/fluo-1.0.0-beta-1/</link>
-        <guid isPermaLink="true">https://fluo.apache.org//release/fluo-1.0.0-beta-1/</guid>
-        
-        
-        <category>release</category>
-        
-      </item>
-    
   </channel>
 </rss>

http://git-wip-us.apache.org/repos/asf/incubator-fluo-website/blob/ecf03970/index.html
----------------------------------------------------------------------
diff --git a/index.html b/index.html
index 26a73b3..faac8ca 100644
--- a/index.html
+++ b/index.html
@@ -123,7 +123,7 @@
         <div class="post-header-home">
           <div class="row">
             <div class="col-sm-12">
-              <p><a href="/release/fluo-recipes-1.0.0-incubating/">Apache Fluo Recipes 1.0.0-incubating released</a> &nbsp;<small class="text-muted">Oct 2016</small></p>
+              <p><a href="/blog/2016/11/10/immutable-bytes/">Java needs an immutable byte string</a> &nbsp;<small class="text-muted">Nov 2016</small></p>
             </div>
           </div>
         </div>
@@ -131,7 +131,7 @@
         <div class="post-header-home">
           <div class="row">
             <div class="col-sm-12">
-              <p><a href="/release/fluo-1.0.0-incubating/">Apache Fluo 1.0.0-incubating released</a> &nbsp;<small class="text-muted">Oct 2016</small></p>
+              <p><a href="/release/fluo-recipes-1.0.0-incubating/">Apache Fluo Recipes 1.0.0-incubating released</a> &nbsp;<small class="text-muted">Oct 2016</small></p>
             </div>
           </div>
         </div>
@@ -139,7 +139,7 @@
         <div class="post-header-home">
           <div class="row">
             <div class="col-sm-12">
-              <p><a href="/blog/2016/06/02/fluo-moving-to-apache/">Fluo is moving to Apache</a> &nbsp;<small class="text-muted">Jun 2016</small></p>
+              <p><a href="/release/fluo-1.0.0-incubating/">Apache Fluo 1.0.0-incubating released</a> &nbsp;<small class="text-muted">Oct 2016</small></p>
             </div>
           </div>
         </div>
@@ -147,7 +147,7 @@
         <div class="post-header-home">
           <div class="row">
             <div class="col-sm-12">
-              <p><a href="/blog/2016/05/17/webindex-long-run-2/">Running Webindex for 3 days on EC2 Again</a> &nbsp;<small class="text-muted">May 2016</small></p>
+              <p><a href="/blog/2016/06/02/fluo-moving-to-apache/">Fluo is moving to Apache</a> &nbsp;<small class="text-muted">Jun 2016</small></p>
             </div>
           </div>
         </div>
@@ -155,7 +155,7 @@
         <div class="post-header-home">
           <div class="row">
             <div class="col-sm-12">
-              <p><a href="/release/fluo-recipes-1.0.0-beta-2/">Fluo Recipes 1.0.0-beta-2 released</a> &nbsp;<small class="text-muted">Mar 2016</small></p>
+              <p><a href="/blog/2016/05/17/webindex-long-run-2/">Running Webindex for 3 days on EC2 Again</a> &nbsp;<small class="text-muted">May 2016</small></p>
             </div>
           </div>
         </div>

http://git-wip-us.apache.org/repos/asf/incubator-fluo-website/blob/ecf03970/news/index.html
----------------------------------------------------------------------
diff --git a/news/index.html b/news/index.html
index 5f429ef..6afa6d0 100644
--- a/news/index.html
+++ b/news/index.html
@@ -113,6 +113,14 @@
     <h3 class="archive-section-header">2016</h3>
   
   <div class="row">
+    <div class="col-md-1"><p>Nov 10</div>
+    <div class="col-md-10"><p><a href="/blog/2016/11/10/immutable-bytes/" class="post-title-archive">Java needs an immutable byte string</a></div>
+  </div>
+
+  
+  
+  
+  <div class="row">
     <div class="col-md-1"><p>Oct 28</div>
     <div class="col-md-10"><p><a href="/release/fluo-recipes-1.0.0-incubating/" class="post-title-archive">Apache Fluo Recipes 1.0.0-incubating released</a></div>
   </div>


Mime
View raw message