<?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 Jigar Chavada on Medium]]></title>
        <description><![CDATA[Stories by Jigar Chavada on Medium]]></description>
        <link>https://medium.com/@chavada.jigar.3?source=rss-79828bdeedf9------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*VMbVqdrqLHGFGtz2cIph7g.jpeg</url>
            <title>Stories by Jigar Chavada on Medium</title>
            <link>https://medium.com/@chavada.jigar.3?source=rss-79828bdeedf9------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 11:42:09 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@chavada.jigar.3/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[Create a Prometheus Monitoring Server with a Grafana Dashboard]]></title>
            <link>https://levelup.gitconnected.com/configure-a-prometheus-monitoring-server-with-a-grafana-dashboard-59faa4a42ef6?source=rss-79828bdeedf9------2</link>
            <guid isPermaLink="false">https://medium.com/p/59faa4a42ef6</guid>
            <category><![CDATA[grafana]]></category>
            <category><![CDATA[prometheus]]></category>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[monitoring]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Jigar Chavada]]></dc:creator>
            <pubDate>Tue, 07 Apr 2020 08:37:58 GMT</pubDate>
            <atom:updated>2020-05-05T12:49:15.353Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OGncw98tP9VVXYuoxXpTtw.png" /><figcaption><em>Node Exporter for Prometheus Dashboard by </em><a href="https://grafana.com/orgs/starsliao">starsliao</a></figcaption></figure><p>Prometheus is a tool that is used for Systems and Service Monitoring. The piece of code programmers write is to be run on actual hardware which means we are utilizing a physical resource that costs us money to operate on. So we better utilize this resource in the most efficient manner. This is where systems monitoring comes in picture. Running complex applications on actual servers is complicated and things can go haywire for several reasons. Some potential problems which can occur are:</p><ul><li>Disk Full -&gt; No new data can be stored</li><li>Software Bug -&gt; Request Errors</li><li>High Temperature -&gt; Hardware Failure</li><li>Network Outage -&gt; Services cannot communicate</li><li>Low Memory Utilization -&gt; money wasted</li></ul><p>These problems occur more often than you think, so it is necessary to monitor your systems and services to keep check of their health.</p><p>Monitoring means to get information from your system, to get insights and act on those insights. There are different ways in which you could do the monitoring.</p><ul><li>Check Based Monitoring -&gt; Run scripts periodically to check the health of servers. Very Static. Very Local Context based on individual machines.</li><li>Logs/ Events -&gt; Record full details about each event. It can be structured and unstructured. Further analysis required. (Loki, InfluxDB). Lack of interservice correlation.</li><li>Metrics/ Time Series -&gt; Numeric values, sampled over time. (OpenTSDB, Prometheus), good for aggregate health monitoring. Need logs for detailed analysis though.</li></ul><p>For inter-service correlation, we use Tracing, track single requests through the entire stack. (Jaeger).</p><p>Prometheus is metrics-based monitoring &amp; alerting stack made for dynamic cloud environments. It doesn’t do logging or tracing.</p><h3>Architecture of Prometheus:</h3><p>There are things called targets from which Prometheus server pulls time-series metrics at regular intervals and store it in a local disk.</p><p>These targets can be of two types, one in which you have control over the source code like your web app or your API which is what we will be doing, here you can use a Prometheus client library to execute an endpoint from which Prometheus can gather this data.</p><p>Another target is something that you don’t necessarily have control upon like a Linux VM or a SQL DB instance. In this case, you use something called an exporter which sits on top of this system and sends metrics to Prometheus.</p><p>Prometheus server is then configured to pull or scrape data from these targets and stores these time series metrics on a local disk.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ktoezmb8yB1wTCukb53X0w.png" /><figcaption><a href="https://prometheus.io/docs/introduction/overview/">https://prometheus.io/docs/introduction/overview/</a></figcaption></figure><p>Having given you enough explanation about what and how of Prometheus, let us create our service and monitor it using Prometheus. You can check out the Github Repository which contains all the code.</p><p><a href="https://github.com/Jigar3/Prometheus-Grafana">Jigar3/Prometheus-Grafana</a></p><p>Let’s start by creating our server.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5bb00010785085396974c29c11b3adcd/href">https://medium.com/media/5bb00010785085396974c29c11b3adcd/href</a></iframe><p>So what we are essentially doing in this piece of code is creating two endpoints, which are /api/v1 and /api/v2. Whenever you hit these endpoints, you get either a 200-OK or 404-NOT FOUNDor 403-FORBIDDEN. The function is coded in such a way that the probability of getting a 200-OK is more than 404-NOT FOUND which in turn is more than 403-FORBIDDEN.</p><p>The metrics which we will be monitoring are displayed on the /metrics endpoint, which we have already populated with some metrics by using the promhttp.Handler(). Some of these pre-populated metrics include <em>go_goroutines: Number of goroutines that currently exist, go_memstats_alloc_bytes: Number of bytes allocated and still in use, go_threads: Number of OS threads created </em>and many more.</p><p>There are four metric types which you could use, I am using the Counter type metric. You can check other metrics <a href="https://prometheus.io/docs/concepts/metric_types/">here</a>. Every time series is uniquely identified by its <em>metric name</em> and optional key-value pairs called <em>labels</em>. Here, we have used the <em>metric name </em>myapp_status_codes and are using two labels endpoint and status_code. The endpoint will give us the name of the endpoint which is being hit while the status_code will return status code.</p><pre>statusCodeProcess.With(prometheus.Labels{“endpoint”: r.URL.Path, “status_code”: strconv.Itoa(statusCode)}).Inc()</pre><p>The above line of code Increments the counter and sets the labels with appropriate values.</p><p>Now, we can run the server by executing go run main.go. You can visit <a href="http://localhost:9000/api/v1">http://localhost:9000/api/v1</a> or <a href="http://localhost:9000/api/v1">http://localhost:9000/api/v</a>2 and check the responses. The counter value can be searched in &#39;http://localhost:9000/metrics. You will see something like</p><pre># TYPE myapp_status_codes counter<br>myapp_status_codes{endpoint=&quot;/api/v1&quot;,status_code=&quot;200&quot;} 1</pre><p>Here 1 indicates the number of times endpoint /api/v1 was hit and returned a 200-OK response.</p><p>Now as our target is ready, we need to create a Prometheus server that will scrape our API server. To create a Prometheus server, we need to create a config file.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/70ccd1d0c6cf96f6143df8672049215a/href">https://medium.com/media/70ccd1d0c6cf96f6143df8672049215a/href</a></iframe><p>The format for writing this config file can be found <a href="https://prometheus.io/docs/prometheus/latest/configuration/configuration/">here</a>. We can now run the server by executing</p><pre>prometheus --config.file=./prometheus.yml</pre><p>Now, you can go to <a href="http://localhost:9090.">http://localhost:9090</a>. You will be greeted will the below-shown screen</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZSWJu8ZtBuI9QZw_J9Eblg.png" /></figure><p>You can now enter a PromQL expression and query the metrics. You can find a guide about how to query using PromQL <a href="https://prometheus.io/docs/prometheus/latest/querying/basics/">here</a>. You can do a lot of useful stuff here alone, but we will go ahead and connect Prometheus with Grafana and make beautiful graphs that will give us useful insights about our service as well.</p><p><strong>Grafana</strong> is open-source visualization and analytics software. It allows you to query, visualize, alert on, and explore your metrics no matter where they are stored. In plain English, it provides you with tools to turn your time-series database (TSDB) data into beautiful graphs and visualizations.</p><p>You can install Grafana by following the instructions mentioned <a href="https://grafana.com/docs/grafana/latest/installation/">here</a>. Once installed you can run a Grafana server by executing</p><pre>grafana-server</pre><p>This will start a Grafana server on <a href="http://localhost:3000.">http://localhost:3000.</a> The default username and password both are admin. Before you start creating beautiful graphs, you first need to Import Prometheus as a data source. You can find to option to Add Datasource on the home screen itself. Select <strong>Prometheus</strong> as a data source and it will direct you to a Settings page, where you need to fill in the appropriate details as shown below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/834/1*ACF35iPwvvJP22Mb9u3UIg.png" /></figure><p>Now, click on <strong>Save &amp; Test</strong>. You should be seeing a notification that says <em>Data source is working.</em></p><p>After adding <strong>Prometheus </strong>as a data source, we will make a new dashboard, to do that, press the + icon in the left pane and click on the dashboard. You will be greeted by the below screen.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/904/1*q12iXbVRtvLaH1mkDRc4eg.png" /></figure><p>Click <em>Add Query, </em>you will be taken to the New Dashboard Screen, where we can make those beautiful graphs using PromQL queries as discussed above.</p><p>The query which we will be performing is the rate at which we get requested on a particular endpoint and what response is being returned. The [15s] means that we are getting rate as measured over the last 15 seconds.</p><pre>rate(myapp_status_codes{endpoint=&quot;/api/v1&quot;, status_code=&quot;200&quot;}[15s])</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4f-RUs3XrNhsRPZ5SE0Q7g.png" /></figure><p>Similar to the above rate query for 200 response, we have done the same for 403 and 404 as well.</p><p>You can do the same now for the other endpoint, below shown is a sample for the other endpoint.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TL9BgO7Bd7T28Nutqycg2A.png" /></figure><p>To generate traffic on our custom server, I am using a tool called <a href="https://github.com/tsenart/vegeta">Vegeta</a>. It is a tool used to simulate traffic on a given endpoint. You can install the tool from its Github Repository. To use <em>Vegeta </em>to simulate traffic, write the command.</p><pre>~ $ echo &quot;GET <a href="http://localhost:9000/api/v1">http://localhost:9000/api/v1</a>&quot; | vegeta attack -duration=600s | tee results.bin | vegeta report</pre><pre>~ $ echo &quot;GET <a href="http://localhost:9000/api/v1">http://localhost:9000/api/v</a>2&quot; | vegeta attack -duration=600s | tee results.bin | vegeta report</pre><p>These commands will hit the particular endpoint on the server for 600s and you can watch the same on the Grafana Dashboard you just created.</p><p>You may think what is the need for checking what status codes which are being returned on a particular endpoint, so let’s take an example of a Payments Gateway service, it will be important to keep a track of successful and unsuccessful responses which are being returned when a user is paying using the service, a sudden spike in unsuccessful responses should mean that something is wrong with the server and you should immediately rectify whatever the problem.</p><p>The final dashboard will look something like below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lJuVlC7Q2bCJar_Aq2nbhw.png" /></figure><p>I hope you were able to understand and follow along on making a Monitoring Dashboard with Prometheus + Grafana. Thanks for reading. If you have any questions, feel free to leave a response.</p><h4>Resources for further reading:</h4><ul><li><a href="https://www.youtube.com/watch?v=5O1djJ13gRU">https://www.youtube.com/watch?v=5O1djJ13gRU</a> (An amazing video to understand why the need for Prometheus)</li><li><a href="https://www.scaleway.com/en/docs/vegeta-load-testing/">https://www.scaleway.com/en/docs/vegeta-load-testing/</a></li><li><a href="https://tomgregory.com/the-four-types-of-prometheus-metrics/">https://tomgregory.com/the-four-types-of-prometheus-metrics/</a></li><li><a href="https://medium.com/@valyala/promql-tutorial-for-beginners-9ab455142085">https://medium.com/@valyala/promql-tutorial-for-beginners-9ab455142085</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=59faa4a42ef6" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/configure-a-prometheus-monitoring-server-with-a-grafana-dashboard-59faa4a42ef6">Create a Prometheus Monitoring Server with a Grafana Dashboard</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[gRPC 101 : Run your Go Code in Python]]></title>
            <link>https://medium.com/swlh/grpc-101-run-your-go-code-in-python-1aab3df732?source=rss-79828bdeedf9------2</link>
            <guid isPermaLink="false">https://medium.com/p/1aab3df732</guid>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[grpc]]></category>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Jigar Chavada]]></dc:creator>
            <pubDate>Sun, 29 Mar 2020 11:24:35 GMT</pubDate>
            <atom:updated>2020-05-03T17:48:09.727Z</atom:updated>
            <content:encoded><![CDATA[<h3>gRPC 101 : Run your Go Code in Python</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XkwZlOqmSO67Dxsf_7dJXA.png" /></figure><p>As the title suggests, we will be writing the function definition in Golang and call the function from a Python program. I know this sounds somewhat absurd as to why a person would want to write a function in one language and execute it from another language. But believe me, you do it more often than you could imagine. An example of this would be to when you write your backend API in any of your favourite programming language or framework like Flask, Express, RoR, etc. and calling those APIs within your client which can be anything from a Web App, Mobile App or even a CLI which is many a times written in a different language then your backend. When you call an API endpoint within your client, what you are essentially doing is executing a function in your server whose call is done from your client.</p><p>Now having understood when you might need to do this cross language calling of functions, lets discuss more about RPC and its advantages over the REST API approach above.</p><p>In RPC, basically what happens is a client application can call methods on a server application which sits on a different machine as if it were a local object to create distributed applications and services. gRPC is a framework developed by Google which enables us to make RPC applications.</p><blockquote>There might be two questions which may arise in your mind at this point of time.<br>1. Why do you want to use RPC when you have your trusty REST working just fine ?<br>2. Why would you write a program in one language and execute it from other? (although I have explained it above, this is more to discuss)</blockquote><p>Answering the first question, lets say you are building a highly scalable application like Flipkart, now as part of this massively complicated e-commerce site you will need to create atleast a dozen services which will do stuff like inventory management, cart management of user, payments, logistics, recommendations, seller side business logic, etc. As you can see there will be a lot of interdependency among these services like payments service will need to know information from user’s cart, the seller side will need to know about logistics and many other such relations. Say you write a REST API for each of the service and exchange the endpoints with each other. Suddenly, your Slack will be flooded with messages like what parameters should I pass in this API and angry messages about how changing one parameter in your Carts API is making the payments service go haywire. The complicacy increases with increase in number of services and this method is not very scalable. To tackle this people use RPC within their backend, which helps in simplying the talking between these dozens of services. As we will see about Proto files which presents itself as absolute truth about what you send in request and what you get in response when making an RPC call.</p><p>Answering the second question, some programming languages are better equipped at one job than others, for example in high frequency trading, speed is of atmost importance so you will have your core logic always written in high performant language like C++, now this service needs to interact with your other services. Therefore, as a business standpoint it makes sense in using different languages for different services.</p><p>Enough talking you might think, show us the code. Let’s begin writing the code. We will write a basic program that given a person’s Github Username will return a list of their followers. The entire code can be accessed on my github profile.</p><p><a href="https://github.com/Jigar3/gRPC_101">Jigar3/gRPC_101</a></p><p>The directory structure followed is given below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/329/1*Yuf03hrkNRv68gdmB6d47Q.png" /><figcaption>Directory Structure</figcaption></figure><p>Let’s look at the <em>github.proto</em> first</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*K_H9_7iw0wdiVflr3ORWsw.png" /></figure><p>Proto files are the way in which you define what functions are going to be exchanged between server and client. As you can see we have defined a service called as <strong><em>GithubService</em></strong><em> </em>and declared that we will have a function called as <strong><em>GetFollowers</em></strong> that will take <strong><em>FollowerRequest</em></strong> as parameter and return <strong><em>FollowerResponse</em></strong> as response. The keyword repeated here means we intend to have an array of string as the type. In <strong><em>string github_username = 1, </em></strong>the number 1 is meant to be an identifier during the serialization and deserialization process. In REST, generally data is passed as JSON but in gRPC it is passed in the form of binary format known as <em>protobuf.</em></p><p>We can’t use this proto file directly to make client and server files, we first need to convert this proto file into actual code. gRPC supports a number of languages, you can check by visiting their <a href="https://grpc.io/">website</a>. You will need the necessary compilers for both Python and Go to compile this proto file into P<a href="https://github.com/protocolbuffers/protobuf/tree/master/python">ython</a> and G<a href="https://github.com/golang/protobuf">o</a> code respectively. Once installed you can run the below commands to generate files.</p><pre><strong><em># GO<br>protoc -I githubpb/ — go_out=plugins=grpc:githubpb/ githubpb/github.proto</em></strong></pre><pre><strong><em># Python<br>python -m grpc_tools.protoc -I. — python_out=githubpb — grpc_python_out=githubpb githubpb/github.proto</em></strong></pre><p>The files that will be generated automatically will be <em>github.pb.go, github_pb2.py, github_pb2_grpc.py</em></p><p>Now, let’s implement the actual code in Golang.</p><p>I won’t go over the implementation of the <strong><em>GetFollowers</em></strong> function, it is just a normal call to the github API to get the data.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/698/1*ajphUJxqcQRXc7B5VK0baA.png" /><figcaption>server.go</figcaption></figure><p>Here, in the main function, we are just registering the Server by using the code which was generated by <em>protoc</em> complier. We are serving the server at <em>localhost:50051. </em>It’s just standard boilerplate code you need to write to get your server running.</p><p>Now, let’s code the client in Python.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/825/1*7KUNgebcujBUE6sP04GsKQ.png" /></figure><p>The <em>sys.path.insert(1, ‘/home/jigar/grpc’) </em>statement is just so we could import files for directory outside the current one.</p><p>We are importing the files generated by the python grpc complier. We make a connection to our server on <em>localhost:50051 </em>and call our <em>GetFollowers</em> function on the server. Again, here you will find some boilerplate code to make the actual connection between the client and server.</p><p>Now for the results, let’s run both the client and server.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*c3jrMZDs0rFBb2g2SO_nFg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RAoGxORvP-g1lycHgrbJAw.png" /></figure><p>So, we have successfully called a function which was implemented in Go by a python program. You can do the reverse as well implement in python and call in Go. For example, I have made a client in Go as well. You can check out that in the repository linked above.</p><p>Hope you got to learn something new and exciting today, feel free to comment and ask doubts.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1aab3df732" width="1" height="1" alt=""><hr><p><a href="https://medium.com/swlh/grpc-101-run-your-go-code-in-python-1aab3df732">gRPC 101 : Run your Go Code in Python</a> was originally published in <a href="https://medium.com/swlh">The Startup</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My Experience Of OpenCode18]]></title>
            <link>https://medium.com/@chavada.jigar.3/my-experience-of-opencode18-4433b6eaf823?source=rss-79828bdeedf9------2</link>
            <guid isPermaLink="false">https://medium.com/p/4433b6eaf823</guid>
            <category><![CDATA[open-source]]></category>
            <dc:creator><![CDATA[Jigar Chavada]]></dc:creator>
            <pubDate>Wed, 07 Feb 2018 05:29:49 GMT</pubDate>
            <atom:updated>2018-02-07T06:46:56.575Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/851/1*E5GP0IprDEa43heG69iB2g.png" /></figure><p><em>Here’s some context , OpenCode is one of the many events that is organized by the FOSS Wing of Geekhaven(Technical Society of IIIT Allahabad). This is the very first event in which there is active participation from all students as it starts in 1st/2nd week of January the time when most of the students have tried learning some kind of development(Web/App). So OpenCode gives student like us an excellent opportunity to test those skills acquired during their winter break as well as learn new things along with it.</em></p><p><em>Coming to my experience of OpenCode, I should say that is was particularly overwhelming and exciting and surprising all at the same time. I still remember the time when people used to jump to get issues assigned to them even before OpenCode Labels were added to those issues. This was some another level of thrill. Sitting in classes not paying attention towards the Professor who is teaching but getting shoved onto your mobile screen, refreshing your browser to see if any new issue has been added. People used to take any issue that comes their way, be it something they even haven’t heard about. I guess, that’s the beauty of OpenCode, it helps us let go of our fear of tackling problems without thinking about whether we can solve them or not.</em></p><p><em>I learned many new things along the way and also applied knowledge of things I knew off previously. It was a great learning curve. Once you start doing OpenSource Development, the enthusiasm never dies as there are plenty of things to learn and improve upon. This experience of OpenCode18 shall surely help me and all of the other participants in coming days(Talking about GSoC here:D).</em></p><blockquote><em>One such experience which I remember was that I was an avid Stock Market follower so I knew about Candle-Stick Graphs, but how are they drawn and from where do I get data was always a mystery. During OpenCode, there was one such issue to do data visualization on any data-set you might like. That’s when I thought it was the time to learn about Matplotlib and try implementing Data Visualization techniques for real. It took me some time to figure about different kinds of plot that can be drawn using matplotlib and that there is an inbuilt sub-module known as matplot.finance which can help me to draw those candlesticks really easily. Getting data wasn’t a huge problem as NSE website allows you to download historical data in .csv format.</em></blockquote><blockquote><a href="https://github.com/opencode18/dataviz-gallery"><em>https://github.com/opencode18/dataviz-gallery</em></a></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*vGJZUplxpqyfRLZM5pInxQ.jpeg" /></figure><blockquote><em>Another issue which I took on without knowing anything about it was doing API calls in Go. There was an issue in Grypto repository to do all the data fetching from one API call. Grypto was a command line interface kind of application in which you can see prices of different cryptocurrencies. That data was being fetched from “https://api.coinmarketcap.com/v1/ticker/” API endpoint and there were several API calls being made. My job was to do all that in one API call. It took some time to learn about how Go handles API requests and how we can extract data from JSON in Go but I was able to finish that issue. I still remember Mubaris Sir commented Good Work on that PR.</em></blockquote><blockquote><a href="https://github.com/gostudent/Grypto/pull/11">https://github.com/gostudent/Grypto/pull/11</a></blockquote><p><em>The best part about OpenSource contribution is the thing that you get to interact with all the intelligent people around. Ideas get shared, suggestions get made and then when those ideas/suggestions get implemented the happiness you get cannot be described in words. This is a very great initiative by our seniors that would definitely bring more people towards OpenSource Development.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4433b6eaf823" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>