Modified: samza/site/startup/quick-start/latest/samza.html
URL: 
http://svn.apache.org/viewvc/samza/site/startup/quick-start/latest/samza.html?rev=1906774&r1=1906773&r2=1906774&view=diff
==============================================================================
--- samza/site/startup/quick-start/latest/samza.html (original)
+++ samza/site/startup/quick-start/latest/samza.html Wed Jan 18 19:33:25 2023
@@ -227,6 +227,12 @@
     
       
         
+      <a class="side-navigation__group-item" data-match-active="" 
href="/releases/1.8.0">1.8.0</a>
+      
+        
+      <a class="side-navigation__group-item" data-match-active="" 
href="/releases/1.7.0">1.7.0</a>
+      
+        
       <a class="side-navigation__group-item" data-match-active="" 
href="/releases/1.6.0">1.6.0</a>
       
         
@@ -545,192 +551,192 @@
    limitations under the License.
 -->
 
-<p>In this tutorial, we will create our first Samza application - 
<code>WordCount</code>. This application will consume messages from a Kafka 
stream, tokenize them into individual words and count the frequency of each 
word.  Let us download the entire project from <a 
href="https://github.com/apache/samza-hello-samza/blob/latest/quickstart/wordcount.tar.gz";>here</a>.</p>
+<p>In this tutorial, we will create our first Samza application - <code 
class="language-plaintext highlighter-rouge">WordCount</code>. This application 
will consume messages from a Kafka stream, tokenize them into individual words 
and count the frequency of each word.  Let us download the entire project from 
<a 
href="https://github.com/apache/samza-hello-samza/blob/latest/quickstart/wordcount.tar.gz";>here</a>.</p>
 
 <h3 id="setting-up-a-java-project">Setting up a Java Project</h3>
 
 <p>Observe the project structure as follows:</p>
 
-<figure class="highlight"><pre><code class="language-bash" 
data-lang="bash"><span></span>wordcount
-<span class="p">|</span>-- build.gradle
-<span class="p">|</span>-- gradle.properties
-<span class="p">|</span>-- scripts
-<span class="p">|</span>-- src
-    <span class="p">|</span>-- main
-        <span class="p">|</span>-- config
-        <span class="p">|</span>-- java
-            <span class="p">|</span>-- samzaapp
-                 <span class="p">|</span>-- 
WordCount.java</code></pre></figure>
+<figure class="highlight"><pre><code class="language-bash" 
data-lang="bash">wordcount
+|-- build.gradle
+|-- gradle.properties
+|-- scripts
+|-- src
+    |-- main
+        |-- config
+        |-- java
+            |-- samzaapp
+                 |-- WordCount.java</code></pre></figure>
 
 <p>You can build the project anytime by running:</p>
 
-<figure class="highlight"><pre><code class="language-bash" 
data-lang="bash"><span></span>&gt; <span class="nb">cd</span> wordcount
-&gt; gradle wrapper --gradle-version <span class="m">4</span>.9
-&gt; ./gradlew build</code></pre></figure>
+<figure class="highlight"><pre><code class="language-bash" 
data-lang="bash"><span class="o">&gt;</span> <span class="nb">cd 
</span>wordcount
+<span class="o">&gt;</span> gradle wrapper <span 
class="nt">--gradle-version</span> 4.9
+<span class="o">&gt;</span> ./gradlew build</code></pre></figure>
 
 <h3 id="create-a-samza-streamapplication">Create a Samza StreamApplication</h3>
 
-<p>Now let’s write some code! An application written using Samza&rsquo;s <a 
href="/learn/documentation/latest/api/high-level-api.html">high-level API</a> 
implements the <a 
href="/learn/documentation/latest/api/javadocs/org/apache/samza/application/StreamApplication.html">StreamApplication</a>
 interface:</p>
+<p>Now let’s write some code! An application written using Samza’s <a 
href="/learn/documentation/latest/api/high-level-api.html">high-level API</a> 
implements the <a 
href="/learn/documentation/latest/api/javadocs/org/apache/samza/application/StreamApplication.html">StreamApplication</a>
 interface:</p>
 
-<figure class="highlight"><pre><code class="language-java" 
data-lang="java"><span></span><span class="kn">package</span> <span 
class="nn">samzaapp</span><span class="o">;</span>
+<figure class="highlight"><pre><code class="language-java" 
data-lang="java"><span class="kn">package</span> <span 
class="nn">samzaapp</span><span class="o">;</span>
 
 <span class="kn">import</span> <span 
class="nn">org.apache.samza.application.StreamApplication</span><span 
class="o">;</span>
 <span class="kn">import</span> <span 
class="nn">org.apache.samza.application.descriptors.StreamApplicationDescriptor</span><span
 class="o">;</span>
 
-<span class="kd">public</span> <span class="kd">class</span> <span 
class="nc">WordCount</span> <span class="kd">implements</span> <span 
class="n">StreamApplication</span> <span class="o">{</span>
+<span class="kd">public</span> <span class="kd">class</span> <span 
class="nc">WordCount</span> <span class="kd">implements</span> <span 
class="nc">StreamApplication</span> <span class="o">{</span>
  <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span 
class="nf">describe</span><span class="o">(</span><span 
class="n">StreamApplicationDescriptor</span> <span 
class="n">streamApplicationDescriptor</span><span class="o">)</span> <span 
class="o">{</span>
+ <span class="kd">public</span> <span class="kt">void</span> <span 
class="nf">describe</span><span class="o">(</span><span 
class="nc">StreamApplicationDescriptor</span> <span 
class="n">streamApplicationDescriptor</span><span class="o">)</span> <span 
class="o">{</span>
  <span class="o">}</span>
 <span class="o">}</span></code></pre></figure>
 
-<p>The interface provides a single method named <code>describe()</code>, which 
allows us to define our inputs, the processing logic and outputs for our 
application. </p>
+<p>The interface provides a single method named <code 
class="language-plaintext highlighter-rouge">describe()</code>, which allows us 
to define our inputs, the processing logic and outputs for our application.</p>
 
