Question: I'm sending a subroutine a hash, and fetching it with `my($arg_ref) = @_;`

But what exactly is `%$arg_ref`? Is `%$` dereferencing the hash?

Answer: 
`$arg_ref` is a scalar since it uses the `$` sigil. Presumably, it holds a hash reference. So yes, `%$arg_ref` deferences that hash reference. Another way to write it is `%{$arg_ref}`. This makes the intent of the code a bit more clear, though more verbose.

To quote from `perldata(1)`: 

```
 Scalar values are always named with '$', even when referring
 to a scalar that is part of an array or a hash.  The '$'
 symbol works semantically like the English word "the" in
 that it indicates a single value is expected.

     $days               # the simple scalar value "days"
     $days[28]           # the 29th element of array @days
     $days{'Feb'}        # the 'Feb' value from hash %days
     $#days              # the last index of array @days

```

So your example would be:

```
     %$arg_ref           # hash dereferenced from the value "arg_ref"

```

`my($arg_ref) = @_;` grabs the first item in the function's argument stack and places it in a local variable called `$arg_ref`. The caller is responsible for passing a hash reference. A more canonical way to write that is:

```
my $arg_ref = shift;

```

To create a hash reference you could start with a hash:

```
some_sub(\%hash);

```

Or you can create it with an anonymous hash reference:

```
some_sub({pi => 3.14, C => 4}); # Pi is a gross approximation.

```
Since it's somewhat clear this construct is being used to provide a hash reference as a list of named arguments to a sub it should also be noted that this

```
sub foo {
  my ($arg_ref) = @_;
  # do something with $arg_ref->{keys}
}

```

may be overkill as opposed to just unpacking @\_

```
sub bar {
  my ($a, $b, $c) = @_;
  return $c / ( $a * $b );
}

```

Depending on how complex the argument list is.