<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Posts on </title>
    <link>https://paulbutler.org/posts/</link>
    <description>Recent content in Posts on </description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-us</language>
    <lastBuildDate>Sat, 08 Feb 2025 00:00:00 +0000</lastBuildDate><atom:link href="https://paulbutler.org/posts/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Smuggling arbitrary data through an emoji</title>
      <link>https://paulbutler.org/2025/smuggling-arbitrary-data-through-an-emoji/</link>
      <pubDate>Sat, 08 Feb 2025 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2025/smuggling-arbitrary-data-through-an-emoji/</guid>
      <description>This Hacker News comment by GuB-42 intrigued me:
 With ZWJ (Zero Width Joiner) sequences you could in theory encode an unlimited amount of data in a single emoji.
 Is it really possible to encode arbitrary data in a single emoji?
tl;dr: yes, although I found an approach without ZWJ. In fact, you can encode data in any unicode character. This sentence has a hidden message󠅟󠅘󠄐󠅝󠅩󠄜󠄐󠅩󠅟󠅥󠄐󠅖󠅟󠅥󠅞󠅔󠄐󠅤󠅘󠅕󠄐󠅘󠅙󠅔󠅔󠅕󠅞󠄐󠅝󠅕󠅣󠅣󠅑󠅗󠅕󠄐󠅙󠅞󠄐󠅤󠅘󠅕󠄐󠅤󠅕󠅨󠅤󠄑. (Try pasting it into this decoder)</description>
    </item>
    
    <item>
      <title>The hater’s guide to Kubernetes</title>
      <link>https://paulbutler.org/2024/the-haters-guide-to-kubernetes/</link>
      <pubDate>Sun, 03 Mar 2024 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2024/the-haters-guide-to-kubernetes/</guid>
      <description>Among a certain tech set, Kubernetes has earned a reputation as an unnecessarily complicated time-sink that startups should avoid. Using Kubernetes with a small team is seen as a sign of over-engineering.
I’m guilty of taking pithy jabs myself.
I might gripe about Kubernetes sometimes, but it really is a great piece of technology. I highly recommend it to all my competitors.
&amp;mdash; Paul Butler (@paulgb) September 9, 2022  Despite my snark, “great piece of technology” truly is sincere; at the time of that post I had recently written about how much of Kubernetes’ complexity is necessary for what it does.</description>
    </item>
    
    <item>
      <title>Generalizing Secret Santa with integer programming in Julia</title>
      <link>https://paulbutler.org/2022/generalizing-secret-santa-with-integer-programming-in-julia/</link>
      <pubDate>Sat, 10 Dec 2022 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2022/generalizing-secret-santa-with-integer-programming-in-julia/</guid>
      <description>You might know Secret Santa as the gifting game where each person in a group is assigned another person in the group to give a gift to.
For three years in a row, I’ve organized a post card exchange for plotter enthusiasts called #ptpx, which I think of as a sort of “generalized Secret Santa”. Instead of just sending and receiving one gift, participants choose how many postcards they’d like to make and send.</description>
    </item>
    
    <item>
      <title>Why is it so hard to give Google money?</title>
      <link>https://paulbutler.org/2022/why-is-it-so-hard-to-give-google-money/</link>
      <pubDate>Tue, 26 Jul 2022 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2022/why-is-it-so-hard-to-give-google-money/</guid>
      <description>I&amp;rsquo;ve been trying to run search ads on Google for over a month. Due to two unrelated snags, I&amp;rsquo;ve only had ~12 hours of uptime with those ads in that time. Based on conversations with other startups that run Google Ads, my experience is neither unique nor surprising. Apropos of Google&amp;rsquo;s earnings day, I wanted to vent a bit about how hard Google makes it to use the product that drives so much of their revenue.</description>
    </item>
    
    <item>
      <title>The problem with bitcoin miners</title>
      <link>https://paulbutler.org/2022/the-problem-with-bitcoin-miners/</link>
      <pubDate>Sun, 15 May 2022 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2022/the-problem-with-bitcoin-miners/</guid>
      <description>Disclosure: I hold short positions in companies mentioned in this article. This is not financial advice.
 Six months ago, I wrote:
 [Bitcoin] miners burn an enormous amount of capital just to capture the same slice of a diminishing pie, but they take advantage of investor confusion over how mining works to frame it as investing in growth.
 I want to go deeper on that idea. But first, some accounting.</description>
    </item>
    
    <item>
      <title>Rust for web devs: Destructuring</title>
      <link>https://paulbutler.org/2022/rust-for-web-devs-destructuring/</link>
      <pubDate>Sat, 19 Feb 2022 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2022/rust-for-web-devs-destructuring/</guid>
      <description>This is the first of an unbounded and weakly-ordered series of posts aimed at developers coming to Rust from a JavaScript/TypeScript background. It&amp;rsquo;s “for web devs” because my imagined reader is a web developer, but it&amp;rsquo;s not about web development. Nor is it meant to be a comprehensive introduction to Rust, just a series of essays on the parts I find interesting. If you&amp;rsquo;re brand new to Rust, you might want to start with The Book or Rust in Action.</description>
    </item>
    
    <item>
      <title>What does it mean to listen on a port?</title>
      <link>https://paulbutler.org/2022/what-does-it-mean-to-listen-on-a-port/</link>
      <pubDate>Sun, 13 Feb 2022 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2022/what-does-it-mean-to-listen-on-a-port/</guid>
      <description>This story explores some concepts in computer networking, inspired by Michael Nielsen&amp;rsquo;s idea of discovery fiction. Code samples can also be found in this repo. Excerpts use openbsd-flavoured netcat on Debian Linux; behviour and IPv6 support may vary by version.