 <h3 id="describe-your-inputs-and-outputs">Describe your inputs and outputs</h3>
 
-<p>To interact with Kafka, we will first create a 
<code>KafkaSystemDescriptor</code> by providing the coordinates of the Kafka 
cluster. For each Kafka topic our application reads from, we create a 
<code>KafkaInputDescriptor</code> with the name of the topic and a serializer. 
Likewise, for each output topic, we instantiate a corresponding 
<code>KafkaOutputDescriptor</code>. </p>
+<p>To interact with Kafka, we will first create a <code 
class="language-plaintext highlighter-rouge">KafkaSystemDescriptor</code> by 
providing the coordinates of the Kafka cluster. For each Kafka topic our 
application reads from, we create a <code class="language-plaintext 
highlighter-rouge">KafkaInputDescriptor</code> with the name of the topic and a 
serializer. Likewise, for each output topic, we instantiate a corresponding 
<code class="language-plaintext 
highlighter-rouge">KafkaOutputDescriptor</code>.</p>
 
-<figure class="highlight"><pre><code class="language-java" 
data-lang="java"><span></span><span class="kd">public</span> <span 
class="kd">class</span> <span class="nc">WordCount</span> <span 
class="kd">implements</span> <span class="n">StreamApplication</span> <span 
class="o">{</span>
- <span class="kd">private</span> <span class="kd">static</span> <span 
class="kd">final</span> <span class="n">String</span> <span 
class="n">KAFKA_SYSTEM_NAME</span> <span class="o">=</span> <span 
class="s">&quot;kafka&quot;</span><span class="o">;</span>
- <span class="kd">private</span> <span class="kd">static</span> <span 
class="kd">final</span> <span class="n">List</span><span 
class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span> 
<span class="n">KAFKA_CONSUMER_ZK_CONNECT</span> <span class="o">=</span> <span 
class="n">ImmutableList</span><span class="o">.</span><span 
class="na">of</span><span class="o">(</span><span 
class="s">&quot;localhost:2181&quot;</span><span class="o">);</span>
- <span class="kd">private</span> <span class="kd">static</span> <span 
class="kd">final</span> <span class="n">List</span><span 
class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span> 
<span class="n">KAFKA_PRODUCER_BOOTSTRAP_SERVERS</span> <span 
class="o">=</span> <span class="n">ImmutableList</span><span 
class="o">.</span><span class="na">of</span><span class="o">(</span><span 
class="s">&quot;localhost:9092&quot;</span><span class="o">);</span>
- <span class="kd">private</span> <span class="kd">static</span> <span 
class="kd">final</span> <span class="n">Map</span><span 
class="o">&lt;</span><span class="n">String</span><span class="o">,</span> 
<span class="n">String</span><span class="o">&gt;</span> <span 
class="n">KAFKA_DEFAULT_STREAM_CONFIGS</span> <span class="o">=</span> <span 
class="n">ImmutableMap</span><span class="o">.</span><span 
class="na">of</span><span class="o">(</span><span 
class="s">&quot;replication.factor&quot;</span><span class="o">,</span> <span 
class="s">&quot;1&quot;</span><span class="o">);</span>
+<figure class="highlight"><pre><code class="language-java" 
data-lang="java"><span class="kd">public</span> <span class="kd">class</span> 
<span class="nc">WordCount</span> <span class="kd">implements</span> <span 
class="nc">StreamApplication</span> <span class="o">{</span>
+ <span class="kd">private</span> <span class="kd">static</span> <span 
class="kd">final</span> <span class="nc">String</span> <span 
class="no">KAFKA_SYSTEM_NAME</span> <span class="o">=</span> <span 
class="s">"kafka"</span><span class="o">;</span>
+ <span class="kd">private</span> <span class="kd">static</span> <span 
class="kd">final</span> <span class="nc">List</span><span 
class="o">&lt;</span><span class="nc">String</span><span class="o">&gt;</span> 
<span class="no">KAFKA_CONSUMER_ZK_CONNECT</span> <span class="o">=</span> 
<span class="nc">ImmutableList</span><span class="o">.</span><span 
class="na">of</span><span class="o">(</span><span 
class="s">"localhost:2181"</span><span class="o">);</span>
+ <span class="kd">private</span> <span class="kd">static</span> <span 
class="kd">final</span> <span class="nc">List</span><span 
class="o">&lt;</span><span class="nc">String</span><span class="o">&gt;</span> 
<span class="no">KAFKA_PRODUCER_BOOTSTRAP_SERVERS</span> <span 
class="o">=</span> <span class="nc">ImmutableList</span><span 
class="o">.</span><span class="na">of</span><span class="o">(</span><span 
class="s">"localhost:9092"</span><span class="o">);</span>
+ <span class="kd">private</span> <span class="kd">static</span> <span 
class="kd">final</span> <span class="nc">Map</span><span 
class="o">&lt;</span><span class="nc">String</span><span class="o">,</span> 
<span class="nc">String</span><span class="o">&gt;</span> <span 
class="no">KAFKA_DEFAULT_STREAM_CONFIGS</span> <span class="o">=</span> <span 
class="nc">ImmutableMap</span><span class="o">.</span><span 
class="na">of</span><span class="o">(</span><span 
class="s">"replication.factor"</span><span class="o">,</span> <span 
class="s">"1"</span><span class="o">);</span>
 
- <span class="kd">private</span> <span class="kd">static</span> <span 
class="kd">final</span> <span class="n">String</span> <span 
class="n">INPUT_STREAM_ID</span> <span class="o">=</span> <span 
class="s">&quot;sample-text&quot;</span><span class="o">;</span>
- <span class="kd">private</span> <span class="kd">static</span> <span 
class="kd">final</span> <span class="n">String</span> <span 
class="n">OUTPUT_STREAM_ID</span> <span class="o">=</span> <span 
class="s">&quot;word-count-output&quot;</span><span class="o">;</span>
+ <span class="kd">private</span> <span class="kd">static</span> <span 
class="kd">final</span> <span class="nc">String</span> <span 
class="no">INPUT_STREAM_ID</span> <span class="o">=</span> <span 
class="s">"sample-text"</span><span class="o">;</span>
+ <span class="kd">private</span> <span class="kd">static</span> <span 
class="kd">final</span> <span class="nc">String</span> <span 
class="no">OUTPUT_STREAM_ID</span> <span class="o">=</span> <span 
class="s">"word-count-output"</span><span class="o">;</span>
 
  <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span 
class="nf">describe</span><span class="o">(</span><span 
class="n">StreamApplicationDescriptor</span> <span 
class="n">streamApplicationDescriptor</span><span class="o">)</span> <span 
class="o">{</span>
+ <span class="kd">public</span> <span class="kt">void</span> <span 
class="nf">describe</span><span class="o">(</span><span 
class="nc">StreamApplicationDescriptor</span> <span 
class="n">streamApplicationDescriptor</span><span class="o">)</span> <span 
class="o">{</span>
    <span class="c1">// Create a KafkaSystemDescriptor providing properties of 
the cluster</span>
-   <span class="n">KafkaSystemDescriptor</span> <span 
class="n">kafkaSystemDescriptor</span> <span class="o">=</span> <span 
class="k">new</span> <span class="n">KafkaSystemDescriptor</span><span 
class="o">(</span><span class="n">KAFKA_SYSTEM_NAME</span><span 
class="o">)</span>
-       <span class="o">.</span><span 
class="na">withConsumerZkConnect</span><span class="o">(</span><span 
class="n">KAFKA_CONSUMER_ZK_CONNECT</span><span class="o">)</span>
-       <span class="o">.</span><span 
class="na">withProducerBootstrapServers</span><span class="o">(</span><span 
class="n">KAFKA_PRODUCER_BOOTSTRAP_SERVERS</span><span class="o">)</span>
-       <span class="o">.</span><span 
class="na">withDefaultStreamConfigs</span><span class="o">(</span><span 
class="n">KAFKA_DEFAULT_STREAM_CONFIGS</span><span class="o">);</span>
+   <span class="nc">KafkaSystemDescriptor</span> <span 
class="n">kafkaSystemDescriptor</span> <span class="o">=</span> <span 
class="k">new</span> <span class="nc">KafkaSystemDescriptor</span><span 
class="o">(</span><span class="no">KAFKA_SYSTEM_NAME</span><span 
class="o">)</span>
+       <span class="o">.</span><span 
class="na">withConsumerZkConnect</span><span class="o">(</span><span 
class="no">KAFKA_CONSUMER_ZK_CONNECT</span><span class="o">)</span>
+       <span class="o">.</span><span 
class="na">withProducerBootstrapServers</span><span class="o">(</span><span 
class="no">KAFKA_PRODUCER_BOOTSTRAP_SERVERS</span><span class="o">)</span>
+       <span class="o">.</span><span 
class="na">withDefaultStreamConfigs</span><span class="o">(</span><span 
class="no">KAFKA_DEFAULT_STREAM_CONFIGS</span><span class="o">);</span>
 
