<!DOCTYPE html>
<html>

    <head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">

    <link rel="shortcut icon" href="/favicon.ico" type="image/x-icon">
    <link rel="icon" href="/favicon.ico" type="image/x-icon">

    <title>Apache Storm 0.9.3 released</title>

    <!-- Bootstrap core CSS -->
    <link href="/assets/css/bootstrap.min.css" rel="stylesheet">
    <!-- Bootstrap theme -->
    <link href="/assets/css/bootstrap-theme.min.css" rel="stylesheet">

    <!-- Custom styles for this template -->
    <link rel="stylesheet" href="http://fortawesome.github.io/Font-Awesome/assets/font-awesome/css/font-awesome.css">
    <link href="/css/style.css" rel="stylesheet">
    <link href="/assets/css/owl.theme.css" rel="stylesheet">
    <link href="/assets/css/owl.carousel.css" rel="stylesheet">
    <script type="text/javascript" src="/assets/js/jquery.min.js"></script>
    <script type="text/javascript" src="/assets/js/bootstrap.min.js"></script>
    <script type="text/javascript" src="/assets/js/owl.carousel.min.js"></script>
    <script type="text/javascript" src="/assets/js/storm.js"></script>
    <!-- Just for debugging purposes. Don't actually copy these 2 lines! -->
    <!--[if lt IE 9]><script src="../../assets/js/ie8-responsive-file-warning.js"></script><![endif]-->
    
    <!-- HTML5 shim and Respond.js for IE8 support of HTML5 elements and media queries -->
    <!--[if lt IE 9]>
      <script src="https://oss.maxcdn.com/html5shiv/3.7.2/html5shiv.min.js"></script>
      <script src="https://oss.maxcdn.com/respond/1.4.2/respond.min.js"></script>
    <![endif]-->
  </head>



    <body>

    <header>
  <div class="container-fluid">
     <div class="row">
          <div class="col-md-5">
            <a href="/index.html"><img src="/images/logo.png" class="logo" /></a>
          </div>
          <div class="col-md-5">
            
          </div>
          <div class="col-md-2">
            <a href="/downloads.html" class="btn-std btn-block btn-download">Download</a>
          </div>
        </div>
    </div>
</header>
<!--Header End-->
<!--Navigation Begin-->
<div class="navbar" role="banner">
  <div class="container-fluid">
      <div class="navbar-header">
          <button class="navbar-toggle" type="button" data-toggle="collapse" data-target=".bs-navbar-collapse">
                <span class="icon-bar"></span>
                <span class="icon-bar"></span>
                <span class="icon-bar"></span>
            </button>
        </div>
        <nav class="collapse navbar-collapse bs-navbar-collapse" role="navigation">
          <ul class="nav navbar-nav">
              <li><a href="/index.html" id="home">Home</a></li>
                <li><a href="/getting-help.html" id="getting-help">Getting Help</a></li>
                <li><a href="/about/integrates.html" id="project-info">Project Information</a></li>
                <li class="dropdown">
                    <a href="#" class="dropdown-toggle" data-toggle="dropdown" id="documentation">Documentation <b class="caret"></b></a>
                    <ul class="dropdown-menu">
                      
                        
                          <li><a href="/releases/2.3.0/index.html">2.3.0</a></li>
                        
                      
                        
                          <li><a href="/releases/2.2.0/index.html">2.2.0</a></li>
                        
                      
                        
                          <li><a href="/releases/2.1.0/index.html">2.1.0</a></li>
                        
                      
                        
                          <li><a href="/releases/2.0.0/index.html">2.0.0</a></li>
                        
                      
                        
                          <li><a href="/releases/1.2.3/index.html">1.2.3</a></li>
                        
                      
                    </ul>
                </li>
                <li><a href="/talksAndVideos.html">Talks and Slideshows</a></li>
                <li class="dropdown">
                    <a href="#" class="dropdown-toggle" data-toggle="dropdown" id="contribute">Community <b class="caret"></b></a>
                    <ul class="dropdown-menu">
                        <li><a href="/contribute/Contributing-to-Storm.html">Contributing</a></li>
                        <li><a href="/contribute/People.html">People</a></li>
                        <li><a href="/contribute/BYLAWS.html">ByLaws</a></li>
                    </ul>
                </li>
                <li><a href="/2020/06/30/storm220-released.html" id="news">News</a></li>
            </ul>
        </nav>
    </div>