PS: I&amp;rsquo;m currently hiring Rust and TypeScript developers for a YC-backed startup.
 In the corner of the student union building there is a coffee shop, and in the corner of the coffee shop are two students.</description>
    </item>
    
    <item>
      <title>“Play-to-earn” and Bullshit Jobs</title>
      <link>https://paulbutler.org/2021/play-to-earn-and-bullshit-jobs/</link>
      <pubDate>Tue, 28 Dec 2021 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2021/play-to-earn-and-bullshit-jobs/</guid>
      <description>In Bullshit Jobs: A Theory, David Graeber makes the case that a sizable chunk of the labour economy is essentially people performing useless work, as a sort of subconscious self-preservation instinct of the economic status quo. The book cites ample anecdotal evidence that people perceive their own jobs as completely disconnected from any sort of value creation, and makes the case that the ruling class stands to lose from the proletariat having extra free time on their hands.</description>
    </item>
    
    <item>
      <title>Betting Against Bitcoin</title>
      <link>https://paulbutler.org/2021/betting-against-bitcoin/</link>
      <pubDate>Tue, 26 Oct 2021 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2021/betting-against-bitcoin/</guid>
      <description>I hold what amounts to a bet against bitcoin, expressed in terms of options and shorts on public market bitcoin-related companies. Given that crypto discourse tends to be dominated by bulls and boosters because that&amp;rsquo;s who shows up, I wanted to share my bear case.
This is, emphatically, not investing advice. The position represents only a small part of my portfolio, and is something of a hobby project. The market can remain irrational, and all that.</description>
    </item>
    
    <item>
      <title>Calling WebAssembly from Rust</title>
      <link>https://paulbutler.org/2021/calling-webassembly-from-rust/</link>
      <pubDate>Sat, 14 Aug 2021 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2021/calling-webassembly-from-rust/</guid>
      <description>WebAssembly originated as a lightweight, portable, sandboxed code execution model for the web. Since its early days, people have realized that these qualities were useful outside of the web as well. As the standard has evolved, a wealth of tooling and standards for running WebAssembly ex-browser have appeared.
As I write this in August 2021, embedding WebAssembly involves understanding a handful of moving parts: language proposals at various stages of implementation; consensus emerging around standards like WASI; and maturing toolchains for various languages.</description>
    </item>
    
    <item>
      <title>Ranked-choice Voting for Data Scientists</title>
      <link>https://paulbutler.org/2021/ranked-choice-voting-for-data-scientists/</link>
      <pubDate>Sat, 12 Jun 2021 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2021/ranked-choice-voting-for-data-scientists/</guid>
      <description>In a few weeks, New York City will become the largest US jurisdiction to use instant-runoff voting when it is used in the mayoral primary elections.
