<?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 Srijan on Medium]]></title>
        <description><![CDATA[Stories by Srijan on Medium]]></description>
        <link>https://medium.com/@srijancse?source=rss-b4f4fb954bf4------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*isEOaYxzJ0wlB2jPx4a91Q.jpeg</url>
            <title>Stories by Srijan on Medium</title>
            <link>https://medium.com/@srijancse?source=rss-b4f4fb954bf4------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 14:37:06 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@srijancse/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[What’s it like to work at Clarisights?]]></title>
            <link>https://medium.com/clarisights/whats-it-like-to-work-at-clarisights-e593e34b801e?source=rss-b4f4fb954bf4------2</link>
            <guid isPermaLink="false">https://medium.com/p/e593e34b801e</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[culture]]></category>
            <category><![CDATA[recruiting]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[hiring]]></category>
            <dc:creator><![CDATA[Srijan]]></dc:creator>
            <pubDate>Fri, 22 Feb 2019 14:50:25 GMT</pubDate>
            <atom:updated>2019-07-25T02:52:07.153Z</atom:updated>
            <content:encoded><![CDATA[<p>March is almost here and 2019 is already two months old. How were your first couple months in this new year, guys? I’m currently in Bengaluru and recently started working with the Growth team at Clarisights. It has been an exciting month of learning, new experiences, and meeting new people!</p><p><em>First things first, what is Clarisights?</em></p><p>Clarisights is a reporting and analytics platform that enables marketers to make sense of and gain unique insights from data. Our platform is a seamless in-browser experience — users can add marketing data sources and begin answering questions on the data, minutes after signing up. Behind the scenes, there’s a lot going on — our backend ingests the data, performs multiple transformations and stores it in our own database. With Clarisights, marketers can build reports to answer questions like <em>“What are my largest sources of traffic and what are the major cost sinkholes?”</em> and then also quickly drill down into granular details like <em>“What kind of ad copy has the least customer acquisition cost”</em> or <em>“Which ad creatives are driving the maximum RoI?”</em> Interesting, isn’t it? Do you want to know the back-story of Clarisights? <a href="https://youtu.be/GFGAcxPragY?t=5919">Check out this video</a> by our CEO, Arun at the Techstars 2018 demo day!</p><p><em>Coming back to me,</em> my first month at Clarisights was dedicated to figuring out how the product works, how we are solving problems for our customers, why our customers chose us and so on. I spoke to everyone including the founders and it was very exhilarating to know how they came up with the idea of Clarisights — heard the company story as they saw it with their own eyes. But, I was able to truly appreciate what an exceptional product we’re building only once I started using it. It was like that “wow” moment you have when you do something new and completely enjoy it — like your first Uber ride or Swiggy delivery. It also allowed me to closely observe the challenging parts of the UX. Looking at the product with fresh eyes was something I could only do once while I was still new, so I tried to make the most of it.</p><p><em>There are few things I like most at Clarisights.</em></p><ol><li><strong>Product</strong> — Clarisights was founded to empower performance marketing and growth teams by creating a platform that gives them insights and superhero powers they have always wanted. Rather than wrestling with spreadsheets and legacy BI platforms that can’t keep pace with their growing volume of marketing channels and data, marketers can use Clarisights to independently explore and analyse all their data in a single and intuitive interface. Marketing teams around the world use Clarisights for every aspect of their performance marketing workflow — and this shows in the level of engagement. On an average, marketers using Clarisights spend over 50 minutes on the platform per day.</li><li><strong>Responsibilities and Ownership </strong>— At Clarisights, you are given freedom to experiment, sense of ownership of your work, license to fail and you have peers who care just as much as you about their work. We have a trust by default policy — i.e. we trust that you will get the work done and won’t micromanage. There’s an immense learning and growth opportunity in small, multi-functional, tightly-knit teams of smart folks here. You want to know, who you would be working with? <a href="https://www.clarisights.com/careers">Check this page out</a>.</li><li><strong>People</strong> — want to know how it’s like to work at Clarisights : flat hierarchy, everyone is friendly, you can crack jokes anywhere anytime, and go to parties with your colleagues. At Clarisights, we live and breathe the company and the work — we are just not a team but a family and it’s a place that makes you feel excited about going to work everyday. When making a decision, we take the holistic approach — everyone’s voice is heard. We are thoughtful about our cross-functional work, customer impact, and each unique touchpoint that goes into the journey of bringing every experience to life. The final product (no matter how big or small) is equally as important as the journey to get there. When decisions are made there is no ultimate decision maker, the title does not matter — whether you are an “Intern”, “Junior Developer”, or “CEO” — your voice carries weight in every discussion.</li></ol><p>Also, we love to play Table Tennis in our free time. Table Tennis is a fierce but sociable competition here. Frequently throughout the day various pairs will take to the table and fight it out to 21-points — before laughing and amicably shaking hands. :D</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2Fsz3pnTuOYyupa%2Ftwitter%2Fiframe&amp;display_name=Giphy&amp;url=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2Fsz3pnTuOYyupa%2Fgiphy.gif&amp;image=https%3A%2F%2Fi.giphy.com%2Fmedia%2Fsz3pnTuOYyupa%2F200.gif&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="355" frameborder="0" scrolling="no"><a href="https://medium.com/media/5b5031bfe292b49a0e8c358d58d2fb50/href">https://medium.com/media/5b5031bfe292b49a0e8c358d58d2fb50/href</a></iframe><h3>Why you should join us</h3><p>I can think of two reasons: a real problem-solving product with a huge addressable market, and you get to work with smart folks who can help you grow and learn. Clarisights is a company that gives you opportunities, recognises your impact and cares about you — you’re not just a resource here, you are a member of the family.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oEQP_ZmVX4wUMCh-DdnW8g.jpeg" /></figure><p>The kind of engineering challenges, we face —</p><ol><li><a href="https://youtu.be/Vo7gUkWSIlc">Ashu Pachauri</a> talking about our backend engineering and infrastructural challenges.</li><li><a href="https://youtu.be/u8Bixn6wCVc">Rohan Malhotra</a> talking about frontend engineering and performance conundrums.</li><li><a href="https://youtu.be/ZzG9QUeB8w8">Yash Arora</a> talking about building a cohesive product experience.</li></ol><p>We have an exciting road ahead, and an early-user group of intelligent marketers from all around the world. They range from EdTech to takeaway brands, and publicly listed multi-billion dollar brands to high growth startups paying us thousands of dollars every month.</p><p>After recently raising a $2.5M round from top European VCs and angels, we’re looking to scale the product both from an engineering and growth perspective. To achieve this, we are building a team of sharp, creative, passionate builders with a “get-shit-done” attitude, the kind of people who see opportunity where others see roadblocks.</p><p>We genuinely love what we do and we’re looking for others who can share the same passion. Here, you will be judged on your work and your aptitude, not just on your pedigree. If this sounds like you, <a href="https://www.clarisights.com/careers/openings">check out our open roles</a>!</p><p>PS - We recently went to our first offsite and if you’d like to see how our culture is, you should surely watch <a href="https://youtu.be/_xBSPLjPR2c">this video</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e593e34b801e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/clarisights/whats-it-like-to-work-at-clarisights-e593e34b801e">What’s it like to work at Clarisights?</a> was originally published in <a href="https://medium.com/clarisights">Clarisights</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Analysing different Operational Transformation algorithms for collaborative editing]]></title>
            <link>https://srijancse.medium.com/analysing-different-operational-transformation-algorithms-for-collaborative-editing-60fcc49ef24b?source=rss-b4f4fb954bf4------2</link>
            <guid isPermaLink="false">https://medium.com/p/60fcc49ef24b</guid>
            <category><![CDATA[algorithms]]></category>
            <category><![CDATA[google-docs]]></category>
            <category><![CDATA[research]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[computer-science]]></category>
            <dc:creator><![CDATA[Srijan]]></dc:creator>
            <pubDate>Wed, 07 Jun 2017 09:30:13 GMT</pubDate>
            <atom:updated>2023-06-17T07:45:05.368Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introduction</h3><p>This is the third post in my series of <strong>Operational Transformation (OT)</strong>, the real time collaborative editing algorithm. The first and second posts were <a href="https://srijancse.medium.com/how-real-time-collaborative-editing-work-operational-transformation-ac4902d75682">How Real-Time Collaborative Editors work? [Operational Transformation]</a> and <a href="https://srijancse.medium.com/operational-transformation-the-real-time-collaborative-editing-algorithm-bf8756683f66">Operational Transformation, the real time collaborative editing algorithm</a> respectively.</p><p>As mentioned in earlier posts, Operational transformation was originally born due to the need for consistency maintenance in collaborative text editors. In the span of over two decades, OTs have gained new capabilities (such as undo operations and group undo) and have been applied to different applications ranging from HTML/XML editing, office <a href="https://hackernoon.com/tagged/tools">tools</a>, and even 3D digital media design tools.</p><p>There are many established approaches that exist in operational transformation. In this post, I will walk through the different OT algorithms that are well defined and implemented.</p><h4>Definitions/Terms used :</h4><p>In the <a href="https://medium.com/@srijancse/operational-transformation-the-real-time-collaborative-editing-algorithm-bf8756683f66">second</a> post, I explained about the two kinds of Transformation functions, i.e, Inclusion Transformation and Exclusion Transformation. These functions have two properties/preconditions which ensures OT correctness. TP1 and TP2 are transformation/convergence properties.</p><p><strong>TP1: </strong>For two concurrent operations O1 and O2, the transform function (T) satisfy TP1 iff O1 <em>o</em> T(O2, O1) ≡ O2 <em>o</em> T(O1, O2) where <em>o</em> denotes the sequence of operations containing Oi followed by Oj and ≡ denotes the equivalence of the two operations. <br><strong>Precondition of TP1:</strong> TP1 is required only if the Operational Transformation system allows any two operations to be executed in different orders.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/235/1*TtAB_QqZEbPrKq9iOPSY7w.jpeg" /><figcaption>TP1 property illustration</figcaption></figure><p><strong>TP2: </strong>For three concurrent operations O1, O2 and O3, the transform function (T) satisfy TP2 iff T(O3, O1 <em>o </em>T(O2, O1)) ≡ T(O3, O2 <em>o </em>T(O1, O2)). <br><strong>Precondition of TP2</strong>: TP2 is required only if the OT system allows two operations O1 and O2 to be IT-transformed in two different document states (or contexts).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/336/1*KeYPN11hgFN6Z7aM27jz4A.jpeg" /><figcaption>TP2 property illustration</figcaption></figure><h3>1. dOPT — distributed Operational Transformation</h3><p>The dOPT Algorithm was one of the first approaches to OT. In dOPT Algorithm, each machine has identifier i, which could be an IP or MAC. Each machine has to maintain a state vector s with <em>n</em> components where <em>n </em>is the number of machines. The <em>i</em> component store the number of changes recorded by the <em>ith</em> machine. The requests are of the form: &lt;i, s, o, p&gt;</p><ul><li>i — the original site’s identifier</li><li>s — the state vector of the machine which is sending</li><li>o — the operation which needs to be performed</li><li>p — the priority which is associated with o [<strong>this is where the algorithm got wrong</strong>]</li></ul><p>A transformation matrix, denoted as T, is what solves<em> conflicting operations</em>. T is a <em>m x m</em> matrix, where <em>m</em> is the number of supported operations in the groupware system. Each entry in the matrix is a function which transforms operations into other operations and to ensure convergence dOPT requires the Transformation Property 1.</p><p>For handling requests, the actions are based on comparisons between <em>s_i </em>[sending state] and<em> s_x </em>[receiving state]. If they are same i.e <em>s_i = s_x</em>, <em>o</em> is executed immediately, if <em>s_i &gt; s_x, o</em> is queued and executed later and if <em>s_i &lt; s_x, o</em> is transformed and then executed.</p><h4>Strengths of the algorithm :</h4><ul><li>Immediate feedback for local operations.</li><li>It does not require the locking of resources.</li><li>Relatively easy to implement due to its simple data structures.</li><li>Satisfies the <em>precedence property, </em>which is defined as<em>, a </em>consistency property that ensures that the execution order is the same as the operations&#39; natural cause-effect order. In other words, if an operation <em>O1 </em>causally precedes another operation<em> O2</em>, then at every site <em>O1</em> will be executed before <em>O2</em>.</li><li>Enforces the <em>Transformation property 1.</em></li></ul><h4>Problems:</h4><p>The priority, <strong>p</strong>, suggested doesn’t work great for two clients. It fails whenever an operation is concurrent with two or more dependent operations. This algorithm is distributed and <strong>does not</strong> have a central server.</p><h3>1.1. <strong>adOPTed Algorithm</strong></h3><p>The shortcomings in dOPT were in the way it transformed operations. The adOPTed introduced the second transformation property [TP2] which ensures that the transformation of operation along different paths will yield the same resulting operation.</p><p>The adOPTed algorithm is right in general, and solves most of the shortcomings of dOPT algorithm but<strong> has not proved Intention Preservation property, </strong>which is defined as, a consistency property which ensures that the intention of operation is preserved after a transformation. The intention of an operation, <em>O</em>, is the effect of applying <em>O </em>on the resource where the operation was generated.</p><p>Also, the intent is always <strong>_of the user_</strong>. Machines have no intent, Humans do. That’s why preserving intention becomes of sufficient importance.</p><h3>2. GOT and GOTO — Generic and Generic Optimized Operational Transformation</h3><p>GOT control algorithm maintains convergence nicely i.e. when the same set of operations have been executed at all sites, all copies of the document which is shared are identical. Also, it is integrated with the <em>Undo/Do/Redo Scheme </em>which states that when a new operation <em>O</em> is ready;</p><ul><li><strong>Undo</strong> operations in <em>History Buffer (</em><strong>HB<em>) </em></strong>(which is defined as ‘saved executed operations at each site’) which totally follow <em>O </em>to restore the document to the state before their execution.</li><li><strong>Do </strong><em>O </em>(the operation)</li><li><strong>Redo </strong>all operations that were undone from the HB.</li></ul><p>Also, in this convergence TP2 is not a necessary condition i.e the precondition CP2/TP2 is required only if the OT systems allow two operations op1 and op2 be IT-transformed [inclusion transformation] in two different document states.</p><h4>Strengths of the algorithm :</h4><ul><li>OT based undo is established, faster and more efficient undo based operations.</li><li><em>Convergence property</em> is fulfilled, which is defined as, a consistency property which ensures that copies of a shared resource are identical at all sites in the state of rest (i.e. ensuring that all operations are executed).</li></ul><h4>Problems :</h4><p>The algorithm only supports basic string operations i.e Insert/Delete. Also, correctness proof of the algorithm is missing.</p><p><strong>GOTO</strong> Algorithm is the <strong>O</strong>ptimized version of GOT Algorithm. The optimization takes place because of two postconditions, <strong>TP1</strong> and <strong>TP2</strong> to reduce the number of<strong> IT/ET </strong>(Inclusion/Exclusion)<strong> </strong>transformations by adding the properties from adOPTed.</p><p>GOTO algorithm uses the function <em>convert2HC()</em> which basically uses ET between an insert and a delete [concurrent], what basically happens is we transpose the entire history to obtain the concurrent operations when integrating a remote operation. The algorithm fulfills the convergence property, precedence property, TP1, TP2 and has better undo operations, but was <strong>never theoretically proven correct for all scenarios</strong>.</p><h3>3. COT — Context-based Operational Transformation</h3><p>The COT algorithm does not use a history buffer (HB) when an operation is executed, instead, it keeps track of the document state in which an operation have been executed in. So instead of an HB it has a context vector.</p><p><strong>Note</strong> — Context vector would be extremely memory intensive even for small changes. Imagine 3 simultaneous backspaces end up storing the entire document thrice. This could be optimized for individual nodes in substance.</p><p>In an OT-based collaborative editor, a document state can be uniquely characterized by the set of original operations executed so far on the document. These original operations may be executed in different orders or forms at different sites, but they must produce the same document state according to the convergence/transformation properties. Moreover, the difference between the two document states can be expressed in terms of different original operations executed in these two states. Since every transformed operation must come from an original operation, <em>org(O)</em> is used to denote the original operation of O.</p><p>A document state, denoted as <strong>DS</strong>, can be represented as :</p><ul><li>The initial Document State is represented by <em>DS = { }</em></li><li>After executing an operation <em>O</em> on <em>DS</em>, the new Document State <em>DS’ = DS ∪ { org(O) }</em>.</li></ul><p>An operation is defined by a site identifier and a number is given when it is generated. This operation, in turn, has <strong>a context vector</strong> that contains the operation context in terms of operations that precedes it. The operations inside the context vector, in turn, have their own site identifiers and defining numbers.</p><p>This is the main difference since COT heavily relies on every operation which is to be executed on the same document state on all locations, if the operation is executed on the same document state at all sites the result can not diverge.</p><p>A context vector, denoted as CV(O), can be represented as :</p><p><strong>CV(O) = [(ns⁰, ic⁰), (ns¹, ic¹), . . . , (ns^N-1, ic^N-1)]</strong> where <em>0 ≤ i ≤ N-1</em> and</p><ul><li><em>ns^i</em> represents all original normal operations at site i</li><li><em>ic^i = [(ns⁰, is⁰), (ns¹, is¹), . . . , (ns^k-1, is^k-1)]</em> represents all inverse operations for <strong>undoing</strong> normal operations at site <em>i</em>.</li></ul><p>Also to capture the essential requirements for correct operation execution and transformation, a set of six rules called <em>Context-based Conditions (CCs)</em> were introduced.</p><ul><li><strong>CC1</strong>: Given an original <em>operation </em>O and a <em>document state </em>DS, where O ∉ DS, O can be transformed for execution on DS only if C(O) ⊆ DS.</li><li><strong>CC2</strong>: Given an original operation O and a document state DS, where O ∉ DS and C(O) ⊆ DS, DS-C(O)² is the set of operations that O must be transformed against before being executed on DS.</li><li><strong>CC3</strong>: Given any operation O and a state DS, O can be executed on DS only if C(O) = DS.</li><li><strong>CC4</strong>: Given an original operation Ox and an operation O of any type, where Ox ∉ C(O), Ox can be transformed to the context of O only if C(Ox) ⊆ C(O).</li><li><strong>CC5</strong>: Given an original operation Ox and an operation O of any type, where Ox ∉ C(O) and C(Ox) ⊆ C(O), C(O) ≠ C(Ox) is the set of operations that Ox must be transformed against before being IT-transformed with O.</li><li><strong>CC6</strong>: Given two operations Oa and Ob, they can be IT-transformed with each other IT(Oa,Ob) or IT(Ob,Oa), only if C(Oa) = C(Ob).</li></ul><p>Due to these conditions and the context vector, the COT algorithm is optimized to the extent that it does not even have a need for the <strong>ET</strong> transformations. This is made possible because of the context vector that enables better use of <strong>IT</strong>s.</p><h4><strong>Strengths of the algorithm:</strong></h4><ul><li>Fulfills the convergence property.</li><li>Fulfills the precedence property.</li><li>A platform capable of more than text editing.</li><li>Has been well tested as it has been implemented in several editing programs such as CoMaya, CoWord and more.</li></ul><h4>Problems :</h4><p>It requires more memory than other algorithms because of the nature of context vectors but can be optimized in the same way other algorithms have.</p><h3>4. Google Wave OT Algorithm</h3><p><a href="https://hackernoon.com/tagged/google">Google</a> Wave OT is basically based on the algorithm given by Jupiter System [dOPT algorithm]. Having a simple and efficient server is important in making wave’s reliable and scalable. With this goal, Google’s Operational Transformation algorithm modifies the basic theory of OT by requiring the client to wait for <strong>acknowledgement [ACKs] </strong>(In the <a href="https://medium.com/@srijancse/operational-transformation-the-real-time-collaborative-editing-algorithm-bf8756683f66">second</a> post, I have explained Client — Server Acknowledgement approach) from the server before sending more operations. When a server acknowledges a client’s operation, it means the server has transformed the client’s operation, applied it to the server’s copy of the wavelet and broadcast the transformed operation to all other connected clients. While the client is waiting for the acknowledgement, it caches operations produced locally and sends them in bulk later.</p><p>With the addition of acknowledgements, a client can infer the server’s OT path. By having this, the client can send operations to the server that are always on the server’s OT path.</p><p>This has the important benefit that the server only needs to have <strong>a single state space</strong>, which is the history of operations it has applied. When it receives a client’s operation, it only needs to transform the operation against the operation history, apply the transformed operation, and then broadcast it. This source of truth also forces the client to wait for the server to <strong>acknowledge</strong> the operation that the client has just sent which would mean that the client always stays on the server’s OT path. This would help in keeping a single history of operations without actually having to keep a mirror of the state for each client that is connected. That would eventually mean the number of clients that are connected to the server would have only one single copy of the document on the server. One trade-off of this change is that a client will see <em>chunks of operations (accumulated batch operations)</em> from another client in intervals of approximately one round trip time to the other client.</p><p>Google Wave OT solves most of the flaws by its Acknowledge command and by strictly limiting the number of participants in communication to <strong>two</strong>. If the number of clients were increased to three, <strong>17%</strong> of the time, conflicts arose. However, there is one flaw that might have slipped through, which is <strong>intention preservation</strong>.</p><h3><strong>Conclusion</strong></h3><p>The viable solution would be to incorporate <strong>Context based OT</strong> with <strong>Google wave OT</strong>, since COT would be able to provide a better intention preservation. Also, COT algorithm is not based on when the operation arrives at different places but in what context [CV(O)] the original operation was executed in. Therefore at each site when Oi arrives a comparison will be made with Oi’s context vector and the site’s own document state.</p><p>Also, note that not all Operational Transformation approaches has been taken into considerations. I have merely listed those which I believed are the most significant ones.</p><p>I would also be researching and writing another post on why Google Wave OT failed in practice by using whatever source code provided by Google implementing a test to prove that Waves OT fails to preserve true intention in practice. Also, I may perform a benchmarking with COT and Google Wave together to know if really COT can be incorporated with Google Wave’s OT.</p><h3>References</h3><ul><li><a href="http://lively-kernel.org/repository/webwerkstatt/projects/Collaboration/paper/Jupiter.pdf">High Latency, Low-Bandwidth Windowing in the Jupiter Collaboration System</a> <em>Authored by David A. Nichols, Pavel Curtis, Michael Dixon, and John Lamping.</em></li><li><a href="http://www.cs.cityu.edu.hk/~jia/research/reduce98.pdf">Achieving Convergence, Causality Preservation, and Intention Preservation in Real-Time Cooperative Editing Systems</a> <em>Authored by Chengzheng Sun, Xiaohua Jia, Yanchun Zhang, Yun Yang and David Chen.</em></li><li><a href="http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.53.933&amp;rep=rep1&amp;type=pdf">Operational Transformation in Real-Time Group Editors: Issues, Algorithms, and Achievements</a> <em>Authored by Chengzheng Sun and Clarence (Skip) Ellis.</em></li><li><a href="https://hal.inria.fr/inria-00138381v4">Compensation in Collaborative Editing</a> <em>Authored by Stephane Weiss, Pascal Urso and Pascal Molli</em></li><li><a href="http://ieeexplore.ieee.org/iel5/71/4359390/04668339.pdf">Context-Based Operational Transformation in Distributed Collaborative Editing Systems</a> <em>Authored by David Sun and Chengzheng Sun</em></li><li><a href="http://dl.acm.org/citation.cfm?id=2145412">Operational Transformation for Dependency Conflict Resolution in Real-time Collaborative 3D Design Systems</a> <em>Authored by Agustina, Chengzheng Sun, Dong Xu</em></li><li><a href="http://pagesperso.lina.univ-nantes.fr/~molli-p/pmwiki/uploads/Main/abdessamad03.pdf">Proving Correctness of Transformation Functions in Real-Time Groupware</a><em> Authored by Abdessamad Imine, Pascal Molli, Gerald Oster and Michael Rusinowitch</em></li><li><a href="https://pdfs.semanticscholar.org/3c81/298899c8156e069feb4e6881e73ecc744fc0.pdf">Undo Any Operation at Any Time in Group Editors</a> <em>Authored by Chengzheng Sun</em></li><li><a href="http://www.ijcaonline.org/volume3/number12/pxc3871115.pdf">A Survey on Operational Transformation Algorithms: Challenges, Issues and Achievements</a> <em>Authored by Santosh Kumawat and Ajay Khunteta</em></li><li><a href="http://ieeexplore.ieee.org/document/1655675/">A Performance Study of Group Editing Algorithms</a> <em>Authored by D. Li and R. Li</em></li><li><a href="http://dl.acm.org/citation.cfm?id=358988">Copies Convergence in a Distributed Real-Time Collaborative Environment</a> <em>Authored by Nicolas VIDOT, Michelle CART, Jean FERRIÉ, Maher SULEIMAN</em></li><li><a href="http://www.waveprotocol.org/whitepapers/operational-transform">Google’s whitepaper on Operational Transformation</a></li><li><a href="https://www.lri.fr/~mbl/ENS/CSCW/2012/papers/Ellis-SIGMOD89.pdf">Concurrency Control in Groupware Systems</a> <em>Authored by C.A. Ellis, S.J. Gibbs</em></li><li><a href="https://en.wikipedia.org/wiki/Operational_transformation">Wikipedia on Operational Transformation</a> <em>One of the most informative articles, I have found on wikipedia, suprisingly.</em></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=60fcc49ef24b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Operational Transformation, the real-time collaborative editing algorithm]]></title>
            <link>https://srijancse.medium.com/operational-transformation-the-real-time-collaborative-editing-algorithm-bf8756683f66?source=rss-b4f4fb954bf4------2</link>
            <guid isPermaLink="false">https://medium.com/p/bf8756683f66</guid>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[collaboration]]></category>
            <category><![CDATA[algorithms]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Srijan]]></dc:creator>
            <pubDate>Sat, 13 May 2017 14:22:11 GMT</pubDate>
            <atom:updated>2019-11-01T06:52:22.214Z</atom:updated>
            <content:encoded><![CDATA[<p>This is the second post related to <strong>Operational Transformation</strong>, the real-time collaborative editing algorithm. The first post was <a href="https://medium.com/@srijancse/how-real-time-collaborative-editing-work-operational-transformation-ac4902d75682">How Real-Time Collaborative Editors work? [Operational Transformation]</a>.</p><p>In this post, I would be digging deep into the transformation function, how clients wait for <strong>acknowledgement</strong> from the server before sending more operations and the compound operational transformation.</p><h3>Transformation function</h3><p>To recap, for handling concurrent operations, we use the <strong>tranform</strong> function that takes two operations that have been applied to the same document state (but on different clients) and computes a new operation that can be applied after the second operation and that preserves the first operation’s intended change.</p><p>Basically, there exists two kinds of transformation functions :</p><ul><li><strong>Inclusion Transformation</strong> : denoted as IT(a, b), which transforms Operation a against another operation b in such a way that the impact of b is effectively included.</li><li><strong>Exclusion Transformation</strong> : denoted as ET(a, b), which transforms operation a against another operation b in such a way that the impact of b is effectively excluded.</li></ul><p>Transformation functions are named differently in different OT systems, and some compound transformation functions may combine both IT and ET functionalities in one function. One of the papers, <a href="http://www.springer.com/cda/content/document/cda_downloaddocument/9788132226369-c2.pdf?SGWID=0-0-45-1564306-p177709634">Analysis of Operational Transformation Algorithms</a> is really good, and analyses all the different OT systems.</p><h4>Character wise Transformation Function</h4><p>A character wise transformation function’s algorithm (for consistency maintenance) is simple. As an example, for a pair of character-wise operations Ins[p, c] (to insert a character c at the position p) and Del[p] (to delete a character at position p), four IT functions, denoted as Tii, Tid, Tdi, Tdd, can be defined as follows:</p><pre>Tii(Ins[p1,c1], Ins[p2, c2]) {<br>      if p1 &lt; p2  or (p1 = p2 and u1 &gt; u2) // breaking insert-tie using user identifiers (u1, u2)<br>            return Ins[p1, c1];  // e.g. Tii(Ins[3, “a”], Ins[4, “b”]) = Ins[3, “a”]<br>      else return Ins[p1+1, c1]; } // Tii(Ins[3, “a”], Ins[1, “b”]) = Ins[4, “a”]<br> <br>Tid(Ins[p1,c1], Del[p2]) {          <br>      if p1 &lt;= p2 return Ins[p1, c1]; // e.g. Tid(Ins[3, “a”], Del[4]) = Ins[3, “a”]<br>     else return Ins[p1-1, c1]; } // Tid(Ins[3, “a”], Del[1] ) = Ins[2, “a”]<br> <br>Tdi(Del[p1], Ins[p2, c2]) {<br>      if p1 &lt; p2 return Del[p1];  // e.g.  Tdi(Del[3], Ins[4, “b”]) = Del[3]<br>      else return Del[p1+1]; } // Tdi(Del[3], Ins[1, “b”]) = Del[4]<br> <br>Tdd(Del[p1], Del[p2]) {<br>      if p1 &lt; p2 return Del[p1]; // e.g.   Tdd(Del[3], Del[4]) = Del[3]<br>      else if p1 &gt; p2 return Del[p1-1]; // Tdd(Del[3], Del[1]) = Del[2]<br>      else return I; } // breaking delete-tie using I (identity op)  Tdd(Del[3]. Del[3]) = I</pre><p>String-wise transformation function’s algorithm is significantly more challenging than character-wise operations’ because:</p><ul><li>a string delete covers a deleting range, which may include the characters in the string as well as the interval positions between characters.</li><li>concurrent string delete operations may arbitrarily overlap with each other and even with concurrent insert operations.</li><li>a string inserted by a previous insert operation may be changed by following (causally after) insert and delete operations.</li></ul><h3>Undo Related Application</h3><p>Operational Transformation ofcourse supports undo in collaborative editors which impose additional requirements :</p><ul><li>One is the undo effect, which requires that undoing an operation O achieves the effect of eliminating the effect of O but retains the effects of other operations in the document. In other words, the effect of undoing O is to transform the document state into one that it would have gone to if O had never been performed but other operations had been performed. This undo effect is consistent with the linear undo effect in single-user editing environments, and also suitable for non-linear undo (e.g. “undoing any operation at any time”) in multi-user and concurrent editing environments.</li><li>The other is the undo property, which requires that the document be restored to any previous state by undoing all operations executed after that state, regardless of the order in which those operations are undone. This property is required to ensure the capability of “restoring any prior state”, which is essential for an undo solution to support error-recovery and alternative exploration.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/518/0*Eg9P1o6V_K-cMbry.jpg" /></figure><h3>Client — Server Acknowledgement approach</h3><p>Just to recap, what the theory of Operational Transformation in <a href="http://lively-kernel.org/repository/webwerkstatt/projects/Collaboration/paper/Jupiter.pdf">High Latency, Low-Bandwidth Windowing in the Jupiter Collaboration System</a> says is that a client can send operations in a sequence to the server and vice versa. This means that the client and server can traverse through the state space through different paths of operational transformation to the same convergent state depending on when they receive the other operations.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/620/0*AnGQ7dnfty0Fz-2d.png" /></figure><p>When multiple clients are connected to the server, every client and server pair have their own state space. One shortcoming of this is that the server would need to carry a state space for every connected client, which can be very memory-intensive. In addition, this complicates the server algorithm by requiring it to convert clients’ operations between state spaces.</p><p>Having a simple and efficient server is important in making waves reliable and scalable. With this goal, Google’s Operational Transformation algorithm modifies the basic theory of OT by requiring the client to wait for <strong>acknowledgement</strong> from the server before sending more operations. When a server acknowledges a client’s operation, it means the server has transformed the client’s operation, applied it to the server’s copy of the wavelet and broadcast the transformed operation to all other connected clients. While the client is waiting for the acknowledgement, it caches operations produced locally and sends them in bulk later.</p><p>With the addition of acknowledgements, a client can infer the server’s OT path. By having this, the client can send operations to the server that are always on the server’s OT path.</p><p>This has the important benefit that the server only needs to have <strong>a single state space</strong>, which is the history of operations it has applied. When it receives a client’s operation, it only needs to transform the operation against the operation history, apply the transformed operation, and then broadcast it. This source of truth also forces the client to wait for the server to <strong>acknowledge</strong> the operation that the client has just sent which would mean that the client always stays on the server’s OT path. This would help in keeping a single history of operations without actually having to keep a mirror of the state for each client that is connected. That would eventually mean the number of clients that are connected to the server would have only one single copy of the document on the server. One trade-off of this change is that a client will see chunks of operations from another client in intervals of approximately one round trip time to the other client.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/544/0*AOaCRP4nhJzamC8b.png" /></figure><h3>Compound Operational Transformation</h3><p>A great tutorial on Compound Operational Transformation is <a href="http://www.codecommit.com/blog/java/understanding-and-applying-operational-transformation">Understanding and Applying Operational Transformation by Daniel Spiewak</a>. One must read this to understand how Compound Operational Transformation works.</p><h3>Conclusion</h3><p>As I have mentioned earlier, <strong>Operational Transformation</strong> is a very powerful <a href="https://hackernoon.com/tagged/tool">tool</a> that allows building great collaborative apps with support for non-blocking concurrent editing. I would keep updating the blog post with whatever I learn more about OT and other real-time collaborative editing algorithms.</p><p>Quoting from the <a href="https://en.wikipedia.org/wiki/Operational_transformation#Critique_of_OT">Wikipedia’s Page</a>:</p><p>While the classic OT approach of defining operations through their offsets in the text seems to be simple and natural, real-world distributed systems raise serious issues. Namely, those operations propagate with finite speed, states of participants are often different, thus the resulting combinations of states and operations are extremely hard to foresee and understand. As Li and Li put it, “Due to the need to consider complicated case coverage, formal proofs are very complicated and error-prone, even for OT algorithms that only treat two characterwise primitives (insert and delete)”.</p><p>Similarly, Joseph Gentle who is a former <a href="https://hackernoon.com/tagged/google">Google</a> Wave engineer and an author of the Share.JS library wrote, “Unfortunately, implementing OT sucks. There are a million algorithms with different tradeoffs, mostly trapped in academic papers. The algorithms are really hard and time-consuming to implement correctly. […] Wave took 2 years to write and if we rewrote it today, it would take almost as long to write a second time.”</p><p>For OT to work, every single change to the data needs to be captured: “Obtaining a snapshot of the state is usually trivial, but capturing edits is a different matter altogether. […] The richness of modern user interfaces can make this problematic, especially within a browser-based environment.” An alternative to OT is differential synchronization.</p><h3>References</h3><p>I’ve read the following papers and articles to learn about Operational Transformation.</p><ul><li><a href="http://lively-kernel.org/repository/webwerkstatt/projects/Collaboration/paper/Jupiter.pdf">High Latency, Low-Bandwidth Windowing in the Jupiter Collaboration System</a> <em>Authored by David A. Nichols, Pavel Curtis, Michael Dixon, and John Lamping.</em></li><li><a href="http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.53.933&amp;rep=rep1&amp;type=pdf">Operational Transformation in Real-Time Group Editors: Issues, Algorithms, and Achievements</a> <em>Authored by Chengzheng Sun and Clarence (Skip) Ellis.</em></li><li><a href="http://www.waveprotocol.org/whitepapers/operational-transform">Google’s whitepaper on Operational Transformation</a></li><li><a href="https://www.lri.fr/~mbl/ENS/CSCW/2012/papers/Ellis-SIGMOD89.pdf">Concurrency Control in Groupware Systems</a> <em>Authored by C.A. Ellis, S.J. Gibbs</em></li><li><a href="https://hal.archives-ouvertes.fr/file/index/docid/629503/filename/doce63-ahmednacer.pdf">Evaluating CRDTs for Real-time Document Editing</a> <em>Authored by Mehdi Ahmed-Nacer, Claudia-Lavinia Ignat, G´erald Oster, Hyun-Gul Roh, Pascal Urso</em></li><li><a href="https://hal.inria.fr/hal-00957167/document">Merging OT and CRDT Algorithms</a> <em>Authored by Mehdi Ahmed-Nacer, Pascal Urso, Valter Balegas, Nuno Pregui¸ca</em></li><li><a href="https://en.wikipedia.org/wiki/Operational_transformation">Wikipedia on Operational Transformation</a> <em>One of the most informative articles, I have found on wikipedia, suprisingly.</em></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bf8756683f66" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building a real-time collaborative editor using Operational Transformation]]></title>
            <link>https://srijancse.medium.com/how-real-time-collaborative-editing-work-operational-transformation-ac4902d75682?source=rss-b4f4fb954bf4------2</link>
            <guid isPermaLink="false">https://medium.com/p/ac4902d75682</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[algorithms]]></category>
            <category><![CDATA[computer-science]]></category>
            <dc:creator><![CDATA[Srijan]]></dc:creator>
            <pubDate>Mon, 01 May 2017 13:49:40 GMT</pubDate>
            <atom:updated>2023-06-17T07:43:21.908Z</atom:updated>
            <content:encoded><![CDATA[<p>For this summers, I would have the incredible privilege of interning with <a href="http://typeset.io/">Typeset</a>. I am really excited for this opportunity and would be working on implementing collaborative editing using Operational Transformation algorithm on the editor with the tech team. This post will explain a very naive approach to the Operational Transformation algorithm.</p><p>I have read various papers on both the methods of implementing collaborative editing : <strong>Operational Transformation</strong>, which goes back to 1989, when it was first implemented by the <a href="https://www.lri.fr/~mbl/ENS/CSCW/2012/papers/Ellis-SIGMOD89.pdf">GROVE (GRoup Outtie Viewing Editor)</a> system (this algorithm is quite old, and Google uses this algorithm for collaborative editing for Google Docs, Google Slides, Wave, etc) and <strong>Conflict-Free Replicated Data Types</strong>, which is a much newer approach to real-time editing.</p><h3>Real challenge of collaborative editing</h3><p>If you know how real-time collaborative editing works, then you may know that handling concurrent editing in multi user environment gracefully is very challenging. However, a few simple concepts can simplify this problem. The main challenge, as mentioned, with collaborative editing is the concurrency control [<strong>concurrent edits</strong>] to the document are not commutative. This needs to be causally ordered before applying either by undoing history, or by transforming the operations [<strong>operational transformation</strong>] before applying them to make them seem commutative.</p><h3>Bringing Latency into action</h3><p>Introducing latency between the client and server is where the problems arise. Latency in a collaborative editor introduces the possibility of version conflicts. Here, where, I said Operational Transformation will come into action.</p><p>Let’s take an example :</p><p><strong>Starting Client’s state :</strong></p><p>ABCD</p><p><strong>Starting Server’s state :</strong></p><p>ABCD</p><p>Now, let’s say, <em>Client</em> enters X in between C and D , the operation would look something like this :</p><p>insert(X,3) //where 3 is the position where x is going to be added (0=A, 1=B, 2=C ..)</p><p>And at the same time, <em>Server</em> deletes b , the operation would be :</p><p>delete(B,1)</p><p>What actually should happen is that the client and server should both end with ACXD but in reality, <em>client</em> ends with ACXD</p><pre>Starting Document State -&gt; ABCD<br>&quot;Insert &#39;X&#39;&quot; operation at offset 3 [local] -&gt; ABCXD<br>&quot;Delete &#39;B&#39;&quot; operation at offset 1 [remote] -&gt; ACXD</pre><p>but the <em>server</em> ends with acdx.</p><pre>Starting Document State -&gt; ABCD<br>&quot;Delete &#39;B&#39;&quot; operation at offset 1 [local] -&gt; ACD<br>&quot;Insert &#39;X&#39;&quot; operation at offset 3 [remote] -&gt; ACDX</pre><p>Ofcourse, ACXD != ACDX and the document which is shared now is in wrong state.</p><p>Here is where the <strong>Operational Transformation</strong> algorithm comes to the rescue.</p><h3>Operational Transformation Algorithm</h3><p>Operational Transformation (OT) is an algorithm/technique for the transformation of operations such that they can be applied to documents whose states have diverged, bringing them both back to the same state.</p><h4>How does Operational Transformation work?</h4><p>A short overview of how OT works :</p><ul><li>Every change (insertion or deletion) is represented as an <strong>operation</strong>. An operation can be applied to the current document which results into a new document state.</li><li>To handle concurrent operations, we use the <strong>tranform</strong> function that takes two operations that have been applied to the same document state (but on different clients) and computes a new operation that can be applied after the second operation and that preserves the first operation’s intended change.</li></ul><p>Let’s apply Operational Transformation in the original example.</p><p>If we apply OT, <em>Client</em> will see :</p><pre>Starting Document State -&gt; ABCD<br>&quot;Insert &#39;X&#39;&quot; operation at offset 3 [local] -&gt; ABCXD<br>&quot;Delete &#39;B&#39;&quot; operation at offset 1 [transformed] -&gt; ACXD</pre><p>and <em>Server</em> will see :</p><pre>Starting Document State -&gt; ABCD<br>&quot;Delete &#39;B&#39;&quot; operation at offset 1 [local] -&gt; ACD<br>&quot;Insert &#39;X&#39;&quot; operation at offset 2 [transformed] -&gt; ACXD //Transform function would add add it in the new (3 - 1 = 2) position</pre><h3>Client — Server [OT] Approach to Collaborative Editing</h3><p>The <strong>transform</strong> function is used to build a client-server protocol that can handle collaboration between any number of clients.</p><p>Choosing a Client-Server architecture will allow scouting a large number of clients without actually complicating the environment. Also, there will be a single system which holds the source of truth i.e. the server, so even if the clients crash/go offline for a long time, we can go back to the server and fetch the document easily.</p><p>This source of truth also forces the client to wait for the server to <strong>acknowledge</strong> the operation that the client has just sent which would mean that the client always stays on the server’s OT path. This would help in keeping a single history of operations without actually having to keep a mirror of the state for each client that is connected. That would eventually mean the number of clients that are connected to the server would have only one single copy of the document on the server.</p><h3>Conclusion</h3><p><strong>Operational Transformation</strong> is a very powerful tool that allows building great collaborative apps with support for non-blocking concurrent editing. I am looking forward to diving deep into the algorithm (and of course extending this blog post) and possibly working on an editor which supports it as well.</p><p>The second post related to <strong>OT</strong> can be found <a href="https://srijancse.medium.com/operational-transformation-the-real-time-collaborative-editing-algorithm-bf8756683f66">here</a>. In this post, I dug deep into the transformation function, how clients wait for an <strong>acknowledgment</strong> from the server before sending more operations and the compound operational transformation.</p><p>The third post in my series of <strong>OT </strong>can be found <a href="https://srijancse.medium.com/analysing-different-operational-transformation-algorithms-for-collaborative-editing-60fcc49ef24b">here</a>. In this post, I walked through the different OT algorithms that are well defined and implemented.</p><h3>Resources</h3><ul><li><a href="http://lively-kernel.org/repository/webwerkstatt/projects/Collaboration/paper/Jupiter.pdf">High Latency, Low-Bandwidth Windowing in the Jupiter Collaboration System</a> <em>Authored by David A. Nichols, Pavel Curtis, Michael Dixon, and John Lamping.</em></li><li><a href="http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.53.933&amp;rep=rep1&amp;type=pdf">Operational Transformation in Real-Time Group Editors: Issues, Algorithms, and Achievements</a> <em>Authored by Chengzheng Sun and Clarence (Skip) Ellis.</em></li><li><a href="http://www.waveprotocol.org/whitepapers/operational-transform">Google’s whitepaper on Operational Transformation</a></li><li><a href="https://www.lri.fr/~mbl/ENS/CSCW/2012/papers/Ellis-SIGMOD89.pdf">Concurrency Control in Groupware Systems</a> <em>Authored by C.A. Ellis, S.J. Gibbs</em></li><li><a href="https://hal.archives-ouvertes.fr/file/index/docid/629503/filename/doce63-ahmednacer.pdf">Evaluating CRDTs for Real-time Document Editing</a> <em>Authored by Mehdi Ahmed-Nacer, Claudia-Lavinia Ignat, G´erald Oster, Hyun-Gul Roh, Pascal Urso</em></li><li><a href="https://hal.inria.fr/hal-00957167/document">Merging OT and CRDT Algorithms</a> <em>Authored by Mehdi Ahmed-Nacer, Pascal Urso, Valter Balegas, Nuno Preguica</em></li><li><a href="https://en.wikipedia.org/wiki/Operational_transformation">Wikipedia on Operational Transformation</a> <em>One of the most informative articles, I have found on wikipedia, surprisingly.</em></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ac4902d75682" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Start Contributing to Open Source Projects?]]></title>
            <link>https://medium.com/hackernoon/how-to-start-contributing-to-open-source-projects-e3c36ebb54e6?source=rss-b4f4fb954bf4------2</link>
            <guid isPermaLink="false">https://medium.com/p/e3c36ebb54e6</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[github]]></category>
            <category><![CDATA[open-source]]></category>
            <dc:creator><![CDATA[Srijan]]></dc:creator>
            <pubDate>Tue, 18 Apr 2017 05:03:43 GMT</pubDate>
            <atom:updated>2019-05-20T04:27:35.028Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/455/1*PW6lORfJV-kEJ8T8Z5OjIQ.png" /></figure><blockquote>If you’ve ever wanted to contribute to open source projects but don’t know where to begin, here are some tips to get you started.</blockquote><h3>Good understanding of one programming language of your choice</h3><p>Understanding of a programming language is not just knowing the syntax or how recursion works. If you already know that, great! You are past the first hurdle. Next, you need to take up the task of learning the multiple major libraries and packages that are going to be used in any medium to large-scale projects. Look up the relevant libraries of your programming language and devote time to <a href="https://hackernoon.com/tagged/learning">learning</a> them. A good understanding of these will go a long way in helping you understand any code base better.</p><h3>Version Control System</h3><p>Yes, this is where Github comes in. Distributed revision control (DVCS) is one way to do collaborative coding which makes sure that all the code remains secure and concurrent at any given point in time. All, and I mean ALL, organizations/projects use some form of version control. Major ones are SVN and Git. Although now, mostly every organization/project have switched to Git for some of its features, while some might still be using SVN. Github is just a Git client which lets you host your code online. Learning Github is not the same as learning Git. Therefore, first, learn Git — book then, move on and learn how to use Github. For quick reference, you can also use this: Try <a href="http://try.github.io/">Git</a>.</p><h3>Learn to read the Source Code</h3><p>There is no substitute for the ability to read through seemingly gigantic code bases. Let’s face it, most of the documentation for any code can be confusing for anyone. It may be useful for the end user, but for any new developer, it’s may appear gibberish. You are on your own when you need to go through the source code of something which spans hundreds of thousands of lines with hundreds of files.</p><p>Where does one start? Well, it depends. Learn how to use bug or issue trackers which most likely, every organization/project will have it. If you don’t know what a software bug is, now will be a good time to start. Bug trackers are like the version control systems which we talked about earlier. In fact, most version control clients will have an implementation of the bug tracker themselves. Github has an <em>“Issues”</em> system, which is the same thing. A bug tracker, basically, lists all the <em>“issues”</em> (or bugs) currently identified with the software and their <em>“status”</em> (Are they solved? Unsolved? Being worked on?). Bug trackers provide the non-developer end-users with a way to point out a problem in the software. They might also be used to request a new feature, which is different from a bug.</p><h3>Submit Patches</h3><p>Once you’ve learned all of the above (and trust me, it is not much), you are ready to submit some patches or bug fixes to a project of your choice. Choose any open-source project — preferably written in a language you know, and more importantly, interests you — and go and browse through its bug tracker. Most bug trackers have issues marked as volunteer or introductory. Search for such issues, or go with any issue which you think you can fix. Comment or write an update on the issue saying you are taking it up. Solve it on your local system (you’ll know what this is once you know how to use version control) and then push it to the organization’s remote code base. This is easier said than done (let’s be honest). You’ll need to know the following, at the very least:</p><ol><li>What DVCS the project is using.</li><li>What are their workflows for code contribution? (Most organizations/projects have a defined way to submit a patch and you MUST follow that).</li><li>How to get involved with the community.</li></ol><h3>Ask Smart Questions</h3><blockquote>Once you are up and running with contributing to a project, you <strong>WILL</strong> face difficulties.</blockquote><p>You might not know how a particular piece of code is working, or you might not know about the required <a href="https://hackernoon.com/tagged/technology">technology</a>. This is the time for you to ASK. Ask the established developers in that project, or anyone you think who might know the answer, in general. Asking is not a sign of weakness but it will, instead, help see you through a lot of unnecessary struggle. But at the same time, remember, <a href="http://www.catb.org/~esr/faqs/smart-questions.html">How To Ask Questions The Smart Way</a>.</p><p>Read this amazing article by Sahil Dua on <a href="https://hackernoon.com/unconventional-way-of-learning-a-new-programming-language-e4d1f600342c">Unconventional way of learning a new programming language</a>.</p><p>Feel free to ping me on <a href="http://www.twitter.com/srijancse">Twitter</a>, and checkout my experiences at <a href="http://www.srijanagarwal.me/">www.srijanagarwal.me</a>.</p><figure><a href="http://bit.ly/HackernoonFB"><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0hqOaABQ7XGPT-OYNgiUBg.png" /></a></figure><figure><a href="https://goo.gl/k7XYbx"><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Vgw1jkA6hgnvwzTsfMlnpg.png" /></a></figure><figure><a href="https://goo.gl/4ofytp"><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gKBpq1ruUi0FVK2UM_I4tQ.png" /></a></figure><blockquote><a href="http://bit.ly/Hackernoon">Hacker Noon</a> is how hackers start their afternoons. We’re a part of the <a href="http://bit.ly/atAMIatAMI">@AMI</a> family. We are now <a href="http://bit.ly/hackernoonsubmission">accepting submissions</a> and happy to <a href="/service/mailto:partners@amipublications.com">discuss advertising &amp; sponsorship</a> opportunities.</blockquote><blockquote>If you enjoyed this story, we recommend reading our <a href="http://bit.ly/hackernoonlatestt">latest tech stories</a> and <a href="https://hackernoon.com/trending">trending tech stories</a>. Until next time, don’t take the realities of the world for granted!</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*35tCjoPcvq6LbB3I6Wegqw.jpeg" /></figure><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fupscri.be%2Fdde502%3Fas_embed%3Dtrue&amp;dntp=1&amp;url=https%3A%2F%2Fupscri.be%2Fhackernoon%2F&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=upscri" width="800" height="400" frameborder="0" scrolling="no"><a href="https://medium.com/media/3c851dac986ab6dbb2d1aaa91205a8eb/href">https://medium.com/media/3c851dac986ab6dbb2d1aaa91205a8eb/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e3c36ebb54e6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/hackernoon/how-to-start-contributing-to-open-source-projects-e3c36ebb54e6">How to Start Contributing to Open Source Projects?</a> was originally published in <a href="https://medium.com/hackernoon">HackerNoon.com</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What is happiness?]]></title>
            <link>https://srijancse.medium.com/what-is-happiness-f26101784bdf?source=rss-b4f4fb954bf4------2</link>
            <guid isPermaLink="false">https://medium.com/p/f26101784bdf</guid>
            <category><![CDATA[life]]></category>
            <category><![CDATA[self-improvement]]></category>
            <category><![CDATA[happiness]]></category>
            <category><![CDATA[materialistic]]></category>
            <dc:creator><![CDATA[Srijan]]></dc:creator>
            <pubDate>Wed, 07 Sep 2016 15:00:35 GMT</pubDate>
            <atom:updated>2016-09-07T15:00:35.331Z</atom:updated>
            <content:encoded><![CDATA[<p>I never thought about this before, to be honest. Material things do not necessarily bring you happiness. That is a fact of life. We all know that, then why do we get happy by them? ‘If material things bring just a temporary and short-term happiness, then what does that mean?’ Does it mean that we have to buy material objects at a rate of perhaps one per day to sustain the temporary and short-term high of getting something new? The problem is, that begins to sound a lot like a drug habit. This train of thinking got me into some very deep areas. Things like:</p><ul><li><strong>What is happiness?</strong></li><li><strong>What does it mean to be happy?</strong></li><li><strong>What do I want to do in my life?</strong></li><li><strong>Does life have meaning?</strong></li></ul><p>Very deep, isn’t it?</p><p>So, I will write about these, when I get the answers, it could be today, tomorrow or maybe after years. But it’ll be there for sure. :)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f26101784bdf" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>