I mostly try not to review books before I've finished reading them, but I'll make an exception in this case as I feel I've read a fair amount and can reasonably comments.
This book is something of a classic, and I must have bought it something like 20 years ago. At which point it basically sat on my shelf. (<checks> Oh, yes, it's got the Johnian crest on it, so I got it with my undergrad book grant!)
It really doesn't look like it should be read end-to-end. Each chapter is pretty self-contained and deals with solving different problems. So, I've been dipping in and reading whatever chapters look fun at the time. It's also not a book you're going to fully understand by reading lightly. However, I'm mostly interested in a survey of numerical techniques, so I'm reading lightly and shrugging at the fact I don't get all the subtle details. If I ever really need to get into the subtleties, I can always re-read!
My impression at the time I bought it was that this was the Monster Fun Manual of Numerical Algorithms. Reading it now, it reminds me of Knuth. Numerical Algorithms are a huge subject, and this book alone, as an overview, can't do it justice. Each subject is an overview, some hints and tips, maybe some results without proof, a chunk of implementing code and a bunch of references to more in-depth texts. In reality, the minimal introduction to numerical algorithms is about 2 feet of textbooks. Even then, we'll probably have Knuth Disease, and you'll end up with textbooks that represent the state of the art 20 years ago, and everything should be superseded by research papers, if you can find the right ones.
One of the great things about the book, the thing that sets it apart for me from similar books, is not the included code, but the hard-won experience. The part that says "Algorithm A is, in theory, better, but in practice Algorithm B is a lot simpler, more stable, and generally does the job really well". I wonder how well that part dates?
One of the other things this book reminds me is that not all code is self-explanatory. I must say, I hate the style of the code in the book - it's very, er, scientist code. You can almost taste the Fortran. However, when I look at the code, I see no way it could be written to make it self-explanatory. If you received the code without comments and without vast numerical knowledge, there's no way you'd work out what the code is supposed to do! This is very different from the kind of code I'm used to working on, and I think it's useful to remind myself that not every algorithm can be made intuitive or transparent (*).
((*) Or maybe it can. But that's beyond my abilities!)
In short, I have no idea whether the contents of this book are a good idea of real-world practitioners. Maybe it's a good starting point to build the base knowledge on which to get the latest and greatest from the internet. However, I'm not deep into this stuff, but it's interesting. It's still a great start for people like me, who don't really care if their knowledge in this area is 20 years out of date. :)