Ranked-choice elections generate a lot of data. It&amp;rsquo;s not clear yet how much of this data the New York City Board of Elections will release immediately following the election — a bill that would mandate a broad data release did not pass before the assembly adjourned on Friday.</description>
    </item>
    
    <item>
      <title>The WebAssembly App Gap</title>
      <link>https://paulbutler.org/2020/the-webassembly-app-gap/</link>
      <pubDate>Sun, 17 May 2020 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2020/the-webassembly-app-gap/</guid>
      <description>To users of Figma, it&amp;rsquo;s no mystery why the browser-based design tool is popular. What has been a mystery to me is why it&amp;rsquo;s so hard to point to Figma equivalents in other categories. Specifically, I mean browser-based apps that embrace modern browser tech (WebAssembly, WebGL) to compete head-to-head with desktop apps without having to compromise features for performance.
The answer, I believe, is simply that nobody&amp;rsquo;s built them yet. This essay states the case for the modern browser as a platform, and explores some components that might fill the gaps in a modern stack.</description>
    </item>
    
    <item>
      <title>Comments on A False Majority</title>
      <link>https://paulbutler.org/2019/comments-on-a-false-majority/</link>
      <pubDate>Sun, 15 Sep 2019 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2019/comments-on-a-false-majority/</guid>
      <description>Over the past year, I have undertaken a project to analyze instant runoff elections at the ballot-level across multiple cities and states. To date, I have processed 31 instant-runoff elections, which has involved implementing in code the ballot counting and tabulation methods of five localities. In the process, I’ve gained some insight into how the instant runoff process works (and when it doesn’t), obscure trivia of state-to-state implementation differences, and tools for analyzing election results.</description>
    </item>
    
    <item>
      <title>The Kelly criterion: How to size bets</title>
      <link>https://paulbutler.org/2019/the-kelly-criterion-how-to-size-bets/</link>
      <pubDate>Sun, 27 Jan 2019 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2019/the-kelly-criterion-how-to-size-bets/</guid>
      <description></description>
    </item>
    
    <item>
      <title>Did the White House Doctor a Video?</title>
      <link>https://paulbutler.org/2018/did-the-white-house-doctor-a-video/</link>
      <pubDate>Fri, 09 Nov 2018 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2018/did-the-white-house-doctor-a-video/</guid>
      <description></description>
    </item>
    
    <item>
      <title>The Misunderstood Electoral College</title>
      <link>https://paulbutler.org/2018/the-misunderstood-electoral-college/</link>
      <pubDate>Tue, 06 Nov 2018 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2018/the-misunderstood-electoral-college/</guid>
      <description></description>
    </item>
    
    <item>
      <title>Understanding the Mandelbrot Fractal</title>
      <link>https://paulbutler.org/2018/understanding-the-mandelbrot-fractal/</link>
      <pubDate>Wed, 15 Aug 2018 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2018/understanding-the-mandelbrot-fractal/</guid>
      <description></description>
    </item>
    
    <item>
      <title>Optimizing Plots with a TSP Solver</title>
      <link>https://paulbutler.org/2018/optimizing-plots-with-a-tsp-solver/</link>
      <pubDate>Sun, 25 Mar 2018 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2018/optimizing-plots-with-a-tsp-solver/</guid>
      <description></description>
    </item>
    
    <item>
      <title>Tuning Style Transfer with a Control Surface</title>
      <link>https://paulbutler.org/2018/tuning-style-transfer-with-a-control-surface/</link>
      <pubDate>Sun, 18 Feb 2018 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2018/tuning-style-transfer-with-a-control-surface/</guid>
      <description>There&amp;rsquo;s a fun technique introduced by Gatys, Ecker, and Bethge that lets you reduce an image into separate &amp;ldquo;content&amp;rdquo; and &amp;ldquo;style&amp;rdquo; representations. Then, by taking a content representation from one image and the style representation from another, you can create a new image that matches the content of the first image in the style of the second.
The gist of style transfer is that you take a pre-trained image classification network (VGG-16 trained on ImageNet), and then run an image through it.</description>
    </item>
    
    <item>
      <title>Surface Projection</title>
      <link>https://paulbutler.org/2017/surface-projection/</link>
      <pubDate>Sat, 16 Dec 2017 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2017/surface-projection/</guid>
      <description></description>
    </item>
    
    <item>
      <title>Stop Dragging Hayek into Bitcoin</title>
      <link>https://paulbutler.org/2017/stop-dragging-hayek-into-bitcoin/</link>
      <pubDate>Sun, 12 Nov 2017 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2017/stop-dragging-hayek-into-bitcoin/</guid>
      <description>Note: This post discusses the relationship between Hayek&amp;rsquo;s work and cryptocurrencies, and is not financial advice. Opinions are my own. I do not hold a position in Bitcoin or other cryptocurrencies.