    <span class="c1">// For each input or output stream, create a 
KafkaInput/Output descriptor</span>
-   <span class="n">KafkaInputDescriptor</span><span class="o">&lt;</span><span 
class="n">KV</span><span class="o">&lt;</span><span 
class="n">String</span><span class="o">,</span> <span 
class="n">String</span><span class="o">&gt;&gt;</span> <span 
class="n">inputDescriptor</span> <span class="o">=</span>
-       <span class="n">kafkaSystemDescriptor</span><span 
class="o">.</span><span class="na">getInputDescriptor</span><span 
class="o">(</span><span class="n">INPUT_STREAM_ID</span><span class="o">,</span>
-           <span class="n">KVSerde</span><span class="o">.</span><span 
class="na">of</span><span class="o">(</span><span class="k">new</span> <span 
class="n">StringSerde</span><span class="o">(),</span> <span 
class="k">new</span> <span class="n">StringSerde</span><span 
class="o">()));</span>
-   <span class="n">KafkaOutputDescriptor</span><span 
class="o">&lt;</span><span class="n">KV</span><span class="o">&lt;</span><span 
class="n">String</span><span class="o">,</span> <span 
class="n">String</span><span class="o">&gt;&gt;</span> <span 
class="n">outputDescriptor</span> <span class="o">=</span>
-       <span class="n">kafkaSystemDescriptor</span><span 
class="o">.</span><span class="na">getOutputDescriptor</span><span 
class="o">(</span><span class="n">OUTPUT_STREAM_ID</span><span 
class="o">,</span>
-           <span class="n">KVSerde</span><span class="o">.</span><span 
class="na">of</span><span class="o">(</span><span class="k">new</span> <span 
class="n">StringSerde</span><span class="o">(),</span> <span 
class="k">new</span> <span class="n">StringSerde</span><span 
class="o">()));</span>
+   <span class="nc">KafkaInputDescriptor</span><span 
class="o">&lt;</span><span class="no">KV</span><span class="o">&lt;</span><span 
class="nc">String</span><span class="o">,</span> <span 
class="nc">String</span><span class="o">&gt;&gt;</span> <span 
class="n">inputDescriptor</span> <span class="o">=</span>
+       <span class="n">kafkaSystemDescriptor</span><span 
class="o">.</span><span class="na">getInputDescriptor</span><span 
class="o">(</span><span class="no">INPUT_STREAM_ID</span><span 
class="o">,</span>
+           <span class="nc">KVSerde</span><span class="o">.</span><span 
class="na">of</span><span class="o">(</span><span class="k">new</span> <span 
class="nc">StringSerde</span><span class="o">(),</span> <span 
class="k">new</span> <span class="nc">StringSerde</span><span 
class="o">()));</span>
+   <span class="nc">KafkaOutputDescriptor</span><span 
class="o">&lt;</span><span class="no">KV</span><span class="o">&lt;</span><span 
class="nc">String</span><span class="o">,</span> <span 
class="nc">String</span><span class="o">&gt;&gt;</span> <span 
class="n">outputDescriptor</span> <span class="o">=</span>
+       <span class="n">kafkaSystemDescriptor</span><span 
class="o">.</span><span class="na">getOutputDescriptor</span><span 
class="o">(</span><span class="no">OUTPUT_STREAM_ID</span><span 
class="o">,</span>
+           <span class="nc">KVSerde</span><span class="o">.</span><span 
class="na">of</span><span class="o">(</span><span class="k">new</span> <span 
class="nc">StringSerde</span><span class="o">(),</span> <span 
class="k">new</span> <span class="nc">StringSerde</span><span 
class="o">()));</span>
 
    <span class="c1">// Obtain a handle to a MessageStream that you can chain 
operations on</span>
-   <span class="n">MessageStream</span><span class="o">&lt;</span><span 
class="n">KV</span><span class="o">&lt;</span><span 
class="n">String</span><span class="o">,</span> <span 
class="n">String</span><span class="o">&gt;&gt;</span> <span 
class="n">lines</span> <span class="o">=</span> <span 
class="n">streamApplicationDescriptor</span><span class="o">.</span><span 
class="na">getInputStream</span><span class="o">(</span><span 
class="n">inputDescriptor</span><span class="o">);</span>
-   <span class="n">OutputStream</span><span class="o">&lt;</span><span 
class="n">KV</span><span class="o">&lt;</span><span 
class="n">String</span><span class="o">,</span> <span 
class="n">String</span><span class="o">&gt;&gt;</span> <span 
class="n">counts</span> <span class="o">=</span> <span 
class="n">streamApplicationDescriptor</span><span class="o">.</span><span 
class="na">getOutputStream</span><span class="o">(</span><span 
class="n">outputDescriptor</span><span class="o">);</span>
+   <span class="nc">MessageStream</span><span class="o">&lt;</span><span 
class="no">KV</span><span class="o">&lt;</span><span 
class="nc">String</span><span class="o">,</span> <span 
class="nc">String</span><span class="o">&gt;&gt;</span> <span 
class="n">lines</span> <span class="o">=</span> <span 
class="n">streamApplicationDescriptor</span><span class="o">.</span><span 
class="na">getInputStream</span><span class="o">(</span><span 
class="n">inputDescriptor</span><span class="o">);</span>
+   <span class="nc">OutputStream</span><span class="o">&lt;</span><span 
class="no">KV</span><span class="o">&lt;</span><span 
class="nc">String</span><span class="o">,</span> <span 
class="nc">String</span><span class="o">&gt;&gt;</span> <span 
class="n">counts</span> <span class="o">=</span> <span 
class="n">streamApplicationDescriptor</span><span class="o">.</span><span 
class="na">getOutputStream</span><span class="o">(</span><span 
class="n">outputDescriptor</span><span class="o">);</span>
  <span class="o">}</span>
 <span class="o">}</span></code></pre></figure>
 
-<p>The above example creates a <a 
href="/learn/documentation/latest/api/javadocs/org/apache/samza/operators/MessageStream.html">MessageStream</a>
 which reads from an input topic named <code>sample-text</code>. It also 
defines an output stream that emits results to a topic named 
<code>word-count-output</code>. Next let’s add our processing logic. </p>
+<p>The above example creates a <a 
href="/learn/documentation/latest/api/javadocs/org/apache/samza/operators/MessageStream.html">MessageStream</a>
 which reads from an input topic named <code class="language-plaintext 
highlighter-rouge">sample-text</code>. It also defines an output stream that 
emits results to a topic named <code class="language-plaintext 
highlighter-rouge">word-count-output</code>. Next let’s add our processing 
logic.</p>
 
