`swf`

is dead, a closed-source project shut down by its owner (Adobe) a few years ago.

Kazerad, best known as the artist-author of the web comic Prequel Adventure, wrote a touching eulogy for it on twitter here.

[Read it “unrolled” (all 15 parts together) here.]

Here’s a simple (first-year-calculus level) math puzzle:

What’s the limit as *n* → ∞ of *nx*⋅(^{nx}√*x* – 1) for *x* > 0 ?

The right insight makes it work out rather elegantly, but suppose your math muse is AWOL cavorting in Cancun today — is there a more systematic way to approach these kinds of problems? It turns out that the tools of Robinson’s hyperreal analysis are very good at attacking this stuff.

Since we’re looking at a limit as *n* approaches infinity, the first thing to do is to simply set *n* to infinity — or rather, to an arbitrary infinite hyperreal (all the positive infinite hyperreals are indistinguishable in a deep sense). The second step is to write everything in terms of infinitesimals, so we introduce the infinitesimal *m* = 1/*n* and our expression becomes *x*⋅((^{x}√*x*)^{m} – 1)/*m*.

Now we want to get everything expressed as polynomials of infinitesimals (here just *m*) of as low an order as lets things work out, so we expand the Maclaurin series of all the not-ploynomial-in-*m* stuff. Here that’s only *f* (*m*) ≝ (^{x}√*x*)^{m}, which expands to *f* (0) + *f ’* (0)⋅*m* + *o*(*m*²) = 1 + (ln ^{x}√*x*)⋅*m* + *o*(*m*²) because *f ’ *(*m*) = (ln ^{x}√*x*)⋅(^{x}√*x*)^{m}.

Plugging this back into *x*⋅((^{x}√*x*)^{m} – 1)/*m* gives *x*⋅((ln ^{x}√*x*)⋅*m* + *o*(*m*²))/*m* = *x*⋅((ln ^{x}√*x*) + *o*(*m*)) = *x*⋅(ln ^{x}√*x*) + *x*⋅*o*(*m*). Now, *x*⋅(ln ^{x}√*x*) = ln (^{x}√*x*)^{x} = ln *x*. Also, *x*⋅*o*(*m*) = *o*(*m*) since *x* is finite. So *nx*⋅(^{nx}√*x* – 1) simplifies into ln *x* + *o*(*m*).

Since *m* is infinitesimal, *o*(*m*) disappears when we transfer back into ordinary reals and make *n* a limit index variable once again, and we have lim_{n→∞} *nx*⋅(^{nx}√*x* – 1) = ln *x*. Now, this is certainly more work than substituting in *w* ≝ 1/*nx* and applying l’Hôpital’s rule, but the general technique works on all kinds of limit calculations where *a-ha!* moments become few and far between.

Comments Off on Calculating limits with hyperreals

*Why Programming is Hard*, Volume CXX: the maintainers of critical pthread implementations will ignore multiple bugfixes from parallel programming experts for a longstanding deadlock bug for three years and counting.

Comments Off on How is this glibc deadlock still unaddressed?

*Why Programming is Hard*, Volume CXIX: a comprehensive explanation by JeanHeyd Meneide of how ABI stability stops us from having nice things despite enormous amounts of high-quality work on ABI-consistency and related issues. Naturally, it’s a dispiriting read. Fortunately, half a year later there’s this follow-up on how to fix it.

Comments Off on Do not meddle with the Application Binary Interface