Consider the following.
var [Example Number] = 5;
[Example Number] = [Example Number] + 5;
print([Example Number]);
int[] [Examples Array] = new int[25];
[Examples Array][[Example Number]] = [Example Number]
Compare it with the more traditional example:
var ExampleNumber = 5;
ExampleNumber = ExampleNumber + 5;
print(ExampleNumber);
int[] ExamplesArray = new int[25];
ExamplesArray[ExampleNumber] = ExampleNumber;
I'm pretty sure you noticed that the strain for your brain to read the second example was much lower.
If you allow whitespaces on an identifier, you'll need to put some other language element to mark the start and the stop of a word. Those delimiters force the brain to do some extra parsing and, depending on which one you pick, create a whole new set of ambiguity issues for the human brain.
If you don't put delimiters, and try to infer what identifier you're talking about when typing code by context only, you invite another type of can of worms:
var Example = 5;
var Number = 10;
var Example Number = Example + Number;
int[] Examples Array = new int[25];
Examples Array[Example Number] = Example Number;
Example Number = Example Number + Example + Number;
print text(Example Number);
Perfectly doable.
A total pain for your brain's pattern matching.
Those examples are painful to read not only because of the choice of the words I'm picking, but also because your brain takes some extra time to identify what is every identifier.
Consider the more regular format, once again:
var Example = 5;
var Number = 10;
var ExampleNumber = Example + Number;
int[] ExamplesArray = new int[25];
ExamplesArray[ExampleNumber] = ExampleNumber;
ExampleNumber = ExampleNumber + Example + Number;
printText(ExampleNumber);
Do you notice something?
The names of the variables are still terrible, but the strain to read it went way down. That happens because your brain now has a natural anchor to identify the beginning and the ending of every word, enabling you to abstract away that part of your thinking. You don't need to worry about that context anymore - you see a break in the text, you know it is a new identifier coming.
When reading code, you brain doesn't much read the words as much as it matches it with what you have in your mind right now. You don't really stop to read "ExampleWord". You see the overal shape of the thing, ExxxxxxWxxd, matches it with whatever you have stashed in your mental heap, and them go ahead reading. That's why it is easy to miss up mistakes like "ExampleWord = ExapmleWord" - your brain isn't really reading it. You're just matching up similar stuff.
Once more, consider the following:
Example Word += Example Word + 1;
Now imagine yourself trying to debug that code. Imagine how many times you'll miss that extra space on "Example Word". A misplaced letter is already hard as fork to detect at first glance; an extra space is an order of magnitude worse.
In the end, it is hard to say that allowing whitespaces would make the text more readable. I find it difficult to believe that the added hassle of extra terminators and the extra overhead on my brain would be worth to use this type of functionality if the language I'm working with had it.
Personally, I consider it bad design - not because of the hassle on the compiler, interpreter, or whatever, but because my brain trips on those spaces thinking that it is a new identifier that is about to begin, when it is not.
In a sense, our brain suffers the same problems than our processors, when it comes to branch prediction.
So please, be kind to our trains of thought. Don't put whitespaces on your identifiers.
I completely forgot to add a mention to a language I use every single day accepts spaces in identifiers - SQL!
That doesn't mean it is a good idea to use them, however. Most people I know agree it's a Bad Idea to shove spaces around on your identifiers - to the point it's sometimes a forgotten feature of the language.
