[0] https://github.com/rectorphp/rector

What kind of things are you having problems with in regards to backwards compatibility?

The one time you actually may have had to work on things was with PHP 7, but that's because they finally removed things that had been deprecated for years, some for over a decade, and all of them were security risks or massive code smell anyway.

The one thing with PHP 8 was the removal of dynamic propery, and again that's a massive code smell that was holding the language back. Any code still using it when PHP 8 released was either written over a decade ago, or something that has way more issues than that with upgrading.

If two packages I require depend on incompatible versions of some third package, there aren't any easy ways for me to resolve it.

This problem exists because of the global nature of PHP namespaces.

A module system and less reliance on PSR the better. Why exactly does PSR still exist?

As a maker, I prefer a clean stack. So that its complexity does not slow me down. Workarounds make development slower and slower, the more it becomes a giant hairball of workarounds and workarounds around workarounds.

In Python and JavaScript, I don't need those workarounds. Would be awesome if PHP catches up.

Your solution works, but unfortunately not something that has any community support. I proposed something similar a year ago but use classes instead because classes seems to be the internal building block in PHP.

For both our solutions is would relatively easy to add a shim to older PHP versions.

module.php

    <?php
    
    return new class {
        public const MY_CONST = 47;

        private const MY_PRIVATE_CONST = 127;
    
        // with PHP 8.1 you also have readonly properties
        public string $myPublic = 'foo';
    
        private int $myPrivate = 17;
    
        public function helloWorld(string $name): void
        {
            echo "Hello, World {$name}!";
        }
    };

    <?php
    
    final class ModuleException extends Exception {
    }
    
    function module(string $name): object
    {
        static $modules = [];
    
        if (isset($modules[$name])) {
            return $modules[$name];
        }
    
        try {
            $module = @require $name;
        } catch (Error $error) {
            throw new ModuleException("No such module {$name}", 0, $error);
        }
    
        if (!is_object($module)) {
            throw new ModuleException("Module {$name} is not an object");
        }
    
        $modules[$name] = $module;
        return $module;
    }
    
    $my = module('module.php');
    $my->helloWorld('Module system');
    
    $other = module('module.php');
    assert($my === $other);
    

If you use a framework then try to write all your own code outside of the framework and pass in all needed framework data as arguments to your own classes/functions.

All in all, super positive.