[int_19h]

> You need something more sophisticated than using smart pointers for everything. In the limit, smart pointers for everything is just called "Python".

I don't see how that follows at all. What makes Python Python (and slow!) is dynamic dispatch everywhere down to the most primitive things. Refcounted smart pointers are a very minor thing in the big picture, which is why we've seen Python implementations without them (Jython, IronPython). Performance-wise, yes, refcounting certainly isn't cheap, but you just do that and keep everything else C++-like, the overall performance profile of such a language is still much closer to C++ than to something like Python.

You can also have refcounting + something like `ref` types in modern C# (which are essentially restricted-lifetime zero-overhead pointers with inferred or very simplistic lifetimes):

https://learn.microsoft.com/en-us/dotnet/csharp/language-ref...

It doesn't cover all the cases that a full-fledged borrow checked with explicit lifetime annotations can, but it does cover quite a few; perhaps enough to adopt the position that refcounting is "good enough" for the rest.

[seanbax]

Python doesn't have lvalues in the way that C++ and Rust do. You can't refcount everything and still pass lvalues to subobjects. If lvalues to subobjects are important, you need borrow checking.

[int_19h]

Yes, which is why I mentioned C# "ref" which is not refcounting but zero-overhead pointers with a simplistic borrow checker that covers most practical scenarios.

[quotemstr]

> Jython, IronPython

Both of which have modern, concurrent, parallel, and generational garbage collectors.

[int_19h]

When you wrote "smart pointers" I naturally assumed refcounting specifically. If you include traced GC references in this category, then sure. Although even then languages like Java and Go are much closer in their performance to C++ than to Python, so even with this definition it's an odd comparison.