When monetary theory comes up in reference to Bitcoin, the work of Friedrich von Hayek is often invoked. I have read a number of claims that the Nobel laureate&amp;rsquo;s 1976 book, Denationalisation of Money,1 lays the theoretical foundation for the cryptocurrencies we see today.</description>
    </item>
    
    <item>
      <title>The Surprising Persistence of Bad Signals</title>
      <link>https://paulbutler.org/2017/the-surprising-persistence-of-bad-signals/</link>
      <pubDate>Sun, 24 Sep 2017 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2017/the-surprising-persistence-of-bad-signals/</guid>
      <description>How likely is a debtor to default on a loan? How likely is a student to succeed in college?
Both of these questions demand a probability that is impossible to measure directly. Instead, we find signals that proxy for them. SAT scores are meant to predict college success. FICO scores proxy for creditworthiness. We accept that there is a certain amount of measurement error in these scores.
If the market for these signals operated like markets for other things (say, lawnmowers or laundry detergent), we would expect that over time better signals would emerge and replace the existing ones.</description>
    </item>
    
    <item>
      <title>Fractal Generation with L-Systems</title>
      <link>https://paulbutler.org/2017/fractal-generation-with-l-systems/</link>
      <pubDate>Sun, 09 Jul 2017 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2017/fractal-generation-with-l-systems/</guid>
      <description></description>
    </item>
    
    <item>
      <title>Visualizing Flight Options</title>
      <link>https://paulbutler.org/2013/visualizing-flight-options/</link>
      <pubDate>Sun, 13 Jan 2013 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2013/visualizing-flight-options/</guid>
      <description>Few routine consumer purchases involve as great a volume of data as booking a flight. For an international trip, there can be dozens of options differing by price, duration, time-of day, connections, and carrier alliances. ITA Software, now part of Google, quietly introduced a Gantt chart-style visualization. The use of Gantt-charts for flights has since been perfected and popularized by Hipmunk. Hipmunk set the bar high, especially for domestic flights, by polishing the design and distilling the data to the minimum needed to book a flight.</description>
    </item>
    
    <item>
      <title>Make for Data Scientists</title>
      <link>https://paulbutler.org/2012/make-for-data-scientists/</link>
      <pubDate>Mon, 15 Oct 2012 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2012/make-for-data-scientists/</guid>
      <description>This is a follow-up to Chris Clark&amp;rsquo;s post, Engineering Practices in Data Science, and is cross-posted to the Kaggle blog.
Any reasonably complicated data analysis or visualization project will involve a number of stages. Typically, the data starts in some raw form and must be extracted and cleaned. Then there are a few transformation stages to get the data in the right shape, merge it with secondary data sources, or run it against a model.</description>
    </item>
    
    <item>
      <title>Groupon Visualization in HBR</title>
      <link>https://paulbutler.org/2011/groupon-visualization-in-hbr/</link>
      <pubDate>Mon, 25 Jul 2011 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2011/groupon-visualization-in-hbr/</guid>
      <description>A version of my Groupon visualization appears in the latest Harvard Business Review. At the suggestion of their editorial and design staff, I re-did the visualization to focus on a smaller subset of the data: deals in San Francisco.
I must give the HBR staff a lot of credit for the final product — they made a visualization designed to be interactive work in print.</description>
    </item>
    
    <item>
      <title>What $480 of Gross Revenue Looks Like to Groupon</title>
      <link>https://paulbutler.org/2011/what-480-of-gross-revenue-looks-like-to-groupon/</link>
      <pubDate>Mon, 28 Feb 2011 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2011/what-480-of-gross-revenue-looks-like-to-groupon/</guid>
      <description>On Saturday, the Wall St. Journal posted details of an internal Groupon memo that reported $760 million in revenue last year.
The WSJ article came just as I was finishing up a visualization of some data I had collected on Groupon deals, which gives perspective on that massive number in terms of the individual deals.
Each box is a deal. I used height to represent number sold, and width to represent the price.</description>
    </item>
    
    <item>
      <title>Visualizing Facebook Friends</title>
      <link>https://paulbutler.org/2010/visualizing-facebook-friends/</link>
      <pubDate>Sat, 18 Dec 2010 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2010/visualizing-facebook-friends/</guid>
      <description>Earlier this week I published a data visualization on the Facebook Engineering blog which, to my surprise, has received a lot of media coverage
