flink-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mj...@apache.org
Subject [2/8] flink-web git commit: rebuild web page
Date Mon, 11 Apr 2016 09:20:56 GMT
http://git-wip-us.apache.org/repos/asf/flink-web/blob/24f3ba5a/content/news/2015/02/09/streaming-example.html
----------------------------------------------------------------------
diff --git a/content/news/2015/02/09/streaming-example.html b/content/news/2015/02/09/streaming-example.html
index 691ec3c..77e6d27 100644
--- a/content/news/2015/02/09/streaming-example.html
+++ b/content/news/2015/02/09/streaming-example.html
@@ -169,7 +169,7 @@ and offers a new API including definition of flexible windows.</p>
 <p>In this post, we go through an example that uses the Flink Streaming
 API to compute statistics on stock market data that arrive
 continuously and combine the stock market data with Twitter streams.
-See the <a href="http://ci.apache.org/projects/flink/flink-docs-master/apis/streaming_guide.html">Streaming Programming
+See the <a href="http://ci.apache.org/projects/flink/flink-docs-master/apis/streaming/index.html">Streaming Programming
 Guide</a> for a
 detailed presentation of the Streaming API.</p>
 
@@ -246,16 +246,16 @@ found <a href="https://github.com/mbalassi/flink/blob/stockprices/flink-staging/
                 <span class="nd">@Override</span>
                 <span class="kd">public</span> <span class="n">StockPrice</span> <span class="nf">map</span><span class="o">(</span><span class="n">String</span> <span class="n">value</span><span class="o">)</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
                     <span class="n">tokens</span> <span class="o">=</span> <span class="n">value</span><span class="o">.</span><span class="na">split</span><span class="o">(</span><span class="s">&quot;,&quot;</span><span class="o">);</span>
-                    <span class="k">return</span> <span class="k">new</span> <span class="nf">StockPrice</span><span class="o">(</span><span class="n">tokens</span><span class="o">[</span><span class="mi">0</span><span class="o">],</span>
+                    <span class="k">return</span> <span class="k">new</span> <span class="n">StockPrice</span><span class="o">(</span><span class="n">tokens</span><span class="o">[</span><span class="mi">0</span><span class="o">],</span>
                         <span class="n">Double</span><span class="o">.</span><span class="na">parseDouble</span><span class="o">(</span><span class="n">tokens</span><span class="o">[</span><span class="mi">1</span><span class="o">]));</span>
                 <span class="o">}</span>
             <span class="o">});</span>
 
     <span class="c1">//Generate other stock streams</span>
-    <span class="n">DataStream</span><span class="o">&lt;</span><span class="n">StockPrice</span><span class="o">&gt;</span> <span class="n">SPX_stream</span> <span class="o">=</span> <span class="n">env</span><span class="o">.</span><span class="na">addSource</span><span class="o">(</span><span class="k">new</span> <span class="nf">StockSource</span><span class="o">(</span><span class="s">&quot;SPX&quot;</span><span class="o">,</span> <span class="mi">10</span><span class="o">));</span>
-    <span class="n">DataStream</span><span class="o">&lt;</span><span class="n">StockPrice</span><span class="o">&gt;</span> <span class="n">FTSE_stream</span> <span class="o">=</span> <span class="n">env</span><span class="o">.</span><span class="na">addSource</span><span class="o">(</span><span class="k">new</span> <span class="nf">StockSource</span><span class="o">(</span><span class="s">&quot;FTSE&quot;</span><span class="o">,</span> <span class="mi">20</span><span class="o">));</span>
-    <span class="n">DataStream</span><span class="o">&lt;</span><span class="n">StockPrice</span><span class="o">&gt;</span> <span class="n">DJI_stream</span> <span class="o">=</span> <span class="n">env</span><span class="o">.</span><span class="na">addSource</span><span class="o">(</span><span class="k">new</span> <span class="nf">StockSource</span><span class="o">(</span><span class="s">&quot;DJI&quot;</span><span class="o">,</span> <span class="mi">30</span><span class="o">));</span>
-    <span class="n">DataStream</span><span class="o">&lt;</span><span class="n">StockPrice</span><span class="o">&gt;</span> <span class="n">BUX_stream</span> <span class="o">=</span> <span class="n">env</span><span class="o">.</span><span class="na">addSource</span><span class="o">(</span><span class="k">new</span> <span class="nf">StockSource</span><span class="o">(</span><span class="s">&quot;BUX&quot;</span><span class="o">,</span> <span class="mi">40</span><span class="o">));</span>
+    <span class="n">DataStream</span><span class="o">&lt;</span><span class="n">StockPrice</span><span class="o">&gt;</span> <span class="n">SPX_stream</span> <span class="o">=</span> <span class="n">env</span><span class="o">.</span><span class="na">addSource</span><span class="o">(</span><span class="k">new</span> <span class="n">StockSource</span><span class="o">(</span><span class="s">&quot;SPX&quot;</span><span class="o">,</span> <span class="mi">10</span><span class="o">));</span>
+    <span class="n">DataStream</span><span class="o">&lt;</span><span class="n">StockPrice</span><span class="o">&gt;</span> <span class="n">FTSE_stream</span> <span class="o">=</span> <span class="n">env</span><span class="o">.</span><span class="na">addSource</span><span class="o">(</span><span class="k">new</span> <span class="n">StockSource</span><span class="o">(</span><span class="s">&quot;FTSE&quot;</span><span class="o">,</span> <span class="mi">20</span><span class="o">));</span>
+    <span class="n">DataStream</span><span class="o">&lt;</span><span class="n">StockPrice</span><span class="o">&gt;</span> <span class="n">DJI_stream</span> <span class="o">=</span> <span class="n">env</span><span class="o">.</span><span class="na">addSource</span><span class="o">(</span><span class="k">new</span> <span class="n">StockSource</span><span class="o">(</span><span class="s">&quot;DJI&quot;</span><span class="o">,</span> <span class="mi">30</span><span class="o">));</span>
+    <span class="n">DataStream</span><span class="o">&lt;</span><span class="n">StockPrice</span><span class="o">&gt;</span> <span class="n">BUX_stream</span> <span class="o">=</span> <span class="n">env</span><span class="o">.</span><span class="na">addSource</span><span class="o">(</span><span class="k">new</span> <span class="n">StockSource</span><span class="o">(</span><span class="s">&quot;BUX&quot;</span><span class="o">,</span> <span class="mi">40</span><span class="o">));</span>
 
     <span class="c1">//Merge all stock streams together</span>
     <span class="n">DataStream</span><span class="o">&lt;</span><span class="n">StockPrice</span><span class="o">&gt;</span> <span class="n">stockStream</span> <span class="o">=</span> <span class="n">socketStockStream</span>
@@ -269,10 +269,10 @@ found <a href="https://github.com/mbalassi/flink/blob/stockprices/flink-staging/
 </div>
 
 <p>See
-<a href="http://ci.apache.org/projects/flink/flink-docs-master/apis/streaming_guide.html#sources">here</a>
+<a href="http://ci.apache.org/projects/flink/flink-docs-master/apis/streaming/index.html#data-sources">here</a>
 on how you can create streaming sources for Flink Streaming
 programs. Flink, of course, has support for reading in streams from
-<a href="http://ci.apache.org/projects/flink/flink-docs-master/apis/streaming_guide.html#stream-connectors">external
+<a href="http://ci.apache.org/projects/flink/flink-docs-master/apis/streaming/connectors/index.html">external
 sources</a>
 such as Apache Kafka, Apache Flume, RabbitMQ, and others. For the sake
 of this example, the data streams are simply generated using the
@@ -336,11 +336,11 @@ of this example, the data streams are simply generated using the
     <span class="nd">@Override</span>
     <span class="kd">public</span> <span class="kt">void</span> <span class="nf">invoke</span><span class="o">(</span><span class="n">Collector</span><span class="o">&lt;</span><span class="n">StockPrice</span><span class="o">&gt;</span> <span class="n">collector</span><span class="o">)</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
         <span class="n">price</span> <span class="o">=</span> <span class="n">DEFAULT_PRICE</span><span class="o">;</span>
-        <span class="n">Random</span> <span class="n">random</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">Random</span><span class="o">();</span>
+        <span class="n">Random</span> <span class="n">random</span> <span class="o">=</span> <span class="k">new</span> <span class="n">Random</span><span class="o">();</span>
 
         <span class="k">while</span> <span class="o">(</span><span class="kc">true</span><span class="o">)</span> <span class="o">{</span>
             <span class="n">price</span> <span class="o">=</span> <span class="n">price</span> <span class="o">+</span> <span class="n">random</span><span class="o">.</span><span class="na">nextGaussian</span><span class="o">()</span> <span class="o">*</span> <span class="n">sigma</span><span class="o">;</span>
-            <span class="n">collector</span><span class="o">.</span><span class="na">collect</span><span class="o">(</span><span class="k">new</span> <span class="nf">StockPrice</span><span class="o">(</span><span class="n">symbol</span><span class="o">,</span> <span class="n">price</span><span class="o">));</span>
+            <span class="n">collector</span><span class="o">.</span><span class="na">collect</span><span class="o">(</span><span class="k">new</span> <span class="n">StockPrice</span><span class="o">(</span><span class="n">symbol</span><span class="o">,</span> <span class="n">price</span><span class="o">));</span>
             <span class="n">Thread</span><span class="o">.</span><span class="na">sleep</span><span class="o">(</span><span class="n">random</span><span class="o">.</span><span class="na">nextInt</span><span class="o">(</span><span class="mi">200</span><span class="o">));</span>
         <span class="o">}</span>
     <span class="o">}</span>
