Answer.

Perl has historically been famous for its dynamic data structures: variable-length arrays and associative arrays (hashes). Even from the first versions of the language, they allow for resizing (push/pop, shift/unshift for arrays; deletion/addition of keys in a hash) on the fly. This flexibility is built into the Perl architecture: memory is managed automatically, and containers are expanded or contracted without explicit programmer intervention.

The problem arises during bulk changes: an inefficient order of operations can lead to unnecessary memory redistribution, while erroneous manipulation of the structure (e.g., iterating through foreach while simultaneously deleting an element) leads to bugs.

The solution is to use built-in bulk operations (splice, delete) or to build new structures using map/grep, avoiding manipulations of the structure during traversal.

Example code (bulk deletion by condition):

# Remove elements with even indices from the array
my @arr = (1..10);
@arr = grep { $_ % 2 } @arr; # Only odd numbers will remain

# Bulk addition
push @arr, (11, 13, 15);

# For hash
my %hash = (a => 1, b => 2, c => 3, d => 4);
delete @hash{ grep { $hash{$_} % 2 == 0 } keys %hash }; # remove even values

Key features:

All structures are dynamically expandable: no need to know the size in advance.
For bulk operations, it's more advantageous to work with map/grep than in a for loop with deletions inside.
There are built-in bulk functions (splice, delete, push, unshift) for efficient changes.

Tricky questions.

Is it safe to delete elements from an array while traversing it with for/foreach?

Answer: No, this will lead to incorrect behavior — the indices shift, and the loop "skips" elements. Use filtering (map/grep) or iterate in reverse order with splice.

How does autovivification affect the creation of new nested structures?

Answer: When accessing a non-existent element, Perl automatically creates a structure, saving time, but it can lead to unexpected side effects (creation of "empty" structures). Control this manually if strict memory management is needed.

my %h;
$h{newkey}{subkey} = 1; # Perl creates a sub-hash automatically!

Is overwriting an existing value in a hash always a fast process?

Answer: For scalar and most simple types, yes; however, if the value is a large structure or reference, there may be overhead due to reference counting. Large structures are better modified in place than by overwriting references.

Common mistakes and anti-patterns

Deleting elements within a foreach loop over the same array.
Taking "infinite" efficiency of push/pop for granted — with a large number of elements, their time is linear.
Using autovivification where it's not necessary, leading to memory leaks.

Real-life example

Negative case

A developer deletes elements from an array directly within foreach, resulting in some data remaining in the array, and the loop operates incorrectly.

Pros:

Written quickly, easy to read at first glance.

Cons:

Sometimes skips elements, bugs are difficult to trace.

Positive case

Uses @arr = grep { condition } @arr for filtering, or deletion by index is performed from the end of the array.