<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Jingnu An on Medium]]></title>
        <description><![CDATA[Stories by Jingnu An on Medium]]></description>
        <link>https://medium.com/@ajingnv?source=rss-d14a0c130039------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*53po4Z0jcWJL2EtGEUQf3w.jpeg</url>
            <title>Stories by Jingnu An on Medium</title>
            <link>https://medium.com/@ajingnv?source=rss-d14a0c130039------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 08:16:51 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ajingnv/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Java Stream APIs Tutorial: How To Use .collect and .sorted With Examples]]></title>
            <link>https://medium.com/@ajingnv/java-stream-apis-tutorial-how-to-use-collect-and-sorted-with-examples-6ec76d55faef?source=rss-d14a0c130039------2</link>
            <guid isPermaLink="false">https://medium.com/p/6ec76d55faef</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[tutorial]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Jingnu An]]></dc:creator>
            <pubDate>Mon, 07 Aug 2023 23:52:23 GMT</pubDate>
            <atom:updated>2023-08-08T02:20:33.515Z</atom:updated>
            <content:encoded><![CDATA[<h3>Java Stream APIs Tutorial: How To Use .collect and .sorted With Example</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NPxfJ58HmbhoYyW_s9AMxA.jpeg" /></figure><p>Stream operations enable Java developers to perform tasks with ease and elegance. In this article, I use two examples to introduce two Stream APIs, .collect() and .sorted() .</p><h3>Turn A List Into A Map Using .collect</h3><p>We have a list of Customer, and each Customer has a field named customerId. The goal is to create a map that uses the customerId as key, and the Customer object reference as value.</p><pre>class Customer {<br>  private String customerId;<br>  public Customer(String id){ this.customerId = id; }<br>  public String getCustomerId(){ return this.customerId; }<br>}<br><br>class Example {<br>  public static void main(String[] args){<br>    List&lt;Customer&gt; customers = new ArrayList&lt;&gt;();<br>    customers.add(new Customer(&quot;001&quot;))<br>    customers.add(new Customer(&quot;002&quot;));<br><br>    /*<br>      create a map that uses the customerId as key, <br>      and the Customer object reference as value. Insert your code below:<br>    */<br><br>  }<br>}</pre><p>I used to write:</p><pre>Map&lt;String, Customer&gt; map = new HashMap&lt;&gt;();<br>for(Customer c :  customers){<br>  map.putIfAbsent(c.getCustomerId(), c);<br>}</pre><p>But since I learned how to use stream, I can also write:</p><pre>Map&lt;String, Customer&gt; map = customers.stream().collect(Collectors.toMap(Customer::getCustomerId, customer -&gt; customer));</pre><p>Let’s break down the above one-liner step by step:</p><ul><li>customers.stream(): The stream() method is called on the customers list, which converts it into a stream. A stream is a sequence of elements that can be processed sequentially or in parallel using stream operations.</li><li>.collect(Collectors.toMap(Customer::getCustomerId, customer -&gt; customer)): .collect is a terminal operation in the Java 8 Stream API. In this example, the stream elements are collected into a map using the toMap collector.</li><li>Customer::getCustomerId: This is a method reference that refers to the getCustomerId() method of the Customer class. It is used as the <strong>key mapper</strong> for the toMap collector, meaning it extracts the customerId from each Customer object to use as the key in the resulting map.</li><li>customer -&gt; customer: This lambda expression represents the <strong>value mapper</strong> for the toMap collector. It specifies that the original Customer object should be used as the value in the resulting map.</li></ul><p>🤔 This is a good point to stop and ponder. Can you answer the following two questions?</p><p>1. Can you write out all entries in the map from the above code example?</p><p>2. You have a list of Recipe and each Recipe has a field recipeName, can you use .collect to create a map with recipeName as the key and the Recipe object reference as its value?</p><h3>Sort A List of Object Using .sorted</h3><p>There is a list of Players and each Player has a field named score. The field score is a double. The goal is to sort the list based on each Player’s score in ascending order.</p><pre>class Player {<br>  private String id;<br>  private double score;<br>  public Player(String id, double score){ ... }<br>  public double getScore(){return this.score; }<br>}<br><br>class Example2 {<br>  public static void main(String[] args){<br>    List&lt;Player&gt; players = new ArrayList&lt;&gt;();<br>    players.add(new Player(&quot;001&quot;, 89.3));<br>    players.add(new Player(&quot;002&quot;, 79.8));<br>  <br>    /*<br>      sort the player list based on each Player&#39;s score in ascending order.<br>      Insert your code below:<br>    */<br>  }<br>}</pre><p>I used to use List.sort like below:</p><pre>players.sort(Comparator.comparingDouble(Player::getScore));</pre><p>but since I learned how to use stream, I can also write:</p><pre>players.stream()<br>   .sorted(Comparator.comparingDouble(Player::getScore))<br>   .toList();</pre><p>Let’s break it down step by step:</p><ul><li>.stream(): The stream() method is called on the players collection, which converts it into a stream. A stream is a sequence of elements that can be processed sequentially or in parallel using stream operations.</li><li>.sorted(Comparator.comparingDouble(Player::getScore)): The sorted method is called on the stream to sort the elements based on the Player object&#39;s score field. This method requires a Comparator to define the sorting order.</li><li>Comparator.comparingDouble(Player::getScore): This creates a comparator using the comparingDouble method of the Comparator class. The comparingDouble method takes a function as an argument, and in this case, we use a method reference Player::getScore. It means we&#39;re comparing the Player objects based on their score field, which should be of type double.</li><li>.toList(): This <strong>terminal operation</strong> collects the elements of the sorted stream into a list.</li></ul><p>After performing all the stream operations, the final result is a new list containing the elements of the players collection, sorted in ascending order based on the score field of each Player object.</p><p>Thank you for reading! If you enjoyed reading this tutorial please consider share it or give it a 👏 clap (or long press for up to 50 claps! A cool hidden trick in my opinion 😁).</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6ec76d55faef" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Tip To Start Using Java HashMap Like A Pro]]></title>
            <link>https://medium.com/@ajingnv/a-tip-to-start-using-java-hashmap-like-a-pro-5500cae720fa?source=rss-d14a0c130039------2</link>
            <guid isPermaLink="false">https://medium.com/p/5500cae720fa</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[hashmap]]></category>
            <category><![CDATA[programming-tips]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Jingnu An]]></dc:creator>
            <pubDate>Thu, 03 Aug 2023 23:40:08 GMT</pubDate>
            <atom:updated>2023-08-03T23:40:08.476Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Pm5dhEp3mfcEQ6SGi8qIog.jpeg" /></figure><p>Take a look at the following hash map. We are going to use it as an example to unlock the pro tip.</p><pre># the example hash map looks like<br>+----------+------------------------------------+<br>|   Key    |               Value                |<br>+----------+------------------------------------+<br>| &quot;usa&quot;    | [&quot;new york&quot;, &quot;boston&quot;]             |<br>| &quot;canada&quot; | [&quot;vancouver&quot;, &quot;québec&quot;, &quot;toronto&quot;] |<br>| ...      |  ...                               |<br>+----------+------------------------------------+</pre><p>The map instance is instantiated by Map&lt;String, List&lt;String&gt;&gt; map = new HashMap&lt;&gt;();. When I want to insert a new value, (“usa”, “los angeles”), into the map, I used to write:</p><pre>String country = &quot;usa&quot;;<br>String city = &quot;los angeles&quot;;<br><br>// if this country is a key we&#39;ve seen before<br>if(map.containsKey(country)){<br>  List&lt;String&gt; cities = map.get(country); // get the list of cities associated with this country<br>  cities.add(city);<br>  map.put(country, cities);<br>} else { // if this is a new country<br>  List&lt;String&gt; cities = new ArrayList&lt;&gt;(); // initialized a new array list for this new country<br>  cities.add(city);<br>  map.put(country, cities);<br>}</pre><p>We can make the above code more concise:</p><pre>// when we encounter a new 🔑 key, create one entry in the map<br>if(!map.containsKey(country)){<br>  map.put(country, new ArrayList&lt;&gt;());<br>} <br>// the if statement above made sure map.get(country) will not return null<br>map.get(country).add(city);</pre><p>We can use the getOrDefault() method to achieve the same goal, but with less code:</p><pre>map.put(country, map.getOrDefault(country, new ArrayList&lt;&gt;());<br>map.get(country).add(city);</pre><h3><strong>The Tip 💡</strong></h3><p>Pause and think. Can we make the above code even shorter? A one-liner? Yes. We can leverage a very helpful method .computeIfAbsent() :</p><pre>map.computeIfAbsent(country, k -&gt; new ArrayList&lt;&gt;()).add(city);</pre><p>When working with a map , knowing whether a key is already present in the map can be very helpful, because often in time, we just want to update the value of the key if the key is already in the map (instead of assigning a new value).</p><p>Let’s take a look at the method signature of computeIfAbsent() :</p><pre>V computeIfAbsent(K key, mappingFunction&lt;? super K, ? extends V&gt; </pre><p>It takes two arguments, a key and a mapping function. It computes a new value for the specified key if the key is not already present in the map. The new value is calculated using the provided mappingFunction, which takes the key as an input and returns a new value.</p><p>If the key already exists, the method does nothing and returns the existing value associated with the key. If the key is missing, the new key-value pair is inserted into the map, and the method returns the computed value.</p><p>In our code example map.computeIfAbsent(country, country -&gt; new ArrayList&lt;&gt;()).add(city); , we pass country as the key and a lambda function as the mappingFunction. This line of code returns an empty array list if country is a new key, or it returns a list of strings if country has already been seen before.</p><p>Another similar but also concise method of map is putIfAbsent() :</p><pre>V putIfAbsent(K key, V value);</pre><p>The putIfAbsent method also inserts the specified key-value pair into the map if the key is not already present. The only differences are</p><ul><li>The value is not computed using the key</li><li>If the key is not present, the new key-value pair is inserted, and the method returns null.</li></ul><p>So we can’t really do the following:</p><pre>map.putIfAbsent(country, new ArrayList&lt;&gt;()).add(city);</pre><p>If the country already exists, the method does nothing and returns the existing value associated with the key, but if country is a new string to the map, putIfAbsent()returns null, resulting a NullPointerException .</p><h3>Summary</h3><p>Two helpful methods that can make our code more concise when working with Map, they are,</p><p><strong>computeIfAbsent(key, mappingFunction)</strong></p><ul><li>It takes two arguments, a key and a mapping function. The mapping function is used to compute a value based on the key. If the key already exists, computeIfAbsent does nothing and returns the existing value associated with the key. If the key is not present, the new key-value pair is inserted into the map with the computed value, <strong>and the method returns the computed value.</strong></li><li>Example:</li></ul><pre>Map&lt;Integer, Integer&gt; map = new HashMap&lt;&gt;();<br>map.computeIfAbsent(3, k -&gt; k * 5);<br><br>// map becomes:<br>+----------+------------------------------------+<br>|   Key    |               Value                |<br>+----------+------------------------------------+<br>|   3      |               15                   |<br>+----------+------------------------------------+</pre><p><strong>putIfAbsent(key, value)</strong></p><ul><li>The putIfAbsent method takes two arguments, a key and a value. If the key already exists, the method does nothing and returns the existing value associated with the key. If the key is not present, the new key-value pair is inserted, and the method returns null.</li><li>Example:</li></ul><pre>Map&lt;Integer, Integer&gt; map = new HashMap&lt;&gt;();<br>map.putIfAbsent(3, 15);<br><br>// map becomes:<br>+----------+------------------------------------+<br>|   Key    |               Value                |<br>+----------+------------------------------------+<br>|   3      |               15                   |<br>+----------+------------------------------------+</pre><p>I hope you enjoyed this tip! Happy coding!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5500cae720fa" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[System Design — A Server Health Monitoring System]]></title>
            <link>https://medium.com/@ajingnv/system-design-a-server-health-monitoring-system-9bdd0066bb9c?source=rss-d14a0c130039------2</link>
            <guid isPermaLink="false">https://medium.com/p/9bdd0066bb9c</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[system-design-interview]]></category>
            <category><![CDATA[software-architecture]]></category>
            <dc:creator><![CDATA[Jingnu An]]></dc:creator>
            <pubDate>Fri, 28 Jul 2023 06:40:30 GMT</pubDate>
            <atom:updated>2023-07-28T06:40:30.645Z</atom:updated>
            <content:encoded><![CDATA[<h3>System Design — A Server Health Monitoring System</h3><p>I recently had a system design interview with a senior engineer. The design question asked during the interview was,</p><blockquote>Suppose we have a cluster of database servers running and we are interested in monitoring their health. We only want to use <strong>CPU fan speed</strong> and <strong>CPU temperature</strong> to measure the server health. Design a system that can help us achieve this goal.</blockquote><p>At the time of the interview, I didn’t realize that was a classic <strong>metrics monitoring </strong>system. Now, without the pressure of the interview process, I want to share some thoughts about this system design question.</p><h3>The data type</h3><p>Metrics monitoring data is often represented as a <strong>time series.</strong> In our case, time series means it captures the values of CPU fan speed and temperature at different points in time. Using time series has several advantages. For example, we can do trend analysis, anomaly detection etc.</p><p>A typical metric might look like:</p><p>timestamp=1678902345, host=us_west_prod_1024, metric_name=cpu_temp metric_value=50</p><h3>Follow the data flow</h3><p>Next, let’s build a high level design following the <strong>data flow</strong>. Specifically, we’re going to answer two questions: 1. where does the data come from, and 2. who is interested in seeing this type of data. Once we figured out the two questions, we can use system design building blocks to help bridge the data source to the interested party.</p><p>Each database server (db server) is a data origin. Each server has a CPU and can record it’s fan speed and temperature. Engineers who maintain the database are the data’s targeted audiences.</p><p>The data flow now is obvious — from servers to engineers. However, if we stop at this simple data flow, it means the engineers would have to go and check every db server’s metrics in person. This is undoubtedly tedious and inefficient.</p><p>Let’s introduce a <strong>Metrics Collecting Service (MCS)</strong>, that sits in between db servers and engineers. The role of MCS is to connect with every db server and collect each db server’s CPU fan speed and temperature. Once all the data is collected, it sends to a time series database (TSDB). Popular time series database includes Amazon Timestream, InfluxDB, Prometheus etc.</p><p>Constantly monitoring a long list of metric logs and manually detecting anomalies is not the most efficient approach for engineers. Instead, engineers are more interested in observing the trend of server health, ideally presented in visual graphs. Moreover, they would greatly benefit from receiving timely alerts when specific metric thresholds are exceeded.</p><p>In order to achieve this, let’s introduce an <strong>Alert Service (AS) </strong>and a <strong>Graph Service (GS) </strong>to help us organize the data a bit before passing to engineers. Both Alert Service and Graph Service are responsible of querying the time series database, then process the retrieved data, and finally send to the engineers through email, pager, or http endpoints.</p><p>Great. We have followed the data flow and constructed a high level db health monitoring system. Below is a diagram illustrating the high level design.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xCS5NCnALslHSA4gIY_MTw.png" /><figcaption>Hight level design illustration-1. Made on excalidraw.com</figcaption></figure><h3>Zoom in and refine</h3><p>The design discussed above provides a high-level abstraction of the system. Now, let’s delve deeper into specific areas and explore the technical options available to us, along with the associated trade-offs we need to consider.</p><h4>Pull vs Push</h4><p>It’s important to have a discussion on how the data would be collected. Generally, there are two strategies, <strong>pull </strong>or<strong> push</strong>.</p><p><strong>In a pull mechanism</strong>, our Metrics Collecting Service actively sends <strong>HTTP requests</strong> to each db server to retrieve the CPU fan speed and temperature data. We can configure the Metrics Collecting Service to request these metrics at regular intervals, such as every 3 seconds. This option provides us with a great deal of <strong>control</strong> and <strong>flexibility</strong> over the data collection process. We can conduct db server health checks, and also identify any server that fails to fulfill the pull request.</p><p><strong>A push mechanism</strong> involves the db servers autonomously sending the CPU metrics to the Metrics Collecting Service. The servers can be configured to push metrics at regular intervals or when specific thresholds are crossed. This approach reduces the work load on the Metrics Collecting Service as it doesn’t need to proactively request data from each server. However, our Metrics Collecting Service now has less control over exactly when it receives the metrics data. Health check on each db server becomes difficult as well.</p><p>For our design case, I’d choose the pull mechanism for metrics collecting.</p><h4>Batch Processing</h4><p>Batch processing allows for efficient data collection. Instead of constantly transmitting individual metric points, metrics can be accumulated over a certain period or until a specific batch size is reached. This approach <strong>reduces the overhead</strong> associated with each individual data collection operation, resulting in improved overall system performance.</p><p>Batch processing also offers the opportunity for <strong>optimized data writing</strong> to the time series database. Instead of writing metric one by one, the collected batch of metrics can be written together as a single unit. This significantly reduces the number of database write operations, enhancing the overall efficiency of data storage.</p><p>Therefore, I would propose configuring the Metrics Collecting Service (MCS) to send data to the Time Series Database (TSDB) in batches, improving efficiency and reducing overhead.</p><h4>Add a data buffer</h4><p>We can add a <strong>message queue</strong> in between the MCS and the TSDB to create a buffer for the large volume of data influx into the TSDB. We can choose Amazon’s Simple Queue Service (SQS) to fulfill this duty. The message queue receives MCS’s batched data and queuing them up, then a streaming data processing service, such as Amazon Kinesis, consumes data from the queue in a <strong>First-In-First-Out</strong> (FIFO) fashion.</p><p>The addition of a message queue and a streaming data processing service offers several benefits. It provides <strong>decoupling</strong> between the MCS and the TSDB, allowing high scalability and fault tolerance. The queue acts as a buffer, absorbing temporary spikes in data volume and allowing the TSDB to process the data at its own pace. It also enables asynchronous communication and a <strong>retry</strong> option between the MCS and the TSDB, minimizing the impact of potential latency or performance fluctuations.</p><h4>Data replication</h4><p>Data replication allows our system to be <strong>highly available</strong>. A common approach for data replication is the leader-follower paradigm, in which all the write requests are directed to the leader node, then streamed to all follower nodes for replication and storage.</p><p>To expand a little bit on <strong>data synchronization </strong>between the leader and replicas, it is not recommended to make all replication processes synchronous. The reason is simple: if all followers need to be updated simultaneously with the leader, any failure or crash in one of the followers would require the leader to hold all write requests and wait for the failed follower to recover. This clearly presents a <strong>single point of failure</strong> issue. If you insist on using a synchronous replication model, it would be more feasible to designate only one follower to perform synchronous replication with the leader, while the remaining followers operate asynchronously. In real industrial level practice, the most commonly used model is to have all followers perform asynchronous replication.</p><p>Now let’s take a look at our more refined design.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RY1jt3akoLUvlCS4i7t-8g.png" /><figcaption>High level design illustration-2. Made on excalidraw.com</figcaption></figure><p>Even the refined design is far from perfect and there are certainly more aspects to zoom in and refine, but for now, I will conclude the discussion here and save the remaining topics for future conversations.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9bdd0066bb9c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Node — You hear it. You see it. But do you know which node is it?]]></title>
            <link>https://medium.com/@ajingnv/node-you-hear-it-you-see-it-but-do-you-know-which-node-is-it-3b76d3a02fdd?source=rss-d14a0c130039------2</link>
            <guid isPermaLink="false">https://medium.com/p/3b76d3a02fdd</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[data-structures]]></category>
            <category><![CDATA[node]]></category>
            <dc:creator><![CDATA[Jingnu An]]></dc:creator>
            <pubDate>Thu, 27 Jul 2023 23:26:27 GMT</pubDate>
            <atom:updated>2023-07-29T05:36:11.733Z</atom:updated>
            <content:encoded><![CDATA[<h3>Node — You hear it. You see it. But do you know which node is it?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SB0oLWnq72qaKv3rKfhyag.jpeg" /></figure><p>As a software engineer I often hear the word “<strong>Node</strong>” being tossed around. For a non-English speaker turned computer science enthusiast like me, the word “Node” is like those catchy songs you can’t get out of your head, but instead of lyrics, it’s just “Node, Node, Node.” And let me tell you, figuring out what this elusive “Node” thing is can feel like trying to navigate a maze blindfolded.</p><p>But fear not, brave souls, you’ve read this far, you’re committed. Today, let’s unveil the mysteries of this tech jargon.</p><h3>Node In Data Structure</h3><p>First of all, Node is often talked about in <strong>data structure</strong>. It’s like a container that serves two purposes: it holds a piece of data while also storing addresses to other Nodes. It really shines when it becomes the building block for a myriad of other frequently used data structures. When we link them sequentially, we get a linear structure — <strong>linked list</strong>. When we place Nodes in a hierarchical fashion, with one Node acting as the “root,” and others branching out as “children”, we get a <strong>tree</strong>. When we just casually connect some Nodes, we can form a <strong>graph</strong>. Node enables efficient manipulation and traversal of the data structures it forms. Operations like insert and delete can be done quickly.</p><h3>Node.js</h3><p>Next, there is Node.js. It is not a language but a <strong>JavaScript runtime environment</strong> that can executes JavaScript code outside a web browser. Software engineers use it to build <strong>server-side</strong> web applications. Node.js is built with the<strong> asynchronous event-driven</strong> model instead of the more common concurrency model. This feature makes Node.js an ideal choice for developing scalable systems. Here is<a href="https://nodejs.org/en/docs/guides/blocking-vs-non-blocking"> a great article</a> to read about the difference between blocking and non-blocking features from Node.js.</p><h3>Node in AWS</h3><p>AWS is short for Amazon Web Services, a leading cloud services provider. In the context of AWS, the term “Node” holds significant importance. Specifically, a group of Amazon Elastic Compute Cloud (EC2) instances collectively forms a cluster, with each <strong>individual instance</strong> within the cluster being referred to as a node. So to put it simple, if you find yourself in a conversation about AWS and somebody mentioned “Node”, they are likely referring to a single EC2 instance.</p><h3>Node in Elasticsearch</h3><p>Elasticsearch is a powerful <strong>search engine</strong>. It is distributed and supports a wide range of data types to be searched (indexed) such as textual, numerical, geospatial. These data can be structured or unstructured. One use case is if you are running an e-commerce website, and you’d like to log some analytic data, then Elasticsearch can be used for your website to help you store log data that can be searched for analytics.</p><p>Next time when you go into a geeky party, rather than resorting to mundane small talk about weather, how about getting everyone involved in a captivating discussion about the nuances of Nodes and their significance in different contexts?</p><p>Leave a comment below if there are other occasions you’ve heard about Node but it’s not referenced here!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3b76d3a02fdd" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>