 <h3 id="add-word-count-processing-logic">Add word count processing logic</h3>
 
-<p>Kafka messages typically have a key and a value. Since we only care about 
the value here, we will apply the <code>map</code> operator on the input stream 
to extract the value. </p>
+<p>Kafka messages typically have a key and a value. Since we only care about 
the value here, we will apply the <code class="language-plaintext 
highlighter-rouge">map</code> operator on the input stream to extract the 
value.</p>
 
-<figure class="highlight"><pre><code class="language-java" 
data-lang="java"><span></span><span class="n">lines</span><span 
class="o">.</span><span class="na">map</span><span class="o">(</span><span 
class="n">kv</span> <span class="o">-&gt;</span> <span class="n">kv</span><span 
class="o">.</span><span class="na">value</span><span 
class="o">)</span></code></pre></figure>
+<figure class="highlight"><pre><code class="language-java" 
data-lang="java"><span class="n">lines</span><span class="o">.</span><span 
class="na">map</span><span class="o">(</span><span class="n">kv</span> <span 
class="o">-&gt;</span> <span class="n">kv</span><span class="o">.</span><span 
class="na">value</span><span class="o">)</span></code></pre></figure>
 
-<p>Next, we will tokenize the message into individual words using the 
<code>flatmap</code> operator.</p>
+<p>Next, we will tokenize the message into individual words using the <code 
class="language-plaintext highlighter-rouge">flatmap</code> operator.</p>
 
-<figure class="highlight"><pre><code class="language-java" 
data-lang="java"><span></span><span class="o">.</span><span 
class="na">flatMap</span><span class="o">(</span><span class="n">s</span> <span 
class="o">-&gt;</span> <span class="n">Arrays</span><span 
class="o">.</span><span class="na">asList</span><span class="o">(</span><span 
class="n">s</span><span class="o">.</span><span class="na">split</span><span 
class="o">(</span><span class="s">&quot;\\W+&quot;</span><span 
class="o">)))</span></code></pre></figure>
+<figure class="highlight"><pre><code class="language-java" 
data-lang="java"><span class="o">.</span><span class="na">flatMap</span><span 
class="o">(</span><span class="n">s</span> <span class="o">-&gt;</span> <span 
class="nc">Arrays</span><span class="o">.</span><span 
class="na">asList</span><span class="o">(</span><span class="n">s</span><span 
class="o">.</span><span class="na">split</span><span class="o">(</span><span 
class="s">"\\W+"</span><span class="o">)))</span></code></pre></figure>
 
-<p>We now need to group the words, aggregate their respective counts and 
periodically emit our results. For this, we will use Samza&rsquo;s 
session-windowing feature.</p>
+<p>We now need to group the words, aggregate their respective counts and 
periodically emit our results. For this, we will use Samza’s 
session-windowing feature.</p>
 
-<figure class="highlight"><pre><code class="language-java" 
data-lang="java"><span></span><span class="o">.</span><span 
class="na">window</span><span class="o">(</span><span 
class="n">Windows</span><span class="o">.</span><span 
class="na">keyedSessionWindow</span><span class="o">(</span>
-   <span class="n">w</span> <span class="o">-&gt;</span> <span 
class="n">w</span><span class="o">,</span> <span class="n">Duration</span><span 
class="o">.</span><span class="na">ofSeconds</span><span 
class="o">(</span><span class="mi">5</span><span class="o">),</span> <span 
class="o">()</span> <span class="o">-&gt;</span> <span class="mi">0</span><span 
class="o">,</span> <span class="o">(</span><span class="n">m</span><span 
class="o">,</span> <span class="n">prevCount</span><span class="o">)</span> 
<span class="o">-&gt;</span> <span class="n">prevCount</span> <span 
class="o">+</span> <span class="mi">1</span><span class="o">,</span>
-   <span class="k">new</span> <span class="n">StringSerde</span><span 
class="o">(),</span> <span class="k">new</span> <span 
class="n">IntegerSerde</span><span class="o">()),</span> <span 
class="s">&quot;count&quot;</span><span class="o">)</span></code></pre></figure>
+<figure class="highlight"><pre><code class="language-java" 
data-lang="java"><span class="o">.</span><span class="na">window</span><span 
class="o">(</span><span class="nc">Windows</span><span class="o">.</span><span 
class="na">keyedSessionWindow</span><span class="o">(</span>
+   <span class="n">w</span> <span class="o">-&gt;</span> <span 
class="n">w</span><span class="o">,</span> <span 
class="nc">Duration</span><span class="o">.</span><span 
class="na">ofSeconds</span><span class="o">(</span><span 
class="mi">5</span><span class="o">),</span> <span class="o">()</span> <span 
class="o">-&gt;</span> <span class="mi">0</span><span class="o">,</span> <span 
class="o">(</span><span class="n">m</span><span class="o">,</span> <span 
class="n">prevCount</span><span class="o">)</span> <span class="o">-&gt;</span> 
<span class="n">prevCount</span> <span class="o">+</span> <span 
class="mi">1</span><span class="o">,</span>
+   <span class="k">new</span> <span class="nf">StringSerde</span><span 
class="o">(),</span> <span class="k">new</span> <span 
class="nc">IntegerSerde</span><span class="o">()),</span> <span 
class="s">"count"</span><span class="o">)</span></code></pre></figure>
 
-<p>Let&rsquo;s walk through each of the parameters to the above 
<code>window</code> function:
-The first parameter is a &ldquo;key function&rdquo;, which defines the key to 
group messages by. In our case, we can simply use the word as the key. The 
second parameter is the windowing interval, which is set to 5 seconds. The 
third parameter is a function which provides the initial value for our 
aggregations. We can start with an initial count of zero for each word. The 
fourth parameter is an aggregation function for computing counts. The next two 
parameters specify the key and value serializers for our window. </p>
+<p>Let’s walk through each of the parameters to the above <code 
class="language-plaintext highlighter-rouge">window</code> function:
+The first parameter is a “key function”, which defines the key to group 
messages by. In our case, we can simply use the word as the key. The second 
parameter is the windowing interval, which is set to 5 seconds. The third 
parameter is a function which provides the initial value for our aggregations. 
We can start with an initial count of zero for each word. The fourth parameter 
is an aggregation function for computing counts. The next two parameters 
specify the key and value serializers for our window.</p>
 
-<p>The output from the window operator is captured in a <a 
href="/learn/documentation/latest/api/javadocs/org/apache/samza/operators/windows/WindowPane.html">WindowPane</a>
 type, which contains the word as the key and its count as the value. We add a 
further <code>map</code> to format this into a <code>KV</code>, that we can 
send to our Kafka topic. To write our results to the output topic, we use the 
<code>sendTo</code> operator in Samza.</p>
+<p>The output from the window operator is captured in a <a 
href="/learn/documentation/latest/api/javadocs/org/apache/samza/operators/windows/WindowPane.html">WindowPane</a>
 type, which contains the word as the key and its count as the value. We add a 
further <code class="language-plaintext highlighter-rouge">map</code> to format 
this into a <code class="language-plaintext highlighter-rouge">KV</code>, that 
we can send to our Kafka topic. To write our results to the output topic, we 
use the <code class="language-plaintext highlighter-rouge">sendTo</code> 
operator in Samza.</p>
 
-<figure class="highlight"><pre><code class="language-java" 
data-lang="java"><span></span><span class="o">.</span><span 
class="na">map</span><span class="o">(</span><span class="n">windowPane</span> 
<span class="o">-&gt;</span>
-   <span class="n">KV</span><span class="o">.</span><span 
class="na">of</span><span class="o">(</span><span 
class="n">windowPane</span><span class="o">.</span><span 
class="na">getKey</span><span class="o">().</span><span 
class="na">getKey</span><span class="o">(),</span>
-       <span class="n">windowPane</span><span class="o">.</span><span 
class="na">getKey</span><span class="o">().</span><span 
class="na">getKey</span><span class="o">()</span> <span class="o">+</span> 
<span class="s">&quot;: &quot;</span> <span class="o">+</span> <span 
class="n">windowPane</span><span class="o">.</span><span 
class="na">getMessage</span><span class="o">().</span><span 
class="na">toString</span><span class="o">()))</span>
+<figure class="highlight"><pre><code class="language-java" 
data-lang="java"><span class="o">.</span><span class="na">map</span><span 
class="o">(</span><span class="n">windowPane</span> <span class="o">-&gt;</span>
+   <span class="no">KV</span><span class="o">.</span><span 
class="na">of</span><span class="o">(</span><span 
class="n">windowPane</span><span class="o">.</span><span 
class="na">getKey</span><span class="o">().</span><span 
class="na">getKey</span><span class="o">(),</span>
+       <span class="n">windowPane</span><span class="o">.</span><span 
class="na">getKey</span><span class="o">().</span><span 
class="na">getKey</span><span class="o">()</span> <span class="o">+</span> 
<span class="s">": "</span> <span class="o">+</span> <span 
class="n">windowPane</span><span class="o">.</span><span 
class="na">getMessage</span><span class="o">().</span><span 
class="na">toString</span><span class="o">()))</span>
 <span class="o">.</span><span class="na">sendTo</span><span 
class="o">(</span><span class="n">counts</span><span 
class="o">);</span></code></pre></figure>
 
