Plus, of course, if you'd enabled perl's warnings system, via 'use warnings;', it would have complained at the use of == on a non-numeric value.
If you don't enable the compiler features that catch problems, then, yes, you can run into problems. Welcome to programming.
Edited to add: I got downvoted within five minutes. If you disagree that my bash analogy is inaccurate, I'd love to hear why.
Maybe not flattering, maybe not a good defense, but I think under the circumstances an acceptable comparison.
Keep in mind the subject here is maintainence - where small changes with minimal impact to production is the rule and the work is often done by programmers with incomplete knowledge and no patience for explanations. For maintenance you want KISS, not TMTOWTDI.
I'm no big fan of bash but at least bash gets the common case right here without any special settings. For example, if I use -eq instead of == and write
#!/bin/bash
x=`cat FOO 2>/dev/null`
if [ $x -eq 'bar' ]; then
echo baz
fi
as you imply, bash won't be silent. It will say bash-3.2$ ./example.sh
./example.sh: line 3: [: bar: integer expression expectedIn both cases, the reasoning is significantly to do with backcompat, I believe.
So, yeah, things that have been around a long time often require a setting to be safe in cases that we, ten or twenty or whatever years on, consider common.
Also: I did keep that in mind. That's why I started off suggesting using warnings, rather than (as I normally do for new code) making them fatal :)
Perl kept amazing backwards compatibility by adding extra statements to modify how it worked. So "use strict;", "use warnings;" and "use <other_newer_perl_features>;".
Both new code -- using the best OO system of the scripting languages, extendable syntax, etc, etc -- will run at the same time as most of the old and crufty stuff from before testing took over after the Millennium.
One could try to call them tradeoffs rather than mistakes, but then you'd have to explain why the programmer benefits from such circuitous thinking.
The mistake, if any, is that numbers and strings are unified into one scalar type in Perl. This allows some tricks, such as being able to use sprintf to perform rounding, but it has fallout in other places in the language, such as here. Given that numbers and strings are unified, having two operators for comparison is the correct decision: it makes the semantics much simpler by having the language not guess which kind of comparison to perform.
For bash, read http://unix.stackexchange.com/questions/16109/bash-double-eq... (especially http://unix.stackexchange.com/a/120235) and weep.
For perl, see for example http://www.perlmonks.org/?node_id=276023
This is why disciplined (i.e. non-tiny-script-y) perl code starts off with
use strict;
use warnings;
just like disciplined javascript starts off with /* use strict */
and disciplined C code enables compiler warnings, and truly disciplined C code makes those fatal, just like in perl you can do use warnings FATAL => 'all';
If you don't do that, then you get the short script/one liner style behaviour where, just like sed, awk or bash, it assumes you know what you're doing. If you don't, then you should be asking the VM to help tell you when those problems exist, same as 'set -x' in bash is incredibly useful if you don't plan to add '|| exit 255;' onto the end of every command.How do you evaluate this, depends on the context. Wasn't that the whole point of a dynamic language anyway?
Javascript, PHP and Perl are weakly typed. Smalltalk, Lisp, Python, Ruby... are strong typed. But all of them are dynamic.
[1] http://en.wikipedia.org/wiki/Strong_and_weak_typing#Predicta...
I don't particularly care how many forms of equality or comparison a language has as long as the compiler or runtime is capable of telling me the particular one I'm using is probably wrong. If == can't be used with strings the damn interpreter should tell me so instead of silently and improperly coercing the arguments.
$ perl -e 'use warnings; use strict; print "content" == "foo", "\n"'
Argument "foo" isn't numeric in numeric eq (==) at -e line 1.
Argument "content" isn't numeric in numeric eq (==) at -e line 1.
1Btw, Java will silently compare references instead of value. Learning a language != increasing vocabulary.