== I'm still running a twelve year old Python program

I've been thinking for a while about the interesting and perhaps
somewhat remarkable fact that I'm still running a twelve year old
Python program (although not [[as intensely as I used to be
IndustrialPython]]). When I say twelve year old, I don't mean that
the program was first written twelve years ago and is still running;
I mean that [[the code https://github.com/siebenmann/portnanny]]
hasn't been touched since 2004. For bonus points, it uses a compiled
module and the source of the module hasn't been changed since 2004
either (although I have periodically rebuilt it, including moving
it from 32-bit to 64-bit).

(I was going to say that the tests all still pass, but it turns out
that I burned a now-obsolete IP address into one of them. Oops.
Other than that, all the tests still pass.)

While the code uses old idioms (it entirely uses the two argument
form of _raise_, for example), none of them are so old and questionable
that Python 2 emits deprecation warnings for them. I'm actually a
little bit surprised by that; even back in 2004 I was probably
writing old fashioned code. Apparently it's still not too old
fashioned.

Some of the long life of this old code can be attributed to the
fact that Python 2 has been moving slowly. In 2004 I was writing
against some version of Python 2.3, and the Python 2 line stopped
really changing no later than Python 2.7 in 2010. Really, I doubt
anyone was in a mood to deprecate very much in Python 2 after 2007
or so, and maybe earlier (I don't know when serious Python 3
development started; 3.0 was released at the end of 2008).

(With that said, [[Python 2.6 did deprecate some things
https://docs.python.org/release/2.7/whatsnew/2.6.html#deprecations-and-removals]],
and there were [[changes in Python 2.4
https://docs.python.org/release/2.7/whatsnew/2.4.html#porting-to-python-2-4]]
and [[2.5
https://docs.python.org/release/2.7/whatsnew/2.5.html#porting-to-python-2-5]]
as well.)

My impression is that this is a reasonably surprising lifespan for
an unchanged set of source code, especially in an interpreted
language.  Even in a compiled language like C, I'd expect to have
to update some function prototypes and stuff (never mind a move
from 32 bits to 64 bits). While it's certainly been convenient for
me in that I haven't had to pay any attention to [[this program
https://github.com/siebenmann/portnanny]] and it just worked and
worked even as I upgraded my system, I find myself a little bit sad
that Python 2 has moved so slowly that twelve years later my code
doesn't even get a single deprecation warning.

(The flip side argument is that my code would get plenty of warnings and
explosions if I ran it on Python 3. In this view the language of Python
as a whole has definitely moved on and I have just chosen to stay behind
in a frozen pocket of oldness that was left for people like me, people
who had old code they didn't want to bother touching.)

PS: It turns out that [[the Github repo
https://github.com/siebenmann/portnanny]] is somewhat ahead
of the state of the code I have running on my system. Apparently I
did some updates when I set up the Github repo without actually
updating the installed version. Such are the hazards of having any
number of copies of code directories.