</div>



    <div class="container-fluid">
        <div class="row">
            <div class="col-md-12">
                <div class="row">
                    <div class="col-md-3">
                        <ul class="news" id="news-list">
                            
                      		<li><a href="/2020/06/30/storm220-released.html">Apache Storm 2.2.0 Released</a></li>
                    		
                      		<li><a href="/2019/10/31/storm210-released.html">Apache Storm 2.1.0 Released</a></li>
                    		
                      		<li><a href="/2019/07/18/storm123-released.html">Apache Storm 1.2.3 Released</a></li>
                    		
                      		<li><a href="/2019/05/30/storm200-released.html">Apache Storm 2.0.0 Released</a></li>
                    		
                      		<li><a href="/2018/06/04/storm122-released.html">Apache Storm 1.2.2 Released</a></li>
                    		
                      		<li><a href="/2018/06/04/storm113-released.html">Apache Storm 1.1.3 Released</a></li>
                    		
                      		<li><a href="/2018/02/19/storm121-released.html">Apache Storm 1.2.1 Released</a></li>
                    		
                      		<li><a href="/2018/02/15/storm120-released.html">Apache Storm 1.2.0 Released</a></li>
                    		
                      		<li><a href="/2018/02/15/storm112-released.html">Apache Storm 1.1.2 Released</a></li>
                    		
                      		<li><a href="/2018/02/14/storm106-released.html">Apache Storm 1.0.6 Released</a></li>
                    		
                      		<li><a href="/2017/09/15/storm105-released.html">Apache Storm 1.0.5 Released</a></li>
                    		
                      		<li><a href="/2017/08/01/storm111-released.html">Apache Storm 1.1.1 Released</a></li>
                    		
                      		<li><a href="/2017/07/28/storm104-released.html">Apache Storm 1.0.4 Released</a></li>
                    		
                      		<li><a href="/2017/03/29/storm110-released.html">Apache Storm 1.1.0 released</a></li>
                    		
                      		<li><a href="/2017/02/14/storm103-released.html">Apache Storm 1.0.3 Released</a></li>
                    		
                      		<li><a href="/2016/09/14/storm0102-released.html">Apache Storm 0.10.2 Released</a></li>
                    		
                      		<li><a href="/2016/09/07/storm097-released.html">Apache Storm 0.9.7 Released</a></li>
                    		
                      		<li><a href="/2016/08/10/storm102-released.html">Apache Storm 1.0.2 Released</a></li>
                    		
                      		<li><a href="/2016/05/06/storm101-released.html">Apache Storm 1.0.1 Released</a></li>
                    		
                      		<li><a href="/2016/05/05/storm0101-released.html">Apache Storm 0.10.1 Released</a></li>
                    		
                      		<li><a href="/2016/04/12/storm100-released.html">Apache Storm 1.0.0 released</a></li>
                    		
                      		<li><a href="/2015/11/05/storm096-released.html">Apache Storm 0.9.6 released</a></li>
                    		
                      		<li><a href="/2015/11/05/storm0100-released.html">Apache Storm 0.10.0 released</a></li>
                    		
                      		<li><a href="/2015/06/15/storm0100-beta-released.html">Apache Storm 0.10.0 Beta Released</a></li>
                    		
                      		<li><a href="/2015/06/04/storm095-released.html">Apache Storm 0.9.5 released</a></li>
                    		
                      		<li><a href="/2015/03/25/storm094-released.html">Apache Storm 0.9.4 released</a></li>
                    		
                      		<li><a href="/2014/11/25/storm093-released.html">Apache Storm 0.9.3 released</a></li>
                    		
                      		<li><a href="/2014/10/20/storm093-release-candidate.html">Apache Storm 0.9.3 release candidate 1 available</a></li>
                    		
                      		<li><a href="/2014/06/25/storm092-released.html">Apache Storm 0.9.2 released</a></li>
                    		
                      		<li><a href="/2014/06/17/contest-results.html">Apache Storm Logo Contest Results</a></li>
                    		
                      		<li><a href="/2014/05/27/round1-results.html">Logo Contest - Round 1 Results</a></li>
                    		
                      		<li><a href="/2014/04/29/logo-jlee3.html">Logo Entry No. 11 - Jennifer Lee</a></li>
                    		
                      		<li><a href="/2014/04/29/logo-jlee2.html">Logo Entry No. 10 - Jennifer Lee</a></li>
                    		
                      		<li><a href="/2014/04/29/logo-jlee1.html">Logo Entry No. 9 - Jennifer Lee</a></li>
                    		
                      		<li><a href="/2014/04/27/logo-sasili.html">Logo Entry No. 8 - Stefano Asili</a></li>
                    		
                      		<li><a href="/2014/04/27/logo-cboustead.html">Logo Entry No. 7 - Calum Boustead</a></li>
                    		
                      		<li><a href="/2014/04/23/logo-abartos.html">Logo Entry No. 6 - Alec Bartos</a></li>
                    		
                      		<li><a href="/2014/04/22/logo-zsayari.html">Logo Entry No. 5 - Ziba Sayari</a></li>
                    		
                      		<li><a href="/2014/04/21/logo-rmarshall.html">Logo Entry No. 4 - Richard Brownlie-Marshall</a></li>
                    		
                      		<li><a href="/2014/04/19/logo-ssuleman.html">Logo Entry No. 3- Shaan Shiv Suleman</a></li>
                    		
                      		<li><a href="/2014/04/17/logo-squinones.html">Logo Entry No. 2 - Samuel Quiñones</a></li>
                    		
                      		<li><a href="/2014/04/17/logo-pforrest.html">Logo Entry No. 1 - Patricia Forrest</a></li>
                    		
                      		<li><a href="/2014/04/10/storm-logo-contest.html">Apache Storm Logo Contest</a></li>
                    		
                      		<li><a href="/2013/12/08/storm090-released.html">Apache Storm 0.9.0 Released</a></li>
                    		
                      		<li><a href="/2013/01/11/storm082-released.html">Apache Storm 0.8.2 released</a></li>
                    		
                      		<li><a href="/2012/09/06/storm081-released.html">Apache Storm 0.8.1 released</a></li>
                    		
                      		<li><a href="/2012/08/02/storm080-released.html">Apache Storm 0.8.0 and Trident released</a></li>
                    		
                        </ul>
                    </div>
                    <div class="col-md-9" id="news-content">
                            <h1 class="page-title">
                               Apache Storm 0.9.3 released
                            </h1>
                                
                            <div class="row" style="margin: -15px;">
                                <div class="col-md-12">
                                    <p class="text-muted credit pull-left">Posted on Nov 25, 2014 by P. Taylor Goetz</p>
                                    <div class="pull-right">
                                        <a 
                                                href="https://twitter.com/share" 
                                                class="twitter-share-button"
                                                data-count=none
                                        >Tweet</a>
                                        <script> !function(d,s,id){
                                                var js,
                                                fjs=d.getElementsByTagName(s)[0],
                                                p=/^http:/.test(d.location)?'http':'https';
                                                if(!d.getElementById(id)){
                                                    js=d.createElement(s);
                                                    js.id=id;
                                                    js.src=p+'://platform.twitter.com/widgets.js';
                                                    fjs.parentNode.insertBefore(js,fjs);
                                                }
                                            }(document, 'script', 'twitter-wjs');
                                        </script>
                                    </div>
                                </div>
                            </div>
                        <div>
                	        <p>We are pleased to announce that Apache Storm 0.9.3 has been released and is available from <a href="/downloads.html">the downloads page</a>. This release includes 100 new fixes and improvements from 62 individual contributors.</p>