@@ -380,7 +380,7 @@ INFO    Custom Source(1/1) switched to DEPLOYING
 <h2 id="window-aggregations">Window aggregations</h2>
 
 <p>We first compute aggregations on time-based windows of the
-data. Flink provides <a href="http://ci.apache.org/projects/flink/flink-docs-master/apis/streaming_guide.html#window-operators">flexible windowing semantics</a> where windows can
+data. Flink provides <a href="http://ci.apache.org/projects/flink/flink-docs-master/apis/streaming/windows.html">flexible windowing semantics</a> where windows can
 also be defined based on count of records or any custom user defined
 logic.</p>
 
@@ -427,7 +427,7 @@ performed on named fields of POJOs, making the code more readable.</p>
 <span class="n">DataStream</span><span class="o">&lt;</span><span class="n">StockPrice</span><span class="o">&gt;</span> <span class="n">maxByStock</span> <span class="o">=</span> <span class="n">windowedStream</span><span class="o">.</span><span class="na">groupBy</span><span class="o">(</span><span class="s">&quot;symbol&quot;</span><span class="o">)</span>
     <span class="o">.</span><span class="na">maxBy</span><span class="o">(</span><span class="s">&quot;price&quot;</span><span class="o">).</span><span class="na">flatten</span><span class="o">();</span>
 <span class="n">DataStream</span><span class="o">&lt;</span><span class="n">StockPrice</span><span class="o">&gt;</span> <span class="n">rollingMean</span> <span class="o">=</span> <span class="n">windowedStream</span><span class="o">.</span><span class="na">groupBy</span><span class="o">(</span><span class="s">&quot;symbol&quot;</span><span class="o">)</span>
-    <span class="o">.</span><span class="na">mapWindow</span><span class="o">(</span><span class="k">new</span> <span class="nf">WindowMean</span><span class="o">()).</span><span class="na">flatten</span><span class="o">();</span>
+    <span class="o">.</span><span class="na">mapWindow</span><span class="o">(</span><span class="k">new</span> <span class="n">WindowMean</span><span class="o">()).</span><span class="na">flatten</span><span class="o">();</span>
 
 <span class="c1">//Compute the mean of a window</span>
 <span class="kd">public</span> <span class="kd">final</span> <span class="kd">static</span> <span class="kd">class</span> <span class="nc">WindowMean</span> <span class="kd">implements</span> 
@@ -447,7 +447,7 @@ performed on named fields of POJOs, making the code more readable.</p>
                 <span class="n">symbol</span> <span class="o">=</span> <span class="n">sp</span><span class="o">.</span><span class="na">symbol</span><span class="o">;</span>
                 <span class="n">count</span><span class="o">++;</span>
             <span class="o">}</span>
-            <span class="n">out</span><span class="o">.</span><span class="na">collect</span><span class="o">(</span><span class="k">new</span> <span class="nf">StockPrice</span><span class="o">(</span><span class="n">symbol</span><span class="o">,</span> <span class="n">sum</span> <span class="o">/</span> <span class="n">count</span><span class="o">));</span>
+            <span class="n">out</span><span class="o">.</span><span class="na">collect</span><span class="o">(</span><span class="k">new</span> <span class="n">StockPrice</span><span class="o">(</span><span class="n">symbol</span><span class="o">,</span> <span class="n">sum</span> <span class="o">/</span> <span class="n">count</span><span class="o">));</span>
         <span class="o">}</span>
     <span class="o">}</span>
 <span class="o">}</span></code></pre></div>
@@ -507,7 +507,7 @@ every 30 seconds.</p>
   <div data-lang="java7">
 
     <div class="highlight"><pre><code class="language-java" data-lang="java"><span class="kd">private</span> <span class="kd">static</span> <span class="kd">final</span> <span class="n">Double</span> <span class="n">DEFAULT_PRICE</span> <span class="o">=</span> <span class="mi">1000</span><span class="o">.;</span>
-<span class="kd">private</span> <span class="kd">static</span> <span class="kd">final</span> <span class="n">StockPrice</span> <span class="n">DEFAULT_STOCK_PRICE</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">StockPrice</span><span class="o">(</span><span class="s">&quot;&quot;</span><span class="o">,</span> <span class="n">DEFAULT_PRICE</span><span class="o">);</span>
+<span class="kd">private</span> <span class="kd">static</span> <span class="kd">final</span> <span class="n">StockPrice</span> <span class="n">DEFAULT_STOCK_PRICE</span> <span class="o">=</span> <span class="k">new</span> <span class="n">StockPrice</span><span class="o">(</span><span class="s">&quot;&quot;</span><span class="o">,</span> <span class="n">DEFAULT_PRICE</span><span class="o">);</span>
 
 <span class="c1">//Use delta policy to create price change warnings</span>
 <span class="n">DataStream</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span> <span class="n">priceWarnings</span> <span class="o">=</span> <span class="n">stockStream</span><span class="o">.</span><span class="na">groupBy</span><span class="o">(</span><span class="s">&quot;symbol&quot;</span><span class="o">)</span>
@@ -517,13 +517,13 @@ every 30 seconds.</p>
             <span class="k">return</span> <span class="n">Math</span><span class="o">.</span><span class="na">abs</span><span class="o">(</span><span class="n">oldDataPoint</span><span class="o">.</span><span class="na">price</span> <span class="o">-</span> <span class="n">newDataPoint</span><span class="o">.</span><span class="na">price</span><span class="o">);</span>
         <span class="o">}</span>
     <span class="o">},</span> <span class="n">DEFAULT_STOCK_PRICE</span><span class="o">))</span>
-<span class="o">.</span><span class="na">mapWindow</span><span class="o">(</span><span class="k">new</span> <span class="nf">SendWarning</span><span class="o">()).</span><span class="na">flatten</span><span class="o">();</span>
+<span class="o">.</span><span class="na">mapWindow</span><span class="o">(</span><span class="k">new</span> <span class="n">SendWarning</span><span class="o">()).</span><span class="na">flatten</span><span class="o">();</span>
 
 <span class="c1">//Count the number of warnings every half a minute</span>
 <span class="n">DataStream</span><span class="o">&lt;</span><span class="n">Count</span><span class="o">&gt;</span> <span class="n">warningsPerStock</span> <span class="o">=</span> <span class="n">priceWarnings</span><span class="o">.</span><span class="na">map</span><span class="o">(</span><span class="k">new</span> <span class="n">MapFunction</span><span class="o">&lt;</span><span class="n">String</span><span class="o">,</span> <span class="n">Count</span><span class="o">&gt;()</span> <span class="o">{</span>
     <span class="nd">@Override</span>
     <span class="kd">public</span> <span class="n">Count</span> <span class="nf">map</span><span class="o">(</span><span class="n">String</span> <span class="n">value</span><span class="o">)</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
-        <span class="k">return</span> <span class="k">new</span> <span class="nf">Count</span><span class="o">(</span><span class="n">value</span><span class="o">,</span> <span class="mi">1</span><span class="o">);</span>
+        <span class="k">return</span> <span class="k">new</span> <span class="n">Count</span><span class="o">(</span><span class="n">value</span><span class="o">,</span> <span class="mi">1</span><span class="o">);</span>
     <span class="o">}</span>
 <span class="o">}).</span><span class="na">groupBy</span><span class="o">(</span><span class="s">&quot;symbol&quot;</span><span class="o">).</span><span class="na">window</span><span class="o">(</span><span class="n">Time</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="mi">30</span><span class="o">,</span> <span class="n">TimeUnit</span><span class="o">.</span><span class="na">SECONDS</span><span class="o">)).</span><span class="na">sum</span><span class="o">(</span><span class="s">&quot;count&quot;</span><span class="o">).</span><span class="na">flatten</span><span class="o">();</span>
 
@@ -568,8 +568,8 @@ every 30 seconds.</p>
 <h2 id="combining-with-a-twitter-stream">Combining with a Twitter stream</h2>
 
 <p>Next, we will read a Twitter stream and correlate it with our stock
-price stream. Flink has support for connecting to <a href="http://ci.apache.org/projects/flink/flink-docs-master/apis/streaming_guide.html#twitter-streaming-api">Twitter’s
-API</a>,
+price stream. Flink has support for connecting to <a href="https://ci.apache.org/projects/flink/flink-docs-master/apis/streaming/connectors/twitter.html">Twitter’s
+API</a>
 but for the sake of this example we generate dummy tweet data.</p>
 
 <p><img alt="Social media analytics" src="/img/blog/blog_social_media.png" width="100%" class="img-responsive center-block" /></p>
