+=head2 C<use I<VERSION>>
+
+As of this release, version declarations like C<use v5.16> now disable all
+features before enabling the new feature bundle. This means that the
+following holds true:
+
+ use 5.016;
+ # 5.16 features enabled here
+ use 5.014;
+ # 5.16 features disabled here
+
+C<use v5.12> and higher continue to enable strict, but explicit
+C<use strict> and C<no strict> now override the version declaration, even
+when they come first:
+
+ no strict;
+ use 5.012;
+ # no strict here
+
+There is a new ":default" feature bundle, that represents the set of
+features enabled before any version declaration or C<use feature> has been
+seen. Version declarations below 5.10 now enable the ":default" feature
+set. This does not actually change the behaviour of C<use v5.8>, because
+features added to the ":default" set are those that were traditionally
+enabled by default, before they could be turned off.
+
+C<$[> is now disabled under C<use v5.16>. It is part of the default
+feature set and can be turned on or off explicitly
+with C<use feature 'array_base'>.
+
+=head2 C<UNIVERSAL::VERSION>
+
+The change to C<UNIVERSAL::VERSION> in 5.15.2 has been reverted. It now
+returns a stringified version object once more.
+
+=head2 C<substr> lvalue revamp
+
+When C<substr> is called in lvalue or potential lvalue context with two or
+three arguments, a special lvalue scalar is returned that modifies the
+original string (the first argument) when assigned to.
+
+Previously, the offsets (the second and third arguments) passed to
+C<substr> would be converted immediately to match the string, negative
+offsets being translated to positive and offsets beyond the end of the
+string being truncated.
+
+Now, the offsets are recorded without modification in the special lvalue
+scalar that is returned, and the original string is not even looked at by
+C<substr> itself, but only when the returned lvalue is read or modified.
+
+These changes result in several incompatible changes and bug fixes:
+
+=over
+
+=item *
+
+If the original string changes length after the call to C<substr> but
+before assignment to its return value, negative offsets will remember
+their position from the end of the string, affecting code like this:
+
+ my $string = "string";
+ my $lvalue = \substr $string, -4, 2;
+ print $lvalue, "\n"; # prints "ri"
+ $string = "bailing twine";
+ print $lvalue, "\n"; # prints "wi"; used to print "il"
+
+The same thing happens with an omitted third argument. The returned lvalue
+will always extend to the end of the string, even if the string becomes
+longer.
+
+=item *
+
+Tied (and otherwise magical) variables are no longer exempt from the
+"Attempt ot use reference as lvalue in substr" warning.
+
+=item *
+
+That warning now occurs when the returned lvalue is assigned to, not when
+C<substr> itself is called. This only makes a difference if the return
+value of C<substr> is referenced and assigned to later.
+
+=item *
+
+The order in which "uninitialized" warnings occur for arguments to
+C<substr> has changed.
+
+=item *
+
+Passing a substring of a read-only value or a typeglob to a function (potential lvalue context) no longer causes an immediate "Can't coerce" or "Modification of a read-only value" error. That error only occurs if and
+when the value passed is assigned to.
+
+The same thing happens with the "substr outside of string" error. If the
+lvalue is only read, not written to, it is now just a warning, as with
+rvalue C<substr>.
+
+=item *
+
+C<substr> assignments no longer call FETCH twice if the first argument is a
+tied variable, but just once.
+
+=back
+
+It was impossible to fix all the bugs without an incompatible change, and
+the behaviour of negative offsets was never specified, so the change was
+deemed acceptable.
+
+=head2 Return value of C<eval>
+
+C<eval> returns C<undef> in scalar context or an empty list in list context
+when there is a run-time error. For syntax errors (when C<eval> is passed
+a string), in list context it used to return a list containing a single
+undefined element. Now it returns an empty list in list context for all
+errors [perl #80630].
+
+=head2 Anonymous handles
+
+Automatically generated file handles are now named __ANONIO__ when the
+variable name cannot be determined, rather than $__ANONIO__.
+
+=head2 Last-accessed filehandle
+
+Perl has an internal variable that stores the last filehandle to be
+accessed. It is used by C<$.> and by C<tell> and C<eof> without arguments.
+
+It used to be possible to set it to a glob copy and then modify that glob
+copy to be something other than a glob, and still have it as the
+last-accessed filehandle after assigning a glob to it again:
+
+ my $foo = *STDOUT; # $foo is a glob copy
+ <$foo>; # $foo is now the last-accessed handle
+ $foo = 3; # no longer a glob
+ $foo = *STDERR; # still the last-accessed handle
+
+Now the C<$foo = 3> assignment unset that internal variable, so there is no
+last-accessed filehandle, just as if C<< <$foo> >> had never happened.
+