<?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 Steven Deutsch on Medium]]></title>
        <description><![CDATA[Stories by Steven Deutsch on Medium]]></description>
        <link>https://medium.com/@_SD10_?source=rss-92323c453fea------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*hl4L-6BveykYIuAp.</url>
            <title>Stories by Steven Deutsch on Medium</title>
            <link>https://medium.com/@_SD10_?source=rss-92323c453fea------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 07:30:04 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@_SD10_/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[No Brown M&M’s]]></title>
            <link>https://medium.com/@_SD10_/no-brown-m-ms-41d739bedbf1?source=rss-92323c453fea------2</link>
            <guid isPermaLink="false">https://medium.com/p/41d739bedbf1</guid>
            <category><![CDATA[online-community]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[project-management]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[github]]></category>
            <dc:creator><![CDATA[Steven Deutsch]]></dc:creator>
            <pubDate>Tue, 10 Apr 2018 21:05:47 GMT</pubDate>
            <atom:updated>2018-04-10T21:16:50.069Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/590/1*tk5bvwdyYmLUbI3hbxes-g.jpeg" /></figure><p>The band <a href="https://en.wikipedia.org/wiki/Van_Halen">Van Halen</a> is known in popular culture for their unique request of a <a href="https://en.wikipedia.org/wiki/Van_Halen#Contract_riders">bowl of M&amp;M’s with all the brown ones removed</a> in their contract rider. Should the request be fufilled, it shows that the party honoring the contract read it thoroughly and paid attention to detail. Should a bowl of M&amp;M’s with browns included be present, or worse there be no bowl at all, the band would have reasonable suspicion to suspect that other requests were not fufilled as well.</p><h4>How can we apply this to open source communities?</h4><p>Open source projects commonly have a set of contributing guidelines that they request new contributors review before opening a new issue or pull request.</p><h4>A checklist</h4><p>It’s common to include a checkbox in an issue or pull request template, however, this approach is far from flawless. The problem is — it’s just too easy to mark a checkbox regardless of whether you’ve completed the request or not.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/479/1*RT-3NqQPU5eu9IJX00LjBA.png" /><figcaption>Pull request checklist with Contributing Guidelines item checked</figcaption></figure><h4>A better approach</h4><p>In the <a href="https://github.com/Moya/Moya/blob/master/Contributing.md">contributing guidelines at Moya</a>, we have included a section telling potential contributors that if they have made it this far in the document that they should start off their new issue or pull request with a specific emoji showing us that they have seen this section.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/903/1*Q2RykRgYTvPp3uSVRthm5Q.png" /><figcaption>Message to contributors telling them to use the ✨emoji.</figcaption></figure><h4>Why is this a good practice?</h4><p>Asking users to include a specific emoji in their request is a better indicator of whether they have read our contributing guidelines because it operates under a show, don’t tell philosophy.</p><p>As an open source maintainer, seeing this indicator provides me with an extra bit of confidence that a contributor has taken the time to think throughly about their suggestion. It is also rewarding to see that people take the time to read the documentation that you have put in place and that they are genuinely trying to the best of their ability to have a positive impact on your project.</p><h4>Acknowledgements</h4><p>Thanks to <a href="https://medium.com/u/6c069297d051">@</a>_alloy and the <a href="https://cocoapods.org/">CocoaPods</a> community for the original Twitter thread that inspired me to adopt this practice.</p><h3>Eloy &quot;DurÃ¡n&quot; Durán on Twitter</h3><p>Every time I see a @CocoaPods issue that starts with 🌈 I&#39;m filled with warm joy about people really wanting to make an effort. See https://t.co/W03i4Eoxo6, which I&#39;d advice anyone with contribution guidelines to consider.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=41d739bedbf1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The RAM Model of Computation and Big O Notation]]></title>
            <link>https://medium.com/@_SD10_/the-ram-model-of-computation-and-big-o-notation-a1b3cc50ec2c?source=rss-92323c453fea------2</link>
            <guid isPermaLink="false">https://medium.com/p/a1b3cc50ec2c</guid>
            <category><![CDATA[algorithm-design-manual]]></category>
            <category><![CDATA[complexity]]></category>
            <category><![CDATA[big-o-notation]]></category>
            <category><![CDATA[algorithms]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Steven Deutsch]]></dc:creator>
            <pubDate>Wed, 28 Mar 2018 10:39:55 GMT</pubDate>
            <atom:updated>2018-03-28T10:42:20.737Z</atom:updated>
            <content:encoded><![CDATA[<p>This post is a summary of my notes from the <a href="http://www.algorist.com/">Algorithm Design Manual</a> in section 2.1 The RAM Model of Computation and 2.1 Big O Notation. I had a difficult time grasping these concepts so please correct me if I’m wrong. I am in no way an expert on this topic.</p><h3>The RAM Model of Computation</h3><p>The RAM (Random Access Machine) model of computation measures the run time of an algorithm by summing up the number of steps needed to execute the algorithm on a set of data. The RAM model operates by the following principles:</p><p>• Basic logical or arithmetic operations (+, *, =, if, call) are considered to be simple operations that take one time step.</p><p>• Loops and subroutines are complex operations composed of multiple time steps.</p><p>• All memory access takes exactly one time step.</p><p>This model encapsulates the core functionality of computers but does not mimic them completely. For example, an addition operation and a multiplication operation are both worth a single time step, however, in reality it will take a machine more operations to compute a product versus a sum.</p><p>The reason the RAM model makes these assumptions is because doing so allows a balance between simplicity and completely imitating underlying machine, resulting in a tool that is useful in practice.</p><p>The exact analysis of algorithms is a difficult task. It is the nature of algorithm analysis to be both machine and language independent. For example, if your computer becomes twice as fast after a recent update, the complexity of your algorithm still remains the same.</p><h3>Complexity Bounding Functions</h3><p>There are 3 bounding functions to consider when talking about the complexity of an algorithm, the upper bound, the lower bound, and a tight bound:</p><ul><li>Upper bound: f(n) = O(g(n))</li><li>Lower bound: f(n) = Ω(g(n))</li><li>Tight bound: f(n) = ϴ(g(n))</li></ul><p>These really confused me at first so without getting too caught up in the notation let’s look at the definitions:</p><p>The upper bound, f(n) = ϴ(g(n)), means that for some constant c and value n0, where positive, the product of the two will always lie on or above f(n).</p><p>The lower bound, f(n) = Ω(g(n)), means that for some constant c and value n0, where positive, the product of the two will always lie on or below f(n).</p><p>The tight bound, f(n) = ϴ(g(n)), means that for two constants exist for the value n0, where positive, that represent an upper bound and lower bound.</p><p>This means for an algorithm to be tightly bounded, f(n) = O(g(n)) and f(n) = Ω(g(n)) must both be true.</p><p>A part of these definitions that may be confusing is the value of n0. This represents a certain threshold of n to which our model applies past this point. It’s okay if the definition does not hold true before a relatively small input. We are only concerned with the analysis of large data sets.</p><p>Let’s look at applying the upper bound to an example:</p><p>3n³-100 = O(n³)</p><p>Is the statement above true? Does a constant exist such that it multiplied by the right side of the equation will always be greater than or equal to the left side? Rather, what value times n³ is always greater than 3n³-100?</p><p>In this case, that value would be any value greater than 3. So this statement holds true and 3 is our threshold.</p><h3>Worst Case Scenario</h3><p>In algorithm analysis, we generally tend to focus on the worst case scenario. This is why we always hear about the notorious “Big O” notation, which is the upper bound of an algorithm.</p><h4>Why focus on the worst case?</h4><p>Exact analysis is hard so it is easier to think of things in the extremes. The worst case complexity is often the most easily calculated and the most informative. Calculating average complexity is difficult because you are required to know all situations you will encounter. Calculating the best complexity can be difficult as it requires you to define “best” and not to mention is probably unlikely in practice.</p><p>For more information I would pick up a copy of the <a href="http://www.algorist.com/">Algorithm Design Manual </a>and check out the lecture on this chapter here:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2Fvideoseries%3Flist%3DPLdWP0vILtbJm65uofYypM_lxU9A2Ey7ow&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DgSyDMtdPNpU&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FgSyDMtdPNpU%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/4e5c0b5caefa10fffea4c54f46d94554/href">https://medium.com/media/4e5c0b5caefa10fffea4c54f46d94554/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a1b3cc50ec2c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Tree Data Structure in Swift]]></title>
            <link>https://medium.com/@_SD10_/tree-data-structure-in-swift-80b6f2c8977f?source=rss-92323c453fea------2</link>
            <guid isPermaLink="false">https://medium.com/p/80b6f2c8977f</guid>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[trees]]></category>
            <category><![CDATA[data-structures]]></category>
            <category><![CDATA[swift]]></category>
            <dc:creator><![CDATA[Steven Deutsch]]></dc:creator>
            <pubDate>Sat, 10 Mar 2018 22:21:45 GMT</pubDate>
            <atom:updated>2018-03-10T22:59:37.858Z</atom:updated>
            <content:encoded><![CDATA[<p>If you’re unfamiliar with the world of data structures and algorithms, a great starting point is the tree data structure. In fact, if you’ve ever used JSON you’re already familiar with the concept.</p><h3>What is a Tree?</h3><p>A tree is a data structure that is useful modeling the hierarchical relationship between objects. The tree is formed of nodes and each node has the following composition:</p><ol><li>A value.</li><li>An optional parent node.</li><li>A list of child nodes.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1006/1*aNeybB6BRykjAzKRDkoJHg.png" /><figcaption>Visual of a Tree data structure</figcaption></figure><h4>Terminology</h4><p>While all objects within a tree are considered nodes, they have different naming conventions depending on the surrounding context.</p><ul><li><strong>Root Node</strong>: This is the node at the highest level of the tree and it is the only node without any parent.</li><li><strong>Leaf Node</strong>: This is a node that does not contain any child nodes.</li></ul><h3>Modeling this in Swift</h3><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b527e8c80e58287d640f982161c08c66/href">https://medium.com/media/b527e8c80e58287d640f982161c08c66/href</a></iframe><p>Some things to note here are that:</p><h4>1. The Node class is generic over the value that it holds.</h4><p>This is not necessary, however, it lends to code reuse by allowing you to build a variety of trees that hold different data types, in the same fashion as arrays.</p><h4>2. We have marked the property holding the parent node as <strong>weak.</strong></h4><p>Since the parent node holds a reference to all its children, and the children hold a reference to their parent, we mark the parent reference as <strong>weak</strong> to prevent creating a <a href="https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/AutomaticReferenceCounting.html#//apple_ref/doc/uid/TP40014097-CH20-ID52">strong reference cycle</a>.</p><h4>3. We have marked the parent and children properties as read only.</h4><p>This is because modifying these values directly can be error prone. It is better to expose a safe API through methods on the Node class. You can see that by using the <strong>addChild</strong> method on Node, we will never forget to set the parent on the newly added node.</p><h3>Where next?</h3><p>Trees and recursion are like bread and butter. You can try to:</p><p>1. Create a method that finds the first node in a tree containing a given value.</p><p>2. Print out a textual representation of a node and all its children.</p><p>Check out this more in depth example of a Tree at the <a href="https://github.com/raywenderlich/swift-algorithm-club/tree/master/Tree">Swift Algorithm Club</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=80b6f2c8977f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Scaling and Managing Open Source Communities]]></title>
            <link>https://medium.com/@_SD10_/scaling-and-managing-open-source-communities-e9761b691e39?source=rss-92323c453fea------2</link>
            <guid isPermaLink="false">https://medium.com/p/e9761b691e39</guid>
            <category><![CDATA[project-management]]></category>
            <category><![CDATA[github]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[swift]]></category>
            <dc:creator><![CDATA[Steven Deutsch]]></dc:creator>
            <pubDate>Tue, 30 Jan 2018 00:32:16 GMT</pubDate>
            <atom:updated>2018-01-30T00:32:16.525Z</atom:updated>
            <content:encoded><![CDATA[<p>I’ve been contributing to the open source iOS community for about a year now and have worked on projects such as <a href="https://github.com/MessageKit/MessageKit"><strong>MessageKit</strong></a>, <a href="https://github.com/Moya/Moya"><strong>Moya</strong></a>,<strong> </strong><a href="https://github.com/SwifterSwift/SwifterSwift"><strong>SwifterSwift</strong></a>, and <a href="https://github.com/IBAnimatable/IBAnimatable"><strong>IBAnimatable</strong></a>. These projects undoubtedly made me a better iOS developer, but the project with the most significant impact has been Moya — in the way that it manages its community.</p><p>If you’re going to build a fairly large, long lasting, and widely used open source project you’re going to need a few extra hands. <strong>The amount of work accumulated through maintaining example documentation, managerial documents, and responding to GitHub issues can be more time consuming than maintaining the actual code base. </strong>This is especially true for mature projects as the code base changes less frequently.<strong> </strong>I’d like to discuss the lessons I’ve learned from Moya in order to build a large community around a project in an effort to maintain it.</p><h3>Have Compassion</h3><p>Contributing to open source can be scary — especially for first-time contributors. People are often hesitant to make contributions for fear of being criticized or looking uninformed. It should go without saying that you should never belittle any contribution or an attempt to make a contribution. One of the first documents your project should adopt is a code of conduct. Moya adheres to the C<a href="https://www.contributor-covenant.org/version/1/3/0/code-of-conduct.html">ontributor Covenant code of conduct</a>.</p><p>If a potential contributor is struggling to make a contribution, do whatever is necessary to aid them in its completion, whether it be <a href="https://github.com/Moya/Moya/pull/1523#issuecomment-355138063">guiding them through the pull request process</a> or writing them a backing unit test for their patch. It’s important that every project has a contributing guidelines document that discusses the project’s <a href="https://github.com/Moya/Moya/blob/master/Contributing.md#development-process">development process</a> and its <a href="https://github.com/Moya/Moya/blob/master/Contributing.md#our-expectations-on-you-as-a-contributor">expectations of contributors</a>. This ensures that new contributors <a href="https://github.com/Moya/Moya/blob/master/Contributing.md#how-can-we-help-you-get-comfortable-contributing">feel comfortable</a> and makes contributing as easy as possible. You should always be flattered that someone cares enough to help improve your project. You never know, that contributor could end up making some of the most significant contributions to your project in the future.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/740/1*V_w1PzIgmRkwOaHtA8Xo_A.png" /><figcaption>Example of a healthy <a href="https://help.github.com/articles/about-community-profiles-for-public-repositories/">GitHub community profile</a></figcaption></figure><h3>Provide a Sense of Ownership</h3><p>The vast majority of open source projects are powered by donated time. It’s important that people feel a sense of ownership in what they help build. I’ve learned that a few ways to do this are:</p><h4><strong>Host your project in an organization.</strong></h4><p>If your project starts to increasingly attract recognition from the rest of the community, you should highly consider moving ownership to an organization. This allows you to form a community around the project and for its members to display the organization badge on their GitHub profiles.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/209/1*xnLYzWF9VKrxR6J-CjiY3g.png" /></figure><h4>Invite users to join your project after their first merged pull request.</h4><p>Moya has adopted this policy and it has worked wonders. At this time, the organization has 126 members all with write access to the project. It sounds crazy, but we lock the master branch, require passing status checks, and code review. There hasn’t been a single issue. Moya has even gone so far as to develop a tool called <a href="https://github.com/Moya/Aeryn">Aeryn</a> to automate the invite process. You can see a list of <a href="https://github.com/Moya/Aeryn/blob/master/Orgs%20Using%20Aeryn.md">other organizations who have adopted Aeryn here.</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/770/1*uddczFjLItLBtXDvkqy3CQ.png" /><figcaption>Automated response notifying the user of their invite to the organization using Aeryn.</figcaption></figure><h4>Do not adopt project prefixes using your own name.</h4><p>Building a successful project is a team effort. You should avoid using project prefixes that reference your own name or adopting any other sort of personal branding. It alludes to you being the sole owner of the project and diminishes the value of other contributors. Personally, I won’t touch a project with this naming convention.</p><h4>Reward top contributors by acknowledging them as a core team.</h4><p>All contributors are valuable but it would be wrong to not recognize those who are especially dedicated to the maintenance and long-term health of the project. This can be as simple as creating a core team within the GitHub organization or by collecting contributor’s names in a formal document. While every project has different requirements, you can see<a href="https://github.com/Moya/contributors/blob/master/Core%20Team.md"> how Moya determines core team members and their responsibilities</a> as a reference.</p><h3>Distribute Responsibility</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/279/1*JQdjTdAW5_LolEQ_Iupczw.png" /><figcaption>10 maintainers of the Moya CocoaPod</figcaption></figure><blockquote>According to <a href="https://twitter.com/ashfurrow">Ash Furrow</a>: … <a href="https://ashfurrow.com/blog/stepping-back-from-moya/">open source maintainers should distribute their power and responsibilities as early as possible. Because the fact is, eventually you <em>will </em>be ready to move on to your next project. Your goal as a maintainer really should be to create a project that can outlive your interest in it.</a></blockquote><p>Being a control freak, this was difficult for me. However, while developing MessageKit I truly learned the importance of this. Recently, I had been so burned out from actively working on the project that I stopped contributing for nearly a month. Before my absence, I had distributed the power to make new releases to the top two contributors and returned to find that they had fixed several bugs, shipped new features, and even made a major release.</p><h3>Vision</h3><p>It’s important to outline the goals of your project in a <a href="https://github.com/Moya/Moya/blob/master/Vision.md">formal document</a>. This helps contributors understand what is and isn’t in scope. This is especially important for the progression of young projects as indecisiveness can cause development to grow stale quickly. While the distribution of power is important, ultimately someone has to be the determining factor.</p><h3>Open Discussion</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/986/1*ZpDlSYFfCUh5IuACXkSeZA.png" /></figure><p>This is an area where Moya particularly excels. All discussion related to the development of the code base, project management, and questions are done in public through GitHub issues. If discussion occurs outside of GitHub, a formal write up of what was discussed often follows. This encourages people to get involved in the conversation, whether they are current contributors or aspiring to be. Most importantly, open discussion is self-documenting. You will not only build up a large repertoire of answered questions but also a record of certain design decisions to aid the future maintainers.</p><h3>Automation</h3><p>Considering the massive amount of time required to manage an open source project, it is important to shave as much time off your workflow as possible. At Moya, we use <a href="https://github.com/danger/danger">danger</a> to formalize and automate the code review done on pull requests.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/770/1*7dym0yJRpSmgFE8LmKCLiQ.png" /><figcaption>Automated response triggered from running <a href="https://github.com/danger">Danger</a> on a pull request</figcaption></figure><p>We have several checks that warn against missing changelog entries, keeping documentation current, and even propagating SwiftLint issues. This helps standardize our workflow and ensure that we continue to ship high-quality changes. You can see every check that is considered inside of <a href="https://github.com/Moya/Moya/blob/master/Dangerfile">Moya’s dangerfile</a>.</p><h3>Finally</h3><p>If you’re interested in more on this subject I would check out <a href="https://ashfurrow.com/blog/">Ash Furrow’s blog</a> post on <a href="https://ashfurrow.com/blog/building-online-communities/">building online communities</a> or his talk on <a href="https://ashfurrow.com/blog/building-compassionate-software/">building compassionate software</a>. The values I discuss in this article I learned from him. You also may want to consider checking out <a href="https://krausefx.com/">Felix Krause’s</a> blog post on <a href="https://krausefx.com/blog/scaling-open-source-communities">scaling open source communities</a>. If you need advice on growing an open source community of your own, all this information can be found at the <a href="https://github.com/Moya/contributors">Moya contributors repo</a>, and don’t hesitate to reach out to me on <a href="https://twitter.com/_SD10_">Twitter</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e9761b691e39" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>