So, like ikegami pointed out, always start your Perl programs with the following three lines:

#!/usr/bin/perl
use strict;
use warnings;

I also like to add:

$| = 1;

because it turns off buffering stdout, which means when you print something, it will immediately appear on the screen. Normally, when you print something, Perl will capture it and hold it in a buffer, and when the buffer gets full, then it will print it. So, you may get weird results where part of your program that you expect to produce some output appears to do nothing. So, basically, I always start my Perl programs with these four lines. The "use strict" and "use warnings" help you avoid weird problems in coding..

my $result = 0;

sub fib
{
 my  @frame = @_;

Note: When you are referring to a single element of an array or list, always put a $ sign in front of it instead of a @. When you use @ in front of an array or list, it means that you are referring to all of the elements. So, this code:

# @frame[0] = @frame[0] + @frame[1];
# @frame[1] = @frame[2];
# @frame[3] = @frame[2];

is better written as:

 $frame[0] += $frame[1];
 $frame[1] = $frame[2];
 $frame[3] = $frame[2];

You may notice that I also changed 

  @frame[0] = @frame[0] + @frame[1];

to

  $frame[0] += $frame[1];
  
just because it is shorter and nicer. 

 count($frame[0]);
[download]

Now, this is not a syntax error, but it's a program design error. Here in the next line you are calling the sub-routine itself, which can cause problems. If you call a sub-routine from within itself many times, that's often a bug. Why? Because each time you call a sub-routine, it uses memory. When you exit a sub, that memory is released. But if you call a sub-routine from within itself before exiting, then your program is just using more and more memory without the ability to release it, so this is a design flaw here. When you want to call a sub-routine from within itself, always think about the problem first and see if you can write the code in a different way, because this is leading to an undesired outcome. Here, in this case, your sub-routine is adding 2 to the first $frame[0] each time, and then the function calls itself millions of times. That means you are possibly using more than 10 megabytes of memory just to do this loop. So, try to redesign this code. I would create a for loop here instead.

 return fib(@frame) unless($frame[0] >= 4000000);
}

sub count
{
        my $increment = @_;
        if(($increment  % 2) == 0)
        {
                $result = $result + $increment;
        }

Another thing: When I do division by 2 and I'm looking
for the remainder, I always use & 1 instead of % 2 like so:

        if(($increment & 1) == 0)
[download]

Why? Because in the computer's internals, a division or multiplication is always slower than a logical operation. An & is a logical operation, because the processor can perform it in one step. A multiplication or division, on the other hand, can take hundreds of steps. So, you speed up your program if you avoid multiplication and divison whenever you can. In this case when you take a number and apply bitwise AND 1, it will leave you with the last digit, which is the same as dividing it by 2 and taking the remainder.

Or for example, when you are multiplying an integer by 2, I like to use the shift left operator << instead of multiplication. When I divide a number by 2, 4, 8, or 16... I use the shift right operator >> because it's faster. The processor can perform a shift in one step, while a multiplication can take longer, and division takes much longer. Example: $A << 3 is the equivalent of $A * 8

(Note: What I just told you about using bitwise AND and SHIFT only applies to integers under 4 billion. If you are making calculations with really big numbers that are far bigger than 4 billion, then you have to use the multiplication and division signs... ( * / % ). But for small numbers, you can use the bitwise operators ( & << >> ), because they are faster.)

}

fib(1,2,3);
print $result;

You're doing great!!