@@ -605,7 +605,7 @@ but for the sake of this example we generate dummy tweet data.</p>
   <div data-lang="java7">
 
     <div class="highlight"><pre><code class="language-java" data-lang="java"><span class="c1">//Read a stream of tweets</span>
-<span class="n">DataStream</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span> <span class="n">tweetStream</span> <span class="o">=</span> <span class="n">env</span><span class="o">.</span><span class="na">addSource</span><span class="o">(</span><span class="k">new</span> <span class="nf">TweetSource</span><span class="o">());</span>
+<span class="n">DataStream</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span> <span class="n">tweetStream</span> <span class="o">=</span> <span class="n">env</span><span class="o">.</span><span class="na">addSource</span><span class="o">(</span><span class="k">new</span> <span class="n">TweetSource</span><span class="o">());</span>
 
 <span class="c1">//Extract the stock symbols</span>
 <span class="n">DataStream</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span> <span class="n">mentionedSymbols</span> <span class="o">=</span> <span class="n">tweetStream</span><span class="o">.</span><span class="na">flatMap</span><span class="o">(</span>
@@ -628,7 +628,7 @@ but for the sake of this example we generate dummy tweet data.</p>
 <span class="n">DataStream</span><span class="o">&lt;</span><span class="n">Count</span><span class="o">&gt;</span> <span class="n">tweetsPerStock</span> <span class="o">=</span> <span class="n">mentionedSymbols</span><span class="o">.</span><span class="na">map</span><span class="o">(</span><span class="k">new</span> <span class="n">MapFunction</span><span class="o">&lt;</span><span class="n">String</span><span class="o">,</span> <span class="n">Count</span><span class="o">&gt;()</span> <span class="o">{</span>
     <span class="nd">@Override</span>
     <span class="kd">public</span> <span class="n">Count</span> <span class="nf">map</span><span class="o">(</span><span class="n">String</span> <span class="n">value</span><span class="o">)</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
-        <span class="k">return</span> <span class="k">new</span> <span class="nf">Count</span><span class="o">(</span><span class="n">value</span><span class="o">,</span> <span class="mi">1</span><span class="o">);</span>
+        <span class="k">return</span> <span class="k">new</span> <span class="n">Count</span><span class="o">(</span><span class="n">value</span><span class="o">,</span> <span class="mi">1</span><span class="o">);</span>
     <span class="o">}</span>
 <span class="o">}).</span><span class="na">groupBy</span><span class="o">(</span><span class="s">&quot;symbol&quot;</span><span class="o">).</span><span class="na">window</span><span class="o">(</span><span class="n">Time</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="mi">30</span><span class="o">,</span> <span class="n">TimeUnit</span><span class="o">.</span><span class="na">SECONDS</span><span class="o">)).</span><span class="na">sum</span><span class="o">(</span><span class="s">&quot;count&quot;</span><span class="o">).</span><span class="na">flatten</span><span class="o">();</span>
 
@@ -638,8 +638,8 @@ but for the sake of this example we generate dummy tweet data.</p>
 
     <span class="nd">@Override</span>
     <span class="kd">public</span> <span class="kt">void</span> <span class="nf">invoke</span><span class="o">(</span><span class="n">Collector</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span> <span class="n">collector</span><span class="o">)</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
-        <span class="n">random</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">Random</span><span class="o">();</span>
-        <span class="n">stringBuilder</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">StringBuilder</span><span class="o">();</span>
+        <span class="n">random</span> <span class="o">=</span> <span class="k">new</span> <span class="n">Random</span><span class="o">();</span>
+        <span class="n">stringBuilder</span> <span class="o">=</span> <span class="k">new</span> <span class="n">StringBuilder</span><span class="o">();</span>
 
         <span class="k">while</span> <span class="o">(</span><span class="kc">true</span><span class="o">)</span> <span class="o">{</span>
             <span class="n">stringBuilder</span><span class="o">.</span><span class="na">setLength</span><span class="o">(</span><span class="mi">0</span><span class="o">);</span>
@@ -721,7 +721,7 @@ these data streams are potentially infinite, we apply the join on a
 <span class="c1">//Compute rolling correlation</span>
 <span class="n">DataStream</span><span class="o">&lt;</span><span class="n">Double</span><span class="o">&gt;</span> <span class="n">rollingCorrelation</span> <span class="o">=</span> <span class="n">tweetsAndWarning</span>
     <span class="o">.</span><span class="na">window</span><span class="o">(</span><span class="n">Time</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="mi">30</span><span class="o">,</span> <span class="n">TimeUnit</span><span class="o">.</span><span class="na">SECONDS</span><span class="o">))</span>
-    <span class="o">.</span><span class="na">mapWindow</span><span class="o">(</span><span class="k">new</span> <span class="nf">WindowCorrelation</span><span class="o">());</span>
+    <span class="o">.</span><span class="na">mapWindow</span><span class="o">(</span><span class="k">new</span> <span class="n">WindowCorrelation</span><span class="o">());</span>
 
 <span class="n">rollingCorrelation</span><span class="o">.</span><span class="na">print</span><span class="o">();</span>
 
@@ -785,7 +785,7 @@ these data streams are potentially infinite, we apply the join on a
 
 <h2 id="other-things-to-try">Other things to try</h2>
 
-<p>For a full feature overview please check the <a href="http://ci.apache.org/projects/flink/flink-docs-master/apis/streaming_guide.html">Streaming Guide</a>, which describes all the available API features.
+<p>For a full feature overview please check the <a href="http://ci.apache.org/projects/flink/flink-docs-master/apis/streaming/index.html">Streaming Guide</a>, which describes all the available API features.
 You are very welcome to try out our features for different use-cases we are looking forward to your experiences. Feel free to <a href="http://flink.apache.org/community.html#mailing-lists">contact us</a>.</p>
 
 <h2 id="upcoming-for-streaming">Upcoming for streaming</h2>

http://git-wip-us.apache.org/repos/asf/flink-web/blob/24f3ba5a/content/news/2015/03/02/february-2015-in-flink.html
----------------------------------------------------------------------
diff --git a/content/news/2015/03/02/february-2015-in-flink.html b/content/news/2015/03/02/february-2015-in-flink.html
index 5b3e5c4..607fbe6 100644
--- a/content/news/2015/03/02/february-2015-in-flink.html
+++ b/content/news/2015/03/02/february-2015-in-flink.html
@@ -230,12 +230,12 @@ graph:</p>
            <span class="n">maxIterations</span><span class="o">)).</span><span class="na">getVertices</span><span class="o">();</span></code></pre></div>
 
 <p>See more Gelly examples
-<a href="https://github.com/apache/flink/tree/master/flink-staging/flink-gelly/src/main/java/org/apache/flink/graph/example">here</a>.</p>
+<a href="https://github.com/apache/flink/tree/master/flink-libraries/flink-gelly-examples">here</a>.</p>
 
 <h3 id="flink-expressions">Flink Expressions</h3>
 
 <p>The newly merged
-<a href="https://github.com/apache/flink/tree/master/flink-staging/flink-table">flink-table</a>
+<a href="https://github.com/apache/flink/tree/master/flink-libraries/flink-table">flink-table</a>
 module is the first step in Flink’s roadmap towards logical queries
 and SQL support. Here’s a preview on how you can read two CSV file,
 assign a logical schema to, and apply transformations like filters and
@@ -256,7 +256,7 @@ joins using logical attributes rather than physical data types.</p>
 
 <h3 id="access-to-hcatalog-tables">Access to HCatalog tables</h3>
 
-<p>With the <a href="https://github.com/apache/flink/tree/master/flink-staging/flink-hcatalog">flink-hcatalog
+<p>With the <a href="https://github.com/apache/flink/tree/master/flink-batch-connectors/flink-hcatalog">flink-hcatalog
 module</a>,
 you can now conveniently access HCatalog/Hive tables. The module
 supports projection (selection and order of fields) and partition

http://git-wip-us.apache.org/repos/asf/flink-web/blob/24f3ba5a/content/news/2015/03/13/peeking-into-Apache-Flinks-Engine-Room.html
----------------------------------------------------------------------
diff --git a/content/news/2015/03/13/peeking-into-Apache-Flinks-Engine-Room.html b/content/news/2015/03/13/peeking-into-Apache-Flinks-Engine-Room.html
index 49fdcbb..23a6e63 100644
--- a/content/news/2015/03/13/peeking-into-Apache-Flinks-Engine-Room.html
+++ b/content/news/2015/03/13/peeking-into-Apache-Flinks-Engine-Room.html
@@ -280,7 +280,7 @@
 
 <p>Ship and local strategies do not depend on each other and can be independently chosen. Therefore, Flink can execute a join of two data sets R and S in nine different ways by combining any of the three ship strategies (RR, BF with R being broadcasted, BF with S being broadcasted) with any of the three local strategies (SM, HH with R being build-side, HH with S being build-side). Each of these strategy combinations results in different execution performance depending on the data sizes and the available amount of working memory. In case of a small data set R and a much larger data set S, broadcasting R and using it as build-side input of a Hybrid-Hash-Join is usually a good choice because the much larger data set S is not shipped and not materialized (given that the hash table completely fits into memory). If both data sets are rather large or the join is performed on many parallel instances, repartitioning both inputs is a robust choice.</p>
 
