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.
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 limn→∞ 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.
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.
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.