<h2 id="improved-kafka-integration">Improved Kafka Integration</h2>

<p>Apache Storm has supported <a href="http://kafka.apache.org/">Apache Kafka</a> as a streaming data source since version 0.9.2-incubating. Version 0.9.3 brings a number of improvements to the Kafka integration including the ability to write data to one or more Kafka clusters and topics.</p>

<p>The ability to both read from and write to Kafka further unlocks potential of the already powerful combination of Apache Storm and Kafka. Apache Storm users can now use Kafka as a source of and destination for streaming data. This allows for inter-topology communication, topology chaining, combining spout/bolt-based topologies with Trident-based data flows, and integration with any external system that supports data ingest from Kafka.</p>

<p>More information about Apache Storm&#39;s Kafka integration can be found in the <a href="https://github.com/apache/storm/blob/v0.9.3/external/storm-kafka/README.md">storm-kafka project documentation</a>.</p>

<h2 id="hdfs-integration">HDFS Integration</h2>

<p>Many stream processing use cases involve storing data in HDFS for further analysis and offline (batch) processing. Apache Storm’s HDFS integration consists of several bolt and Trident state implementations that allow topology developers to easily write data to HDFS from any Storm topology. </p>

<p>More information about Apache Storm&#39;s HDFS integration can be found in the <a href="https://github.com/apache/storm/tree/v0.9.3/external/storm-hdfs">storm-hdfs project documentation</a>.</p>