-<p>Flink features a cost-based optimizer which automatically chooses the execution strategies for all operators including joins. Without going into the details of cost-based optimization, this is done by computing cost estimates for execution plans with different strategies and picking the plan with the least estimated costs. Thereby, the optimizer estimates the amount of data which is shipped over the the network and written to disk. If no reliable size estimates for the input data can be obtained, the optimizer falls back to robust default choices. A key feature of the optimizer is to reason about existing data properties. For example, if the data of one input is already partitioned in a suitable way, the generated candidate plans will not repartition this input. Hence, the choice of a RR ship strategy becomes more likely. The same applies for previously sorted data and the Sort-Merge-Join strategy. Flink programs can help the optimizer to reason about existing data properties by 
 providing semantic information about  user-defined functions <a href="http://ci.apache.org/projects/flink/flink-docs-master/apis/programming_guide.html#semantic-annotations">[4]</a>. While the optimizer is a killer feature of Flink, it can happen that a user knows better than the optimizer how to execute a specific join. Similar to relational database systems, Flink offers optimizer hints to tell the optimizer which join strategies to pick <a href="http://ci.apache.org/projects/flink/flink-docs-master/apis/dataset_transformations.html#join-algorithm-hints">[5]</a>.</p>
+<p>Flink features a cost-based optimizer which automatically chooses the execution strategies for all operators including joins. Without going into the details of cost-based optimization, this is done by computing cost estimates for execution plans with different strategies and picking the plan with the least estimated costs. Thereby, the optimizer estimates the amount of data which is shipped over the the network and written to disk. If no reliable size estimates for the input data can be obtained, the optimizer falls back to robust default choices. A key feature of the optimizer is to reason about existing data properties. For example, if the data of one input is already partitioned in a suitable way, the generated candidate plans will not repartition this input. Hence, the choice of a RR ship strategy becomes more likely. The same applies for previously sorted data and the Sort-Merge-Join strategy. Flink programs can help the optimizer to reason about existing data properties by 
 providing semantic information about  user-defined functions <a href="https://ci.apache.org/projects/flink/flink-docs-release-1.0/apis/batch/index.html#semantic-annotations">[4]</a>. While the optimizer is a killer feature of Flink, it can happen that a user knows better than the optimizer how to execute a specific join. Similar to relational database systems, Flink offers optimizer hints to tell the optimizer which join strategies to pick <a href="https://ci.apache.org/projects/flink/flink-docs-release-1.0/apis/batch/dataset_transformations.html#join-algorithm-hints">[5]</a>.</p>
 
 <h3 id="how-is-flinks-join-performance">How is Flink’s join performance?</h3>
 
@@ -337,8 +337,8 @@
 <p>[1] <a href="">“MapReduce: Simplified data processing on large clusters”</a>, Dean, Ghemawat, 2004 <br />
 [2] <a href="http://ci.apache.org/projects/flink/flink-docs-release-0.8/dataset_transformations.html">Flink 0.8.1 documentation: Data Transformations</a> <br />
 [3] <a href="http://ci.apache.org/projects/flink/flink-docs-release-0.8/dataset_transformations.html#join">Flink 0.8.1 documentation: Joins</a> <br />
-[4] <a href="http://ci.apache.org/projects/flink/flink-docs-master/apis/programming_guide.html#semantic-annotations">Flink 0.9-SNAPSHOT documentation: Semantic annotations</a> <br />
-[5] <a href="http://ci.apache.org/projects/flink/flink-docs-master/apis/dataset_transformations.html#join-algorithm-hints">Flink 0.9-SNAPSHOT documentation: Optimizer join hints</a> <br /></p>
+[4] <a href="https://ci.apache.org/projects/flink/flink-docs-release-1.0/apis/batch/index.html#semantic-annotations">Flink 1.0 documentation: Semantic annotations</a> <br />
+[5] <a href="https://ci.apache.org/projects/flink/flink-docs-release-1.0/apis/batch/dataset_transformations.html#join-algorithm-hints">Flink 1.0 documentation: Optimizer join hints</a> <br /></p>
 
       </article>
     </div>

http://git-wip-us.apache.org/repos/asf/flink-web/blob/24f3ba5a/content/news/2015/04/07/march-in-flink.html
----------------------------------------------------------------------
diff --git a/content/news/2015/04/07/march-in-flink.html b/content/news/2015/04/07/march-in-flink.html
index 5417571..ad7c641 100644
--- a/content/news/2015/04/07/march-in-flink.html
+++ b/content/news/2015/04/07/march-in-flink.html
@@ -162,15 +162,9 @@
 
 <p>March has been a busy month in the Flink community.</p>
 
-<h3 id="flink-runner-for-google-cloud-dataflow">Flink runner for Google Cloud Dataflow</h3>
+<h3 id="scaling-als">Scaling ALS</h3>
 
-<p>A Flink runner for Google Cloud Dataflow was announced. See the blog
-posts by <a href="http://data-artisans.com/dataflow.html">data Artisans</a> and
-the <a href="http://googlecloudplatform.blogspot.de/2015/03/announcing-Google-Cloud-Dataflow-runner-for-Apache-Flink.html">Google Cloud Platform Blog</a>.
-Google Cloud Dataflow programs can be written using and open-source
-SDK and run in multiple backends, either as a managed service inside
-Google’s infrastructure, or leveraging open source runners,
-including Apache Flink.</p>
+<p>Flink committers employed at <a href="http://data-artisans.com">data Artisans</a> published a <a href="http://data-artisans.com/how-to-factorize-a-700-gb-matrix-with-apache-flink/">blog post</a> on how they scaled matrix factorization with Flink and Google Compute Engine to matrices with 28 billion elements.</p>
 
 <h3 id="learn-about-the-internals-of-flink">Learn about the internals of Flink</h3>
 
@@ -202,14 +196,14 @@ future of Flink. The talk is available on
 
 <h3 id="table-api-in-scala-and-java">Table API in Scala and Java</h3>
 
-<p>The new <a href="https://github.com/apache/flink/tree/master/flink-staging/flink-table">Table
+<p>The new <a href="https://github.com/apache/flink/tree/master/flink-libraries/flink-table">Table
 API</a>
 in Flink is now available in both Java and Scala. Check out the
-examples <a href="https://github.com/apache/flink/blob/master/flink-staging/flink-table/src/main/java/org/apache/flink/examples/java/JavaTableExample.java">here (Java)</a> and <a href="https://github.com/apache/flink/tree/master/flink-staging/flink-table/src/main/scala/org/apache/flink/examples/scala">here (Scala)</a>.</p>
+examples <a href="https://github.com/apache/flink/blob/master/flink-libraries/flink-table/src/main/java/org/apache/flink/examples/java/JavaTableExample.java">here (Java)</a> and <a href="https://github.com/apache/flink/tree/master/flink-libraries/flink-table/src/main/scala/org/apache/flink/examples/scala">here (Scala)</a>.</p>
 
 <h3 id="additions-to-the-machine-learning-library">Additions to the Machine Learning library</h3>
 
-<p>Flink’s <a href="https://github.com/apache/flink/tree/master/flink-staging/flink-ml">Machine Learning
+<p>Flink’s <a href="https://github.com/apache/flink/tree/master/flink-libraries/flink-ml">Machine Learning
 library</a>
 is seeing quite a bit of traction. Recent additions include the <a href="http://arxiv.org/abs/1409.1458">CoCoA
 algorithm</a> for distributed
@@ -225,11 +219,6 @@ checkpoints at failure recovery. This functionality is currently
 limited in that it does not yet handle large state and iterative
 programs.</p>
 
-<h3 id="flink-on-tez">Flink on Tez</h3>
-
-<p>A new execution environment enables non-iterative Flink jobs to use
-Tez as an execution backend instead of Flink’s own network stack. Learn more
-<a href="http://ci.apache.org/projects/flink/flink-docs-master/setup/flink_on_tez.html">here</a>.</p>
 
       </article>
     </div>

http://git-wip-us.apache.org/repos/asf/flink-web/blob/24f3ba5a/content/news/2015/04/13/release-0.9.0-milestone1.html
----------------------------------------------------------------------
diff --git a/content/news/2015/04/13/release-0.9.0-milestone1.html b/content/news/2015/04/13/release-0.9.0-milestone1.html
index 33de1d2..c522a03 100644
--- a/content/news/2015/04/13/release-0.9.0-milestone1.html
+++ b/content/news/2015/04/13/release-0.9.0-milestone1.html
@@ -198,7 +198,7 @@ for Flink programs. Tables are available for both static and streaming
 data sources (DataSet and DataStream APIs).</p>
 
 <p>Check out the Table guide for Java and Scala
-<a href="http://ci.apache.org/projects/flink/flink-docs-master/libs/table.html">here</a>.</p>
+<a href="https://ci.apache.org/projects/flink/flink-docs-master/apis/batch/libs/table.html">here</a>.</p>
 
 <h3 id="gelly-graph-processing-api">Gelly Graph Processing API</h3>
 
@@ -212,14 +212,14 @@ vertex-centric graph processing, as well as a library of common graph
 algorithms, including PageRank, SSSP, label propagation, and community
 detection.</p>
 
