Why not:
using namespace std;
map<int, vector<int>> whatever;
It's a lot shorter, actually correct, and it's totally cool to import whole namespaces in a .cpp implementation file where you're likely to actually declare something like that.
If you're going to critique the language you should try to learn it first.
I connected an SNMP monitoring system using two socats and an ssh tunnel. One socat to forward UDP over TCP to the locally encrypted port, and another to take it off on the other side and forward it to a local SNMP listener. It was a for a control system we were building that could monitor temperatures and control fan speeds in a computer cooling system. We ran it across several states in the US, and it was just to get an early demo of how the system would work before hardware was more locally available and the damned thing worked...
This made a lot of people very happy and it was really crazy to be on the phone with the other folks and have them rev up the fans in our lab via SNMP through this channel.
Coraid ships ATA over ethernet storage based on Plan 9.
Bell Labs still uses plan 9 internally and develops it.
9front is a community fork of Plan 9 with a bunch of interesting changes.
There's a small but interested community of die-hard plan 9'ers that care about it, and the principles it set forth. A lot of it came from some very good, very sane development with people who often spend more time thinking than coding (a virtue we could all benefit from I think)
If static typing wasn't useful, I don't think anyone would bother with types. At the same time some static type systems are restrictive while coding, so you're seeing more and more type inference in languages.
Go does it by allowing one to declare a variable with an expression " a := 1".
C++ 2011 has it with "auto"
Haskell is pretty darned good at it, and a lot of people don't write the types of their functions, though I think it's good practice to make sure you and the compiler agree on what you've written.
That said there's languages like Clojure which are dynamically typed in a sense, and I believe pay a slight performance penalty because they have to use reflection to behave that way. There's ways to annotate types in Clojure to get around that. This is an interesting case because Lisp is typically a dynamically typed language.
At the same time there's awesome languages and environments like Racket that have statically typed and dynamically typed versions of their scheme dialects.
My feeling is that a ruling on whether types are useful or not is sort of a pointless discussion. It's not even true that "the jury is out". You're just choosing tools with different properties and some make sense for some situations and others for others.
It's a lot shorter, actually correct, and it's totally cool to import whole namespaces in a .cpp implementation file where you're likely to actually declare something like that.
If you're going to critique the language you should try to learn it first.