 <p>The full processing logic looks like the following:</p>
 
-<figure class="highlight"><pre><code class="language-java" 
data-lang="java"><span></span><span class="n">lines</span>
+<figure class="highlight"><pre><code class="language-java" 
data-lang="java"><span class="n">lines</span>
    <span class="o">.</span><span class="na">map</span><span 
class="o">(</span><span class="n">kv</span> <span class="o">-&gt;</span> <span 
class="n">kv</span><span class="o">.</span><span class="na">value</span><span 
class="o">)</span>
-   <span class="o">.</span><span class="na">flatMap</span><span 
class="o">(</span><span class="n">s</span> <span class="o">-&gt;</span> <span 
class="n">Arrays</span><span class="o">.</span><span 
class="na">asList</span><span class="o">(</span><span class="n">s</span><span 
class="o">.</span><span class="na">split</span><span class="o">(</span><span 
class="s">&quot;\\W+&quot;</span><span class="o">)))</span>
-   <span class="o">.</span><span class="na">window</span><span 
class="o">(</span><span class="n">Windows</span><span class="o">.</span><span 
class="na">keyedSessionWindow</span><span class="o">(</span>
-       <span class="n">w</span> <span class="o">-&gt;</span> <span 
class="n">w</span><span class="o">,</span> <span class="n">Duration</span><span 
class="o">.</span><span class="na">ofSeconds</span><span 
class="o">(</span><span class="mi">5</span><span class="o">),</span> <span 
class="o">()</span> <span class="o">-&gt;</span> <span class="mi">0</span><span 
class="o">,</span> <span class="o">(</span><span class="n">m</span><span 
class="o">,</span> <span class="n">prevCount</span><span class="o">)</span> 
<span class="o">-&gt;</span> <span class="n">prevCount</span> <span 
class="o">+</span> <span class="mi">1</span><span class="o">,</span>
-       <span class="k">new</span> <span class="n">StringSerde</span><span 
class="o">(),</span> <span class="k">new</span> <span 
class="n">IntegerSerde</span><span class="o">()),</span> <span 
class="s">&quot;count&quot;</span><span class="o">)</span>
+   <span class="o">.</span><span class="na">flatMap</span><span 
class="o">(</span><span class="n">s</span> <span class="o">-&gt;</span> <span 
class="nc">Arrays</span><span class="o">.</span><span 
class="na">asList</span><span class="o">(</span><span class="n">s</span><span 
class="o">.</span><span class="na">split</span><span class="o">(</span><span 
class="s">"\\W+"</span><span class="o">)))</span>
+   <span class="o">.</span><span class="na">window</span><span 
class="o">(</span><span class="nc">Windows</span><span class="o">.</span><span 
class="na">keyedSessionWindow</span><span class="o">(</span>
+       <span class="n">w</span> <span class="o">-&gt;</span> <span 
class="n">w</span><span class="o">,</span> <span 
class="nc">Duration</span><span class="o">.</span><span 
class="na">ofSeconds</span><span class="o">(</span><span 
class="mi">5</span><span class="o">),</span> <span class="o">()</span> <span 
class="o">-&gt;</span> <span class="mi">0</span><span class="o">,</span> <span 
class="o">(</span><span class="n">m</span><span class="o">,</span> <span 
class="n">prevCount</span><span class="o">)</span> <span class="o">-&gt;</span> 
<span class="n">prevCount</span> <span class="o">+</span> <span 
class="mi">1</span><span class="o">,</span>
+       <span class="k">new</span> <span class="nf">StringSerde</span><span 
class="o">(),</span> <span class="k">new</span> <span 
class="nc">IntegerSerde</span><span class="o">()),</span> <span 
class="s">"count"</span><span class="o">)</span>
    <span class="o">.</span><span class="na">map</span><span 
class="o">(</span><span class="n">windowPane</span> <span class="o">-&gt;</span>
-       <span class="n">KV</span><span class="o">.</span><span 
class="na">of</span><span class="o">(</span><span 
class="n">windowPane</span><span class="o">.</span><span 
class="na">getKey</span><span class="o">().</span><span 
class="na">getKey</span><span class="o">(),</span>
-           <span class="n">windowPane</span><span class="o">.</span><span 
class="na">getKey</span><span class="o">().</span><span 
class="na">getKey</span><span class="o">()</span> <span class="o">+</span> 
<span class="s">&quot;: &quot;</span> <span class="o">+</span> <span 
class="n">windowPane</span><span class="o">.</span><span 
class="na">getMessage</span><span class="o">().</span><span 
class="na">toString</span><span class="o">()))</span>
+       <span class="no">KV</span><span class="o">.</span><span 
class="na">of</span><span class="o">(</span><span 
class="n">windowPane</span><span class="o">.</span><span 
class="na">getKey</span><span class="o">().</span><span 
class="na">getKey</span><span class="o">(),</span>
+           <span class="n">windowPane</span><span class="o">.</span><span 
class="na">getKey</span><span class="o">().</span><span 
class="na">getKey</span><span class="o">()</span> <span class="o">+</span> 
<span class="s">": "</span> <span class="o">+</span> <span 
class="n">windowPane</span><span class="o">.</span><span 
class="na">getMessage</span><span class="o">().</span><span 
class="na">toString</span><span class="o">()))</span>
    <span class="o">.</span><span class="na">sendTo</span><span 
class="o">(</span><span class="n">counts</span><span 
class="o">);</span></code></pre></figure>
 
 <h3 id="configure-your-application">Configure your application</h3>
 
-<p>In this section, we will configure our word count example to run locally in 
a single JVM. Let us add a file named “word-count.properties” under the 
config folder. </p>
+<p>In this section, we will configure our word count example to run locally in 
a single JVM. Let us add a file named “word-count.properties” under the 
config folder.</p>
 
-<figure class="highlight"><pre><code class="language-jproperties" 
data-lang="jproperties"><span></span><span class="na">job.name</span><span 
class="o">=</span><span class="s">word-count</span>
-<span class="c"># Use a PassthroughJobCoordinator since there is no 
coordination needed</span>
-<span class="na">job.coordinator.factory</span><span class="o">=</span><span 
class="s">org.apache.samza.standalone.PassthroughJobCoordinatorFactory</span>
-<span class="na">job.coordination.utils.factory</span><span 
class="o">=</span><span 
class="s">org.apache.samza.standalone.PassthroughCoordinationUtilsFactory</span>
+<figure class="highlight"><pre><code class="language-jproperties" 
data-lang="jproperties">job.name=word-count
+# Use a PassthroughJobCoordinator since there is no coordination needed
+job.coordinator.factory=org.apache.samza.standalone.PassthroughJobCoordinatorFactory
+job.coordination.utils.factory=org.apache.samza.standalone.PassthroughCoordinationUtilsFactory
 
-<span class="na">job.changelog.system</span><span class="o">=</span><span 
class="s">kafka</span>
+job.changelog.system=kafka
 
-<span class="c"># Use a single container to process all of the data</span>
-<span class="na">task.name.grouper.factory</span><span class="o">=</span><span 
class="s">org.apache.samza.container.grouper.task.SingleContainerGrouperFactory</span>
-<span class="na">processor.id</span><span class="o">=</span><span 
class="s">0</span>
+# Use a single container to process all of the data
+task.name.grouper.factory=org.apache.samza.container.grouper.task.SingleContainerGrouperFactory
+processor.id=0
 
-<span class="c"># Read from the beginning of the topic</span>
-<span class="na">systems.kafka.default.stream.samza.offset.default</span><span 
class="o">=</span><span class="s">oldest</span></code></pre></figure>
+# Read from the beginning of the topic
+systems.kafka.default.stream.samza.offset.default=oldest</code></pre></figure>
 
-<p>For more details on Samza&rsquo;s configs, feel free to check out the 
latest <a 
href="/learn/documentation/latest/jobs/configuration-table.html">configuration 
reference</a>.</p>
+<p>For more details on Samza’s configs, feel free to check out the latest <a 
href="/learn/documentation/latest/jobs/configuration-table.html">configuration 
reference</a>.</p>
 
