Is the compiler "smart enough" to know that I exited the loop and therefore the memory allocated to $j can now be reclaimed?

Perl doesn't reclaim lexicals, it just clears them. And yes, $j gets cleared.

sub DESTROY { print("DESTROYED\n"); }

for ( my $i = 0; $i < 10; $i++ ) {
    my $j = bless({});
    if ( $i == 0 ) { goto newlocation; }
}
newlocation:
  print( "jumped out" );
[download]

DESTROYED
jumped out
[download]

for ( my $i = 0; $i < 10; $i++ ) {
    my $j = $i;
    if ( $i == 5 ) { goto newlocation; }
  }
newlocation:
  print( "jumped out" );
[download]

Now my question is what happened to $j there? Is the compiler "smart enough" to know that I exited the loop and therefore the memory allocated to $j can now be reclaimed?

for ( my $i = 0; $i < 10; $i++ ) {
    my $j = $i;
    if ( $i == 5 ) { last; }
  }

  print( "jumped out" );
[download]

Or else, could you indicate why you have worries about the first construct, but not the last?

Even worse, what happens when I use goto to jump between subroutines?

It is because I don't know the answers to these questions that I do my best to avoid the use of goto

I have to admit, you weren't arguing against the use of goto in particular. You were arguing against using constructs you don't know the details about. That's a smart thing. The wise thing would be to actually learn about them instead of bragging ones ignorance.

The big difference between last and next is that those functions give deterministic answers to the compiler as to code flow. On the other hand goto may not offer as clear an indication of the target; although given a label the compiler may be able to work out whether the destination is outside the given closure anyway.

So here's the next example, what does the following do:

  for ( my $i = 0; $i < 10; $i++ ) {
    my $j = $i;
    if ( $i == 5 ) { goto nextpoint; }
  }

  for ( my $k = 0; $k < 10; $k++ ) {
    my $m = $k;
nextpoint:
    print( "$m\n" );
  }
[download]

Well I tried it, but the point is I didn't know what it would do before hand. If that is "bragging one's ignorance" then so be it. Rightly or wrongly I came from a C background where if you tried risky behaviour like this you got into real trouble. Perl is far more forgiving.

I do prefer to program in a manner that has a degree of portability between languages; as I said before, goto is risky: if you consider yourself an expert in the language at the time and the compiler behaviour and implications (if any) to the stack then by all means go ahead. I'll stick to what I know is safe.

So here's the next example, what does the following do:

Well, that's answered by the same second line of the goto documentation: It may not be used to go into any construct that requires initialization, such as a subroutine or a foreach loop.

For the third example, will to be trying to goto in a while block?