Recently, I was forwarded a link to The Worthlessness of Code. James is right on the principles, i.e. that code is highly overvalued, that there is a another larger source of value largely ignored and the obstacle those misunderstandings place to necessary refactoring.
That said, I've got a few things to add here. First, the "value" of old code isn't the number one issue preventing rewrites. The biggest one is the customers, and the length of time rewrites take. Any reasonably skilled programmer can refactor from the old into the new, but no matter how skilled they are, it will take time. And in a major piece of software the sum of all those parts may add up to a greater duration than customers are willing to wait from one release to the next.
Worse yet, if the problem has been building for sometime, and you've lost large amounts of value already through "layoffs and attrition", those durations are even longer. That is why companies, after they've seen the light continue down the path we all know is wrong.
Advocating complete rewrites as the only solution doesn't solve the problem, you need to be smarter than that. If you're in a hole, jumping out seems to be a good idea, but what if it's too deep?
There are opportunities for just this situation. One part of the solution is to remember that there's probably pieces of "value" that really aren't worth anything. Nobody wants them. Finding that out can be difficult though so if you start writing from scratch with the goal of dropping a great deal of excess baggage, expect to have a "transition" release. That's the version that is nice bright and shiny, but everyone hates because it's missing X, or Y doesn't work the way they expect.
If you want to have a transition release and stay in business, you'll need a "keep em happy" path. Maybe you're lucky enough that the prior version is good enough customers with complaints can be accommodated by just letting them choose, old or new. But if you're in a hole, and have competitors, likely that's not the case.
So likely you're forced to have parallel tracks. Personally, my example is Windows 95/NT/98/2000/XP, but I'm sure there are others. Part of any parallel track strategy is finding ways to bring the distance between the tracks closer together. Good planning on both sides can make the transition a great deal smoother.
Another opportunity is that large pieces of software often have had so many features added, they're more like 5 applications than one application. The answer is to decompose. If you break down a large application into smaller composable pieces, you can create shorter release cycles. Plus, there lots of other good things to gain from decomposition. You can still offer the pieces together as a composite application, but the transition can manage each more independently than before. You'll still get stuck with transitioning and retirement, but in more manageable chunks.
Rewrite sounds so nice and clean, but if jump in that boat you better make your management and customers won't toss a the 2 ton dead weight of "legacy" in with you. It may just sink you.