<?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 Conrad Irwin on Medium]]></title>
        <description><![CDATA[Stories by Conrad Irwin on Medium]]></description>
        <link>https://medium.com/@conradirwin?source=rss-96b7f0fc6b------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*_VYJYU9_ftFtYVJg.jpg</url>
            <title>Stories by Conrad Irwin on Medium</title>
            <link>https://medium.com/@conradirwin?source=rss-96b7f0fc6b------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 05:51:17 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@conradirwin/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 to eliminate regular expression denial of service]]></title>
            <link>https://medium.com/superhuman-co/how-to-eliminate-regular-expression-denial-of-service-f8983bb76afc?source=rss-96b7f0fc6b------2</link>
            <guid isPermaLink="false">https://medium.com/p/f8983bb76afc</guid>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[developer]]></category>
            <category><![CDATA[regex]]></category>
            <dc:creator><![CDATA[Conrad Irwin]]></dc:creator>
            <pubDate>Wed, 19 Feb 2020 18:33:24 GMT</pubDate>
            <atom:updated>2020-02-19T18:33:24.227Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bLXAGI1LxP3zQubgzjM1sg.jpeg" /></figure><p>At <a href="https://superhuman.com/?utm_source=medium&amp;utm_medium=blog&amp;utm_campaign=redos">Superhuman</a><em> </em>we make the fastest email experience in the world. We must therefore process massive amounts of text <em>very</em> rapidly. We need to find links, validate emails, parse invitations, and much more.</p><p>Most programmers process text with <a href="https://en.wikipedia.org/wiki/Regular_expression">regular expressions</a>. And rightly so: regular expressions are concise yet powerful.</p><p>But many programmers have also encountered the dark side of regular expressions. When regular expressions go wrong, they go devastatingly<em> </em>wrong.</p><h4>The dark side of regular expressions</h4><p>Superhuman automatically converts email addresses into mailto: links.</p><p>In this case, we defined an email address as any string that matches this regular expression: /([^@]*)@([^@]*)/. You can read this as: “0 or more of any character except @, then an @ sign, then 0 or more of any character except @”.</p><p>But while reading the <a href="https://tools.ietf.org/html/rfc5322#section-3.4.1">formal specification</a> of email addresses, we found some that did not match our regular expression. For example, if the username is quoted then it can also contain an @ sign. Consider &quot;joe@home&quot;@example.com.</p><p>Now you might be thinking: “That’s crazy! Who would do that?!” But when you deal with user data, the unexpected happens all the time. Imagine you have 1 million users, and that each user has 50,000 emails. Between them, this is 50 billion emails. Even if it only happens once in every billion emails, that could still easily be 50 times!</p><p>Wanting to do the right thing, we naïvely changed our regular expression to /(&quot;[^&quot;]*&quot;|[^@])*@[^@]*/. This is exactly the same as before, but also allows the username to contain 0 or more quoted sections.</p><p>It only took a few days before we received an email saying: “Please help! Superhuman is using 100% CPU and not responding…”</p><p>We could see that the problem started after we changed this regular expression, and we could see that Superhuman broke on one email in particular. In some cases, the CPU would lock up for days.</p><p>But why?</p><p>It turns out that we had accidentally become vulnerable to <a href="https://snyk.io/blog/redos-and-catastrophic-backtracking/">regular expression denial of service</a> (ReDoS).</p><h4>Regular expression denial of service</h4><p>Theoretically, a regular expression is equivalent to a state machine that matches one character at a time. The state machine for our first email matcher looks like this:</p><figure><img alt="Example state-machine for /[^@]*@[^@]*/" src="https://cdn-images-1.medium.com/max/1024/1*AMe_vHGBZprBtMqrPwc3PA.png" /><figcaption>Example state machine for /[^@]*@[^@]*/</figcaption></figure><p>This state machine has 3 states: A, B, and $. The machine starts in state A. While here, the machine will match any character except @ and remain in state A. If it encounters an @ sign, the machine will transition to state B.</p><p>In state B, the machine will match any character except @, and remain in state B. At the end of the string, the machine transitions to state $.</p><p>If the machine encountered an @ sign while in state B, it would error as there are no matching transitions. The error would show that the string did not match the regular expression.</p><p>So what changed when we updated our regular expression? The state machine for our second email matcher looks like this:</p><figure><img alt="Example state-machine for /(“[^”]*”|[^@])*@[^@]*/" src="https://cdn-images-1.medium.com/max/1024/1*c0_OkgishQfQv2Imsukclw.png" /><figcaption>Example state machine for /(&quot;[^&quot;]*&quot;|[^@])*@[^@]*/</figcaption></figure><p>Do you see the problem?</p><p>It’s not obvious, but we introduced non-determinism. In state A, if the machine sees &quot; it has a choice: treat it as &quot; and transition to state C, or treat it as any character except @ and stay in state A.</p><p>There are some <a href="https://swtch.com/~rsc/regexp/regexp1.html">theoretical solutions</a> to this problem, but JavaScript and most modern programming languages take a dangerous approach: when the state machine has multiple paths, it will just choose one and continue. If that choice leads to the entire string matching, the machine will stop. If that choice does not lead to a match, it will <em>backtrack</em> and try the next path.</p><p>In the worst case, the state machine has to try every single possible combination of options before it can determine that there is no match. And the number of options very quickly becomes huge. In our example, every &quot; character doubles the number of possibilities. Our regular expression can therefore take <em>O</em>(2<em>ⁿ</em>)<em> </em>attempts to match, where <em>n</em> is the length of the string.</p><p>If you don’t believe me, open your browser console and type:</p><pre>let regex = /(&quot;[^&quot;]*&quot;|[^@])*@([^@]*)/<br>t = performance.now()<br>regex.test(&#39;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&quot;&#39;)<br>console.log(performance.now() - t) // about 3 seconds.</pre><p>Each additional &quot; character doubles the time required. This 40 character string takes about 3 seconds on a high-end MacBook Pro. A similar string of just 64 characters will take more than 2 years — assuming you don’t run out of battery in the meantime!</p><p>In summary:</p><ol><li>If our regular expression is run against a valid email address, it will not backtrack and it will run very quickly.</li><li>If our regular expression is run against the vast majority of common input, it will backtrack a little and it will still run quickly.</li><li>If our regular expression is run against a very specific pattern, it will backtrack catastrophically and may never end.</li></ol><p>In other words, ReDoS manifests only in specific conditions, is catastrophic when it does, and — worst of all — cannot be caught by traditional testing as the conditions needed to trigger it are rare.</p><h4>The solution</h4><p>We turned to academia, and found that identifying ReDoS is still a relatively new area of research. One paper, however, was particularly useful. In “<a href="http://www.cs.bham.ac.uk/~hxt/research/redos_full.pdf">Static Analysis for Regular Expression Exponential Runtime via Substructural Logics</a>”, the authors describe a beautiful theoretical approach to this problem. They also provide a tool to test regular expressions. It works like this:</p><ol><li>Compile the regular expression into a state machine.</li><li>Look for ambiguity within the loops of the state machine execution graph.</li><li>Run a bounded search of the execution graph to determine if these ambiguities can be triggered in a loop. If so, this would indicate a ReDoS vulnerability.</li></ol><p>A brilliant side effect of this strategy is that it generates an example string that will trigger ReDoS. This can be extremely useful for debugging, as you can see which parts of the regular expression are triggered.</p><p>The original tool is written in OCaml and requires many dependencies to run. To make it easily available for everyday use, we created <a href="https://regex.rip/?utm_source=medium&amp;utm_medium=blog&amp;utm_campaign=redos">regex.rip</a>! This is the OCaml tool wrapped in an HTTP API, and with some extra javascript-regex features.</p><p>With <a href="https://regex.rip/?utm_source=medium&amp;utm_medium=blog&amp;utm_campaign=redos">regex.rip</a>, you can create regexes with confidence. You can test your regexes so that users don’t have to. And best of all, you can avoid catastrophic downtime that you would otherwise only see in production.</p><p>Please feel free to use <a href="https://regex.rip/?utm_source=medium&amp;utm_medium=blog&amp;utm_campaign=redos">regex.rip</a> with all your regular expressions. If you want to contribute, please find the code on GitHub at <a href="https://github.com/superhuman/rxxr2">superhuman/rxxr2</a>.</p><p><em>Thanks to </em><a href="https://twitter.com/e_tatarchenko"><em>Elena</em></a><em>, </em><a href="https://twitter.com/jkebertz"><em>Joy</em></a><em>, </em><a href="https://www.linkedin.com/in/rvarshney/"><em>Ruchi</em></a><em>, </em><a href="https://twitter.com/terinjokes"><em>Terin</em></a><em>, and </em><a href="https://www.linkedin.com/in/isharabash/"><em>Islam</em></a><em> for comments and suggestions on this post.</em></p><p><em>At Superhuman we’re rebuilding the email experience for web &amp; mobile. Think vim / Sublime for email: blazingly fast and visually gorgeous.</em></p><p><em>If you enjoy working on user-facing problems that push existing solutions to their very limits — or beyond — join us! </em><a href="https://superhuman.com/?utm_source=medium&amp;utm_medium=blog&amp;utm_campaign=redos"><em>Learn more</em></a><em> or </em><a href="/service/mailto:conrad@superhuman.com"><em>email me</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f8983bb76afc" width="1" height="1" alt=""><hr><p><a href="https://medium.com/superhuman-co/how-to-eliminate-regular-expression-denial-of-service-f8983bb76afc">How to eliminate regular expression denial of service</a> was originally published in <a href="https://medium.com/superhuman-co">Superhuman</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Performance metrics for blazingly fast web apps]]></title>
            <link>https://medium.com/superhuman-co/performance-metrics-for-blazingly-fast-web-apps-ec12efa26bcb?source=rss-96b7f0fc6b------2</link>
            <guid isPermaLink="false">https://medium.com/p/ec12efa26bcb</guid>
            <category><![CDATA[metrics]]></category>
            <category><![CDATA[performance]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[Conrad Irwin]]></dc:creator>
            <pubDate>Tue, 24 Sep 2019 20:03:03 GMT</pubDate>
            <atom:updated>2019-12-11T01:32:04.860Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1RziAA40uBncN3UBwn9i7w.jpeg" /></figure><p><em>At </em><a href="https://superhuman.com/?utm_source=medium&amp;utm_medium=blog&amp;utm_campaign=better-performance-metrics"><em>Superhuman</em></a><em>, we’re building the fastest email experience in the world. Get through your inbox twice as fast as before, and sustain inbox zero!</em></p><p>As the saying goes: “If you can’t measure it, you can’t improve it.”</p><p>We therefore spend a<em> lot</em> of time measuring speed. And as it turns out, performance metrics are surprisingly challenging to get right.</p><p>On the one hand, it is hard to design metrics that accurately represent the user experience. On the other hand, it is difficult to make metrics that are usefully precise. As a result, many teams cannot trust their performance data.</p><p>Even with accurate and precise metrics, the data is hard to use. How do we define “fast”? How do we balance speed and consistency? How do we quickly find regressions or see the impact of optimizations?</p><p>In this post, we share how to build performance metrics for blazingly fast web apps.</p><h4>1. Use the right clock</h4><p>Javascript has two clocks: performance.now() and new Date().</p><p>What’s the difference? For us, there are two:</p><ol><li>performance.now() is significantly more precise. new Date() is precise to ±1ms, whereas performance.now() is precise to ±100μs. (Yes, <a href="https://bugs.chromium.org/p/chromium/issues/detail?id=506723">microseconds</a>!)</li><li>performance.now() is strictly monotonic. In other words, it can never go back in time. If your machine time changes, new Date() will also change — ruining your data. But performance.now() will just keep counting.</li></ol><p>While performance.now() is clearly the better clock to use, it is not perfect. They both suffer from the same issue when the machine is asleep: the measurements include the time when the machine was not even active.</p><h4>2. Ensure your app is in the foreground</h4><p>If your user switches to another browser tab, your metrics will break. Why? Because browsers throttle the CPU for apps running in the background.</p><p>We now have two situations that will skew our metrics and make things appear to be much slower than they are:</p><ol><li>The machine going to sleep</li><li>The app running in a background tab</li></ol><p>Both of these situations are quite likely. Fortunately, we have two possible solutions.</p><p>Firstly, we could simply ignore skewed metrics by dropping <em>outrageous</em> numbers. Your button did not take 15 minutes to do its thing! This quick approach might be all you need.</p><p>Secondly, we could use document.hidden and the visibilitychange <a href="https://developer.mozilla.org/en-US/docs/Web/API/Document/visibilitychange_event">event</a> . This event fires when the user switches to or from the tab, when the browser is minimized or restored, and when the machine awakes from sleep. In other words, it does exactly what we need. And while the tab is in the background, document.hidden is true.</p><p>Here’s a simple implementation:</p><pre>let lastVisibilityChange = 0</pre><pre>window.addEventListener(&#39;visibilitychange&#39;, () =&gt; {<br>  lastVisibilityChange = performance.now()<br>})</pre><pre>// don’t log any metrics started before the last visibility change<br>// or if the page is hidden</pre><pre>if (metric.start &lt; lastVisibilityChange || document.hidden) return</pre><p>We are discarding data, but that is a good thing. We are discarding the data from when the machine was not running our app at full speed.</p><p>While this is data we don’t care about, there are plenty of other interactions we do care about. Let’s see how we can measure those.</p><h4>3. Find the best event start time</h4><p>One of the most controversial JavaScript features is that the event loop is single-threaded. Only one piece of code can run at a time, and it cannot be interrupted.</p><p>If the user presses a key while code is running, you won’t know until <em>after</em> the code has finished. For example, if your app spent 1000ms in a tight loop, and your user hit Escape after 100ms, you would not register it for a further 900ms!</p><p>This can really distort our metrics. If we want to accurately measure what users perceive, this is a huge problem!</p><p>Fortunately, there is an easy solution. If there is a current event, instead of using performance.now() (the time we see the event), we use window.event.timeStamp (the time the system logged the event).</p><p>The event timestamp is set by the browser’s main process. Since this process is not blocked when the event loop is blocked, event.timeStamp provide a much better idea of when the event actually started.</p><p>I should note that this is still not perfect. There is still 9–15ms of unaccounted latency between the physical keypress and the event arriving in Chrome. (Pavel Fatin has an incredible article that explains <a href="https://pavelfatin.com/typing-with-pleasure/#machine-side">why this takes time</a>.)</p><p>However, even if we <em>could</em> measure the time before events reach Chrome, we shouldn’t include this time in our metrics. Why? Because we cannot make code changes that significantly affect this latency. It is not actionable.</p><p>It seems that event.timeStamp is the best place to start.</p><p>Where is the best place to finish?</p><h4>4. Finish in requestAnimationFrame()</h4><p>The JavaScript event loop has another consequence: unrelated code can run after your code, but before the browser display updates.</p><p>Consider React. After your code runs, React updates the DOM. If you only measured time in your code, you’d miss the time in React.</p><p>To measure this extra time, we use requestAnimationFrame() to end our timer only when the browser is ready to flush the frame:</p><pre>requestAnimationFrame(() =&gt; { metric.finish(performance.now()) })</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/798/0*7Q4lWTWtrt7j-C3i.png" /><figcaption>Diagram from an excellent article on requestAnimationFrame by <a href="https://medium.com/@paul_irish/requestanimationframe-scheduling-for-nerds-9c57f7438ef4">Paul Irish</a></figcaption></figure><p>As the diagram shows, requestAnimationFrame() runs after the CPU work is done, and just before the frame is rendered. If we end our timer here, we can be quite confident that we included all the time before the screen updates.</p><p>So far, so good! But now things will become rather complex…</p><h4>5. Ignore layout and paint times</h4><p>The frame diagram illustrates another problem. Before the frame is over, the browser has to Layout and Paint. If we don’t include these, our measured time will still be less than the time for our update to appear on the screen.</p><p>Luckily, requestAnimationFrame has another trick up its sleeve. When it is called, it is passed a timestamp that is the start of the current frame (the far left of the diagram). The timestamp is usually shortly after the end of the previous frame.</p><p>We could therefore fix the shortfall by measuring the total time from event.timeStamp until the start of the next frame. Note the nested requestAnimationFrame:</p><pre>requestAnimationFrame(() =&gt; {<br>  requestAnimationFrame((timestamp) =&gt; { metric.finish(timestamp) })<br>})</pre><p>Although this seems like a great solution, we ended up not using it. For whilst it increases <em>accuracy</em>, it reduces <em>precision</em>. These timings can be at most as precise as the Chrome frame rate. Chrome frames run every <a href="https://developers.google.com/web/fundamentals/performance/rendering/">16ms</a>, so the best precision is ±16ms. And if the browser is overloaded and dropping frames, the precision will be unpredictably worse than that.</p><p>If you implement this solution, major performance improvements — such as shaving 15ms off a 32ms task — can make no difference to the metrics.</p><p>By skipping Layout and Paint, we acquire significantly more precise metrics (±100μs) for the code that we can control. And every improvement will show in the numbers.</p><p>We also explored a related idea:</p><pre>requestAnimationFrame(() =&gt; {<br>  setTimeout(() =&gt; { metric.finish(performance.now()) }<br>})</pre><p>This would include rendering time, and would also not be quantized to 16ms. However, we decided not to use this approach either: if there are long input events, setTimeouts can be significantly delayed until after the UI updates.</p><h4>6. Measure the “% of events that are under target”</h4><p>When building for performance, we are trying to optimize two things:</p><ol><li>Speed. The fastest tasks should be as close as possible to 0ms.</li><li>Consistency. The slowest tasks should be as close as possible to the fastest tasks.</li></ol><p>Because these two variables both change over time, it is hard to visualize and reason about. Can we design a visualization that encourages us to optimize speed <em>and</em> consistency?</p><p>The typical approach is to measure the <em>90th percentile latency.</em> This creates a line graph with milliseconds on the y-axis, and you can see that 90% of events were faster than the line.</p><p>We know that <a href="https://www.nngroup.com/articles/response-times-3-important-limits/">100ms</a> is the perceptual threshold between fast and slow.</p><p>But what does a <em>90th percentile latency</em> of 103ms tell us about our user experience? Not much. What percentage of the time is our app a good experience? There’s no way to know for sure.</p><p>And what does a <em>90th percentile latency</em> of 93ms tell us about our user experience? It is likely a bit better than with 103ms of latency, but that’s about all we can say. Again, there’s no way to know for sure.</p><p>We found a solution to this problem: <em>measure the % of events under 100ms</em>. This approach has three big advantages:</p><ol><li>The metric is framed around the user. It can tell us what percentage of time our app is fast, and what percentage of users experience speed.</li><li>The metric lets us re-introduce the accuracy lost from not measuring to the very end of the frame (section 5). By setting a target that is a multiple of the frame rate, metrics that are close to the target will fall into slower or faster buckets.</li><li>The metric is easier to calculate. Simply count the number of events that are under target and divide it by the total number of events. Percentiles are much harder to calculate. There are somewhat efficient approximations, but to do it properly you need to compute every measurement.</li></ol><p>This approach has only one downside: if you are slower than your target, it can be hard to see improvements.</p><h4>7. Show multiple thresholds</h4><p>In order to visualize the impact of performance optimization, we add additional thresholds above and below 100ms. We group latencies into &lt;50ms (fast), &lt;100ms (ok), &lt;1000ms (slow) and “terrible”. The terrible bucket lets us see where we are severely missing the mark, which is why we color it bright red. The 50ms bucket is very sensitive to changes; performance improvements are often visible here well before the 100ms bucket.</p><p>For example, this graph visualizes the performance of viewing a thread in Superhuman:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*goZNy9Ae9LeigP1_.png" /><figcaption>Performance of viewing a thread in Superhuman</figcaption></figure><p>It shows a period where performance regressed, and was later fixed. It is hard to spot the regression if you look only at the 100ms results (the top of the blue bars). It is easy to spot if you look at the 50ms results (the top of the green bars).</p><p>With a traditional approach to performance metrics, we may well have missed this issue. But because of how we measure and visualize our metrics, we were able to very rapidly find and fix the issue.</p><h4>Conclusion</h4><p>Performance metrics are surprisingly challenging to get right.</p><p>We found a better way to build performance metrics for web apps:</p><ol><li>Measure time starting at event.timeStamp</li><li>Measure time ending at performance.now() in a requestAnimationFrame()</li><li>Ignore anything that happened while the tab was not focused</li><li>Aggregate data using “% of events that are under target”</li><li>Visualize multiple thresholds</li></ol><p>With this approach, you can create metrics that are accurate and precise. You can make graphs that quickly show regressions. You can design visualizations that quickly show the impact of optimizations. And most importantly, you can build fast software faster! ⚡️</p><p>I hope you try these metrics out in your own app. If you do, or if you have any questions, please do get in touch: <a href="https://twitter.com/conradirwin">@conradirwin</a>, <a href="/service/mailto:conrad@superhuman.com">conrad@superhuman.com</a></p><p>— Conrad Irwin, CTO, Superhuman</p><p><em>At Superhuman we’re rebuilding the email experience for web &amp; mobile. Think vim / Sublime for email: blazingly fast and visually gorgeous.</em></p><p><em>If you love solving interesting problems in elegant ways — join us! </em><a href="https://superhuman.com/jobs?utm_source=medium&amp;utm_medium=blog&amp;utm_campaign=better-performance-metrics"><em>Learn more</em></a><em> or </em><a href="/service/mailto:conrad@superhuman.com"><em>email me</em></a><em>.</em></p><p><em>Thanks to </em><a href="https://twitter.com/paul_irish"><em>Paul Irish</em></a><em>, </em><a href="https://twitter.com/banga_shrey"><em>Shrey Banga</em></a><em>, </em><a href="https://twitter.com/cyen"><em>Christine Yen</em></a>, <a href="https://twitter.com/alden_daniels"><em>Alden Daniels</em></a><em>, j</em><a href="https://twitter.com/jessicard"><em>essicard</em></a><em>, </em><a href="https://twitter.com/_timothee"><em>Tim Boucher</em></a><em>, </em><a href="https://twitter.com/gauravvohra1"><em>Gaurav Vohra</em></a><em>, </em><a href="https://www.linkedin.com/in/michael-kassoff/"><em>Mike Kassoff</em></a><em>, and </em><a href="https://twitter.com/mikeklaas"><em>Mike Klaas</em></a><em> for their input and review.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ec12efa26bcb" width="1" height="1" alt=""><hr><p><a href="https://medium.com/superhuman-co/performance-metrics-for-blazingly-fast-web-apps-ec12efa26bcb">Performance metrics for blazingly fast web apps</a> was originally published in <a href="https://medium.com/superhuman-co">Superhuman</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building reliable apps on unreliable networks]]></title>
            <link>https://medium.com/superhuman-co/building-reliable-apps-on-unreliable-networks-3f75743fc457?source=rss-96b7f0fc6b------2</link>
            <guid isPermaLink="false">https://medium.com/p/3f75743fc457</guid>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[engineering]]></category>
            <dc:creator><![CDATA[Conrad Irwin]]></dc:creator>
            <pubDate>Thu, 16 Mar 2017 21:18:35 GMT</pubDate>
            <atom:updated>2019-10-11T05:05:48.795Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*v_vMOrsU98i4LnUBU4cmvQ.jpeg" /></figure><p><em>This post describes how we detect and communicate network status as part of making </em><a href="https://superhuman.com/?utm_source=medium&amp;utm_medium=blog&amp;utm_campaign=connection-status"><em>Superhuman</em></a><em> the fastest and most reliable email experience in the world. Our </em><a href="https://blog.superhuman.com/architecting-a-web-app-to-just-work-offline-part-1-8697f316c0eb"><em>previous post</em></a><em> described an offline architecture that is fast, robust, and maintainable.</em></p><p>We are rapidly approaching a world with ubiquitous wireless internet. We can be connected wherever we are, and we can stay productive on the go.</p><p>Though connectivity is increasingly prevalent, it is also increasingly unreliable: wireless networks are not as stable as their wired forbears. Users are often stymied by latency, packet loss, and limited bandwidth. Recall Gmail on a flaky connection. When will it load? Is my inbox up to date? Did my email actually send?</p><p>In Superhuman, we handle unstable connections in two important ways:</p><ol><li>We carefully monitor all network activity and keep an internal model of “is the internet working?”</li><li>We clearly and non-intrusively convey this state to the user. We reassure them that they can keep on working.</li></ol><p>Together with our <a href="https://blog.superhuman.com/architecting-a-web-app-to-just-work-offline-part-1-8697f316c0eb">robust offline architecture</a>, these ensure that users always understand the state of the network, and that users never lose work.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*53sphEuqJUPwjq73d0CVMg.png" /><figcaption>We designed the offline indicator to be visible, non-intrusive, and reassuring.</figcaption></figure><h3>Offline detection</h3><p>At first blush, offline detection may seem simple. Surely there’s a browser API?</p><p>Yes, in theory, there is: <a href="https://developer.mozilla.org/en-US/docs/Web/API/NavigatorOnLine/onLine">navigator.onLine</a>. But in practice, you would quickly find that it is not truthful enough to be useful. In particular, it has the following issues:</p><ul><li>It returns true when there’s a local network connection, even if there’s no internet connection;</li><li>It reacts too quickly to transient states like switching networks or resuming from sleep;</li><li>It can <a href="https://bugs.chromium.org/p/chromium/issues/detail?id=678075">sometimes return false</a> even when the internet is available.</li></ul><p>The inescapable reality is that networks fail in many ways. You could be completely disconnected. You could have insufficient bandwidth to do useful work. You could even be on a hotel hotspot that only allows access to certain sites. From the perspective of a Superhuman user these are all the same: some emails haven’t sent, and some haven’t been received.</p><p>In order to communicate this in the product, we monitor all network activity and maintain an internal model of “is the internet working?”. If this model indicates that <em>any</em> of our dependencies is offline, we show the blue offline bar.</p><h4>Simplifying the mental model</h4><p>We want to reduce the number of states in the product, as this reduces both the number of things the user needs to think about, and also the number of code paths we need to test. We therefore treat every kind of network failure as “offline” — and we also ensure that the entire product is considered offline.</p><p>All HTTP and WebSocket requests are made via wrappers that do three things:</p><ol><li>If our internal model says we are offline, pre-emptively abort the request with an OfflineError. This avoids unnecessary failed requests and preserves battery life.</li><li>If the request times out or fails at the network level, abort the request with an OfflineError and update our internal model to indicate that the appropriate dependency is down. This causes the blue offline bar to appear.</li><li>Provide a method to determine when connectivity is restored.</li></ol><p>It is surprisingly hard to set time out limits. For example, we used to set a hard limit on how long requests could take. However, this would misfire on connections that are very high latency but otherwise mostly fine — such as on a plane. Instead, we now make heavy use of <a href="https://developer.mozilla.org/en-US/docs/Web/API/ProgressEvent">progress events</a>, and time out requests that make no progress within 5 minutes.</p><p>Since any failed request causes the product to go offline, we can greatly simplify error handling and also be confident that our messaging makes sense.</p><p>Consider sending an email whilst offline:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*d_0EOY9FBfEYhqHMRNBhMg.png" /><figcaption>The “error” notification if you send an email offline whilst offline.</figcaption></figure><p>The “Message will send when online” notification shows if and only if the network request failed with an OfflineError. This means that offline notifications can only show if the blue offline bar is also visible. The UI will always be consistent.</p><h3>Online detection</h3><p>When the app is set offline by a failed request, it starts polling the dependency every 10 seconds (with a little bit of jitter). For example, after a failed Gmail request, the app will ping a certain Gmail API endpoint. And after a failed Firebase request, the app will ping a certain Firebase key.</p><p>When the app successfully contacts a dependency that was marked offline, it marks that dependency as online again. When all dependencies are marked online, the app is online once again and the blue bar disappears.</p><p>Since we poll each dependency separately, we can display which dependencies are down.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*D3SKmQCoxo3VrKg_t2wGBQ.png" /><figcaption>The offline indicator in the case that a Google dependency (e.g. Firebase) is down.</figcaption></figure><p>This approach has less than perfect availability in some unlikely scenarios, but it does also result in a simple programming model and a coherent user interface.</p><h3>Inconsistent connectivity</h3><p>On tethered connections, where some requests fail but most succeed, the blue offline bar would often flicker in and out. To help Superhuman feel more stable, we add some hysteresis: when a dependency is marked offline, the app waits 10 seconds before polling it. The bar is therefore always visible for at least 10 seconds.</p><p>We found cases where the blue offline bar would still oscillate every 10 seconds. Whilst this is better than flickering, it still gets old fast. To address this, if the app goes offline twice in quick succession, the timeout increases to 60 seconds. These numbers were picked based on how they felt: we want the bar to feel stable without sacrificing perceived availability.</p><h3>Conclusion</h3><p>Ubiquitous connectivity is here to stay. And whilst wireless networks are continually improving, most modern apps still do not behave well on unstable connections.</p><p>It’s time to write better apps. We owe it to our users to:</p><ol><li>Avoid losing their data at all costs;</li><li>Communicate clearly about the state of the network;</li><li>Engineer network robustness into our products.</li></ol><p>If you have any feedback about our approach please add a comment below; we’d love to hear from you.</p><p>Otherwise hold tight for Part 3, where we explain how to store and index gigabytes of data in the browser itself!</p><p>— Conrad Irwin, CTO, Superhuman</p><p><em>At Superhuman we’re rebuilding the email experience for web &amp; mobile. Think vim / Sublime for email: blazingly fast and visually gorgeous.</em></p><p><em>Thank you to </em><a href="https://twitter.com/owencm"><em>Owen Campbell-Moore</em></a>, <a href="https://twitter.com/bkrausz"><em>Brian Krausz</em></a>, <a href="https://twitter.com/dreadpirateryan"><em>Ryan Gerard</em></a>, <a href="https://twitter.com/igrigorik"><em>Ilya Grigorik</em></a>, <em>and</em> <a href="https://www.linkedin.com/in/ben-greenstein-5070345/"><em>Ben Greenstein</em></a><em> for reading early drafts of this post.</em></p><p><em>If you love solving interesting problems in elegant ways — join us! </em><a href="https://superhuman.com/?utm_source=medium&amp;utm_medium=blog&amp;utm_campaign=connection-status"><em>Learn more</em></a><em> or </em><a href="/service/mailto:conrad@superhuman.com"><em>email me</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3f75743fc457" width="1" height="1" alt=""><hr><p><a href="https://medium.com/superhuman-co/building-reliable-apps-on-unreliable-networks-3f75743fc457">Building reliable apps on unreliable networks</a> was originally published in <a href="https://medium.com/superhuman-co">Superhuman</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to hack beautiful flourishes into your font]]></title>
            <link>https://medium.com/superhuman-co/how-to-hack-beautiful-flourishes-into-your-font-dc630bc52c3f?source=rss-96b7f0fc6b------2</link>
            <guid isPermaLink="false">https://medium.com/p/dc630bc52c3f</guid>
            <category><![CDATA[css]]></category>
            <category><![CDATA[email]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[typography]]></category>
            <category><![CDATA[fonts]]></category>
            <dc:creator><![CDATA[Conrad Irwin]]></dc:creator>
            <pubDate>Thu, 11 Aug 2016 17:30:01 GMT</pubDate>
            <atom:updated>2016-08-16T18:08:22.201Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CbHDRCV1ioMT6-bzeZbedQ.png" /></figure><p>I’ve recently been doing some work on making <a href="http://superhuman.com/">Superhuman</a> the most beautiful email experience in the world.</p><p>One of the features we want is automatic “smart quotes”.</p><p>Instead of bland vertical quotes, we’d use fun, curvy quotes to make the text feel more alive:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*z4SKdzJr_5fY7iV6n6XZsw.png" /></figure><p>I’d known for a while that <a href="https://en.wikipedia.org/wiki/OpenType">OpenType</a> was capable of processing during font rendering. So I set myself the challenge of implementing smart quotes in the font file itself.</p><p>To cut a long-story short: <a href="https://cirw.in/etc/fanwood">it works</a>, and it’s easy to modify an existing font to support it!</p><h4>1. font-feature-settings</h4><p>The first trick to getting fancy font features working on the web is to set up your <a href="https://developer.mozilla.org/en-US/docs/Web/CSS/font-feature-settings"><em>font-feature-settings</em></a> CSS properties (or <em>-moz-font-feature-settings </em>for Firefox):</p><pre>body {<br>  font-feature-settings: &quot;kern&quot; 1, &quot;dlig&quot; 1;<br>}</pre><p><em>NB: This is supported up-prefixed by Chrome 50, IE 9, Safari 9.1, and Firefox 34. Chrome enables “kern” by default, Safari enables both “kern” and “dlig” by default.</em></p><p>Your <em>font-feature-settings</em> property will be a list of quoted four-letter <a href="https://en.wikipedia.org/wiki/List_of_typographic_features">OpenType features</a>, followed by a number for their value.</p><p>The most essential feature to enable is <em>“kern”</em>, which enables proper <a href="https://en.wikipedia.org/wiki/Kerning">kerning</a>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/230/1*BZrhc81bHyQdiSO8EpAsgA.png" /><figcaption>Kerning corrects letter spacing</figcaption></figure><p>It’s also nice to enable <em>“liga”</em> and <em>“dlig”</em> which control the use of <a href="https://en.wikipedia.org/wiki/Typographic_ligature">ligatures</a>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/149/1*yvWajkaQefRj-NUXKOSvZA.png" /><figcaption>Ligatures correct for specific combinations of adjacent letters</figcaption></figure><p>Look at the following image. Notice how the ugly space between the <em>nw</em> of <a href="https://www.theleagueofmoveabletype.com/fanwood">Fanwood</a> is tightened, and how the messy fl is replaced by a ligature.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_oshSz0731QTjyEW9XKE0w.png" /></figure><h3>2. Smart quotes</h3><p>The second trick is to actually implement curly quotes.</p><p>Under the hood, each OpenType feature is a set of pattern matches. When a certain sequence of glyphs occurs, you can <strong>sub</strong>stitute in a new glyph, or change its <strong>pos</strong>ition.</p><p>The <a href="http://opentypecookbook.com/index.html">OpenType Cookbook</a> is a good reference for the syntax, which is supported by most font editing tools and processed by the <a href="https://github.com/adobe-type-tools/afdko">ADFKO</a>.</p><p>The patterns are very simple, yet you can use a few techniques to implement surprisingly complicated substitutions:</p><ol><li>You can specify an ignore rule to skip a rule.</li><li>You can define character classes to group characters together.</li><li>You can group rules into lookups, using only one rule from each lookup.</li></ol><p><em>Exercise for the reader: I think this makes an OpenType font a finite-state machine, anyone fancy implementing arbitrary regexes?</em></p><p>Starting small, we can create a simple rule to replace exactly two hyphens (--) by an em-dash ( — ):</p><pre># ignore two hyphens followed by a third hyphen<br>ignore sub hyphen&#39; hyphen&#39; hyphen;</pre><pre># and ignore two hyphens preceded by a hyphen<br>ignore sub hyphen hyphen&#39; hyphen&#39;;</pre><pre># replace all remaining hyphens by em-dashes<br>sub hyphen&#39; hyphen&#39; by emdash;</pre><p>To implement smart-quotes we need to be able to tell if a quote is at the start of a line.</p><p>We can approximate this by defining the character class <em>@All</em> which contains all the glyphs in the font. We can then use <em>@All</em> to catch any quotes that happen after a character. Quotes that don’t happen after any character are at the start of a line.</p><pre># smart-quotes<br># quotes surrounded by spaces, just leave alone<br>ignore sub space quotedbl&#39; space;</pre><pre># quotes after numbers, assume are primes, and leave alone<br>ignore sub [<br>  one two three four five six seven eight nine zero<br>] quotedbl&#39;;</pre><pre># quotes after opening characters are open-quotes<br>sub [space<br>     equal<br>     less<br>     parenleft parenleft.u<br>     bracketleft bracketleft.u<br>     braceleft braceleft.u<br>     guillemotleft guillemotleft.u<br>     guilsinglleft guilsinglleft.u<br>     quotedblleft quoteleft quotesingle quotedbl<br>] quotedbl&#39; @All by quotedblleft;</pre><pre># other quotes in the middle of the line are closing quotes<br>sub @All quotedbl&#39; by quotedblright;</pre><pre># quotes at the start of the line are opening<br>sub quotedbl&#39; @All by quotedblleft;</pre><p>Because there was no pre-defined OpenType feature name for smart quotes, I added it to the font as “ss01” or Stylistic Set 1. This is the result:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CUIn4oJgmFucL41CoJ66Lg.png" /></figure><h3>3. Hanging punctuation</h3><p>Finally, inspired by <a href="https://blot.im/typeset/">Typeset</a>, I wanted to see if I could also implement <a href="https://en.wikipedia.org/wiki/Hanging_punctuation">hanging punctuation</a>. This gives the left-margin of a paragraph a strong vertical line by having punctuation marks hang to the left.</p><p>Once I had the substitution rules and the character classes set up for the smart quotes, this turned out to be simple:</p><pre># feature &quot;opbd&quot;<br>ignore pos @All quotedblleft&#39;;<br>pos quotedblleft&#39; &lt;-421 0 -421 0&gt;;</pre><pre>ignore pos @All quoteleft&#39;;<br>pos quoteleft&#39; &lt;-228 0 -228 0&gt;;</pre><p>The positioning rules move the left and right of the glyph independently. The number 421 comes from looking at the glyph for a curvy left quote and taking its width including some spacing. I only needed to look at the curly left-quote, because the “opbd” feature is defined after “ss01” and so all the plain quotes have already been replaced at this point.</p><p>This technique only works for punctuation on the left, but as most text on-screen is set with a ragged right margin, we don’t need punctuation that hangs out to the right.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y5yhYUyoso7afhvZFIDE2w.png" /></figure><p>More work could be done — for example, Typeset moves “Y”s, “V”s and “W”s out a little too — but this serves as a proof of concept.</p><h3>Conclusion</h3><p>Implementing smart-quotes in your font is totally doable.</p><p>It’s not as good as using the correct glyphs in the first place, but it’s on-par with doing it in Javascript. And it’s a lot more convenient: there’s no code to run.</p><p>You can download my hacked version of <a href="https://github.com/ConradIrwin/fanwood">Fanwood Text</a> from GitHub, or <a href="https://cirw.in/etc/fanwood">preview it here</a>.</p><p>I used <a href="https://glyphsapp.com/">Glyphs</a> to open the existing Fanwood font and add new features. If you use a different app the UI may be slightly different, though I’m sure you can re-use the syntax.</p><p>That’s all for now — please recommend and share if you enjoyed this. And don’t forget to <a href="https://medium.com/superhuman-co">follow our publication</a> for more updates!</p><p>— Conrad, CTO @ Superhuman</p><p><em>At Superhuman we’re rebuilding the email experience for web &amp; mobile. Think vim / Sublime for email: blazingly fast and visually gorgeous.</em></p><p><em>We’re hiring experienced full stack engineers who love solving interesting problems in elegant ways: </em><a href="https://superhuman.com/jobs?utm_source=medium&amp;utm_medium=blog&amp;utm_campaign=smart-quotes"><em>learn more</em></a><em> or </em><a href="/service/mailto:conrad@superhuman.com"><em>email me</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dc630bc52c3f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/superhuman-co/how-to-hack-beautiful-flourishes-into-your-font-dc630bc52c3f">How to hack beautiful flourishes into your font</a> was originally published in <a href="https://medium.com/superhuman-co">Superhuman</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Do you have an idea?]]></title>
            <link>https://medium.com/@conradirwin/do-you-have-an-idea-3e59aa0b9baf?source=rss-96b7f0fc6b------2</link>
            <guid isPermaLink="false">https://medium.com/p/3e59aa0b9baf</guid>
            <dc:creator><![CDATA[Conrad Irwin]]></dc:creator>
            <pubDate>Mon, 17 Jun 2013 20:56:15 GMT</pubDate>
            <atom:updated>2013-06-17T20:56:15.212Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*jBXTXQOgJyPresDO.jpeg" /><figcaption>— bit.ly/FILMNOIR</figcaption></figure><p>As I was walking home through Palo Alto this evening, I was hailed by a stranger.</p><blockquote>J: Excuse me, sir.</blockquote><blockquote>Me: Hello?</blockquote><blockquote>J: What do you do for a living?</blockquote><blockquote>Me: I’m a software developer. How about you?</blockquote><blockquote>J: I’m a real estate guy. &lt;<em>pause&gt;. </em>Where’s your accent from?</blockquote><blockquote>Me: I’m from the UK.</blockquote><blockquote>J: Cool. I have a house in South Kensington.</blockquote><blockquote>Me: Nice.</blockquote><blockquote>J: So I can’t help feeling that the internet has kind of run out of steam, wouldn’t you say?</blockquote><blockquote>Me: <em>&lt;pause&gt;</em> I’m not sure what you mean….</blockquote><blockquote>J: Me neither. I’m drunk. <em>&lt;pause&gt;</em> Do you have an idea?</blockquote><blockquote>Me: I have several, what kind of idea?</blockquote><blockquote>J: You know, to fix it.</blockquote><blockquote>Me: Oh. I’m not sure. I guess progress is quite slow, it’d be nice to be able to speed up developers a little.</blockquote><blockquote>J: <em>&lt;pause&gt; </em>How old are you?</blockquote><blockquote>Me: I’m 23.</blockquote><blockquote>J: I’m 40. <em>&lt;pause&gt;.</em> Sorry, you missed it. I was going to write you a cheque of 20 million dollars to work on your idea.<em>&lt;walks off&gt;</em></blockquote><blockquote>Me: <em>&lt;walks on&gt;</em></blockquote><blockquote>J: <em>&lt;from a distance&gt; </em>Keep up the good work!</blockquote><p>While I’m reasonably sure that nothing I’d have said could have won me that cheque, it did make me think.</p><p>What will I say next time?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3e59aa0b9baf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Don’t be an angry developer]]></title>
            <link>https://medium.com/@conradirwin/dont-be-an-angry-developer-3576dd1882db?source=rss-96b7f0fc6b------2</link>
            <guid isPermaLink="false">https://medium.com/p/3576dd1882db</guid>
            <dc:creator><![CDATA[Conrad Irwin]]></dc:creator>
            <pubDate>Fri, 17 May 2013 18:06:22 GMT</pubDate>
            <atom:updated>2013-05-17T18:06:22.646Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6Mr2mMBCbJgpN9Le.jpeg" /><figcaption>ROCK DROPWING / ©Hans Hillewaert</figcaption></figure><p>I was an angry developer. If you know many developers this won’t surprise you, developers love being angry.</p><p>Why?</p><p>Two reasons: computers are stupid, humans are stupid, everything has bugs.</p><p>As programmers we’re in an unenviable position, we are the bridge between humans and machines. We teach machines what to do and we interpret their responses. On the face of it this sounds awesome, but there’s a problem.</p><p>The problem is that communication is hard. Communcation between humans and computers is particularly hard because humans are imprecise pattern-matchers but computers are precise number crunchers.</p><p>Source-code is supposedly a nice happy medium. It’s got lots of high-level structure and patterns so humans can guess what it’s doing, and plenty of low-level detail so computers know how to do it. But, for all its wonderful properties, source-code doesn’t solve the underlying problem: humans are not precise enough to write code that always works and computers cannot improvise or even notice when things are broken.</p><p>The result: Bugs. Everywhere.</p><p>Every single change you try to make fails to work first time. You’ll have bugs in your code, bugs in the code you’re calling, bugs in configuration, bugs in the tools you’re using, and bugs in things you didn’t even know were things until they broke. Sometimes you’ll waste hours fixing bugs, sometimes entire days.It’s enough to make anyone angry.</p><p>It used to make me angry too, but then I noticed: debugging is actually a lot of fun. It’s fun to try reading source code like a computer, it’s even more fun to try and guess at what’s wrong and use print statements to see if you’re right. Perhaps the most fun of all is to open a debugger and dissect the innards of a live program.</p><p>In the battle between your infinitely versatile human mind, and a totally predictable (albeit very buggy) machine, there’s always one winner: You.</p><blockquote>If debugging is the process of removing bugs, then programming must be the process of putting them in.</blockquote><blockquote>—Edsger W. Dijkstra.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3576dd1882db" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>