 <h3 id="run-your-application">Run your application</h3>
 
-<p>We are ready to add a <code>main()</code> function to the 
<code>WordCount</code> class. It parses the command-line arguments and 
instantiates a <code>LocalApplicationRunner</code> to execute the application 
locally.</p>
+<p>We are ready to add a <code class="language-plaintext 
highlighter-rouge">main()</code> function to the <code 
class="language-plaintext highlighter-rouge">WordCount</code> class. It parses 
the command-line arguments and instantiates a <code class="language-plaintext 
highlighter-rouge">LocalApplicationRunner</code> to execute the application 
locally.</p>
 
-<figure class="highlight"><pre><code class="language-java" 
data-lang="java"><span></span><span class="kd">public</span> <span 
class="kd">static</span> <span class="kt">void</span> <span 
class="nf">main</span><span class="o">(</span><span 
class="n">String</span><span class="o">[]</span> <span 
class="n">args</span><span class="o">)</span> <span class="o">{</span>
- <span class="n">CommandLine</span> <span class="n">cmdLine</span> <span 
class="o">=</span> <span class="k">new</span> <span 
class="n">CommandLine</span><span class="o">();</span>
- <span class="n">OptionSet</span> <span class="n">options</span> <span 
class="o">=</span> <span class="n">cmdLine</span><span class="o">.</span><span 
class="na">parser</span><span class="o">().</span><span 
class="na">parse</span><span class="o">(</span><span class="n">args</span><span 
class="o">);</span>
- <span class="n">Config</span> <span class="n">config</span> <span 
class="o">=</span> <span class="n">cmdLine</span><span class="o">.</span><span 
class="na">loadConfig</span><span class="o">(</span><span 
class="n">options</span><span class="o">);</span>
- <span class="n">LocalApplicationRunner</span> <span class="n">runner</span> 
<span class="o">=</span> <span class="k">new</span> <span 
class="n">LocalApplicationRunner</span><span class="o">(</span><span 
class="k">new</span> <span class="n">WordCount</span><span class="o">(),</span> 
<span class="n">config</span><span class="o">);</span>
+<figure class="highlight"><pre><code class="language-java" 
data-lang="java"><span class="kd">public</span> <span class="kd">static</span> 
<span class="kt">void</span> <span class="nf">main</span><span 
class="o">(</span><span class="nc">String</span><span class="o">[]</span> <span 
class="n">args</span><span class="o">)</span> <span class="o">{</span>
+ <span class="nc">CommandLine</span> <span class="n">cmdLine</span> <span 
class="o">=</span> <span class="k">new</span> <span 
class="nc">CommandLine</span><span class="o">();</span>
+ <span class="nc">OptionSet</span> <span class="n">options</span> <span 
class="o">=</span> <span class="n">cmdLine</span><span class="o">.</span><span 
class="na">parser</span><span class="o">().</span><span 
class="na">parse</span><span class="o">(</span><span class="n">args</span><span 
class="o">);</span>
+ <span class="nc">Config</span> <span class="n">config</span> <span 
class="o">=</span> <span class="n">cmdLine</span><span class="o">.</span><span 
class="na">loadConfig</span><span class="o">(</span><span 
class="n">options</span><span class="o">);</span>
+ <span class="nc">LocalApplicationRunner</span> <span class="n">runner</span> 
<span class="o">=</span> <span class="k">new</span> <span 
class="nc">LocalApplicationRunner</span><span class="o">(</span><span 
class="k">new</span> <span class="nc">WordCount</span><span 
class="o">(),</span> <span class="n">config</span><span class="o">);</span>
  <span class="n">runner</span><span class="o">.</span><span 
class="na">run</span><span class="o">();</span>
  <span class="n">runner</span><span class="o">.</span><span 
class="na">waitForFinish</span><span class="o">();</span>
 <span class="o">}</span></code></pre></figure>
 
-<p>Before running <code>main()</code>, we will create our input Kafka topic 
and populate it with sample data. You can download the scripts to interact with 
Kafka along with the sample data from <a 
href="https://github.com/apache/samza-hello-samza/blob/latest/quickstart/wordcount.tar.gz";>here</a>.</p>
+<p>Before running <code class="language-plaintext 
highlighter-rouge">main()</code>, we will create our input Kafka topic and 
populate it with sample data. You can download the scripts to interact with 
Kafka along with the sample data from <a 
href="https://github.com/apache/samza-hello-samza/blob/latest/quickstart/wordcount.tar.gz";>here</a>.</p>
 
-<figure class="highlight"><pre><code class="language-bash" 
data-lang="bash"><span></span>&gt; ./scripts/grid install zookeeper <span 
class="o">&amp;&amp;</span> ./scripts/grid start zookeeper
-&gt; ./scripts/grid install kafka <span class="o">&amp;&amp;</span> 
./scripts/grid start kafka</code></pre></figure>
+<figure class="highlight"><pre><code class="language-bash" 
data-lang="bash"><span class="o">&gt;</span> ./scripts/grid <span 
class="nb">install </span>zookeeper <span class="o">&amp;&amp;</span> 
./scripts/grid start zookeeper
+<span class="o">&gt;</span> ./scripts/grid <span class="nb">install 
</span>kafka <span class="o">&amp;&amp;</span> ./scripts/grid start 
kafka</code></pre></figure>
 
-<figure class="highlight"><pre><code class="language-bash" 
data-lang="bash"><span></span>&gt; ./deploy/kafka/bin/kafka-topics.sh --create 
--zookeeper localhost:2181 --topic sample-text --partition <span 
class="m">1</span> --replication-factor <span class="m">1</span>
-&gt; ./deploy/kafka/bin/kafka-console-producer.sh --topic sample-text --broker 
localhost:9092 &lt; ./sample-text.txt</code></pre></figure>
+<figure class="highlight"><pre><code class="language-bash" 
data-lang="bash"><span class="o">&gt;</span> ./deploy/kafka/bin/kafka-topics.sh 
<span class="nt">--create</span> <span class="nt">--zookeeper</span> 
localhost:2181 <span class="nt">--topic</span> sample-text <span 
class="nt">--partition</span> 1 <span class="nt">--replication-factor</span> 1
+<span class="o">&gt;</span> ./deploy/kafka/bin/kafka-console-producer.sh <span 
class="nt">--topic</span> sample-text <span class="nt">--broker</span> 
localhost:9092 &lt; ./sample-text.txt</code></pre></figure>
 
