Another way to interpret it is that Perl uses the same mechanism C uses to perform this op, so however C behaves on your system, Perl should behave the same...

Perl doesn't use the same mechanism as C, however. Perl uses an optree, which (compiled) C doesn't do. (A C compiler may use a similar tree structure for optimizations, but it doesn't guarantee the order of operations for similar reasons, not because it uses the same mechanism.)

Since my co-worker can seem to accurately predict the printed results, it seems to defy everything (Or is it pure luck?) I've read in the reference materials that I quoted in my posting, that are available online. That's why I'm thinking someone may have an insight as to how this can happen on my system in such a consistent fashion. If not, so be it, but I was hoping to at least have a better understanding of it on my system, as it's acting.

Thank you Solo

brusimm:

It's consistent because Perl will generate the code the same way each time you compile it. However, another version of Perl may generate slightly different code for the same sequence.

For example, suppose you have the statement $j = $i++ + $i++;. It's perfectly acceptable for perl to implement it as:

   $temp_1 = $i;
   $temp_2 = $i;
   $j = $temp_1 + $temp_2;
   $i = $i + 1;
   $i = $i + 1;
[download]

and it's also acceptable for it to implement it like:

   $temp_1 = $i;
   $i = $i + 1;
   $temp_2 = $i;
   $i = $i + 1;
   $j = $temp_1 + $temp_2;
[download]

(Other implementations are also possible...) So while any particular perl compiler will be consistent from run to run, and program to program, different perl compilers (version, platform, vendor, etc.) are free to do it another way.

Your co-worker appears to know which way it's implemented on your perl compiler.

roboticus

Things can be entirely consistent and predictable and yet not reliable.

What?

When the docs say you can't rely on something, it means that the behaviour isn't part of the public interface. It's liable to change without notice.

In fact, docs are more likely to say that about predictable things, since those are the very behaviours which users are likely to assume are reliable.

This sort of thing is more of a problem when you do too much learning through experimenting. You can't tell whether things you learn via experimentation are defined behaviour or an accidental side-effect of implementation, so you need to check them against the docs before relying on them.