The main benefit of python to me is that while slow, it's predictable. I do think they're going to get a lot more resistance to adding JITs, moving GCs, etc. it will become java with a million knobs to tune. If people want a JIT'd python just use pypy, right?

On profilers - profiling will come in 3.15, are you referring to remote exec? It is a great feature I am very exited about, at the same time afraid that the company won’t allow ptrace capability in prod.

Java lost almost all those knobs a while ago (I mean they're there, but you're better off relying on the defaults). The modern GCs have one or at most two knobs remaining, and even that will become unnecessary next year. As to predictablity, you get maximal pause time of well under 1ms for heaps up to 16TB.

As Python using SRE and supporting Python Flask apps, most of us would love JIT in Python assuming it pretty much drop in replacement.

PyPy doesn't have the support it needs and is stuck on 3.11.

It is the same for me. Predicability is better than any optimization.

yes. remote exec allows me to attach profilers (e.g. memray) directly into a running process. i'm also excited about the upcoming statistical (cpu) profiler from 3.15

Resistance from anyone who matters to the developers?

Why not just use Go? It has a proper concurrent, non-moving GC that, AIUI, has not been associated with sudden memory spikes.

And if people want python with java, there's always Jython.

The no-GIL work (free-threading) is unrelated to this incremental GC work.

Free-threading actually uses its own, separate GC: https://labs.quansight.org/blog/free-threaded-gc-3-14

For personal projects, yes. For code going into production, you still need human code review, and that has to happen in a language that the humans you've hired are comfortable with. One day, we'll all be YOLOing vibe code straight into production, but that day is not today.

Jython is unmaintained, I'd recommend Clojure. Use python libraries and code while seamlessly targeting the JVM.

I think we'll eventually be generating machine code directly. But until then we should be using code that our team can actually read and understand. If you know go, then that works you, Not everyone does.

I think humans are still accountable for the code generated by agents.

You are free to switch language but you still need to understand it.

nothing about the performance characteristics of python changed with AI so why would you use python over golang if performance is a requirement/bottleneck? Trying to understand the reasoning as to me golang and python are equally simple to write and understand.

jython has been basically unmaintained for quite some time

Graal vm has support for python 3 unfortunately it’s funded by oracle.

If language X is a persons comfort zone, that person will often default to it. Python is certainly more widespread then go.

Also, even if it looks like that to you, there are still people that write code with their own hands.

Java is funded by Oracle, all of it.

People parrot to use OpenJDK without understanding it is mostly Oracle employees working on it.

And if you dislike Oracle, the other minor contributors are Red-Hat, IBM, SAP, Microsoft, Alibaba, Azul,... which for many HNers are the same.

Well, they never made the jump to Python 3. But shipping 2.7 interpreters in 2024 was quite an achievement on its own. So their users already know this pain. And from my experience in academia, python 2.7 and java 8 will probably be used for another 20 years before the last machine running that stuff burns out.

