I'm not deaf but I think that there is enough a community for deaf people that they have a cultural identity of being deaf. By implanting children with the device, they are no longer in that culture, but neither are they a "normal" fully hearing person, even when they have the device plugged in. This may actually lead to a lower self-esteem for the child than if they were surrounded by people like them (i.e. deaf).
I have a fairly significant hearing loss which caused me a great deal of difficulty when I was at school. My hearing was good enough for me to definitely not be considered deaf, but it often wasn't good enough for me to be able to reliably have conversations with my peers (how well I can hear people varies hugely from very well to not at all).
At the time, I was seriously considering whether I would have preferred to be profoundly deaf for precisely the reasons you outline. Now, my hearing loss is much less of an issue for two reasons: one is that I have better hearing aids, and have had more time to adjust to them, and the other is that I have tuned my life so that I no longer feel any particular desire to socialise, avoiding the problem completely, but at the cost of living a rather more lonely life.
I may, however, just be taking my current level of hearing for granted; I don't know.
The love comes from all the cool things that Python can do, for free. Dynamic typing,
You do realize there's no dynamic typing in F#, right? It's very rigidly typed, in fact, more so than C/C#/Java - it won't let you use an int where a float is expected! (it's the price you have to pay for type inference - it doesn't play well with ambiguity)
The hate comes from the sheer lunacy that is Python syntax. Forced whitespacing doesn't suit my debugging style
F# is indentation-driven by default, much like Python (actually, more like Haskell, with more subtle rules). You can turn that off, technically, and use explicit semicolons - but that is considered legacy mode, and the community at large shuns it.
functions names like len() are just, frankly, idiotic (length() is much more readable to beginners, and takes only a few extra milliseconds to type for experienced users)
FP languages traditionally have terse names - how about the classic foldl and foldr ("fold left" and "fold right")? F# mostly follows suite - the most recent version is a tad more verbose, but you'll still be dealing with things such as Seq.mapi.
Although to be honest, I'd love to find a python front end that uses non-insane syntax and then simply precompiles it into python syntax at run-time.
On the whole, it looks like what you're looking for is actually called Ruby.
So why do we have so many unique languages?
It's because we don't have a clear idea on which language features are good, and which aren't. If you ask someone (say, me ~), you'll probably get a straightforward reply, but if you ask another guy, he is quite likely to strongly disagree on many major points.
There are many arguments both for and against dynamic typing, for example. There are similarly many arguments for and against OOP. There are advantages of having code pre-compiled to native, and there are also advantages of having a VM with a JIT compiler. Tracing GC vs manual memory management (+ smart pointers). The list goes on and on...
Within the static typing camp, there are still unsolved issues with the expressivity of type systems - some believe that typeclasses (Haskell-style) are the way to go, but there are still some unresolved problems there for more complex things. Some want effect typing. Some decry both as overcomplicated, and say that they're overkill, and it's easier to simplify the code.
Then there are bleeding-edge language features. Do we need STM? Do we even want it - can it be efficiently implemented at all?
Consequently, you get different languages, depending on which of the above (and many other) points are emphasized. Lately, we're starting to get more "kitchen sink" languages combining all approaches in hope that all of them are useful to one extent or another. F# is actually such a language, in a sense, being hybrid FP/OO (it also has "duck typing" member access, though no means to define true dynamic classes as in Python or Ruby). Scala is even more so.
Existing languages are also heading in the same direction - C# is a good example of that, starting its life as Java-like OO language, then getting some FP features in 2.0, a major FP'esque facelift in 3.0, and now duck typing in the upcoming 4.0.
By the way, F# isn't really a new language. The base language is ML, which is over 30 years old now. The specific ML dialect from which F# is derived is OCaml - that one is still in active development, but got started 14 years ago.
We go over there to give them aid, and they get mad because we weren't there sooner. When we actually are there, they shoot at us and steal our things.
Obviously you're grossly over-generalising, etc, etc. But more to the point, this is predictable, and it's not their faults. If you dine in front of a starving person, expect them to get angry. If you go on a spending spree in front of a homeless person, expect them to get pissed.
I don't know enough about the incident in question to respond directly to it, but I'm responding to your comment in general. They ("they" referring to the people in Haiti who have been affected by the disaster) do not have perfect information (they don't know whether the rest of the world is helping, or whether we're too busy with our trivial lives (which, incidentally, for the most part, we are)). If they see some folk who look like tourists, surrounded by life's luxuries, cruise by in a van, they're going to get angry. Sure, it'd be nice if they approached the situation more logically---maybe querying the tourists as to their purpose there---but in their situation, I'm betting emotions are going to come first.
Despite the fact that I strongly disagreed with her previous post, girlintraining made a good point about helping a drowning person. They're likely to cling to you, probably endangering you both. But that _doesn't_ mean you shouldn't help them, and that _doesn't_ make them a bad person. It's an understandable and predictable response. It means you should factor it in when trying to help them. If you want to help a lion with a thorn in its paw, don't be surprised if it tries to eat you first.
If there's no law enforcement left, just how are the emergency supplies that are moving all to slowly going to wind up in the right hands?
The "right hands"? That's rather arrogant of you.
No, it's not. The emergency supplies should be distributed as evenly as possible, with bias in favour of those who need it most. If you're in the sort of situation that people in Haiti are in, and you see a van full of everything you need to survive, you're quite possibly going to do whatever you need to do to get at it (as you yourself mention). Allowing this to happen is _not_ in the best interest of the population as a whole. Don't get me wrong, I'm not in the slightest blaming, judging or harbouring negative thoughts against these people---quite the opposite. But what I am saying is that to help them requires proper organisation, and not recklessly sparking a riot, during which supplies will be wasted, and distributed to only a fraction of the number of people which could be allowed to benefit from them.
Notice that just because I am writing this in the comfort of my armchair does not make it any less true. If I were in their position, I would probably do the same. If you read this as anything even resembling an attack on the people in question, then you read this wrong (or I explained it wrong, or whatever).
it will be stolen someday. (~750.000 stolen bikes per year, on 15 million people).
My understanding is that most of these bikes have built-in locks which go around the back wheel. These are extremely convenient, but provide almost no real security. Thus, your statistics probably don't apply to people who use a decent lock. So, if you want to ride an expensive bike in the Netherlands, use a decent lock.
If you're not part of the solution, you're part of the precipitate.