Advantages:
1. Ensures everyone is developing on the exact same versions of every package
2. We have a complete record of correctly working dependencies' versions in the source tree at all times
3. Some random package developer can't introduce a bug in my software by pushing a new buggy version of their package right before I cut a release
Disadvantages:
1. You may not get bug fixes immediately. Solution: do a fresh `npm install` and `npm shrinkwrap` regularly (but not in the middle of testing a release branch, for example)
2. If someone unpublishes a version depend on you have to drop what you're doing and fix your npm-shrinkwrap.json
Also, `npm deprecate` allows package maintainers to deprecate specific versions (e.x. if a vulnerability is found), and you'll get a warning when installing, even if you use shrinkwrap. I'm not sure how common it's usage is though.
I've been programming for closing in on 20 years, and have seen a wide variety of approaches to the dependency management problem over that time, under a number of names. My experience is that locking down the version of every single dependency causes you to push off the pain of changing dependencies for a long time, but the upgrade headache will be far nastier when it happens. There is less overall pain from constantly integrating new versions and fixing breakage as it happens.
I doubt that the node.js community will realize this until they go through something like the series of remote code execution vulnerabilities that Ruby on Rails had a few years back. And then they find that all of their software is vulnerable and they can't get rid of the vulnerability until every library depends recursively on the latest version of everything so that you can get the security fix every place that you need it.
That upgrade will be a series of insane nightmares.