-<p>Gelly internally builds on top of Flink’s <a href="http://ci.apache.org/projects/flink/flink-docs-master/apis/iterations.html">delta
+<p>Gelly internally builds on top of Flink’s <a href="https://ci.apache.org/projects/flink/flink-docs-master/apis/batch/iterations.html">delta
 iterations</a>. Iterative
 graph algorithms are executed leveraging mutable state, achieving
 similar performance with specialized graph processing systems.</p>
 
 <p>Gelly will eventually subsume Spargel, Flink’s Pregel-like API. Check
 out the Gelly guide
-<a href="http://ci.apache.org/projects/flink/flink-docs-master/libs/gelly_guide.html">here</a>.</p>
+<a href="https://ci.apache.org/projects/flink/flink-docs-master/apis/batch/libs/gelly.html">here</a>.</p>
 
 <h3 id="flink-machine-learning-library">Flink Machine Learning Library</h3>
 

http://git-wip-us.apache.org/repos/asf/flink-web/blob/24f3ba5a/content/news/2015/05/14/Community-update-April.html
----------------------------------------------------------------------
diff --git a/content/news/2015/05/14/Community-update-April.html b/content/news/2015/05/14/Community-update-April.html
index 6338b77..9be75a3 100644
--- a/content/news/2015/05/14/Community-update-April.html
+++ b/content/news/2015/05/14/Community-update-April.html
@@ -162,6 +162,16 @@
 
 <p>April was an packed month for Apache Flink. </p>
 
+<h3 id="flink-runner-for-google-cloud-dataflow">Flink runner for Google Cloud Dataflow</h3>
+
+<p>A Flink runner for Google Cloud Dataflow was announced. See the blog
+posts by <a href="http://data-artisans.com/announcing-google-cloud-dataflow-on-flink-and-easy-flink-deployment-on-google-cloud/">data Artisans</a> and
+the <a href="http://googlecloudplatform.blogspot.de/2015/03/announcing-Google-Cloud-Dataflow-runner-for-Apache-Flink.html">Google Cloud Platform Blog</a>.
+Google Cloud Dataflow programs can be written using and open-source
+SDK and run in multiple backends, either as a managed service inside
+Google’s infrastructure, or leveraging open source runners,
+including Apache Flink.</p>
+
 <h2 id="flink-090-milestone1-release">Flink 0.9.0-milestone1 release</h2>
 
 <p>The highlight of April was of course the availability of <a href="/news/2015/04/13/release-0.9.0-milestone1.html">Flink 0.9-milestone1</a>. This was a release packed with new features, including, a Python DataSet API, the new SQL-like Table API, FlinkML, a machine learning library on Flink, Gelly, FLink’s Graph API, as well as a mode to run Flink on YARN leveraging Tez. In case you missed it, check out the <a href="/news/2015/04/13/release-0.9.0-milestone1.html">release announcement blog post</a> for details</p>
@@ -180,7 +190,7 @@
 
 <h2 id="upcoming-events">Upcoming events</h2>
 
-<p>Stay tuned for a wealth of upcoming events! Two Flink talsk will be presented at <a href="http://berlinbuzzwords.de/15/sessions">Berlin Buzzwords</a>, Flink will be presented at the <a href="http://2015.hadoopsummit.org/san-jose/">Hadoop Summit in San Jose</a>. A <a href="http://www.meetup.com/Apache-Flink-Meetup/events/220557545/">training workshop on Apache Flink</a> is being organized in Berlin. Finally, <a href="http://flink-forward.org">Flink Forward</a>, the first conference to bring together the whole Flink community is taking place in Berlin in October 2015.</p>
+<p>Stay tuned for a wealth of upcoming events! Two Flink talsk will be presented at <a href="http://berlinbuzzwords.de/15/sessions">Berlin Buzzwords</a>, Flink will be presented at the <a href="http://2015.hadoopsummit.org/san-jose/">Hadoop Summit in San Jose</a>. A <a href="http://www.meetup.com/Apache-Flink-Meetup/events/220557545/">training workshop on Apache Flink</a> is being organized in Berlin. Finally, <a href="http://2015.flink-forward.org/">Flink Forward</a>, the first conference to bring together the whole Flink community is taking place in Berlin in October 2015.</p>
 
       </article>
     </div>

http://git-wip-us.apache.org/repos/asf/flink-web/blob/24f3ba5a/content/news/2015/08/24/introducing-flink-gelly.html
----------------------------------------------------------------------
diff --git a/content/news/2015/08/24/introducing-flink-gelly.html b/content/news/2015/08/24/introducing-flink-gelly.html
index 726f15a..355ac32 100644
--- a/content/news/2015/08/24/introducing-flink-gelly.html
+++ b/content/news/2015/08/24/introducing-flink-gelly.html
@@ -233,7 +233,7 @@ of vertices, edges and the node degrees. </p>
 the ones provided by the batch processing API. These transformations can be applied one after the
 other, yielding a new Graph after each step, in a fashion similar to operators on DataSets: </p>
 
-<div class="highlight"><pre><code class="language-java"><span class="n">inputGraph</span><span class="o">.</span><span class="na">getUndirected</span><span class="o">().</span><span class="na">mapEdges</span><span class="o">(</span><span class="k">new</span> <span class="nf">CustomEdgeMapper</span><span class="o">());</span></code></pre></div>
+<div class="highlight"><pre><code class="language-java"><span class="n">inputGraph</span><span class="o">.</span><span class="na">getUndirected</span><span class="o">().</span><span class="na">mapEdges</span><span class="o">(</span><span class="k">new</span> <span class="n">CustomEdgeMapper</span><span class="o">());</span></code></pre></div>
 
 <p>Transformations can be applied on:</p>
 
@@ -269,7 +269,7 @@ one or more values per vertex, the more general  <code>groupReduceOnEdges()</cod
 <p>Assume you would want to compute the sum of the values of all incoming neighbors for each vertex.
 We will call the <code>reduceOnNeighbors()</code> aggregation method since the sum is an associative and commutative operation and the neighbors’ values are needed:</p>
 
-<div class="highlight"><pre><code class="language-java"><span class="n">graph</span><span class="o">.</span><span class="na">reduceOnNeighbors</span><span class="o">(</span><span class="k">new</span> <span class="nf">SumValues</span><span class="o">(),</span> <span class="n">EdgeDirection</span><span class="o">.</span><span class="na">IN</span><span class="o">);</span></code></pre></div>
+<div class="highlight"><pre><code class="language-java"><span class="n">graph</span><span class="o">.</span><span class="na">reduceOnNeighbors</span><span class="o">(</span><span class="k">new</span> <span class="n">SumValues</span><span class="o">(),</span> <span class="n">EdgeDirection</span><span class="o">.</span><span class="na">IN</span><span class="o">);</span></code></pre></div>
 
 <p>The vertex with id 1 is the only node that has no incoming edges. The result is therefore:</p>
 
@@ -455,7 +455,7 @@ playlist, we use a coGroup function to filter out the mismatches.</p>
 <span class="c1">// read the mismatches dataset and extract the songIDs</span>
 <span class="n">DataSet</span><span class="o">&lt;</span><span class="n">Tuple3</span><span class="o">&lt;</span><span class="n">String</span><span class="o">,</span> <span class="n">String</span><span class="o">,</span> <span class="n">Integer</span><span class="o">&gt;&gt;</span> <span class="n">validTriplets</span> <span class="o">=</span> <span class="n">triplets</span>
         <span class="o">.</span><span class="na">coGroup</span><span class="o">(</span><span class="n">mismatches</span><span class="o">).</span><span class="na">where</span><span class="o">(</span><span class="mi">1</span><span class="o">).</span><span class="na">equalTo</span><span class="o">(</span><span class="mi">0</span><span class="o">)</span>
