An advantage of interpreted languages
One of the useful things about interpreted languages like Python for programming, especially system administration, is that there is no distinction between the source code and the executable program. This means that you never have to play the exciting game of 'where's the source, and for that matter the build instructions, and does it even build with a modern compiler?'
(I once had the interesting assignment of converting a program written
for the V6 Unix version of C into something that would compile on a more
conventional C compiler. For those that have not encountered it before,
the V6 version of C put the operator on the right side of the
in-place assignment (eg
=+ instead of the modern
+=), among other
This means that when I write something in Python, Perl, or so on, everything is right there and complete; I do not have to worry that I may be abandoning co-workers with infrastructure that they have no idea how to reproduce. I find this reassuring, because it means that we have at least a fighting chance if something goes wrong.
(I once heard a story about a pretty much irreplaceable machine, which was that way because the developer of the program running on it had died and no one had any idea where the source code was. That's the kind of thing that can all too easily lead to an appearance in comp.risks.)