DEV Community: Rob Lauer

Python 3.15 (Or, How Python is Slowly Becoming Perl)

Rob Lauer — Fri, 24 Jul 2026 15:13:47 +0000

Here we go again. The tech sphere is buzzing, Medium articles are

dropping, and the Python community is collectively celebrating

the "revolutionary" features coming in Python 3.15.

I read through the latest feature announcements, and as someone who

has spent over four decades in IT, 3 of them writing Perl code, I

couldn't help but smile. For years I have felt like Python is

essentially just Perl for folks who found Perl "too indecipherable".

But Python it seems to me has become a Frankenstein monster born out

of someone's irrational fear of curly braces and sigils (that's @$%

for you Pythonistas).

And looking at the Python 3.15 changelog, it is clearer than ever:

Python is not really innovating, it's just improving itself by borrowing

concepts that Perl has embraced like...forever.

Let’s take a look at the "groundbreaking" features in Python 3.15.

1. The "Lazy Import" Revolution

Python 3.15 introduces lazy import syntax to speed up initialization

times. The idea is simple: don't load a heavy module until the exact

moment you actually need to execute it - because you might not need to.

Revolutionary, right? Except Perl developers have had require and

autouse for decades. Perl solved dynamic, on-demand loading back

when developers realized milliseconds (and size) matter when running web

applications. No special syntax proxy; Perl just trusts the

programmer to know when to pull things into memory (and complains

loudly if they forget).

2. Flattening Nested Data

Python is now touting the ability to use *group unpacking inside

list comprehensions so that developers can finally flatten nested

lists without writing confusing, double for-loop syntax.

Meanwhile, in Perl: @flat = (@list1, @{$list2}, %list3).

Lists just flatten. By default. Perl doesn't make you go through hoops

(or loops) or wait for a major version bump to accomplish something as

mathematically fundamental as combining arrays. And for more exciting

ways of manipulating arrays see List::Util!

As much as I hate to see Perl bolt on too much syntactic sugar, some

of the features of List::Util should have been part of the

language. The compromise was adding List::Util to core in Perl

5.7.

3. Immutability

Python 3.15 is finally adding frozendict as a built-in type to give

developers a truly immutable dictionary. I'm sorry, but frozendict?

Is that supposed to be some kind of locker room humor? I can't wait

for Python 3.16 to introduce limpdict and of course the corrupted

hash - soredict.

Immutability is a good idea, especially for configurations. But

watching Python incrementally bolt on data-locking mechanisms rings a

bell. I think I've heard this one before. constant?, Readonly?,

Hash::Util::lock_keys? Buehler? Anyone?

4. Help! I Have a Syntax Error!

When a developer accidentally tries to use JavaScript syntax in Python

(like .push() instead of .append()), Python 3.15 will now catch

the error and politely suggest the correct method. I think this says

something about the average Python developer by the way if they really

need this feature. I suppose (hope) it's aimed at Python newbies. But

it is also a very polite, modern echo of Perl's use diagnostics;