<h2 id="hbase-integration">HBase Integration</h2>

<p>Apache Storm’s HBase integration includes a number of components that allow Apache Storm topologies to both write to and query HBase in real-time. Many organizations use Apache HBase as part of their big data strategy for batch, interactive, and real-time workflows. Apache Storm HBase integration allows users to leverage data assets in HBase as streaming queries, as well as using HBase as a destination for streaming computation results.</p>

<p>More information about Apache Storm&#39;s HBase integration can be found in the <a href="https://github.com/apache/storm/tree/v0.9.3/external/storm-hbase">storm-hbase project documentation</a>.</p>

<h2 id="reduced-dependency-conflicts">Reduced Dependency Conflicts</h2>

<p>In previous Apache Storm releases, it was not uncommon for users&#39; topology dependencies to conflict with the libraries used by Apache Storm. In Apache Storm 0.9.3 several dependency packages that were common sources of conflicts have been package-relocated (shaded) to avoid this situation. Developers are free to use the Storm-packaged versions, or supply their own version. </p>

<p>The following table lists the dependency package relocations:</p>

<table><thead>
<tr>
<th style="text-align: left">Dependency</th>
<th style="text-align: left">Original Package</th>
<th style="text-align: left">Apache Storm Package</th>
</tr>
</thead><tbody>
<tr>
<td style="text-align: left">Apache Thrift</td>
<td style="text-align: left"><code>org.apache.thrift</code></td>
<td style="text-align: left"><code>org.apache.thrift7</code></td>
</tr>
<tr>
<td style="text-align: left">Netty</td>
<td style="text-align: left"><code>org.jboss.netty</code></td>
<td style="text-align: left"><code>org.apache.storm.netty</code></td>
</tr>
<tr>
<td style="text-align: left">Google Guava</td>
<td style="text-align: left"><code>com.google.common</code></td>
<td style="text-align: left"><code>org.apache.storm.guava</code></td>
</tr>
<tr>
<td style="text-align: left"></td>
<td style="text-align: left"><code>com.google.thirdparty</code></td>
<td style="text-align: left"><code>org.apache.storm.guava.thirdparty</code></td>
</tr>
<tr>
<td style="text-align: left">Apache HTTPClient</td>
<td style="text-align: left"><code>org.apache.http</code></td>
<td style="text-align: left"><code>org.apache.storm.http</code></td>
</tr>
<tr>
<td style="text-align: left">Apache ZooKeeper</td>
<td style="text-align: left"><code>org.apache.zookeeper</code></td>
<td style="text-align: left"><code>org.apache.storm.zookeeper</code></td>
</tr>
<tr>
<td style="text-align: left">Apache Curator</td>
<td style="text-align: left"><code>org.apache.curator</code></td>
<td style="text-align: left"><code>org.apache.storm.curator</code></td>
</tr>
</tbody></table>

