<?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 Aurum Linh on Medium]]></title>
        <description><![CDATA[Stories by Aurum Linh on Medium]]></description>
        <link>https://medium.com/@aurum-linh?source=rss-9ea8634ee552------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*hq7TmQ2uyhQ8goRYFzOdOg.png</url>
            <title>Stories by Aurum Linh on Medium</title>
            <link>https://medium.com/@aurum-linh?source=rss-9ea8634ee552------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 22:47:13 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@aurum-linh/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[How Machines Make Decisions Is A Human Rights Issue]]></title>
            <link>https://aurum-linh.medium.com/how-machines-make-decisions-is-a-human-rights-issue-80f5ada8d377?source=rss-9ea8634ee552------2</link>
            <guid isPermaLink="false">https://medium.com/p/80f5ada8d377</guid>
            <category><![CDATA[litigation]]></category>
            <category><![CDATA[human-rights]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[digital-rights]]></category>
            <dc:creator><![CDATA[Aurum Linh]]></dc:creator>
            <pubDate>Mon, 18 Jan 2021 18:27:27 GMT</pubDate>
            <atom:updated>2021-01-18T18:27:27.579Z</atom:updated>
            <content:encoded><![CDATA[<p><em>We launched a project at the intersection of machine learning and human rights. </em><a href="https://www.atlaslab.org/"><em>Atlas Lab</em></a><em> is a platform that helps legal professionals better understand how machine learning and algorithmic decision making are intersecting with human rights. Here’s why you should care.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*P2LNVTi-Vwgmss4kSNr_aw.png" /></figure><p>Technology is not just an industry; it is a tool that has transformed every industry. What does that <em>actually</em> mean for our relationship to technology<em>, </em>as the people who are building it<em>?</em></p><p>Let’s take a step back. All tools get their meaning from the context in which they are used. If you’re building a house, a hammer is essential. It is not easy to imagine building a house without one. However, suppose your goal is to cut a mirror into a circular shape. In that case, a hammer is not only useless, but it has destructive consequences.</p><p>Of course, a hammer is an oversimplified analogy. It doesn’t get to the real power that technology holds. The potential damage that a hammer could do is limited by its power, scale, and use. Applying this understanding back to tech, let’s now ask the question: what is the context in which all technologies exist?</p><p><strong>Technology exists in a social and political context from which it cannot be meaningfully separated.</strong></p><p>People outside of the technology bubble have this completely wrong assumption that machine decision-making is this higher intelligence free from biases. Yet, the reality is that <strong>biased people do not make neutral technology. </strong>Systems of oppression, and the anti-Blackness, racism, and colonialism that fuel it, do not go away when technologies are being designed, developed, and deployed.</p><p>Humanity’s relationship to free will began with carrying out a divine entity’s will to a shift, where many humans found power in making their own decisions. Another shift is happening today — this time to algorithms.</p><p>This shift from human to machine decision-making was an attractive idea at first. However, we have seen time and time again that machine-decision making is not neutral and is inherently biased.</p><p><strong>Law has not been able to keep pace with the rapid growth of technology.</strong> Lawmakers struggle to grasp how machine learning technology works and which problems need to be addressed. Inaction does not reflect a lack of will, so much as a lack of sharing knowledge between industries.</p><p><strong>How machines make decisions is a human rights issue. </strong>For this reason, we are launching Atlas Lab — an effort to help close this knowledge gap by educating and connecting lawyers working on the front lines of AI and human rights litigation.</p><p>As part of closing this knowledge gap, <a href="https://www.atlaslab.org/">Atlas Lab</a> has resources for technologists as well. We feature explainer articles on the litigation process, human rights law, and a small collection of summaries of court decisions at the intersection of these two worlds.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1004/1*R6ifjiy3E_KtJOEDEmOsiw.png" /></figure><p>In the coming months, outside the activities of DFF and Mozilla, I’ll be organizing an <a href="https://www.atlaslab.org/event-details/algorithmic-injustice-event-series">event series</a> focused on the stories of those who have been affected by algorithmic decision-making in the coming months. The series will revolve around the criminal justice system, immigration agencies, and child welfare services. To stay updated, <a href="https://www.atlaslab.org/event-details/algorithmic-injustice-event-series">RSVP</a> for the event series on Atlas Lab and follow along on <a href="http://twitter.com/atlaslabhq">Twitter</a> and <a href="http://linkedin.com/company/atlas-lab-hq">LinkedIn</a>! Please contact me at aurum@atlaslab.org if you notice anything incorrect or missing from our explanations.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=80f5ada8d377" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Binary Search Algorithms explained using security camera footage]]></title>
            <link>https://medium.com/free-code-camp/binary-search-algorithm-7170ae244438?source=rss-9ea8634ee552------2</link>
            <guid isPermaLink="false">https://medium.com/p/7170ae244438</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[tech]]></category>
            <category><![CDATA[algorithms]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[technology]]></category>
            <dc:creator><![CDATA[Aurum Linh]]></dc:creator>
            <pubDate>Sat, 17 Feb 2018 19:22:09 GMT</pubDate>
            <atom:updated>2025-08-20T12:49:16.461Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gjDukf9SgTpJOq2tFe9Iyw.jpeg" /></figure><blockquote>Binary search, also known as half-interval search or logarithmic search, is a search algorithm that finds the position of a target value within a sorted array.</blockquote><h3>Context</h3><p>I used to live in a building that had a communal kitchen for over 100 students. As you might imagine, there were almost always dishes that weren’t washed in the sink. A group at my school pitched the idea to put up a camera to see who left them behind.</p><p>To illustrate my point, let’s say you found dirty dishes at 12 pm, and you hadn’t been in the kitchen for a full 24 hours.</p><p>Think about the way that you would search for the person who left the dishes. Would you watch all 24 hours of footage, from the beginning, until you found the moment someone left the dish in the sink?</p><p>Probably not. Most likely you’d be hopping around the footage, checking to see if the dishes were in the sink, say, 12 hours ago — at 12 am. If they were, then you’d know that it happened before 12 am. You might flip back to 10 pm after that. If the dishes <em>aren’t</em> there, you’ve now narrowed down the time frame from 10 pm to 12 am — in other words, you’ve ruled out any time before 10 pm. You’d continue this process until you found the footage you were looking for.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/655/1*mwZ01_RIo9GtID5vC4grxA.gif" /><figcaption>Binary search for the moment the orange cup is put into the sink (Youtube video used)</figcaption></figure><p>What would have taken you up to 24 hours, if you had watched the footage in its entirety, now only takes a few seconds.</p><p>Whether you knew it or not, the specific process we just went through is a binary search! A binary search is a <em>very specific</em> way of hopping back and forth in the footage.</p><p>Namely, the footage is split at its midpoint to check for the dishes each time. Notice how the distance to the midpoint gets exponentially smaller with each click.</p><p>Binary searches are used to find elements quickly and efficiently. The catch, though, is that <strong>binary searches only work when the structure you’re looking through is <em>sorted</em></strong>.</p><p>In the camera example, what is the footage sorted by? What are we looking for within that sorted arrangement?</p><p>In this case, the data we are searching is sorted by time. Time allows for a linear measurement. Therefore, it allows us to perform a binary search to find someone who doesn’t wash their dishes within a matter of seconds.</p><p>We also need something that we’re looking for. In this case, it’s the presence of unwashed dishes in the communal sink.</p><h3>Binary Search Algorithm</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*JZFB7cGIwHg7ThIIYShUow.png" /></figure><p>While programming, a binary search can be used in a multitude of contexts. It’s an <em>extremely</em> quick way to find elements within a sorted structure.</p><p>Binary searches can be implemented in an iterative or recursive fashion. An iterative implementation uses a while loop. Meanwhile, a recursive implementation will call itself from within its own body.</p><p>In code, I’ll be performing a binary search on a relatively simple, sorted set of data to highlight the core implementation of a binary search.</p><p>Given an array of sorted numbers, return True if 53 is an element.</p><pre>[0, 3, 4, 5, 6, 15, 18, 22, 25, 27, 31, 33, 34, 35, 37, 42, 53, 60]</pre><h4>Iterative</h4><p>In the iterative approach, a while loop runs until the range of possibilities is zero. This is done by changing the upper and lower bounds of where we are looking and calculating the middle index <em>of that range.</em></p><p>The range exists between the lower and upper bounds, inclusive of the bounds themselves.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*JZFB7cGIwHg7ThIIYShUow.png" /></figure><p>Before the while loop begins, the lower bound is zero and the upper bound is the length of the array. The upper bound changes if the number we’re looking for is in the first half of the range. The lower bound changes if the number we’re looking for is in the second half of the range.</p><p>If the while loop finishes, meaning there is a range of length zero, return False.</p><pre>def binarySearch(array, number):<br>   lowerBound = 0<br>   upperBound = len(array)</pre><pre>while lowerBound &lt; upperBound:<br>        middleIndex = int(math.floor(lowerBound + (upperBound —    lowerBound) / 2))<br>        if array[middleIndex] == number:<br>             return True<br>        elif array[middleIndex] &lt; number:<br>             lowerBound += 1<br>        elif array[middleIndex] &gt; number:<br>             upperBound = middleIndex<br>   return False</pre><p>I’d like to elaborate on this equation:</p><p>int(math.floor(lowerBound + (upperBound — lowerBound) / 2))</p><p>The <em>length</em> of the<em> </em><strong>range</strong> is calculated by subtracting the lower bound from the upper bound. However, knowing how long the range is isn’t enough.</p><p>At this point, we don’t know which indexes to check in the array. So we are shifting up the array by the lower bound.</p><p>We then divide that by two, and round down, to get the middle index of the range. math.floor returns a float, so we also have to cast the result to an int.</p><h4>Recursive</h4><p>In the recursive approach, the function will call itself from within its body.</p><p>The upper bound in this function is the length of the array passed in. Again, the upper bound changes if the number we’re looking for is in the first half of the array. The lower bound changes if the number we’re looking for is in the second half of the array.</p><pre>def binarySearch(array, number):<br>    middleIndexOfArray = int(math.floor(len(array) / 2))<br>    if middleIndexOfArray == 0:<br>        return False</pre><pre>if array[middleIndexOfArray] == number:<br>        return True<br>   elif array[middleIndexOfArray] &gt; number:<br>        return binarySearch(array[:middleIndexOfArray], number)<br>   elif array[middleIndexOfArray] &lt; number:<br>        return binarySearch(array[middleIndexOfArray:], number)</pre><p>The function then calls itself, passing in an argument of an array half the length of the array that was its argument.</p><p>If there are zero elements in the array, return False.</p><p>The code is available on my <a href="https://github.com/juliascript/Algorithms-and-Data-Structures">Algorithms and Data Structures</a> repo — star it to stay updated!</p><h3>Next Steps</h3><p>I wrote my first binary search to implement a stochastic sampling algorithm. It generates a sentence based on the frequency of words in a corpus of text.</p><p>Feel free to try and build a similar project, which has quite a bit of prep before you can implement the binary search. Or think of your own projects and share them in the comments!</p><p>This is the second post of my algorithm and data structures series. In each post, I’ll present a problem that can be better solved with an algorithm or data structure to illustrate the algorithm/data structure itself.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7170ae244438" width="1" height="1" alt=""><hr><p><a href="https://medium.com/free-code-camp/binary-search-algorithm-7170ae244438">Binary Search Algorithms explained using security camera footage</a> was originally published in <a href="https://medium.com/free-code-camp">We’ve moved to freeCodeCamp.org/news</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Guide To Organizing Your iOS Debug, Development, and Release States With .xcconfig Files]]></title>
            <link>https://medium.com/hackernoon/a-cleaner-way-to-organize-your-ios-debug-development-and-release-distributions-6b5eb6a48356?source=rss-9ea8634ee552------2</link>
            <guid isPermaLink="false">https://medium.com/p/6b5eb6a48356</guid>
            <category><![CDATA[swift-3]]></category>
            <category><![CDATA[xcode]]></category>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[configuration-management]]></category>
            <category><![CDATA[ios]]></category>
            <dc:creator><![CDATA[Aurum Linh]]></dc:creator>
            <pubDate>Wed, 26 Apr 2017 02:24:51 GMT</pubDate>
            <atom:updated>2022-04-26T23:03:04.394Z</atom:updated>
            <content:encoded><![CDATA[<h4>Storing API Keys and Other Constants in Swift 3</h4><h4>Introduction</h4><p>After your app is on the App Store, you’ll have at least two states of your app to maintain: the app as it is on the App Store, and the app that you actively add features to in <a href="https://hackernoon.com/tagged/development">development</a>.</p><p>If you have a server running in the backend, you’ll definitely have a server for production and a server for active development. On the <a href="https://hackernoon.com/tagged/ios">iOS</a> development side, we need some way of organizing our code base to prevent crashing the production version of the app.</p><p>A Constants file or the info.plist file is commonly used to store variables which not only contain sensitive data, but might also change depending on the state of your app—like server URLs and API keys.</p><p>This is a guide to setting up different configurations of your app through schemes for different states of the app: Debug, Development, and Release — and specifying our configurations in the Project Settings.</p><h4>How To Add .xcconfig Files To Your XCode Project</h4><p>You can download the starter project <a href="https://github.com/juliascript/xcconfigTutorial/commit/053528c6ce8df9a50fdbf575bbaaae8fe1b9caf0">here</a> if you aren’t using Cocoapods, and <a href="https://github.com/juliascript/xcconfigTutorial-withCocoapods/commit/f58e5821dee2c8101d9ae6bea36159c8eae8cbe4">here</a> if you are.</p><ol><li>Create a new folder in your XCode project — I called mine Config. I’m adding three .xcconfig files: Development, Debug, and Release.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8ySRLJSWxiOgpD66v5qO2w.gif" /></figure><p>2. Add your configuration files to your project settings. You’ll most likely have to create an extra Configuration for Development.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ygltVONee2xF0kFN5KdgJg.gif" /></figure><p><strong>If you’re not using Cocoapods, you can skip to #3.</strong> If you are using Cocopods, you’ll have to delete the .xcworkspace file, the Podfile.lock, and the Pods/ directory. <strong>Do not delete the Podfile.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/770/1*r1K_afOho2oIRAiHR7UA8Q.gif" /></figure><p>Then, go to your terminal. Make sure that you’re in the project directory and run pod install.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/801/1*2ncXxex_CCdIMO_jeY_6gQ.gif" /></figure><p>Now, open the newly generated .xcworkspace file and add the .xcconfig path for Cocoapods in your own .xcconfig file.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_gLew7Ld1vVDndvZECJ2HQ.gif" /></figure><p>3. Add new schemes to your project and make sure your target is your XCode project name. Set up your scheme to correspond to your configuration.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qLfx6po0mwq-H-I-pbnXdA.gif" /></figure><p>4. Now you can set variables in your config files and access them via your info.plist file.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j694dflULmyKt9h1jvGsmQ.gif" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3LFvVdWkpnX-r1TeRLLaCA.gif" /></figure><h4>Warnings and Common Pitfalls</h4><ul><li>Beware of putting a string as a value for a key within a .xcconfig file — it automatically stringifies any value.</li><li>In these examples, I pushed my .xcconfig files to my repo so you can download and run the project. In a real working environment, you should put these files in your .gitignore — and then have a private repository to keep up with updates in the config files.</li></ul><p>You can find the working code <a href="https://github.com/juliascript/xcconfigTutorial">here</a> if you weren’t using Cocoapods, and <a href="https://github.com/juliascript/xcconfigTutorial-withCocoapods">here</a> if you were. Please let me know if you have any questions!</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=6b5eb6a48356" width="1" height="1" alt=""><hr><p><a href="https://medium.com/hackernoon/a-cleaner-way-to-organize-your-ios-debug-development-and-release-distributions-6b5eb6a48356">Guide To Organizing Your iOS Debug, Development, and Release States With .xcconfig Files</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[Guide to Handling Internet Archive’s CDX Server API Response]]></title>
            <link>https://medium.com/hackernoon/guide-to-handling-internet-archives-cdx-server-api-response-c469df5b81f4?source=rss-9ea8634ee552------2</link>
            <guid isPermaLink="false">https://medium.com/p/c469df5b81f4</guid>
            <category><![CDATA[cdx-server-api]]></category>
            <category><![CDATA[archive]]></category>
            <category><![CDATA[digital-archives]]></category>
            <category><![CDATA[internet-archive]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Aurum Linh]]></dc:creator>
            <pubDate>Mon, 24 Apr 2017 00:11:51 GMT</pubDate>
            <atom:updated>2019-05-16T07:40:14.599Z</atom:updated>
            <content:encoded><![CDATA[<h4>Accessing a digital archive of web pages</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lOtv6SSmqX-ZmtRgNFmb1w.jpeg" /><figcaption>Photo credit: <a href="http://www.adra.com/uk/products/balancer-balance-sheet-reconciliation-software/digital-archive/">Adra</a></figcaption></figure><p>For those who don’t know already, the <a href="https://archive.org/web/web.php">Wayback Machine</a> is a comprehensive digital <a href="https://hackernoon.com/tagged/archive">archive</a> of web pages on the Internet — having already collected more than 286 billion web pages since 2001.</p><p>Wayback uses the <a href="https://github.com/internetarchive/wayback/blob/master/wayback-cdx-server/README.md">CDX Server API</a> to lookup captures — it allows for complex querying, filtering and analysis of Wayback capture data. I recently used this API to visualize a website over time using d3’s radial treemap. You can see the result <a href="http://juliageist.com/internet-archive-website-visualization/">here</a>.</p><p>Since the most difficult part of my project was figuring out how to turn the response of the CDX API into an HTML page that I could crawl, this article is a guide to making a request to and handling the response from the <a href="https://hackernoon.com/tagged/api">API</a>.</p><h4>Making the Request</h4><p>Making the request is simply a GET request to <a href="http://web.archive.org/cdx/search/cdx.">http://web.archive.org/cdx/search/cdx.</a> A website is specified via a query string — and it’s the only required query string argument. (To see what other query strings can be specified, <a href="https://github.com/internetarchive/wayback/blob/master/wayback-cdx-server/README.md">check the docs</a>).</p><p>To get all archived versions, or captures, of reddit.com, you would make a GET request to <a href="http://web.archive.org/cdx/search/cdx?url=reddit.com.">http://web.archive.org/cdx/search/cdx?url=reddit.com.</a></p><p>Sweet! Let’s revisit the objective — get all the captures of a web page from the CDX API so I can send my crawler through the archived HTML. Okay, what to do from here?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/850/1*v0V4eBVBgLZiFVx_ZjeK-Q.png" /><figcaption>Ummmmmm…</figcaption></figure><h4>Handling the Response</h4><p>The Content-Type of the response is text/plain— so we’ll do the parsing ourselves. As it says in the <a href="https://github.com/internetarchive/wayback/blob/master/wayback-cdx-server/README.md">documentation</a>, the columns, split by spaces, correspond to the following, in order: urlkey, timestamp, original url, mimetype, status code, digest, and length.</p><p>I created a data model object to represent one capture.</p><pre>// snapshot.py</pre><pre>class Snapshot(dict):<br>   def __init__(self, urlkey=None, timestamp=None, original=None, mimetype=None, statuscode=None, digest=None, length=None):<br>       super(Snapshot, self).__init__()<br>       self[‘urlkey’] = urlkey<br>       self[‘timestamp’] = timestamp<br>       self[‘original’] = original<br>       self[‘mimetype’] = mimetype<br>       self[‘statuscode’] = statuscode<br>       self[‘digest’] = digest<br>       self[‘length’] = length<br>       self[‘snapshot_url’] = ‘http://web.archive.org/web/%s/%s/’ % (timestamp, original)</pre><p>All I’m doing is setting keys on a dictionary object. Notice that I added a key that wasn’t provided in the CDX response to my Snapshot model — snapshot_url.</p><p>The HTML page for any given capture lives at a URL that is formatted from the timestamp and original URL of the capture. The format is http://web.archive.org/web/&lt;/TIMESTAMP&gt;/&lt;/URL&gt;.</p><p>If you would prefer to get the original page back (without the Wayback Machine rewriting URLs on the page to point into the Archive), you should use this formatting: http://web.archive.org/web/&lt;/TIMESTAMP&gt;id_/&lt;/URL&gt;.</p><p>Sweet! Now that we have the data model (namely, the Snapshot class) set up, we can make the request to the CDX API and create instances of the Snapshot class with the response.</p><p>Since we get back a text file, we’ll first split by \n, or new line, to get a list of capture strings. For each capture, we’ll split by a space(‘ ’) to get the individual columns returned in a list format. After this is done, we’ll have a list of lists, representing the captures returned from the API.</p><pre>// reddit.py</pre><pre>from snapshot import Snapshot<br>import requests as req</pre><pre>res = req.get(“http://web.archive.org/cdx/search/cdx?url=reddit.com&quot;)</pre><pre>snapshots = res.text.split(‘\n’)</pre><pre>for snapshot in snapshots:<br>    snapshot_items = snapshot.split(‘ ‘)</pre><p>Next, we’ll instantiate a new Snapshot object for each snapshot returned by the API.</p><pre>// reddit.py</pre><pre>from snapshot import Snapshot<br>import requests as req</pre><pre>res = req.get(&quot;http://web.archive.org/cdx/search/cdx?url=reddit.com&quot;)</pre><pre>snapshots = res.text.split(&#39;\n&#39;)<br>snapshot_list = []</pre><pre>for snapshot in snapshots:<br>    snapshot_items = snapshot.split(&#39; &#39;)<br>    if len(snapshot_items) == 7:<br>        snap = Snapshot(snapshot_items[0], snapshot_items[1], snapshot_items[2], snapshot_items[3], snapshot_items[4], snapshot_items[5], snapshot_items[6])<br>    snapshot_list.append(snap)</pre><p>Now the snapshot_list variable contains Snapshot objects that you can use! Make sure you check that statuscode == 200 before making the request to that specific snapshot_url.</p><p>I hope this article helped! Let me know if you have any questions!</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=c469df5b81f4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/hackernoon/guide-to-handling-internet-archives-cdx-server-api-response-c469df5b81f4">Guide to Handling Internet Archive’s CDX Server API Response</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[iOS Design Patterns: MVC (Model View Controller)]]></title>
            <link>https://medium.com/series/model-view-controller-mvc-92eedbec1da8?source=rss-9ea8634ee552------2</link>
            <guid isPermaLink="false">https://medium.com/p/92eedbec1da8</guid>
            <dc:creator><![CDATA[Aurum Linh]]></dc:creator>
            <pubDate>Fri, 03 Mar 2017 20:05:28 GMT</pubDate>
            <atom:updated>2017-03-03T20:18:16.340Z</atom:updated>
            <content:encoded><![CDATA[<p>MVC is a widely known design pattern, especially in iOS development.</p><p>This is a short introduction to MVC, its benefits, and its drawbacks compared to other design patterns.</p><p>In short, MVC requires that objects are classified by the role they play in the application.</p><p>The separation of the roles define not only the <em>responsibilities</em> of each object but how the objects <em>communicate</em> with each other.</p><p>There are three roles that an object can play: Model, View or Controller.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/533/1*BjA8olDmtm40rYuV9ubOfw.png" /><figcaption>Views only care about how they’re presented, models only care about data, and view controllers only care about connecting the two without knowing too much about their internal structure</figcaption></figure><p>The benefits of MVC include:</p><ul><li>code becomes easily reused</li><li>the clear separation of roles tend to create better defined interfaces</li><li>applications are easily extensible and adaptive to changing environments</li></ul><p>Some drawbacks of MVC include:</p><ul><li>with larger applications, the view controller becomes large and hard to manage (which is why MVVM is becoming more widely used)</li><li>when the data model is updated, the views do not automatically reflect the change (FRP is another design pattern that directly connects view and model. <a href="https://medium.com/ios-development-with-swift-3/functional-reactive-programming-in-swift-f67a0939266b">Read more here</a>)</li></ul><p>If you’re interested in learning more about iOS development, check out my blog at <a href="http://juliageist.com/blog/ios-development-swift-3/">juliageist.com/blog/ios-development-swift-3/</a></p><h4>. . .</h4><p>Julia is a mid-level iOS Engineer who is passionate about creating positive impact through her work and extending the knowledge she has beyond herself.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=92eedbec1da8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Functional Reactive Programming in Swift 3]]></title>
            <link>https://medium.com/hackernoon/functional-reactive-programming-in-swift-f67a0939266b?source=rss-9ea8634ee552------2</link>
            <guid isPermaLink="false">https://medium.com/p/f67a0939266b</guid>
            <category><![CDATA[swift-3]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[frp]]></category>
            <dc:creator><![CDATA[Aurum Linh]]></dc:creator>
            <pubDate>Tue, 15 Nov 2016 07:46:28 GMT</pubDate>
            <atom:updated>2025-08-20T12:44:52.824Z</atom:updated>
            <content:encoded><![CDATA[<h4>Data Binding with RxSwift</h4><p>This post is a tutorial that will teach you how to bind data to views using RxSwift, which is a part of the Functional Reactive <a href="https://hackernoon.com/tagged/programming">Programming</a> (FRP) <a href="https://hackernoon.com/tagged/design">design</a> pattern — where views react to changes to data. <strong>FRP is <em>not </em>MVC. </strong>These design patterns are distinct from each other. Unless you have a good reason to use both in a single project, I suggest that you be consistent in your architectural pattern — stick to just one!</p><p>As a reminder, Model View Controller (MVC), consists of having a <strong>View Controller</strong> be a “middleman” between a <strong>Data Model</strong> and the <strong>View</strong> on screen.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/910/1*cFoDnOh9xYQsLhNBZikSWg.jpeg" /><figcaption>The Model and View never directly communicate, but use the Controller to pass information.</figcaption></figure><p>Note that when using the MVC design pattern, the Model and the View <em>never</em> directly communicate.</p><p>An <em>alternative</em> to MVC is a design pattern called Functional Reactive Programming (FRP). FRP is quite the opposite of MVC — in regards to the fact that the Model and the View have a <strong>direct connection</strong>.</p><p>In this tutorial, we’ll only be looking at binding data to views using RxSwift— your views will update automatically whenever the data is updated.</p><p>This tutorial requires you to use a Cocoapod called <a href="https://github.com/ReactiveX/RxSwift">RxSwift</a>. <strong>The link I provided is for Swift 3. </strong>Please use <a href="https://github.com/ReactiveX/RxSwift/tree/rxswift-2.0">this branch of RxSwift</a> if you are using Swift 2.3.</p><p>What we’ll be doing is setting up a direct connection between the data and the view. You can fork and clone my starter repo <a href="https://github.com/juliascript/FRPTutorial/tree/b97fe32f05a4f97a95478c99a62502ed7261a0fe">here</a>.</p><p>Let’s use the example of having a UILabel that is updated upon text input from a UIAlertController.</p><p>Normally, you might have a variable that looks like this to represent the name value:</p><pre>let name: String = &quot;Julia&quot;</pre><p>To convert this variable into one that will be compatible with RxSwift, we have to change the type of the variable.</p><pre>let name: Variable&lt;String&gt; = Variable(&quot;Julia&quot;)</pre><p>Note that our variable is now of the Variable class, which is part of the RxSwift library.</p><p>As you might have noticed, the Variable class serves as a <em>wrapper</em> for the data stored in the variable. So, you can still access the string “Julia” by calling name.value.</p><p>Next, we call the asObservable function on our variable, name. We then call the bindTo function on the result, passing in the view element that we are binding to.</p><pre>name.asObservable()<br>    .bindTo(nameLabel.rx.text)</pre><p>In this particular case, we are binding to the text property of a UILabel named nameLabel. However, the bindTo function also allows us to bind to other properties of views, such as backgroundColor.</p><p>And lastly, we have to initialize and use a dispose bag. <strong>The binds that we create between data and views will persist even after the View Controller is deallocated.</strong> The dispose bag will make sure that the bindings are also deallocated when the View Controller is deallocated.</p><pre>let disposeBag = DisposeBag()</pre><p>In order to add the binding to the dispose bag, we have to call one last function on the binding. Here is what the final binding should look like:</p><pre>name.asObservable()<br>    .bindTo(nameLabel.rx.text)<br>    .addDisposableTo(disposeBag)</pre><p>Lastly, in order for your views to change, you need to change the data! The variable in this tutorial changes based on text input from a UIAlertController, we’ll implement the code that changes the view.</p><p>Normally, your action closure might look like this:</p><pre>let okAction = UIAlertAction(title: &quot;OK&quot;, style: .default) { action in<br>            if let textInput = alert.textFields?.first?.text {<br>                self.name = textInput<br>                self.nameLabel.text = self.name<br>           }<br>}</pre><p>Note that you have to update your views as well as your data. When we bind our views to the data, we don’t have to update the views. The binding implies it automatically updates! All we have to do is change the data itself.</p><pre>let okAction = UIAlertAction(title: &quot;OK&quot;, style: .default) { action in<br>            if let textInput = alert.textFields?.first?.text {<br>                self.name.value = textInput<br>            }<br>}</pre><p>Remember that the type of name is Variable—meaning the data is enclosed in a wrapper. Instead of updating the name variable itself, we have to update the data, which happens to be at its value property.</p><p>Here is a link to a <a href="https://github.com/juliascript/FRPTutorial">Github repo</a> with the working code from this tutorial. Please feel free to reach out if you have any questions!</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><a href="https://goo.gl/Ahtev1"><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*35tCjoPcvq6LbB3I6Wegqw.jpeg" /></a></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=f67a0939266b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/hackernoon/functional-reactive-programming-in-swift-f67a0939266b">Functional Reactive Programming in Swift 3</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[The Trie Data Structure (Prefix Tree)]]></title>
            <link>https://medium.com/free-code-camp/trie-prefix-tree-algorithm-ee7ab3fe3413?source=rss-9ea8634ee552------2</link>
            <guid isPermaLink="false">https://medium.com/p/ee7ab3fe3413</guid>
            <category><![CDATA[data-structures]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[algorithms]]></category>
            <dc:creator><![CDATA[Aurum Linh]]></dc:creator>
            <pubDate>Mon, 07 Nov 2016 04:09:23 GMT</pubDate>
            <atom:updated>2025-08-20T12:44:06.012Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>A Trie, (also known as a prefix tree) is a special type of tree used to store associative data structures</blockquote><p>A trie (pronounced try) gets its name from re<strong>trie</strong>val — its structure makes it a stellar matching algorithm.</p><h3>Context</h3><pre>Write your own shuffle method to randomly shuffle characters in a string. </pre><pre>Use the words text file, located at /usr/share/dict/words, and your shuffle method to create an anagram generator that only produces real words.</pre><pre>Given a string as a command line argument, print one of its anagrams. </pre><p>The words in the text file are separated by new lines. Its formatting makes it a lot easier to put the words into a data structure. For now, I’m storing them in a list — each element being a single word from the file.</p><p>One approach to this challenge is to:</p><ul><li>randomly shuffle the characters in the string</li><li>then, check it against all words that were in <em>/usr/share/dict/words </em>to verify that it’s a real word.</li></ul><p>However, this approach requires that I check that the randomly shuffled characters in the new string matches one of 235,887 words in that file — that means <strong>235,887 operations</strong> <strong>for <em>each</em> string</strong> that I want to verify as a real word.</p><p>This was an unacceptable solution for me. I first looked up libraries that had already been implemented to check if words exist in a language, and found <a href="https://github.com/rfk/pyenchant">pyenchant</a>. I first completed the challenge using the library, in a few lines of code.</p><pre>def generateAnagram(string, language=&quot;en_US&quot;):<br>   languageDict = enchant.Dict(language) <br>   numOfPossibleCombinationsForString = math.factorial(len(string))<br>   for i in range(0, numOfPossibleCombinationsForString):<br>       wordWithShuffledCharacters = shuffleCharactersOf(string)</pre><pre>       if languageDict.check(wordWithShuffledCharacters):<br>            return wordWithShuffledCharacters<br> <br>    return &quot;There is no anagram in %s for %s.&quot; % (language, string)</pre><p>Using a couple of library functions in my code was a quick and easy solution. However, I didn’t learn much by finding a library to solve the problem for me.</p><p>I was positive that the library wasn’t using the approach I mentioned earlier. I was curious and dug through the source code — I found a trie.</p><h3>Trie</h3><p>A trie stores data in “steps”. Each step is a node in the trie.</p><p>Storing words is a perfect use case for this kind of tree, since there are a finite amount of letters that can be put together to make a string.</p><p>Each step, or node, in a language trie will represent one letter of a word. The steps begin to branch off when the order of the letters diverge from the other words in the trie, or when a word ends.</p><p>I created a trie out of directories on my Desktop to <strong><em>visualize</em></strong> stepping down through nodes. This is a trie that contains two words: apple and app.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vuZ47z2Ff_EyAuRi087ICQ.gif" /><figcaption>You can visualize stepping down through nodes in a trie as changing directories.</figcaption></figure><p>Note that the end of a word is denoted with a ‘$’. I’m using ‘$’ because it is a unique character that will not be present in any word in any language.</p><p>If I were to add the word ‘aperture’ to this trie, I would loop over the letters in the word ‘aperture’ while simultaneously stepping down the nodes in the trie. If the letter exists as a child of the current node, step down into it. If the letter does not exist as a child of the current node, create it and then step down into it. To visualize these steps using my directories:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zX2hBSdXJTGI0jMzYS3HfA.gif" /></figure><p>While stepping down the trie, the first two letters of ‘aperture’ are already present in the trie, so I step down into those nodes.</p><p>The third letter, ‘e’, however, is not a child of the ‘p’ node. A new node is created to represent the letter ‘e’, branching off from the other words in the trie. New nodes for the letters that follow are created as well.</p><p>To generate a trie from a words file, this process will happen for each word, until all combinations for every word are stored.</p><p>You might be thinking: “Wait, won’t it take really long to generate the trie from that text file with 235,887 words in it? What’s the point of looping over <em>every single character</em> in every single word?”</p><p>Yes, iterating over each character of every word to generate a trie does take some time. However, the time taken to create the trie is <em>well worth it </em>— because to check if a word exists in the text file, it takes at most, as many operations as the <em>length of the word itself</em>. <em>Much better</em> than the 235,887 operations it was going to take before.</p><p>I wrote the simplest version of a trie, using nested dictionaries. This isn’t the most efficient way to implement one, but it is a good exercise to understand the logic behind a trie.</p><pre>endOfWord = &quot;$&quot;</pre><pre>def generateTrieFromWordsArray(words):<br>   root = {}<br>   for word in words:<br>      currentDict = root<br>      for letter in word:<br>         currentDict = currentDict.setdefault(letter, {})<br>      currentDict[endOfWord] = endOfWord<br>   return root</pre><pre>def isWordPresentInTrie(trie, word):<br>   currentDict = trie<br>   for letter in word:<br>      if letter in currentDict:<br>         currentDict = currentDict[letter]<br>      else: <br>         return False<br>   return endOfWord in currentDict</pre><p>You can see my <a href="https://github.com/juliascript/Python-Challenges/blob/master/accurateAnagram.py">solution</a> for the anagram generator on my Github. Since exploring this algorithm, I’ve decided to make this blog post one of many — each post covering one algorithm or data structure. The code is available on my <a href="https://github.com/juliascript/Algorithms-and-Data-Structures">Algorithms and Data Structures</a> repo — star it to stay updated!</p><h3>Next Steps</h3><p>I suggest checking out Ray Wenderlich’s <a href="https://github.com/raywenderlich/swift-algorithm-club/tree/master/Trie">trie repo</a>. Although written in Swift, it’s a valuable source for explanations of various algorithms.</p><p>Similar to the trie (but more memory efficient) is a suffix tree, or radix. In short, instead of storing single characters at every node, the end of a word, its suffix, is stored and the paths are created relatively.</p><p>However, a radix is more complicated to implement than a trie. I suggest taking a look at Ray Wenderlich’s <a href="https://github.com/raywenderlich/swift-algorithm-club/tree/master/Radix%20Tree">radix repo</a> if you’re interested.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ee7ab3fe3413" width="1" height="1" alt=""><hr><p><a href="https://medium.com/free-code-camp/trie-prefix-tree-algorithm-ee7ab3fe3413">The Trie Data Structure (Prefix Tree)</a> was originally published in <a href="https://medium.com/free-code-camp">We’ve moved to freeCodeCamp.org/news</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Have an idea for a project? Read this first.]]></title>
            <link>https://medium.com/hackernoon/have-an-idea-for-a-project-read-this-first-4f33afb2bacd?source=rss-9ea8634ee552------2</link>
            <guid isPermaLink="false">https://medium.com/p/4f33afb2bacd</guid>
            <category><![CDATA[product-development]]></category>
            <category><![CDATA[projects]]></category>
            <category><![CDATA[side-project]]></category>
            <dc:creator><![CDATA[Aurum Linh]]></dc:creator>
            <pubDate>Thu, 03 Nov 2016 05:43:54 GMT</pubDate>
            <atom:updated>2025-08-20T12:42:28.450Z</atom:updated>
            <content:encoded><![CDATA[<p>As a software developer, I try to create products that solve <a href="https://hackernoon.com/tagged/meaningful">meaningful</a> problems. I believe that to solve any problem, you must first understand it. Then, identify and solve its root cause, not its symptoms.</p><p>A common mistake that I’ve made is having the assumption that my experience of the problem represents the problem in its <a href="https://hackernoon.com/tagged/entirety">entirety</a>. This led me to create a product from my own bias and with my own assumptions about reality.</p><p>Who we are seeps into what we create. However, we have control over how much bias is ingrained our products.</p><h3>Know Your Problem, Beyond Your Own Experience</h3><p>Use the solution you currently have as means to understanding your own assumptions. <strong><em>Ask yourself</em></strong>: What needs to be true about the world in order for my solution to work?</p><p>The answers to this question will be a list of your assumptions. From here, reach out to people who you believe experience the problem you’re solving.</p><p><strong>Ask them questions that threaten to invalidate your assumptions.</strong></p><p>It’s important that you don’t ask directly about your solution. You are (in)validating <em>your assumptions about the problem</em>, not the solution. Most of the time, users don’t know what they want until it’s in front of them. However, they can give you valuable information about the problem they experience from their own perspective.</p><p>Asking questions that threaten your understanding of the problem broaden the potential of your solution. With enough perspective, your solution can stretch across the entirety of the problem’s effect on the world.</p><h3>Apply External Perspectives to Your Solution</h3><p>Once you’ve gathered a deeper understanding of your problem, you can revise your solution to be applicable to the multiple dimensions of the problem.</p><p>With perspective, your solution is now able to adapt to cover cases that you initially overlooked.</p><h3>Build</h3><p><strong><em>Ask yourself: </em></strong>What is the smallest thing I can build that would provide value to users?</p><p>The answer to this question will be the simplest version of your product, also known as your <em>minimally viable product</em>(MVP).</p><p>Building your MVP first is beneficial because it gives you the ability to ship a usable product to users for feedback. A MVP also serves as clearly defined, quickly attainable goals, allowing you to filter out features that aren’t <em>absolutely</em> necessary in providing value to your users.</p><p>Now that you have a deeper understanding of the problem and your own bias in solving it, have adapted your solution to include other perspectives, and have scoped your product down to the simplest way to provide value to your users, you’re ready to build! Don’t forget whom you’ve asked questions to — they might be your first users!</p><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>To learn more, <a href="https://goo.gl/4ofytp">read our about page</a>, <a href="http://bit.ly/HackernoonFB">like/message us on Facebook</a>, or simply, <a href="https://goo.gl/k7XYbx">tweet/DM @HackerNoon.</a></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><p><a href="https://upscri.be/hackernoon/">https://upscri.be/hackernoon/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4f33afb2bacd" width="1" height="1" alt=""><hr><p><a href="https://medium.com/hackernoon/have-an-idea-for-a-project-read-this-first-4f33afb2bacd">Have an idea for a project? Read this first.</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[CSS Selectors Part 3]]></title>
            <link>https://aurum-linh.medium.com/css-selectors-part-3-d9df818a6e58?source=rss-9ea8634ee552------2</link>
            <guid isPermaLink="false">https://medium.com/p/d9df818a6e58</guid>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[css]]></category>
            <dc:creator><![CDATA[Aurum Linh]]></dc:creator>
            <pubDate>Mon, 31 Oct 2016 20:01:09 GMT</pubDate>
            <atom:updated>2016-10-31T20:01:09.985Z</atom:updated>
            <content:encoded><![CDATA[<p>In my <a href="https://medium.com/@julia.geist/css-selectors-part-2-d9cc6f5caf4e#.snsf0p7mj">last post</a>, I went over sibling and child selectors. In this resource, I’ll be going over styling links in CSS.</p><h4>An Important Note</h4><p>It is <em>very important</em> that you implement these styles in order. CSS implements it’s styles in the order that they’re written (with some exceptions). Your links won’t look the way you expect if you implement them out of order. A good way to remember the order is <strong>L</strong>o<strong>V</strong>e and <strong>HA</strong>te. <strong>L</strong>ink, <strong>V</strong>isited, <strong>H</strong>over, <strong>A</strong>ctive.</p><h3>Link</h3><p>When you include a <a href="https://www.google.com/#q=the+matrix">link</a> on your page, you want to make it clear to a user that it’s clickable.</p><p>When you search on Google, the result links appear in blue text.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-R_88Y-hY9xXXtPrtwqV7Q.png" /><figcaption>Note that the resulting links all appear in blue text to show I have not clicked on them yet.</figcaption></figure><p>The CSS might look something like this:</p><pre>a:link {<br> color: blue;<br>}</pre><h3>Visited</h3><p>If you click on a few results and then go back at the results page, Google will show you the pages you’ve already visited by displaying them with purple text.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PM2noyggJ290DYbj72rUDA.png" /><figcaption>The first two links now appear in purple text to show that I’ve visited those links already.</figcaption></figure><p>The CSS might look something like this:</p><pre>a:visited {<br>  color: purple;<br>}</pre><h3>Hover</h3><p>When you hover over a link on the search result page, the link is underlined.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UkfXaT-dSPSyBinA27G9lQ.gif" /><figcaption>The blue text is underlined when the mouse is hovering over the link.</figcaption></figure><p>The CSS might look something like this:</p><pre>a:hover {<br>  text-decoration: underline;<br>}</pre><h3>Active</h3><p>You can also add a style to what your links look like when they’re clicked. Google doesn’t have a style for this, but that doesn’t mean you can’t!</p><p>To add a style to how your links look when they’re clicked:</p><pre>a:active {<br>  <br>}</pre><p>Again, <strong>don’t forget</strong> to implement these styles in order! See my note at the start of this post.</p><p>That’s all for now! In my next post, I’ll be covering adding and removing classes with Javascript!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d9df818a6e58" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[CSS Selectors Part 2]]></title>
            <link>https://aurum-linh.medium.com/css-selectors-part-2-d9cc6f5caf4e?source=rss-9ea8634ee552------2</link>
            <guid isPermaLink="false">https://medium.com/p/d9cc6f5caf4e</guid>
            <category><![CDATA[css-selectors]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[css]]></category>
            <dc:creator><![CDATA[Aurum Linh]]></dc:creator>
            <pubDate>Mon, 31 Oct 2016 01:11:07 GMT</pubDate>
            <atom:updated>2016-10-31T19:29:01.017Z</atom:updated>
            <content:encoded><![CDATA[<p>In my <a href="https://medium.com/@julia.geist/css-selectors-part-1-f46f562a3261#.80pxvd1gq">last post</a>, I went over selecting by type, id, class, and descendants. In this next reference, I’ll provide examples for sibling and child selectors.</p><h3>Adjacent Sibling Selector</h3><p>A + B</p><p>Selects all B elements that <em>directly</em> follow A as a sibling. An element is a sibling to another when they are both on the same level or depth. In HTML, siblings will be at the same indentation level.</p><p>To select every &lt;span&gt; that <em>directly </em>follows a &lt;div&gt;:</p><pre>div + span {</pre><pre>}</pre><p>To select every element with a class “selected” that <em>directly</em> follows a &lt;p&gt;:</p><pre>p + .selected {</pre><pre>}</pre><h3>General Sibling Selector</h3><p>A ~ B</p><p>Selects elements that follow another element.</p><p>To select all elements with class “selected” after a &lt;p&gt;:</p><pre>p ~ .selected {</pre><pre>}</pre><p>To select all elements with an id “post” after a &lt;div&gt;:</p><pre>div + #post {</pre><pre>}</pre><h3>Child Selector</h3><p>A &gt; B</p><p>Selects elements that are <em>direct children</em> of other elements. A child element is any element that is nested directly in another element. Elements that are nested deeper than that are <em>descendant</em> <em>elements</em>.</p><p>To select all elements with class “post” in an element with id “newsfeed”:</p><pre>#newsfeed &lt; .post {</pre><pre>}</pre><p>To select all &lt;p&gt; within an &lt;article&gt;:</p><pre>article &lt; p {</pre><pre>}</pre><h3>First-Child Pseudo Selector</h3><p>:first-child</p><p>Selects the first child of an element.</p><p>To select <em>all </em>first-child elements:</p><pre>:first-child {</pre><pre>}</pre><p>To select all &lt;a&gt; first-child elements:</p><pre>a:first-child {</pre><pre>}</pre><p>To select all &lt;a&gt; first-child elements in &lt;p&gt;:</p><pre>p a:first-child {</pre><pre>} </pre><h3>Only-Child Pseudo Selector</h3><p>:only-child</p><p>Selects any element that is the <em>only element</em> inside another one</p><p>To select all elements that are only-children:</p><pre>:only-child {</pre><pre>}</pre><p>To select &lt;p&gt; that is the only element inside of any other element:</p><pre>p:only-child {</pre><pre>}</pre><p>To select &lt;span&gt; that is the only element inside of a &lt;div&gt;:</p><pre>div span:only-child {</pre><pre>}</pre><h3>Last-Child Pseudo Selector</h3><p>:last-child</p><p>Selects last element inside another element.</p><p>To select all last-child elements:</p><pre>:last-child {</pre><pre>}</pre><p>To select all last-child &lt;a&gt; elements:</p><pre>a:last-child {</pre><pre>}</pre><p>To select the last &lt;p&gt; in a &lt;div&gt;:</p><pre>div p:last-child {</pre><pre>}</pre><h3>Nth Child Pseudo Selector</h3><p>:nth-child(A)</p><p>Selects the <em>nth child</em> element in the another element</p><p>To select <em>every</em> element that is the 4th child of another element:</p><pre>:nth-child(6){</pre><pre>}</pre><p>To select the third &lt;p&gt; in <em>every</em> &lt;div&gt;:</p><pre>div p:nth-child(3) {</pre><pre>}</pre><p>And that’s all for now! In addition to the type, id, class, and descendant selectors, the child and sibling selectors give you means for using the flexibility of CSS to your advantage.</p><p>In the next post, I’ll cover styling user interaction with links on your page.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d9cc6f5caf4e" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>