(which almost no Perl programmer today would leave in production code

and probably doesn't even need while developing new code!).

The Final Assessment

Python is fine (I guess). It has clearly won the popularity contest in

the data science and ML spaces (and yes I'm jealous). These 3.15

updates - including a new Tachyon sampling profiler (see

Devel::NYTProf) and a much stronger JIT compiler - are genuinely good

improvements.

But let's be honest, stripped of the marketing hype, Python is on a

trajectory as predictable as Halley's Comet. It morphed from a

minimalist, heavily opinionated scripting language with OWTDI (one way

to do it) into a language that is now appeasing developers looking for

TIMTOWDI (there's more than one way to do it)!

Python is begrudgingly bolting on the things I've always appreciated

about Perl. It's actually annoying to watch, especially since these

are the exact same features Python developers originally claimed to

hate about Perl.

Feature Comparison: Python 3.15 vs Perl

Feature	Python 3.15	Perl 5.10 / Ecosystem
Lazy Loading / Delayed Imports	Introduces `lazy import` syntax to defer module loading.	`require` and `autouse`
Flattening Nested Data	Allows `*group` unpacking directly inside list comprehensions.	Native list context and array flattening (`@flat = (@a, @b)`)
Immutable Dictionaries	Adds `frozendict` as a built-in, read-only dictionary type.	The `constant` pragma, `Hash::Util::lock_keys`, and the `Readonly` module
Helpful Error Messages	Provides contextual typo suggestions, like replacing `.push()` with `.append()`.	The `use diagnostics;` core pragma
Zero-Overhead Profiling	Introduces the Tachyon Sampling Profiler for running processes.	The `Devel::NYTProf` CPAN module

Python is finally catching up. Maybe in another 76 years, they'll

discover the power of @_.

Release Notes in 3 minutes vs 30 using AI - More Makefile Magic

Rob Lauer — Tue, 17 Mar 2026 16:51:48 +0000

Use a make target to help AI generate detailed and accurate release notes.

https://blog.tbcdevelopmentgroup.com/2026-03-17-post.html

Go Ahead ‘make’ My Day

Rob Lauer — Fri, 14 Nov 2025 11:33:57 +0000

Last in my 3 part series on GNU make and scriptlets!

Bump Your Semantic Version

Rob Lauer — Sun, 20 Apr 2025 14:27:05 +0000

While looking at some old bash script that bumps my semantic
versions I almost puked looking at my old ham handed way of bumping
the version. That led me to see how I could do it "better". Why? I
dunno know...bored on a Saturday morning and not motivated enough to
do the NY Times crossword...

So you want to bump a semantic version string like 1.2.3

major, minor, or patch - and you don’t want ceremony. You want one line, no dependencies, and enough arcane flair to scare off coworkers.

Here's a single-line Bash–Perl spell that does exactly that:

v=$(cat VERSION | p=$1 perl -a -F[.] -pe \
'$i=$ENV{p};$F[$i]++;$j=$i+1;$F[$_]=0 for $j..2;$"=".";$_="@F"')

What It Does

Reads the current version from a VERSION file (1.2.3)
Increments the part you pass (0 for major, 1 for minor, 2 for patch)
Resets all lower parts to zero
Writes the result to v

Scriptlet Form

Wrap it like this in a shell function:

bump() {
  v=$(cat VERSION | p=$1 perl -a -F[.] -pe \
  '$i=$ENV{p};$F[$i]++;$j=$i+1;$F[$_]=0 for $j..2;$"=".";$_="@F"')
  echo "$v" > VERSION
}

Then run:

bump 2   # bump patch (1.2.3 => 1.2.4)
bump 1   # bump minor (1.2.3 => 1.3.0)
bump 0   # bump major (1.2.3 => 2.0.0)

Makefile Integration

Want to bump right from make?

bump-major:
    @v=$$(cat VERSION | p=0 perl -a -F[.] -pe '$$i=$$ENV{p};$$F[$$i]++;$$j=$$i+1;$$F[$$_]=0 for $$j..2;$$"=".";$_="$$F"') && \
    echo $$v > VERSION && echo "New version: $$v"

bump-minor:
    @$(MAKE) bump-major p=1

bump-patch:
    @$(MAKE) bump-major p=2

Or break it out into a .bump-version script and source it from your build tooling.

How It Works (or ...Why I Love Perl)

-a            # autosplit into @F
-F[.]         # split on literal dot
$i=$ENV{p}    # get part index from environment (e.g., 1 for minor)
$F[$i]++      # bump it
$j=$i+1       # start index for resetting
$F[$_]=0 ...  # zero the rest
$"=".";       # join array with dots
$_="@F"       # set output

If you have to explain this to some junior dev, just say RTFM skippy
perldoc perlrun. Use the force Luke.

And if the senior dev wags his finger and say UUOC, tell him Ego
malum edo.