News for hackers. Stuff that matters.
Re:Reverting the incremental GC in Python 3.14 and 3.15 by brianwawok on Wednesday May 13, 2026 @11:21AM (#48123130)
In the world of AI written code, Python just doesn’t make sense. Converted about 100k lines in the last few months to golang and the performance is life changing. Curious if we will see global Python adoption fall by 75% or more in the next few years.
Re:Reverting the incremental GC in Python 3.14 and 3.15 by dec0dedab0de on Wednesday May 13, 2026 @12:13PM (#48123871)
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.
Re:Reverting the incremental GC in Python 3.14 and 3.15 by H8crilA on Wednesday May 13, 2026 @03:53PM (#48126598)
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.
Re:Reverting the incremental GC in Python 3.14 and 3.15 by mau on Wednesday May 13, 2026 @11:40AM (#48123373)
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.

Re:Reverting the incremental GC in Python 3.14 and 3.15 by tdb7893 on Wednesday May 13, 2026 @11:49AM (#48123503)
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.
Re:Reverting the incremental GC in Python 3.14 and 3.15 by mywittyname on Wednesday May 13, 2026 @01:01PM (#48124545)
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.

Re:Reverting the incremental GC in Python 3.14 and 3.15 by Yokohiii on Wednesday May 13, 2026 @01:29PM (#48124883)
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.

Re:Reverting the incremental GC in Python 3.14 and 3.15 by __loam on Wednesday May 13, 2026 @01:17PM (#48124743)
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.
Re:Reverting the incremental GC in Python 3.14 and 3.15 by lijok on Wednesday May 13, 2026 @01:55PM (#48125208)
We should all go back to writing assembly
Re:Reverting the incremental GC in Python 3.14 and 3.15 by __loam on Wednesday May 13, 2026 @03:04PM (#48126028)
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.
Re:Reverting the incremental GC in Python 3.14 and 3.15 by lijok on Wednesday May 13, 2026 @04:45PM (#48127311)
What about the projects that python handles better?
Re:Reverting the incremental GC in Python 3.14 and 3.15 by __loam on Thursday May 14, 2026 @04:07PM (#48140542)
I mentioned those explicitly. People are still using it as a backend language for projects like huge SaaS deployments though, with the hypothesis being that dev time is expensive. With modern languages like kotlin and go, I think that gap is much too narrow to justify using a slow and badly designed language with good syntax.
Re:Reverting the incremental GC in Python 3.14 and 3.15 by 3836293648 on Wednesday May 13, 2026 @06:56PM (#48128692)
> X is a terrible language because of the lack of static analysis available.

> (Mocking) Yes, that's why we should go back to Y with even worse static analysis.

Sure

Re:Reverting the incremental GC in Python 3.14 and 3.15 by wiseowise on Thursday May 14, 2026 @02:38AM (#48131882)
> Python is a garbage language. Dynamic types are a disaster

Python has gradual type system.

Re:Reverting the incremental GC in Python 3.14 and 3.15 by sieve on Wednesday May 13, 2026 @04:35PM (#48127158)
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.

Re:Reverting the incremental GC in Python 3.14 and 3.15 by adrian_b on Thursday May 14, 2026 @12:09PM (#48137411)
Exceptions are not the only alternative to error codes.

Many early programming languages handled errors by providing multiple return addresses to functions.

Thus a function returned to the place of invocation in the normal case, otherwise it returned to one of the error handlers that were grouped at the end of the function that invoked it, away from the happy path.

This was more efficient than the modern way of returning an error code, as it eliminated the superfluous testing of the error code and the expensive conditional jump based on the result of the testing.

Moreover, in my opinion in the majority of the cases maximum information about an error is inside the function that has invoked the function where the error happened and neither in an exception handler several levels above it, nor inside the invoked function, so the place where the error handlers had to be put in this old method is actually optimal for meaningful error messages.

From the point of view of the source text, this old error handling method is equivalent with using exceptions with the constraint of placing the exception handlers in the function that has invoked the function that generates the exception. This limitation enabled a more efficient implementation than for exceptions where the handler can be placed anywhere above the invoked function and a complex stack unwinding may be necessary.

Re:Reverting the incremental GC in Python 3.14 and 3.15 by sieve on Thursday May 14, 2026 @05:27PM (#48141508)
While it sounds interesting, I do not see this gaining traction. My main complaint would be that I do not want to think about errors except when I want to. This system sounds like Java checked exceptions in a way. You have to handle every exception that a function might throw every single time. That eventually resulted in the famous catch-swallow stratagem.

I distinguish between Faults and Errors. Faults are system level events you cannot recover from. Errors are things you may encounter in the course of doing business. Most applications do not really need to do any recovery; simply tell the user something bad happened and ask them to fix the problem.

For workflows that do need error recovery, or functions with logical failure conditions, you are free to use a Result or Optional type.

Also, I have implemented exception handling with stack unwinding for my VM. The code that does it is not really that complex. If you want to retry... then things get messy.

Re:Reverting the incremental GC in Python 3.14 and 3.15 by backwardation_b on Wednesday May 13, 2026 @11:33AM (#48123274)
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.
Re:Reverting the incremental GC in Python 3.14 and 3.15 by phainopepla2 on Wednesday May 13, 2026 @11:41AM (#48123393)
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.
Re:Reverting the incremental GC in Python 3.14 and 3.15 by zozbot234 on Wednesday May 13, 2026 @02:16PM (#48125455)
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.
Re:Reverting the incremental GC in Python 3.14 and 3.15 by LPisGood on Wednesday May 13, 2026 @06:02PM (#48128200)
What about the semantics are bonkers in your opinion?
Re:Reverting the incremental GC in Python 3.14 and 3.15 by Yokohiii on Wednesday May 13, 2026 @01:37PM (#48124971)
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.

Re:Reverting the incremental GC in Python 3.14 and 3.15 by lern_too_spel on Wednesday May 13, 2026 @03:06PM (#48126054)
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.
Re:Reverting the incremental GC in Python 3.14 and 3.15 by JackSlateur on Wednesday May 13, 2026 @06:02PM (#48128198)
But that day is not today .. unless you are working for microslop or clownflare ? Half-kidding, sorry :)