If it makes you feel any better (it probably doesn't), the development of OpenJDK and the Java language itself is also mostly funded by Oracle

jpype and graalpy are life.

jython went EOL.with python 2 going EOL.

For a new project, teams can decide whether to use Go, but there are many millions of lines of existing Python servers out there.

Not to mention that there are differences in ecosystem, familiarity, and ergonomics that may make a team want to stick with Python.

“Just use Go” is not really actionable advice in most cases.

Did really well, unfortunately.

There is almost no dog fooding on Windows development since version 8, Typescript team rather rewrite the compiler in Go, Azure has plenty of Go, Rust and Java projects alongside .NET.

With a similar amount of experience with both languages I found Go much easier to read. I've always been a bit miffed why Python is seen as easy to read for experienced developers. I get the syntax is good for short code or people with little experience but my experience is those readability benefits went away quickly with time or complexity.

Regardless of whether golang and python are actually equally simple, python certainly has the reputation of being easier to write and read than almost any other language. That is a big part of its popularity.

PEPs aren't necessarily just for language changes, e.g https://peps.python.org/pep-0436/ which is largely a CPython implementation detail.

Doubt it. LLMs will always be more expensive per-token than compilers, and high level languages need fewer tokens than machine code. Also, type systems, warnings, overlap with natural language in names - those are very useful.

Python is not really simple though, the semantics are actually quite bonkers. It just has "simple"-looking syntax, but that only helps you for trivial programs where the bonkers semantics does not get in the way.

Why are you miffed about it? I legitimately hate reading golang with passion and find python to be pretty intuitive, outside of the odd ambitious list comprehensions. I worked in a golang shop for several years, so it's not just an familiarity situation either.

We are just different. That's not something to be mad about.

I'm currently in a .NET shop so not an issue for me, makes me wonder if Python will eventually adopt the concept of LTS releases, this could have been avoided as an issue if it was part of a non-LTS release.

Any language that uses error codes instead of exceptions is a non-starter for me. Produces code that craps all over the happy path.

Python has a different problem: it is slow as f---. I did a micro benchmark comparison against 5 other languages in preparation for my python replacement language. Outside of dictionary lookups, it is 50-600 times slower than C depending on the workload.

Go, Rust etc are fine. They land at 1.25-3x slower than C. But I prefer the readability of python minus its dynamic nature.

In my opinion most interpreted languages today tend to produce very dense code. Fancy call chains and closures interleaving. If you look for a subtle bug those are hard to reason about, you have to know the details of a lot of different APIs.

Go is verbose partly for that reason, but a silly loop is a silly loop. The constraints are clear, you only have to do the logic.

Well, .NET is just not in the same class as Go and Rust.

Go is, essentially, nearly perfect at what it does - even if the language itself leaves much to be desired and would ideally be much safer.

Microsoft should up their game. They have a few research languages in development.

They've always been great with languages. Hopefully, they rise to the occassion.

Python is a garbage language. Dynamic types are a disaster for maintaining large codebases and we waste enormous amounts of compute running large systems with it.

Microsoft does use Go/Rest/Java in places but they still have a ton of .Net.

Windows Development is not "We are not dogfooding", it's that incentives are misaligned with customer wants.

.Net team incentives are aligned with customer wants, provide a language that is highly performant and easy enough to write.

We should all go back to writing assembly

No we should write one of the many modern programming languages that handle certain projects way better, including kotlin, go, or Java. The only things python is best in class at are scripting and as a harness for high performance c++ or fortran.

Oh, they really don't dogfood Windows development any longer, regardless of the incentives.

I have my WinRT 8, UAP 8.1, UWP 10, Project Reunion, .NET Native, C++/CX, C++/WinRT, XAML Islands, XAML Direct, WinUI 2.0, WinUi 3.0, WinAppSDK and what not scars to prove how they aren't dog fooding any piece of it in any meaningful manner.

Heck they keep talking about C++ support in WinUI 3, as if the team hasn't left the project and is now playing with Rust instead.

They managed that plenty of early WinRT advocates became their hardest critics, while not believing anything else they put out, like now this Windows K2 project.

All Python versions are LTS if you consider 5-year a good measure.

https://devguide.python.org/versions/

The only thing Go has going for it was getting lucky with Docker and co, and UNIX/Plan 9/Inferno pedigree.

Now we're stuck with it in anything CNCF related.

What? If you are talking web development, .Net is just about the same as Go. It's 100% Java OOP type writing but result is same, very performant API server.

Sure, Rust is completely different beast with different target system.

What about the projects that python handles better?

If all releases are LTS, then none are. Part of the point GP was making is that when some releases have a very short maintenance window, then changes that are terrible in them don't need to be reverted (since the maintenance window will close soon anyways).

Java 1.5 kind of thing, with plenty error handling boilerplate, errors as strings, and SCM urls straight in the code...

I like my programming language flame wars just as much as the next guy but Go is a really easy language to get started with, while also being very fast. It's not just luck

> The key point here is our programmers are Googlers, they’re not researchers. They’re typically, fairly young, fresh out of school, probably learned Java, maybe learned C or C++, probably learned Python. They’re not capable of understanding a brilliant language but we want to use them to build good software. So, the language that we give them has to be easy for them to understand and easy to adopt.

-- Rob Pike

Any reference to the biggest issues with Go in your opinion, and what are you comparing it to?

Basically complete disregard for the history of programming languages and learnt lessons.

Go fits well close to Oberon released in 1987, or Limbo in 1995, when exceptions and generics were still esoteric features.

Instead they had to reach out to Phil Wadler to help them, as he did previously with Java almost a decade earlier, panic/recover is clunky way to do exceptions, instead of doing enumerations like Pascal in 1976, it needs a a iota/const code pattern, hardcoded urls for source repos, if err all over the place like last century programming, many errors are plain strings, ah and nil interfaces what a great gotcha.

Thanks!