Answer

AUTOLOAD allows dynamically handling calls to non-existing methods or functions in a package. This is convenient for creating proxy objects, dynamically generated methods (ORM), implementing lazy loading logic, etc.

Example of using AUTOLOAD:

package MyAuto;
sub AUTOLOAD {
    our $AUTOLOAD;
    my ($self, @args) = @_;
    my ($method) = $AUTOLOAD =~ /::(\w+)$/;
    print "Called $method with @args
";
}
package main;
my $obj = bless {}, 'MyAuto';
$obj->any_method(1,2,3);   # Will invoke AUTOLOAD

Advantages

• Flexibility: can implement API access to dynamic properties/methods.
• Reduces boilerplate code.

Disadvantages and pitfalls

• Does not catch calls to new, DESTROY.
• Errors in implementation can lead to recursion.
• Debugging difficulties: it's not always clear from the stack trace what exactly was invoked.
• Performance degradation due to lack of direct calls.

---

Trick question

Question: Will AUTOLOAD be invoked if trying to call a non-existing constructor new?

Answer: No. Perl looks for the constructor new directly in the package and does not call AUTOLOAD for it if it's not found. AUTOLOAD is invoked only for regular method calls, not when trying to create an object via Class->new().

Example:

package Foo;
sub AUTOLOAD {
    print "AUTOLOAD!
";
}

# $obj = Foo->new(); # Error: Can't locate object method "new" ...

---

Examples of real errors due to lack of knowledge of nuances of the topic

---

Story In a cryptographic service, they implemented proxying for many similar methods through AUTOLOAD. They forgot to handle the situation with the DESTROY method, and when finalizing objects, infinite recursive calls occurred, causing the script to crash.

---

Story In an ORM, they used AUTOLOAD for magic field access, but did not implement correct value return when the method was actually absent. As a result, Perl issued a confusing message instead of "Can't locate...", with bugs appearing only in production.

---

Story During refactoring, they removed some actual methods, so all calls went through AUTOLOAD. This sharply decreased the performance of large tasks (processing an array of millions of objects became 10-15 times longer than before refactoring).