 <p>Let’s kick off our application and use gradle to run it. Alternately, you 
can also run it directly from your IDE, with the same program arguments.</p>
 
-<figure class="highlight"><pre><code class="language-bash" 
data-lang="bash"><span></span>&gt; <span class="nb">export</span> <span 
class="nv">BASE_DIR</span><span class="o">=</span><span 
class="sb">`</span><span class="nb">pwd</span><span class="sb">`</span>
-&gt; ./gradlew run --args<span class="o">=</span><span 
class="s2">&quot;--config 
job.config.loader.factory=org.apache.samza.config.loaders.PropertiesConfigLoaderFactory
 --config job.config.loader.properties.path=</span><span 
class="nv">$BASE_DIR</span><span 
class="s2">/src/main/config/word-count.properties&quot;</span></code></pre></figure>
+<figure class="highlight"><pre><code class="language-bash" 
data-lang="bash"><span class="o">&gt;</span> <span class="nb">export 
</span><span class="nv">BASE_DIR</span><span class="o">=</span><span 
class="sb">`</span><span class="nb">pwd</span><span class="sb">`</span>
+<span class="o">&gt;</span> ./gradlew run <span class="nt">--args</span><span 
class="o">=</span><span class="s2">"--config 
job.config.loader.factory=org.apache.samza.config.loaders.PropertiesConfigLoaderFactory
 --config job.config.loader.properties.path=</span><span 
class="nv">$BASE_DIR</span><span 
class="s2">/src/main/config/word-count.properties"</span></code></pre></figure>
 
-<p>The application will output to a Kafka topic named 
&ldquo;word-count-output&rdquo;. We will now fire up a Kafka consumer to read 
from this topic:</p>
+<p>The application will output to a Kafka topic named “word-count-output”. 
We will now fire up a Kafka consumer to read from this topic:</p>
 
-<figure class="highlight"><pre><code class="language-bash" 
data-lang="bash"><span></span>&gt;  
./deploy/kafka/bin/kafka-console-consumer.sh --topic word-count-output 
--zookeeper localhost:2181 --from-beginning</code></pre></figure>
+<figure class="highlight"><pre><code class="language-bash" 
data-lang="bash"><span class="o">&gt;</span>  
./deploy/kafka/bin/kafka-console-consumer.sh <span class="nt">--topic</span> 
word-count-output <span class="nt">--zookeeper</span> localhost:2181 <span 
class="nt">--from-beginning</span></code></pre></figure>
 
 <p>It will show the counts for each word like the following:</p>
 
-<figure class="highlight"><pre><code class="language-bash" 
data-lang="bash"><span></span>well: <span class="m">4</span>
-complaining: <span class="m">1</span>
-die: <span class="m">3</span>
-but: <span class="m">22</span>
-not: <span class="m">50</span>
-truly: <span class="m">5</span>
-murmuring: <span class="m">1</span>
-satisfied: <span class="m">3</span>
-the: <span class="m">120</span>
-thy: <span class="m">8</span>
-gods: <span class="m">8</span>
-thankful: <span class="m">1</span>
-and: <span class="m">243</span>
-from: <span class="m">16</span></code></pre></figure>
+<figure class="highlight"><pre><code class="language-bash" 
data-lang="bash">well: 4
+complaining: 1
+die: 3
+but: 22
+not: 50
+truly: 5
+murmuring: 1
+satisfied: 3
+the: 120
+thy: 8
+gods: 8
+thankful: 1
+and: 243
+from: 16</code></pre></figure>
 
-<p>Congratulations! You&rsquo;ve successfully run your first Samza 
application.</p>
+<p>Congratulations! You’ve successfully run your first Samza application.</p>
 
-<h3 id="more-examples"><a href="/startup/code-examples/latest">More Examples 
&gt;&gt;</a></h3>
+<h3 id="more-examples"><a href="/startup/code-examples/latest">More Examples 
»</a></h3>
 
            
         </div>

Modified: samza/site/startup/releases/latest/release-notes.html
URL: 
http://svn.apache.org/viewvc/samza/site/startup/releases/latest/release-notes.html?rev=1906774&r1=1906773&r2=1906774&view=diff
==============================================================================
--- samza/site/startup/releases/latest/release-notes.html (original)
+++ samza/site/startup/releases/latest/release-notes.html Wed Jan 18 19:33:25 
2023
@@ -227,6 +227,12 @@
     
       
         
+      <a class="side-navigation__group-item" data-match-active="" 
href="/releases/1.8.0">1.8.0</a>
+      
+        
+      <a class="side-navigation__group-item" data-match-active="" 
href="/releases/1.7.0">1.7.0</a>
+      
+        
       <a class="side-navigation__group-item" data-match-active="" 
href="/releases/1.6.0">1.6.0</a>
       
         
@@ -546,67 +552,62 @@
 -->
 
 <ol>
-<li><a href="#release-notes">Release Notes for Samza-latest version</a></li>
-<li><a href="#upgrade-notes">Upgrade Notes</a></li>
+  <li><a href="#release-notes">Release Notes for Samza-latest version</a></li>
+  <li><a href="#upgrade-notes">Upgrade Notes</a></li>
 </ol>
 
 <h3 id="release-notes">Release Notes</h3>
 
 <!-- Add notes on new features, modified behavior of existing features, 
operational/performance improvements, new tools etc -->
-
 <ul>
-<li><a href="https://issues.apache.org/jira/browse/SAMZA-1510";>SAMZA-1510</a> 
- Samza SQL</li>
-<li><a href="https://issues.apache.org/jira/browse/SAMZA-1438";>SAMZA-1438</a> 
- Producer and consumer for Azure EventHubs</li>
-<li><a href="https://issues.apache.org/jira/browse/SAMZA-1515";>SAMZA-1515</a> 
- Kinesis consumer</li>
-<li><a href="https://issues.apache.org/jira/browse/SAMZA-1486";>SAMZA-1486</a> 
- Checkpoint provider for Azure tables</li>
-<li><a href="https://issues.apache.org/jira/browse/SAMZA-1421";>SAMZA-1421</a> 
- Support for durable state in high-level API</li>
-<li><a href="https://issues.apache.org/jira/browse/SAMZA-1392";>SAMZA-1392</a> 
- KafkaSystemProducer performance and correctness with concurrent sends and 
flushes</li>
-<li><a href="https://issues.apache.org/jira/browse/SAMZA-1406";>SAMZA-1406</a> 
- Enhancements to the ZooKeeper-based deployment model</li>
-<li><a href="https://issues.apache.org/jira/browse/SAMZA-1321";>SAMZA-1321</a> 
- Support for multi-stage batch processing</li>
+  <li><a 
href="https://issues.apache.org/jira/browse/SAMZA-1510";>SAMZA-1510</a> - Samza 
SQL</li>
+  <li><a 
href="https://issues.apache.org/jira/browse/SAMZA-1438";>SAMZA-1438</a> - 
Producer and consumer for Azure EventHubs</li>
+  <li><a 
href="https://issues.apache.org/jira/browse/SAMZA-1515";>SAMZA-1515</a> - 
Kinesis consumer</li>
+  <li><a 
href="https://issues.apache.org/jira/browse/SAMZA-1486";>SAMZA-1486</a> - 
Checkpoint provider for Azure tables</li>
+  <li><a 
href="https://issues.apache.org/jira/browse/SAMZA-1421";>SAMZA-1421</a> - 
Support for durable state in high-level API</li>
+  <li><a 
href="https://issues.apache.org/jira/browse/SAMZA-1392";>SAMZA-1392</a> - 
KafkaSystemProducer performance and correctness with concurrent sends and 
flushes</li>
+  <li><a 
href="https://issues.apache.org/jira/browse/SAMZA-1406";>SAMZA-1406</a> - 
Enhancements to the ZooKeeper-based deployment model</li>
+  <li><a 
href="https://issues.apache.org/jira/browse/SAMZA-1321";>SAMZA-1321</a> - 
Support for multi-stage batch processing</li>
 </ul>
 