I’ve received a lot comments about the image, many asking for more details on how I created it. When I tell people I used R, the reaction I get is roughly what I would expect if I told them I made it with Microsoft Paint and a bottle of Jägermeister.</description>
    </item>
    
    <item>
      <title>Data Structures for Range-Sum Queries</title>
      <link>https://paulbutler.org/2010/data-structures-for-range-sum-queries/</link>
      <pubDate>Sat, 10 Jul 2010 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2010/data-structures-for-range-sum-queries/</guid>
      <description>This week I attended the Canadian Undergraduate Mathematics Conference. I enjoyed talks from a number of branches of mathematics, and gave a talk of my own on range-sum queries. Essentially, range-aggregate queries are a class of database queries which involve taking an aggregate (in SQL terms, SUM, AVG, COUNT, MIN, etc.) over a set of data where the elements are filtered by simple inequality operators (in SQL terms, WHERE colname {&amp;lt;, &amp;lt;=, =, &amp;gt;=, &amp;gt;} value AND …).</description>
    </item>
    
    <item>
      <title>An experiment in A/B Testing my Résumé</title>
      <link>https://paulbutler.org/2010/an-experiment-in-a/b-testing-my-r%C3%A9sum%C3%A9/</link>
      <pubDate>Thu, 01 Jul 2010 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2010/an-experiment-in-a/b-testing-my-r%C3%A9sum%C3%A9/</guid>
      <description>Objective I’ll admit it: my résumé doesn’t stand out. I’ve had some great internships, but also a tendency to work for companies that aren’t (yet!) household names. And though I’m doing fine academically, it’s not well enough to stand out on my marks alone.
On the other hand, my blog lets me stand out. I’ve had a few opportunities to meet and interview with some great people and companies because they read my blog.</description>
    </item>
    
    <item>
      <title>Why R Doesn&#39;t Suck</title>
      <link>https://paulbutler.org/2010/why-r-doesnt-suck/</link>
      <pubDate>Sat, 19 Jun 2010 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2010/why-r-doesnt-suck/</guid>
      <description>I first encountered the R programming language a few years ago when I needed to make some plots. Although I’ve used it occasionally since, I always considered it a sort of “Perl for statisticians” — a useful swiss-army knife with ugly syntax and inconsistent semantics. My workflow generally involved manipulating the data in Python and using R to make a simple plot, minimizing the amount of R code I wrote as much as possible.</description>
    </item>
    
    <item>
      <title>Groupon Math: Data Scraping to Estimate Revenue</title>
      <link>https://paulbutler.org/2010/groupon-math-data-scraping-to-estimate-revenue/</link>
      <pubDate>Thu, 15 Apr 2010 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2010/groupon-math-data-scraping-to-estimate-revenue/</guid>
      <description>There’s been a lot of talk recently about the Chicago startup Groupon. Groupon brands itself as a group-buying site, but it’s really more of a localized version of what woot.com does. They post a new deal (which they call a Groupon) every day, available only on that day. If enough people want to buy it, everyone gets it for a substantial discount. Otherwise, nobody gets anything, but this rarely happens from what I can tell.</description>
    </item>
    
    <item>
      <title>Do we Really Need Another Programming Language?</title>
      <link>https://paulbutler.org/2009/do-we-really-need-another-programming-language/</link>
      <pubDate>Wed, 11 Nov 2009 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2009/do-we-really-need-another-programming-language/</guid>
      <description>Yesterday, a group inside Google released a new programming language called go. Among the many comments on the new language, I noticed a number of people rhetorically asking if there is really room for more programming languages. I’ve seen the same sentiment expressed before, seemingly whenever someone releases a pet language (Arc, Factor) or rediscovers an older programming language (Smalltalk, Erlang, LISP).
I’m convinced that there is, in fact, room for more programming languages.</description>
    </item>
    
    <item>
      <title>N-Queens in a Tweet</title>
      <link>https://paulbutler.org/2009/n-queens-in-a-tweet/</link>
      <pubDate>Wed, 24 Jun 2009 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2009/n-queens-in-a-tweet/</guid>
      <description>Most people who like puzzles or study computer science have probably encountered the famous N-Queens problem. If you haven’t, before reading any further, try this online version of the most popular form, the 8-Queens problem.