<h2 id="multi-lang-improvements">Multi-Lang Improvements</h2>

<p>Apache Storm 0.9.3 includes a new <a href="http://nodejs.org">Node.js</a> multi-lang implementation that allows developers to write spouts and bolts in JavaScript.</p>

<p>In addition to the Node.js implementation, the multi-lang protocol has been substantially improved in terms of robustness and error handling capabilities. As a result, <strong>the multi-lang API has changed in a non-backward-compatible way</strong>. Users with existing multi-lang topologies should consult the Python, Ruby, and JavaScript multi-lang examples to determine the impact prior to upgrading.</p>

<h2 id="thanks">Thanks</h2>

<p>Special thanks are due to all those who have contributed to Apache Storm -- whether through direct code contributions, documentation, bug reports, or helping other users on the mailing lists. Your efforts are much appreciated.</p>

<h2 id="full-changelog">Full Changelog</h2>

<ul>
<li>STORM-558: change &quot;swap!&quot; to &quot;reset!&quot; to fix assignment-versions in supervisor</li>
<li>STORM-555: Storm json response should set charset to UTF-8</li>
<li>STORM-513: check heartbeat from multilang subprocess</li>
<li>STORM-549: &quot;topology.enable.message.timeouts&quot; does nothing</li>
<li>STORM-546: Local hostname configuration ignored by executor</li>
<li>STORM-492: Test timeout should be configurable</li>
<li>STORM-540: Change default time format in logs to ISO8601 in order to include timezone</li>
<li>STORM-511: Storm-Kafka spout keeps sending fetch requests with invalid offset</li>
<li>STORM-538: Guava com.google.thirdparty.publicsuffix is not shaded</li>
<li>STORM-497: don&#39;t modify the netty server taskToQueueId mapping while the someone could be reading it.</li>
<li>STORM-537: A worker reconnects infinitely to another dead worker (Sergey Tryuber)</li>
<li>STORM-519: add tuple as an input param to HBaseValueMapper </li>
<li>STORM-488: Exit with 254 error code if storm CLI is run with unknown command</li>
<li>STORM-506: Do not count bolt acks &amp; fails in total stats</li>
<li>STORM-490: fix build under Windows</li>
<li>STORM-439: Replace purl.js qith jquery URL plugin</li>
<li>STORM-499: Document and clean up shaded dependncy resolution with maven</li>
<li>STORM-210: Add storm-hbase module</li>
<li>STORM-507: Topology visualization should not block ui</li>
<li>STORM-504: Class used by <code>repl</code> command is deprecated.</li>
<li>STORM-330: Implement storm exponential backoff stategy for netty client and curator</li>
<li>STORM-461: exit-process! does not always exit the process, but throws an exception</li>
<li>STORM-341: fix assignment sorting</li>
<li>STORM-476: external/storm-kafka: avoid NPE on null message payloads</li>
<li>STORM-424: fix error message related to kafka offsets</li>
<li>STORM-454: correct documentation in STORM-UI-REST-API.md</li>
<li>STORM-474: Reformat UI HTML code</li>
<li>STORM-447: shade/relocate packages of dependencies that are common causes of dependency conflicts</li>
<li>STORM-279: cluster.xml doesn&#39;t take in STORM_LOG_DIR values.</li>
<li>STORM-380: Kafka spout: throw RuntimeException if a leader cannot be found for a partition</li>
<li>STORM-435: Improve storm-kafka documentation</li>
<li>STORM-405: Add kafka trident state so messages can be sent to kafka topic</li>
<li>STORM-211: Add module for HDFS integration</li>
<li>STORM-337: Expose managed spout ids publicly</li>
<li>STORM-320: Support STORM_CONF_DIR environment variable to support</li>
<li>STORM-360: Add node details for Error Topology and Component pages</li>
<li>STORM-54: Per-Topology Classpath and Environment for Workers</li>
<li>STORM-355: excluding outdated netty transitively included via curator</li>
<li>STORM-183: Replacing RunTime.halt() with RunTime.exit()</li>
<li>STORM-213: Decouple In-Process ZooKeeper from LocalCluster.</li>
<li>STORM-365: Add support for Python 3 to storm command.</li>
<li>STORM-332: Enable Kryo serialization in storm-kafka</li>
<li>STORM-370: Add check for empty table before sorting dom in UI</li>
<li>STORM-359: add logviewer paging and download</li>
<li>STORM-372: Typo in storm_env.ini</li>
<li>STORM-266: Adding shell process pid and name in the log message</li>
<li>STORM-367: Storm UI REST api documentation.</li>
<li>STORM-200: Proposal for Multilang&#39;s Metrics feature</li>
<li>STORM-351: multilang python process fall into endless loop</li>
<li>STORM-375: Smarter downloading of assignments by supervisors and workers</li>
<li>STORM-328: More restrictive Config checks, strict range check within Utils.getInt()</li>
<li>STORM-381: Replace broken jquery.tablesorter.min.js to latest</li>
<li>STORM-312: add storm monitor tools to monitor throughtput interactively</li>
<li>STORM-354: Testing: allow users to pass TEST-TIMEOUT-MS as param for complete-topology</li>
<li>STORM-254: one Spout/Bolt can register metric twice with same name in different timeBucket</li>
<li>STORM-403: heartbeats-to-nimbus in supervisor-test failed due to uninten...</li>
<li>STORM-402: FileNotFoundException when using storm with apache tika</li>
<li>STORM-364: The exception time display as default timezone.</li>
<li>STORM-420: Missing quotes in storm-starter python code</li>
<li>STORM-399: Kafka Spout defaulting to latest offset when current offset is older then 100k</li>
<li>STORM-421: Memoize local hostname lookup in executor</li>
<li>STORM-414: support logging level to multilang protocol spout and bolt</li>
<li>STORM-321: Added a tool to see the current status of STORM JIRA and github pulls.</li>
<li>STORM-415: validate-launched-once in supervisor-test can not handle multiple topologies</li>
<li>STORM-155: Storm rebalancing code causes multiple topologies assigned to a single port</li>
<li>STORM-419: Updated test so sort ordering is very explicit.</li>
<li>STORM-406: Fix for reconnect logic in netty client.</li>
<li>STORM-366: Add color span to most recent error and fix ui templates.</li>
<li>STORM-369: topology summary page displays wrong order.</li>
<li>STORM-239: Allow supervisor to operate in paths with spaces in them</li>
<li>STORM-87: fail fast on ShellBolt exception</li>
<li>STORM-417: Storm UI lost table sort style when tablesorter was updated</li>
<li>STORM-396: Replace NullPointerException with IllegalArgumentExeption</li>
<li>STORM-451: Latest storm does not build due to a pom.xml error in storm-hdfs pom.xml</li>
<li>STORM-453: migrated to curator 2.5.0</li>
<li>STORM-458: sample spout uses incorrect name when connecting bolt</li>
<li>STORM-455: Report error-level messages from ShellBolt children</li>
<li>STORM-443: multilang log&#39;s loglevel protocol can cause hang</li>
<li>STORM-449: Updated ShellBolt to not exit when shutting down.</li>
<li>STORM-464: Simulated time advanced after test cluster exits causes intermittent test failures</li>
<li>STORM-463: added static version of metrics helpers for Config</li>
<li>STORM-376: Add compression to serialization</li>
<li>STORM-437: Enforce utf-8 when multilang reads from stdin</li>
<li>STORM-361: Add JSON-P support to Storm UI API</li>
<li>STORM-373: Provide Additional String substitutions for *.worker.childopts</li>
<li>STORM-274: Add support for command remoteconfvalue in storm.cmd</li>
<li>STORM-132: sort supervisor by free slot in desending order</li>
<li>STORM-472: Improve error message for non-completeable testing spouts</li>
<li>STORM-401: handle InterruptedIOException properly.</li>
<li>STORM-461: exit-process! does not always exit the process, but throws an exception instead</li>
<li>STORM-475: Storm UI pages do not use UTF-8</li>
<li>STORM-336: Logback version should be upgraded</li>
<li>STORM-386: nodejs multilang protocol implementation and examples</li>
<li>STORM-500: Add Spinner when UI is loading stats from nimbus</li>
<li>STORM-501: Missing StormSubmitter API</li>
<li>STORM-493: Workers inherit storm.conf.file/storm.options properties of their supervisor</li>
<li>STORM-498: make ZK connection timeout configurable in Kafka spout</li>
<li>STORM-428: extracted ITuple interface</li>
<li>STORM-508: Update DEVELOPER.md now that Storm has graduated from Incubator</li>
<li>STORM-514: Update storm-starter README now that Storm has graduated from Incubator</li>
</ul>

                	    </div>
                    </div>
                </div>
            </div>
        </div>
    </div>
    <footer>
    <div class="container-fluid">
        <div class="row">
            <div class="col-md-3">
                <div class="footer-widget">
                    <h5>Meetups</h5>
                    <ul class="latest-news">
                        
                        <li><a href="http://www.meetup.com/Apache-Storm-Apache-Kafka/">Apache Storm & Apache Kafka</a> <span class="small">(Sunnyvale, CA)</span></li>
                        
                        <li><a href="http://www.meetup.com/Apache-Storm-Kafka-Users/">Apache Storm & Kafka Users</a> <span class="small">(Seattle, WA)</span></li>
                        
                        <li><a href="http://www.meetup.com/New-York-City-Storm-User-Group/">NYC Storm User Group</a> <span class="small">(New York, NY)</span></li>
                        
                        <li><a href="http://www.meetup.com/Bay-Area-Stream-Processing">Bay Area Stream Processing</a> <span class="small">(Emeryville, CA)</span></li>
                        
                        <li><a href="http://www.meetup.com/Boston-Storm-Users/">Boston Realtime Data</a> <span class="small">(Boston, MA)</span></li>
                        
                        <li><a href="http://www.meetup.com/storm-london">London Storm User Group</a> <span class="small">(London, UK)</span></li>
                        
                        <!-- <li><a href="http://www.meetup.com/Apache-Storm-Kafka-Users/">Seatle, WA</a> <span class="small">(27 Jun 2015)</span></li> -->
                    </ul>
                </div>
            </div>
            <div class="col-md-3">
                <div class="footer-widget">
                    <h5>About Apache Storm</h5>
                    <p>Apache Storm integrates with any queueing system and any database system. Apache Storm's spout abstraction makes it easy to integrate a new queuing system. Likewise, integrating Apache Storm with database systems is easy.</p>
               </div>
            </div>
            <div class="col-md-3">
                <div class="footer-widget">
                    <h5>First Look</h5>
                    <ul class="footer-list">
                        <li><a href="/releases/current/Rationale.html">Rationale</a></li>
                        <li><a href="/releases/current/Tutorial.html">Tutorial</a></li>
                        <li><a href="/releases/current/Setting-up-development-environment.html">Setting up development environment</a></li>
                        <li><a href="/releases/current/Creating-a-new-Storm-project.html">Creating a new Apache Storm project</a></li>
                    </ul>
                </div>
            </div>
            <div class="col-md-3">
                <div class="footer-widget">
                    <h5>Documentation</h5>
                    <ul class="footer-list">
                        <li><a href="/releases/current/index.html">Index</a></li>
                        <li><a href="/releases/current/javadocs/index.html">Javadoc</a></li>
                        <li><a href="/releases/current/FAQ.html">FAQ</a></li>
                    </ul>
                </div>
            </div>
        </div>
        <hr/>
        <div class="row">   
            <div class="col-md-12">
                <p align="center">Copyright © 2019 <a href="http://www.apache.org">Apache Software Foundation</a>. All Rights Reserved. 
                    <br>Apache Storm, Apache, the Apache feather logo, and the Apache Storm project logos are trademarks of The Apache Software Foundation. 
                    <br>All other marks mentioned may be trademarks or registered trademarks of their respective owners.</p>
            </div>
        </div>
    </div>
</footer>
<!--Footer End-->
<!-- Scroll to top -->
<span class="totop"><a href="#"><i class="fa fa-angle-up"></i></a></span> 

    </body>

</html>