 <h3 id="upgrade-notes">Upgrade Notes</h3>
-
 <!-- Add detailed notes on how someone using an older version of samza 
(typically, currentVersion - 1) can upgrade to the latest -->
-
 <!-- Notes typically include config changes, public-api changes, new user 
guides/tutorials etc -->
 
 <h4 id="configuration-changes">Configuration Changes</h4>
 
 <!-- PR 290 -->
-
 <ul>
-<li>Introduced a new <strong>mandatory</strong> configuration - 
<code>job.coordination.utils.factory</code>. Read more about it
+  <li>Introduced a new <strong>mandatory</strong> configuration - <code 
class="language-plaintext 
highlighter-rouge">job.coordination.utils.factory</code>. Read more about it
 <a href="/learn/documentation/latest/jobs/configuration-table.html">here</a>. 
<br />This config is applicable to all Samza
-applications deployed using the <code>LocalApplicationRunner</code> (that is, 
non-yarn deployments).</li>
+applications deployed using the <code class="language-plaintext 
highlighter-rouge">LocalApplicationRunner</code> (that is, non-yarn 
deployments).</li>
 </ul>
 
 <h4 id="api-changes">API Changes</h4>
 
 <!-- PR 292 -->
-
 <ul>
-<li>The following APIs in <code>SystemAdmin</code> have been deprecated in the 
previous versions and hence, replaced with newer APIs.
+  <li>The following APIs in <code class="language-plaintext 
highlighter-rouge">SystemAdmin</code> have been deprecated in the previous 
versions and hence, replaced with newer APIs.
 If you have a custom <strong>System</strong> implementation, then you have to 
update to the newer APIs.
-
-<ul>
-<li><del>void createChangelogStream(String streamName, int 
numOfPartitions);</del> -&gt; <code>boolean createStream(StreamSpec 
streamSpec);</code></li>
-<li><del>void createCoordinatorStream(String streamName);</del> -&gt; 
<code>boolean createStream(StreamSpec streamSpec);</code></li>
-<li><del>void validateChangelogStream(String streamName, int 
numOfPartitions);</del> -&gt; <code>void validateStream(StreamSpec streamSpec) 
throws StreamValidationException;</code></li>
-</ul></li>
+    <ul>
+      <li><del>void createChangelogStream(String streamName, int 
numOfPartitions);</del> -&gt; <code class="language-plaintext 
highlighter-rouge">boolean createStream(StreamSpec streamSpec);</code></li>
+      <li><del>void createCoordinatorStream(String streamName);</del> -&gt; 
<code class="language-plaintext highlighter-rouge">boolean 
createStream(StreamSpec streamSpec);</code></li>
+      <li><del>void validateChangelogStream(String streamName, int 
numOfPartitions);</del> -&gt; <code class="language-plaintext 
highlighter-rouge">void validateStream(StreamSpec streamSpec) throws 
StreamValidationException;</code></li>
+    </ul>
+  </li>
 </ul>
 
 <!-- PR 292 -->
-
 <ul>
-<li>New API has been added to <code>SystemAdmin</code> that clear a stream. 
<br />
-<code>
-boolean clearStream(StreamSpec streamSpec);
-</code>
-<br />
-Read more about it in the <a 
href="/learn/documentation/latest/api/javadocs/org/apache/samza/system/SystemAdmin.html">API
 docs</a>.</li>
+  <li>New API has been added to <code class="language-plaintext 
highlighter-rouge">SystemAdmin</code> that clear a stream. <br />
+    <div class="language-plaintext highlighter-rouge"><div 
class="highlight"><pre class="highlight"><code>boolean clearStream(StreamSpec 
streamSpec);
+</code></pre></div>    </div>
+    <p><br />
+Read more about it in the <a 
href="/learn/documentation/latest/api/javadocs/org/apache/samza/system/SystemAdmin.html">API
 docs</a>.</p>
+  </li>
 </ul>
 
+
            
         </div>
       </div>

Modified: samza/site/talks/index.html
URL: 
http://svn.apache.org/viewvc/samza/site/talks/index.html?rev=1906774&r1=1906773&r2=1906774&view=diff
==============================================================================
--- samza/site/talks/index.html (original)
+++ samza/site/talks/index.html Wed Jan 18 19:33:25 2023
@@ -81,7 +81,7 @@
     </div>
     <div class="main-navigation__items" data-menu-opened>
       <a class="main-navigation__item" href="/">Home</a>
-      <a class="main-navigation__item" 
href="/learn/documentation/1.8.0/core-concepts/core-concepts.html">Docs</a>
+      <a class="main-navigation__item" 
href="/learn/documentation/latest/core-concepts/core-concepts.html">Docs</a>
       <a class="main-navigation__item" href="/powered-by/">Powered By</a>
       <a class="main-navigation__item" href="/startup/download/">Downloads</a>
       <a class="main-navigation__item" href="/blog/">Blog</a>
@@ -152,10 +152,10 @@
     
       
         
-      <a class="side-navigation__group-item" data-match-active="" 
href="/startup/quick-start/1.8.0/">QuickStart</a>
+      <a class="side-navigation__group-item" data-match-active="" 
href="/startup/quick-start/latest/">QuickStart</a>
       
         
-      <a class="side-navigation__group-item" data-match-active="" 
href="/startup/code-examples/1.8.0/">Code Examples</a>
+      <a class="side-navigation__group-item" data-match-active="" 
href="/startup/code-examples/latest/">Code Examples</a>
       
 
     
@@ -187,7 +187,7 @@
         <i class="side-navigation__group-title-icon icon 
ion-md-arrow-dropdown"></i>
         Documentation
       </div>
-      <div class="side-navigation__group-items 
side-navigation__group-has-submenus" data-sub-menu 
data-documentation="/learn/documentation/1.8.0/">
+      <div class="side-navigation__group-items 
side-navigation__group-has-submenus" data-sub-menu 
data-documentation="/learn/documentation/latest/">
     
 
     <!-- Handle sub navigation items from data -->
@@ -227,6 +227,12 @@
     
       
         
+      <a class="side-navigation__group-item" data-match-active="" 
href="/releases/1.8.0">1.8.0</a>
+      
+        
+      <a class="side-navigation__group-item" data-match-active="" 
href="/releases/1.7.0">1.7.0</a>
+      
+        
       <a class="side-navigation__group-item" data-match-active="" 
href="/releases/1.6.0">1.6.0</a>
       
         
@@ -805,7 +811,7 @@
         <div class="footer__items">
           <a class="footer__item" href="/meetups/">Meetups</a>
           <a class="footer__item" href="/blog/">Blog</a>
-          <a class="footer__item" 
href="/learn/documentation/1.8.0/introduction/background.html">About</a>
+          <a class="footer__item" 
href="/learn/documentation/latest/introduction/background.html">About</a>
         </div>
       </div>
       <div>


Reply via email to