Yes, the definition of what "rewrite" means is open to interpretation. FWIW, I was following the spirit of the definition used by Joel Spolsky

I agree that the term is subject to interpretation, but I think using NT as an example of a "rewrite" (of 3.1 or 95), misses the spirit of Joel's definition.

There are 3 parts to any piece of software development

1. The design: This is the external view of the software.

   It includes the GUI or the CUI.

   It also includes any external interface APIS; input, output, and interchange file formats; communications protocols; and DB schemas.

   The interface can remain the same, whilst both of the following change.

2. The architecture: This is the internal structure and organisation of the software.

   This is harder to define, but for example, for interpreters and compilers, it covers such things as whether it is a single or multi-pass.

   It covers whether the program is written as a single monolithic flow, or is broken up into procedures and subroutines.

   For OO code, it determines how it is broken up into classes. For example, and MIS system might have Job Role as an attribute of an Employee class. Alternatively, an Employee might be an attribute of a Job Role class.

   For a server, it might be pre-forking; or event-driven; or on demand threaded; or thread-pooled; or some combination of two or more of those.

   The architecture is independent of the implementation. It may be implemented in many languages; or implemented many times in the same language.

3. The implementation: A specific set of source codes.

   You can re-write the implementation without changing the architecture.

   You can also re-architecture the program whilst retaining much of the existing implementation.

I think Joel Spolsky's example of the Netscape browser is a good example of a re-write because both version 4 and version 6 were effectively written to meet the same design: HTML rendered to a SDI GUI. My reading of his point is that whilst Netscape 4 had evolved into a spaghetti architecture, much of code underlying the rendering could have been retained.

I cannot comment on the Perl 4/5 transition as I never used 4 and have never looked at the implementation.

For Perl 5/6. Whilst the language retains the flavour of Perl, it is sufficiently different to consider that the design has changed. The complete segregation of the parsing & AST generation from the interpreter run-loop, means that the architecture is radically different. And the fact that almost nothing of the Perl 5 implementation could be reused--even if it was desired--means that the implementation has to be completely new. As such, I would say that it is not a re-write, but rather a substantial re-design; and radical re-architecture; and a completely new implementation.

And getting back to NT/95/3.1. 3.1 was a single user, single address-space, cooperative multi-tasking OS with no security, and no protection or differentiation between different tasks, nor even between application and kernel level code.

NT was designed from the ground up with sophisticated--many would say overcomplicated--security and right management; pre-emptive multi-tasking; strict segregation of kernel (ring 0) and user (ring 3) code; protected virtual address spaces; blah blah.

I think that as an example for your purposes, its inclusion actually weakens your argument.