-        <span class="o">.</span><span class="na">with</span><span class="o">(</span><span class="k">new</span> <span class="nf">CoGroupFunction</span><span class="o">()</span> <span class="o">{</span>
+        <span class="o">.</span><span class="na">with</span><span class="o">(</span><span class="k">new</span> <span class="n">CoGroupFunction</span><span class="o">()</span> <span class="o">{</span>
                 <span class="kt">void</span> <span class="nf">coGroup</span><span class="o">(</span><span class="n">Iterable</span> <span class="n">triplets</span><span class="o">,</span> <span class="n">Iterable</span> <span class="n">invalidSongs</span><span class="o">,</span> <span class="n">Collector</span> <span class="n">out</span><span class="o">)</span> <span class="o">{</span>
                         <span class="k">if</span> <span class="o">(!</span><span class="n">invalidSongs</span><span class="o">.</span><span class="na">iterator</span><span class="o">().</span><span class="na">hasNext</span><span class="o">())</span> <span class="o">{</span>
                             <span class="k">for</span> <span class="o">(</span><span class="n">Tuple3</span> <span class="n">triplet</span> <span class="o">:</span> <span class="n">triplets</span><span class="o">)</span> <span class="o">{</span> <span class="c1">// valid triplet</span>
@@ -493,7 +493,7 @@ basically iterate through the edge value and collect the target (song) of the ma
 
 <div class="highlight"><pre><code class="language-java"><span class="c1">//get the top track (most listened to) for each user</span>
 <span class="n">DataSet</span><span class="o">&lt;</span><span class="n">Tuple2</span><span class="o">&gt;</span> <span class="n">usersWithTopTrack</span> <span class="o">=</span> <span class="n">userSongGraph</span>
-        <span class="o">.</span><span class="na">groupReduceOnEdges</span><span class="o">(</span><span class="k">new</span> <span class="nf">GetTopSongPerUser</span><span class="o">(),</span> <span class="n">EdgeDirection</span><span class="o">.</span><span class="na">OUT</span><span class="o">);</span>
+        <span class="o">.</span><span class="na">groupReduceOnEdges</span><span class="o">(</span><span class="k">new</span> <span class="n">GetTopSongPerUser</span><span class="o">(),</span> <span class="n">EdgeDirection</span><span class="o">.</span><span class="na">OUT</span><span class="o">);</span>
 
 <span class="kd">class</span> <span class="nc">GetTopSongPerUser</span> <span class="kd">implements</span> <span class="n">EdgesFunctionWithVertexValue</span> <span class="o">{</span>
     <span class="kt">void</span> <span class="nf">iterateEdges</span><span class="o">(</span><span class="n">Vertex</span> <span class="n">vertex</span><span class="o">,</span> <span class="n">Iterable</span><span class="o">&lt;</span><span class="n">Edge</span><span class="o">&gt;</span> <span class="n">edges</span><span class="o">)</span> <span class="o">{</span>
@@ -506,7 +506,7 @@ basically iterate through the edge value and collect the target (song) of the ma
                 <span class="n">topSong</span> <span class="o">=</span> <span class="n">edge</span><span class="o">.</span><span class="na">getTarget</span><span class="o">();</span>
             <span class="o">}</span>
         <span class="o">}</span>
-        <span class="k">return</span> <span class="k">new</span> <span class="nf">Tuple2</span><span class="o">(</span><span class="n">vertex</span><span class="o">.</span><span class="na">getId</span><span class="o">(),</span> <span class="n">topSong</span><span class="o">);</span>
+        <span class="k">return</span> <span class="k">new</span> <span class="n">Tuple2</span><span class="o">(</span><span class="n">vertex</span><span class="o">.</span><span class="na">getId</span><span class="o">(),</span> <span class="n">topSong</span><span class="o">);</span>
     <span class="o">}</span>
 <span class="o">}</span></code></pre></div>
 
@@ -542,14 +542,14 @@ straightforward as a call to the <code>Graph.fromDataSet()</code> method.</p>
                 <span class="o">}</span>
         <span class="o">})</span>
         <span class="o">.</span><span class="na">groupBy</span><span class="o">(</span><span class="mi">1</span><span class="o">)</span>
-        <span class="o">.</span><span class="na">reduceGroup</span><span class="o">(</span><span class="k">new</span> <span class="nf">GroupReduceFunction</span><span class="o">()</span> <span class="o">{</span>
+        <span class="o">.</span><span class="na">reduceGroup</span><span class="o">(</span><span class="k">new</span> <span class="n">GroupReduceFunction</span><span class="o">()</span> <span class="o">{</span>
                 <span class="kt">void</span> <span class="nf">reduce</span><span class="o">(</span><span class="n">Iterable</span><span class="o">&lt;</span><span class="n">Edge</span><span class="o">&gt;</span> <span class="n">edges</span><span class="o">,</span> <span class="n">Collector</span><span class="o">&lt;</span><span class="n">Edge</span><span class="o">&gt;</span> <span class="n">out</span><span class="o">)</span> <span class="o">{</span>
-                    <span class="n">List</span> <span class="n">users</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">ArrayList</span><span class="o">();</span>
+                    <span class="n">List</span> <span class="n">users</span> <span class="o">=</span> <span class="k">new</span> <span class="n">ArrayList</span><span class="o">();</span>
                     <span class="k">for</span> <span class="o">(</span><span class="n">Edge</span> <span class="n">edge</span> <span class="o">:</span> <span class="n">edges</span><span class="o">)</span> <span class="o">{</span>
                         <span class="n">users</span><span class="o">.</span><span class="na">add</span><span class="o">(</span><span class="n">edge</span><span class="o">.</span><span class="na">getSource</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="n">users</span><span class="o">.</span><span class="na">size</span><span class="o">()</span> <span class="o">-</span> <span class="mi">1</span><span class="o">;</span> <span class="n">i</span><span class="o">++)</span> <span class="o">{</span>
                             <span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">j</span> <span class="o">=</span> <span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="o">;</span> <span class="n">j</span> <span class="o">&lt;</span> <span class="n">users</span><span class="o">.</span><span class="na">size</span><span class="o">()</span> <span class="o">-</span> <span class="mi">1</span><span class="o">;</span> <span class="n">j</span><span class="o">++)</span> <span class="o">{</span>
-                                <span class="n">out</span><span class="o">.</span><span class="na">collect</span><span class="o">(</span><span class="k">new</span> <span class="nf">Edge</span><span class="o">(</span><span class="n">users</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">i</span><span class="o">),</span> <span class="n">users</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">j</span><span class="o">)));</span>
+                                <span class="n">out</span><span class="o">.</span><span class="na">collect</span><span class="o">(</span><span class="k">new</span> <span class="n">Edge</span><span class="o">(</span><span class="n">users</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">i</span><span class="o">),</span> <span class="n">users</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">j</span><span class="o">)));</span>
                             <span class="o">}</span>
                         <span class="o">}</span>
                     <span class="o">}</span>
@@ -580,12 +580,12 @@ among their neighbors. </p>
 
 <span class="c1">// update the vertex values and run the label propagation algorithm</span>
 <span class="n">DataSet</span><span class="o">&lt;</span><span class="n">Vertex</span><span class="o">&gt;</span> <span class="n">verticesWithCommunity</span> <span class="o">=</span> <span class="n">similarUsersGraph</span>
-        <span class="o">.</span><span class="na">joinWithVertices</span><span class="o">(</span><span class="n">idsWithlLabels</span><span class="o">,</span> <span class="k">new</span> <span class="nf">MapFunction</span><span class="o">()</span> <span class="o">{</span>
+        <span class="o">.</span><span class="na">joinWithVertices</span><span class="o">(</span><span class="n">idsWithlLabels</span><span class="o">,</span> <span class="k">new</span> <span class="n">MapFunction</span><span class="o">()</span> <span class="o">{</span>
                 <span class="kd">public</span> <span class="n">Long</span> <span class="nf">map</span><span class="o">(</span><span class="n">Tuple2</span> <span class="n">idWithLabel</span><span class="o">)</span> <span class="o">{</span>
                     <span class="k">return</span> <span class="n">idWithLabel</span><span class="o">.</span><span class="na">f1</span><span class="o">;</span>
                 <span class="o">}</span>
         <span class="o">})</span>
-        <span class="o">.</span><span class="na">run</span><span class="o">(</span><span class="k">new</span> <span class="nf">LabelPropagation</span><span class="o">(</span><span class="n">numIterations</span><span class="o">))</span>
+        <span class="o">.</span><span class="na">run</span><span class="o">(</span><span class="k">new</span> <span class="n">LabelPropagation</span><span class="o">(</span><span class="n">numIterations</span><span class="o">))</span>
         <span class="o">.</span><span class="na">getVertices</span><span class="o">();</span></code></pre></div>
 
 <p><a href="#top">Back to top</a></p>

http://git-wip-us.apache.org/repos/asf/flink-web/blob/24f3ba5a/content/news/2015/09/03/flink-forward.html
----------------------------------------------------------------------
diff --git a/content/news/2015/09/03/flink-forward.html b/content/news/2015/09/03/flink-forward.html
index 107468b..9440c4a 100644
--- a/content/news/2015/09/03/flink-forward.html
+++ b/content/news/2015/09/03/flink-forward.html
@@ -160,7 +160,7 @@
       <article>
         <p>03 Sep 2015</p>
 
-<p><a href="http://flink-forward.org/">Flink Forward 2015</a> is the first
+<p><a href="http://2015.flink-forward.org/">Flink Forward 2015</a> is the first
 conference with Flink at its center that aims to bring together the
 Apache Flink community in a single place. The organizers are starting
 this conference in October 12 and 13 from Berlin, the place where
@@ -170,7 +170,7 @@ Apache Flink started.</p>
 <img src="/img/blog/flink-forward-banner.png" style="width:80%;margin:15px" />
 </center>
 
-<p>The <a href="http://flink-forward.org/?post_type=day">conference program</a> has
+<p>The <a href="http://2015.flink-forward.org/?post_type=day">conference program</a> has
 been announced by the organizers and a program committee consisting of
 Flink PMC members. The agenda contains talks from industry and
 academia as well as a dedicated session on hands-on Flink training.</p>
@@ -179,7 +179,7 @@ academia as well as a dedicated session on hands-on Flink training.</p>
 
 <ul>
   <li>
-    <p>A keynote by <a href="http://flink-forward.org/?speaker=william-vambenepe">William
+    <p>A keynote by <a href="http://2015.flink-forward.org/?speaker=william-vambenepe">William
 Vambenepe</a>,
 lead of the product management team responsible for Big Data
 services on Google Cloud Platform (BigQuery, Dataflow, etc…) on
@@ -201,9 +201,8 @@ fault tolerance, the internal runtime architecture, and others.</p>
   </li>
 </ul>
 
-<p>Check out the <a href="http://flink-forward.org/?post_type=day">schedule</a> and
-<a href="http://flink-forward.org/?page_id=96">register</a> for the
-conference.</p>
+<p>Check out the <a href="http://2015.flink-forward.org/?post_type=day">schedule</a> and
+register for the conference.</p>
 
 
       </article>

http://git-wip-us.apache.org/repos/asf/flink-web/blob/24f3ba5a/content/news/2015/09/16/off-heap-memory.html
----------------------------------------------------------------------
diff --git a/content/news/2015/09/16/off-heap-memory.html b/content/news/2015/09/16/off-heap-memory.html
index 4383cc1..317e596 100644
--- a/content/news/2015/09/16/off-heap-memory.html
+++ b/content/news/2015/09/16/off-heap-memory.html
@@ -328,7 +328,7 @@ Either <code>0 + absolutePointer</code> or <code>objectRefAddress + offset</code
 
 <h2 id="appendix-detailed-micro-benchmarks">Appendix: Detailed Micro Benchmarks</h2>
 
-<p>These microbenchmarks test the performance of the different memory segment implementations on various operation. The code is available <a href="https://github.com/apache/flink/blob/master/flink-core/src/test/java/org/apache/flink/core/memory/benchmarks/MemorySegmentSpeedBenchmark.java">as part of the Flink project</a></p>
+<p>These microbenchmarks test the performance of the different memory segment implementations on various operation.</p>
 
 <p>Each experiments tests the different implementations multiple times in different orders, to balance the advantage/disadvantage of the JIT compiler specializing towards certain code paths. All experiments were run 5x, discarding the fastest and slowest run, and then averaged. This compensated for delay before the JIT kicks in.</p>
 

http://git-wip-us.apache.org/repos/asf/flink-web/blob/24f3ba5a/content/news/2015/12/11/storm-compatibility.html
----------------------------------------------------------------------
diff --git a/content/news/2015/12/11/storm-compatibility.html b/content/news/2015/12/11/storm-compatibility.html
index a7fd3d9..95b4303 100644
--- a/content/news/2015/12/11/storm-compatibility.html
+++ b/content/news/2015/12/11/storm-compatibility.html
@@ -199,13 +199,13 @@ For this, you only need to replace the dependency <code>storm-core</code> by <co
 First, the program is assembled the Storm way without any code change to Spouts, Bolts, or the topology itself.</p>
 
 <div class="highlight"><pre><code class="language-java"><span class="c1">// assemble topology, the Storm way</span>
-<span class="n">TopologyBuilder</span> <span class="n">builder</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">TopologyBuilder</span><span class="o">();</span>
-<span class="n">builder</span><span class="o">.</span><span class="na">setSpout</span><span class="o">(</span><span class="s">&quot;source&quot;</span><span class="o">,</span> <span class="k">new</span> <span class="nf">StormFileSpout</span><span class="o">(</span><span class="n">inputFilePath</span><span class="o">));</span>
-<span class="n">builder</span><span class="o">.</span><span class="na">setBolt</span><span class="o">(</span><span class="s">&quot;tokenizer&quot;</span><span class="o">,</span> <span class="k">new</span> <span class="nf">StormBoltTokenizer</span><span class="o">())</span>
+<span class="n">TopologyBuilder</span> <span class="n">builder</span> <span class="o">=</span> <span class="k">new</span> <span class="n">TopologyBuilder</span><span class="o">();</span>
+<span class="n">builder</span><span class="o">.</span><span class="na">setSpout</span><span class="o">(</span><span class="s">&quot;source&quot;</span><span class="o">,</span> <span class="k">new</span> <span class="n">StormFileSpout</span><span class="o">(</span><span class="n">inputFilePath</span><span class="o">));</span>
+<span class="n">builder</span><span class="o">.</span><span class="na">setBolt</span><span class="o">(</span><span class="s">&quot;tokenizer&quot;</span><span class="o">,</span> <span class="k">new</span> <span class="n">StormBoltTokenizer</span><span class="o">())</span>
        <span class="o">.</span><span class="na">shuffleGrouping</span><span class="o">(</span><span class="s">&quot;source&quot;</span><span class="o">);</span>
-<span class="n">builder</span><span class="o">.</span><span class="na">setBolt</span><span class="o">(</span><span class="s">&quot;counter&quot;</span><span class="o">,</span> <span class="k">new</span> <span class="nf">StormBoltCounter</span><span class="o">())</span>
-       <span class="o">.</span><span class="na">fieldsGrouping</span><span class="o">(</span><span class="s">&quot;tokenizer&quot;</span><span class="o">,</span> <span class="k">new</span> <span class="nf">Fields</span><span class="o">(</span><span class="s">&quot;word&quot;</span><span class="o">));</span>
-<span class="n">builder</span><span class="o">.</span><span class="na">setBolt</span><span class="o">(</span><span class="s">&quot;sink&quot;</span><span class="o">,</span> <span class="k">new</span> <span class="nf">StormBoltFileSink</span><span class="o">(</span><span class="n">outputFilePath</span><span class="o">))</span>
+<span class="n">builder</span><span class="o">.</span><span class="na">setBolt</span><span class="o">(</span><span class="s">&quot;counter&quot;</span><span class="o">,</span> <span class="k">new</span> <span class="n">StormBoltCounter</span><span class="o">())</span>
+       <span class="o">.</span><span class="na">fieldsGrouping</span><span class="o">(</span><span class="s">&quot;tokenizer&quot;</span><span class="o">,</span> <span class="k">new</span> <span class="n">Fields</span><span class="o">(</span><span class="s">&quot;word&quot;</span><span class="o">));</span>
+<span class="n">builder</span><span class="o">.</span><span class="na">setBolt</span><span class="o">(</span><span class="s">&quot;sink&quot;</span><span class="o">,</span> <span class="k">new</span> <span class="n">StormBoltFileSink</span><span class="o">(</span><span class="n">outputFilePath</span><span class="o">))</span>
        <span class="o">.</span><span class="na">shuffleGrouping</span><span class="o">(</span><span class="s">&quot;counter&quot;</span><span class="o">);</span></code></pre></div>
 
 <p>In order to execute the topology, we need to translate it to a <code>FlinkTopology</code> and submit it to a local or remote Flink cluster, very similar to submitting the application to a Storm cluster.<sup><a href="#fn1" id="ref1">1</a></sup></p>
@@ -214,7 +214,7 @@ First, the program is assembled the Storm way without any code change to Spouts,
 <span class="c1">// replaces: StormTopology topology = builder.createTopology();</span>
 <span class="n">FlinkTopology</span> <span class="n">topology</span> <span class="o">=</span> <span class="n">FlinkTopology</span><span class="o">.</span><span class="na">createTopology</span><span class="o">(</span><span class="n">builder</span><span class="o">);</span>
 
-<span class="n">Config</span> <span class="n">conf</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">Config</span><span class="o">();</span>
+<span class="n">Config</span> <span class="n">conf</span> <span class="o">=</span> <span class="k">new</span> <span class="n">Config</span><span class="o">();</span>
 <span class="k">if</span><span class="o">(</span><span class="n">runLocal</span><span class="o">)</span> <span class="o">{</span>
 	<span class="c1">// use FlinkLocalCluster instead of LocalCluster</span>
 	<span class="n">FlinkLocalCluster</span> <span class="n">cluster</span> <span class="o">=</span> <span class="n">FlinkLocalCluster</span><span class="o">.</span><span class="na">getLocalCluster</span><span class="o">();</span>
@@ -254,14 +254,14 @@ As Storm is type agnostic, it is required to specify the output type of embedded
 <span class="c1">// use Spout as source</span>
 <span class="n">DataStream</span><span class="o">&lt;</span><span class="n">Tuple1</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;&gt;</span> <span class="n">source</span> <span class="o">=</span> 
   <span class="n">env</span><span class="o">.</span><span class="na">addSource</span><span class="o">(</span><span class="c1">// Flink provided wrapper including original Spout</span>
-                <span class="k">new</span> <span class="n">SpoutWrapper</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;(</span><span class="k">new</span> <span class="nf">FileSpout</span><span class="o">(</span><span class="n">localFilePath</span><span class="o">)),</span> 
+                <span class="k">new</span> <span class="n">SpoutWrapper</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;(</span><span class="k">new</span> <span class="n">FileSpout</span><span class="o">(</span><span class="n">localFilePath</span><span class="o">)),</span> 
                 <span class="c1">// specify output type manually</span>
                 <span class="n">TypeExtractor</span><span class="o">.</span><span class="na">getForObject</span><span class="o">(</span><span class="k">new</span> <span class="n">Tuple1</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;(</span><span class="s">&quot;&quot;</span><span class="o">)));</span>
 <span class="c1">// FileSpout cannot be parallelized</span>
 <span class="n">DataStream</span><span class="o">&lt;</span><span class="n">Tuple1</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;&gt;</span> <span class="n">text</span> <span class="o">=</span> <span class="n">source</span><span class="o">.</span><span class="na">setParallelism</span><span class="o">(</span><span class="mi">1</span><span class="o">);</span>
 
 <span class="c1">// further processing with Flink</span>
-<span class="n">DataStream</span><span class="o">&lt;</span><span class="n">Tuple2</span><span class="o">&lt;</span><span class="n">String</span><span class="o">,</span><span class="n">Integer</span><span class="o">&gt;</span> <span class="n">tokens</span> <span class="o">=</span> <span class="n">text</span><span class="o">.</span><span class="na">flatMap</span><span class="o">(</span><span class="k">new</span> <span class="nf">Tokenizer</span><span class="o">()).</span><span class="na">keyBy</span><span class="o">(</span><span class="mi">0</span><span class="o">);</span>
+<span class="n">DataStream</span><span class="o">&lt;</span><span class="n">Tuple2</span><span class="o">&lt;</span><span class="n">String</span><span class="o">,</span><span class="n">Integer</span><span class="o">&gt;</span> <span class="n">tokens</span> <span class="o">=</span> <span class="n">text</span><span class="o">.</span><span class="na">flatMap</span><span class="o">(</span><span class="k">new</span> <span class="n">Tokenizer</span><span class="o">()).</span><span class="na">keyBy</span><span class="o">(</span><span class="mi">0</span><span class="o">);</span>
 
 <span class="c1">// use Bolt for counting</span>
 <span class="n">DataStream</span><span class="o">&lt;</span><span class="n">Tuple2</span><span class="o">&lt;</span><span class="n">String</span><span class="o">,</span><span class="n">Integer</span><span class="o">&gt;</span> <span class="n">counts</span> <span class="o">=</span>
@@ -269,7 +269,7 @@ As Storm is type agnostic, it is required to specify the output type of embedded
                    <span class="c1">// specify output type manually</span>
                    <span class="n">TypeExtractor</span><span class="o">.</span><span class="na">getForObject</span><span class="o">(</span><span class="k">new</span> <span class="n">Tuple2</span><span class="o">&lt;</span><span class="n">String</span><span class="o">,</span><span class="n">Integer</span><span class="o">&gt;(</span><span class="s">&quot;&quot;</span><span class="o">,</span><span class="mi">0</span><span class="o">))</span>
                    <span class="c1">// Flink provided wrapper including original Bolt</span>
-                   <span class="k">new</span> <span class="n">BoltWrapper</span><span class="o">&lt;</span><span class="n">String</span><span class="o">,</span><span class="n">Tuple2</span><span class="o">&lt;</span><span class="n">String</span><span class="o">,</span><span class="n">Integer</span><span class="o">&gt;&gt;(</span><span class="k">new</span> <span class="nf">BoltCounter</span><span class="o">()));</span>
+                   <span class="k">new</span> <span class="n">BoltWrapper</span><span class="o">&lt;</span><span class="n">String</span><span class="o">,</span><span class="n">Tuple2</span><span class="o">&lt;</span><span class="n">String</span><span class="o">,</span><span class="n">Integer</span><span class="o">&gt;&gt;(</span><span class="k">new</span> <span class="n">BoltCounter</span><span class="o">()));</span>
 
 <span class="c1">// write result to file via Flink sink</span>
 <span class="n">counts</span><span class="o">.</span><span class="na">writeAsText</span><span class="o">(</span><span class="n">outputPath</span><span class="o">);</span>
@@ -293,7 +293,7 @@ We are also investigating the integration of Storm’s higher-level programming
 This enables you to even embed third-party Spouts and Bolts where the source code is not available.
 While you can embed Spouts/Bolts in a Flink program and mix-and-match them with Flink operators, running whole topologies is the easiest way to get started and can be achieved with almost no code changes.</p>
 
-<p>If you want to try out Flink’s Storm compatibility package checkout our <a href="https://ci.apache.org/projects/flink/flink-docs-master/apis/storm_compatibility.html">Documentation</a>.</p>
+<p>If you want to try out Flink’s Storm compatibility package checkout our <a href="https://ci.apache.org/projects/flink/flink-docs-master/apis/streaming/storm_compatibility.html">Documentation</a>.</p>
 
 <hr />
 

http://git-wip-us.apache.org/repos/asf/flink-web/blob/24f3ba5a/content/news/2015/12/18/a-year-in-review.html
----------------------------------------------------------------------
diff --git a/content/news/2015/12/18/a-year-in-review.html b/content/news/2015/12/18/a-year-in-review.html
index 502c9a2..20a2597 100644
--- a/content/news/2015/12/18/a-year-in-review.html
+++ b/content/news/2015/12/18/a-year-in-review.html
@@ -198,7 +198,7 @@ meetups around the globe</a>:</p>
 
 <h1 id="flink-forward-2015">Flink Forward 2015</h1>
 
-<p>One of the highlights of the year for Flink was undoubtedly the <a href="http://flink-forward.org/">Flink
+<p>One of the highlights of the year for Flink was undoubtedly the <a href="http://2015.flink-forward.org/">Flink
 Forward</a> conference, the first conference
 on Apache Flink that was held in October in Berlin. More than 250
 participants (roughly half based outside Germany where the conference
@@ -206,7 +206,7 @@ was held) attended more than 33 technical talks from organizations
 including Google, MongoDB, Bouygues Telecom, NFLabs, Euranova, RedHat,
 IBM, Huawei, Intel, Ericsson, Capital One, Zalando, Amadeus, the Otto
 Group, and ResearchGate. If you have not yet watched their talks,
-check out the <a href="http://flink-forward.org/?post_type=day">slides</a> and
+check out the <a href="http://2015.flink-forward.org/?post_type=day">slides</a> and
 <a href="https://www.youtube.com/playlist?list=PLDX4T_cnKjD31JeWR1aMOi9LXPRQ6nyHO">videos</a>
 from Flink Forward.</p>
 

http://git-wip-us.apache.org/repos/asf/flink-web/blob/24f3ba5a/content/news/2016/04/06/cep-monitoring.html
----------------------------------------------------------------------
diff --git a/content/news/2016/04/06/cep-monitoring.html b/content/news/2016/04/06/cep-monitoring.html
index 1be1758..f545a47 100644
--- a/content/news/2016/04/06/cep-monitoring.html
+++ b/content/news/2016/04/06/cep-monitoring.html
@@ -280,7 +280,7 @@ Our pattern select function generates for each matching pattern a <code>Temperat
         <span class="n">TemperatureEvent</span> <span class="n">first</span> <span class="o">=</span> <span class="o">(</span><span class="n">TemperatureEvent</span><span class="o">)</span> <span class="n">pattern</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="s">&quot;First Event&quot;</span><span class="o">);</span>
         <span class="n">TemperatureEvent</span> <span class="n">second</span> <span class="o">=</span> <span class="o">(</span><span class="n">TemperatureEvent</span><span class="o">)</span> <span class="n">pattern</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="s">&quot;Second Event&quot;</span><span class="o">);</span>
 
-        <span class="k">return</span> <span class="k">new</span> <span class="nf">TemperatureWarning</span><span class="o">(</span>
+        <span class="k">return</span> <span class="k">new</span> <span class="n">TemperatureWarning</span><span class="o">(</span>
             <span class="n">first</span><span class="o">.</span><span class="na">getRackID</span><span class="o">(),</span> 
             <span class="o">(</span><span class="n">first</span><span class="o">.</span><span class="na">getTemperature</span><span class="o">()</span> <span class="o">+</span> <span class="n">second</span><span class="o">.</span><span class="na">getTemperature</span><span class="o">())</span> <span class="o">/</span> <span class="mi">2</span><span class="o">);</span>
     <span class="o">}</span>
@@ -322,7 +322,7 @@ Thus, we will only generate a <code>TemperatureAlert</code> if and only if the t
         <span class="n">TemperatureWarning</span> <span class="n">second</span> <span class="o">=</span> <span class="n">pattern</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="s">&quot;Second Event&quot;</span><span class="o">);</span>
 
         <span class="k">if</span> <span class="o">(</span><span class="n">first</span><span class="o">.</span><span class="na">getAverageTemperature</span><span class="o">()</span> <span class="o">&lt;</span> <span class="n">second</span><span class="o">.</span><span class="na">getAverageTemperature</span><span class="o">())</span> <span class="o">{</span>
-            <span class="n">out</span><span class="o">.</span><span class="na">collect</span><span class="o">(</span><span class="k">new</span> <span class="nf">TemperatureAlert</span><span class="o">(</span><span class="n">first</span><span class="o">.</span><span class="na">getRackID</span><span class="o">()));</span>
+            <span class="n">out</span><span class="o">.</span><span class="na">collect</span><span class="o">(</span><span class="k">new</span> <span class="n">TemperatureAlert</span><span class="o">(</span><span class="n">first</span><span class="o">.</span><span class="na">getRackID</span><span class="o">()));</span>
         <span class="o">}</span>
     <span class="o">});</span></code></pre></div>
 


Mime
View raw message