One thing that seems terribly broken in most IDEs/code-editors is that tiny spelling mistakes can ruin your program. Visual Studio helps out with AutoComplete, in that you can deliberately never fully type a variable/function yourself, always use intellisense to complete things and use the right letter case. Although it's still not completely immune.
When you run a script in Coda, say, first instinct is to look for functional problems, and usually there will be some, so you'll change stuff. But additionally there will be these tiny spelling errors, and failing to fix them right away leads to all sorts of trouble.
How do most folk deal with this? Just get 'better' at not making small mistakes?
How do most folk deal with this? Just get 'better' at not making small mistakes?
Yeah, this is exactly what happens when you do a lot of programming. Apparently, writing code isn't like writing natural language, where some people are terrible spellers and just can't get better. I know lots of programmers who are terrible spellers, some who can't spell a word twice the same way to save their lives, and in code they are as good at getting function and variable names right as anyone else. (FWIW, I observe this working in statically checked, compiled languages. Bad spellers don't seem to go through more "fix typo, compile, fix typo, compile" cycles than good spellers. It might be different when you don't have the compiler's immediate feedback pricking you to make fewer mistakes.)
The only problem is when people create class, function, and variable names that contain misspellings. Then your brain has to fight with itself, leading to repeated errors.
You get better at not making them - but much more importantly, you get better at realizing what mistakes you're likely to make, so when you make them and something doesn't work as expected, you find and fix the small mistakes very quickly.
You also generally get better at testing and at diagnosis.
Yeah you get better. It's like learning to ice skate, maybe... you fall a lot and get a lot of bruises at first but eventually it gets to the point where you don't think about it.
I learned to program before IDEs and I still use Emacs as my primary editor for almost everything. I find the Visual Studio "IntelliSense" type behaviors in most IDEs annoying in the extreme. But I can see how if that's what you started with, you'd come to find it useful.
With VS it's almost like testing each individual line though, at least for syntax and spelling. What I did was deliberately type things with as little attention to case/formatting as possible, and then watch to see VS transform it into neatness. Which meant it understood the line as expected.
Can't expect every editor to have the same features, but some sort of 'smart' plugin would that monitored your words and picked up things that were 'probably a mistake' would be useful. Then you could run the plugin every so often. A spelling mistake can be practically invisible because of the way your brain processes things.