The 8-Queens problem is to find positions on a chess board for eight queen chess pieces so that none of them “threaten” the others. Since a queen in chess can move horizontally, vertically, and diagonally, this means placing each queen on her own horizontal, vertical, and diagonal lines.</description>
    </item>
    
    <item>
      <title>Python Debugging with Decorators</title>
      <link>https://paulbutler.org/2008/python-debugging-with-decorators/</link>
      <pubDate>Sun, 22 Jun 2008 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2008/python-debugging-with-decorators/</guid>
      <description>I’ve written a little python function which I have found to be very helpful for debugging. It takes a function, and returns a function which is identical to the original except that it prints a message to the console with useful information every time the function is called or returns.
Here is the function:
# Number of times to indent output # A list is used to force access by reference __report_indent = [0] def report(fn): &amp;quot;&amp;quot;&amp;quot;Decorator to print information about a function call for use while debugging.</description>
    </item>
    
    <item>
      <title>SimpleDiff in Python</title>
      <link>https://paulbutler.org/2008/simplediff-in-python/</link>
      <pubDate>Wed, 13 Feb 2008 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2008/simplediff-in-python/</guid>
      <description>A while ago I posted a PHP implementation of a diff algorithm I came up with. Since it was well received, and it’s a useful little algorithm to have, I created a Python version as well.
There are a few performance improvements as well. The PHP version creates an array in memory proportional to the square of the size of the input, while the Python version’s array is directly proportional to the size of the input.</description>
    </item>
    
    <item>
      <title>Tail Recursion in Python</title>
      <link>https://paulbutler.org/2007/tail-recursion-in-python/</link>
      <pubDate>Thu, 13 Dec 2007 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2007/tail-recursion-in-python/</guid>
      <description>After spending a lot of time in Scheme, it’s hard not to think in recursion from time to time. When I recently started to improve my Python skills, I missed having Scheme optimize my tail recursive calls.
For example, consider the mutually recursive functions even and odd. You know a number, n, is even if it is 0, or if n – 1 is odd. Similarly, you know a number is not odd if it is 0, and that it is odd if n – 1 is even.</description>
    </item>
    
    <item>
      <title>Garden Path Sentences</title>
      <link>https://paulbutler.org/2007/garden-path-sentences/</link>
      <pubDate>Wed, 27 Jun 2007 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2007/garden-path-sentences/</guid>
      <description>I recently came across an interesting post on the Powerset Blog recently about garden path sentences. Garden path sentences are sentences that lead you down the wrong path through a string of words with multiple meanings. For example,
The complex houses married and single students and their families  In this case, most readers would probably think complex was an adjective that modified the plural noun houses. The post ended with a challenge – how easy would it be to create a program to automatically generate these sentences.</description>
    </item>
    
    <item>
      <title>A Simple Diff Algorithm in PHP</title>
      <link>https://paulbutler.org/2007/a-simple-diff-algorithm-in-php/</link>
      <pubDate>Tue, 15 May 2007 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2007/a-simple-diff-algorithm-in-php/</guid>
      <description>A diff algorithm in its most basic form takes two strings, and returns the changes needed to make the old string into the new one. They are useful in comparing different versions of a document or file, to see at a glance what the differences are between the two. Wikipedia, for example, uses diffs to compare the changes between two revisions of the same article.
Solving the problem is not as simple as it seems, and the problem bothered me for about a year before I figured it out.</description>
    </item>
    
    <item>
      <title>webFractal: Web-based Fractal Explorer</title>
      <link>https://paulbutler.org/2007/webfractal-web-based-fractal-explorer/</link>
      <pubDate>Sat, 17 Feb 2007 00:00:00 +0000</pubDate>
      
      <guid>https://paulbutler.org/2007/webfractal-web-based-fractal-explorer/</guid>
      <description>Last weekend, I won a nice new Toshiba laptop in a local software competition. My entry was a web-based fractal explorer. I had a lot of fun making it, and it is fun to play with as well. I have decided to release it under an open-source license so that other people can play around with it (see the download link at the bottom of this post).
Unfortunately, I do not have access to a powerful Tomcat server with a lot of bandwidth, so I can’t host an online demo.</description>
    </item>
    
  </channel>
</rss>
