If you are using "httpx", it's likely caused by a reference cycle. I made a PR to fix it but the maintainers haven't applied it. :-( https://github.com/encode/httpx/pull/3733
The reference cycle httpx creates is kind of a worst-case scenario for the incremental GC issue. Both the generational (3.13 and older) and incremental GC are triggered by the net new "container" objects (objects that have references to others, like lists and not like ints and floats). The short summary is that you need to create more container objects before the incremental GC triggers. In the case of the httpx reference cycle, you have a relatively small number of container objects hanging on to a lot of memory, due the SSL context data (which is a big memory hog).
Reverting back to the generational GC was the wise thing to do, even though it's a bit scary to do in a bugfix release. The incremental GC works for most people but in the minority of cases it doesn't, it uses quite a lot more memory. I'm pretty sure with some additional tuning, the incremental GC would be fine too but it just didn't get that tuning. The generational GC has literal decades of real-world use (Guido merged my patch on Jun 2000, Tim Peters did a bunch of tuning after that to optimize it).
Just an FYI, for people looking at the low pass rates for mypy and ty and concluding they must not be very useful. These test suites are checking many odd corners of the typing spec.
For "normal" Python code, I find mypy does pretty good. Certainly I find it helpful, especially on a large code base and when working with other developers of various experience levels.
The reason I prefer pyrefly over mypy is mostly because of speed. Better accuracy is nice but speed it the killer feature. Given the quality of uv and ruff and the experience of the team working on ty, I'm quite confident it's going to be great in that respect as well.
My CS college used Turbo Pascal as a teaching language. I had a professor who told us "don't turn the range and overflow checking off, even when compiling for production". That turned out to be very wise advice, IMHO. Too bad C and C++ compiler/language designers never got that message. So much wasted to save that less than 1% performance gain.
This is a silly benchmark though. Look at pyperformance if you want something that might represent real script/application performance. Generally 3.14t is about 0.9x the performance of the default build. That depends on a lot of things though.
The "starve the beast" strategy (https://en.wikipedia.org/wiki/Starve_the_beast) has been around for a long time and is something that some right wing conservative people want to do. E.g. Norquist's quote that "My goal is to cut government in half in twenty-five years, to get it down to the size where we can drown it in the bathtub.".
As someone else mentioned, this isn't only about improving efficiency of the government but also about it doing less. So things that currently you would be getting from the government you would no longer be getting. You might agree or disagree with this idea.
Predicting what Trump is going to do is not easy. I don't think he really knows himself each day what he will get up to. Mostly draw a lot of attention to himself, seems the main goal. He's doing fantastic on that front. Regarding policy, he is a lot more purposeful vs his previous term and he is pretty closely following the Project 2025 playbook:
Enacting government policy primarily through executive orders is an "interesting" approach. I would say that's not how you want a government to work. Maybe Trump's extreme use of EOs will prompt some reform or maybe it will become the new norm. The other branches of the US government don't seem very interested in actually performing their job.
The key enabling tech is thread safe reference counting. There are many other problems that Sam Gross solved in order to make it happen but the reference counting was one of the major blockers.
There are a whole set of problems, IMHO. The code-of-conduct working-group (CoC WG) members are self selected. There is no effective oversight mechanism. No matter if you think they are currently doing a good job or not, it's not a proper way to organize such a group. The steering council (SC) did a poor job in communicating and their tendency towards secretiveness does not inspire confidence that the machinery regarding these things is working correctly. Part of the justification for secrecy is that they are protecting the banned person. That is hard to believe since it's trivial to figure out who they are talking about given their initial ban announce posting (X number of posts in a certain topic points to exactly one person). So it looks more like the secrecy is to avoid answering uncomfortable questions about the decision making and the process and not about actually protecting the accused.
Someone made a great analogy about what is happening here. You have a machine that is supposed to make toy dolls. One day you notice the dolls coming out the machine are deformed and weird looking. So, you say to the doll factory manager:
> I think something is wrong with the doll making machine.
They say
> No, this is a very high quality doll making machine, look at the specifications on the great looking dolls it will make. Don't you trust that this machine will make proper dolls? The manufacturer and people running the machine are all very trustworthy
You say:
> That might be true but I see the dolls coming out are deformed, something must be wrong.
Tim does not get a free pass to behave badly just because he is a long-time Python contributor. However, given his literal decades of civil behavior in many public forums, it is hard to believe he did something that was justifying a ban. Based on looking at what the CoC WG shared and what Tim shared, I don't see anything that justifies it. So, I don't think the "machine" is working correctly.
darktable is still being developed. There are pretty regular releases. I use it as my main photo processing software (raw-based workflow).
As I said in my other comment, Aurélien has strong opinions. He felt he could not effectively work with the other darktable devs and decided to fork the project.
This is the work of a former "darktable" developer (Aurélien Pierre) who decided to fork the codebase and go it alone. He has strong opinions about the correct way to do things. I like some of the cleanup on the UI that he has done. For now, Ansel and darktable are compatible in terms of the underlying database. So you can easily switch back and forth between them. If the fork diverges significantly, it would be more difficult to maintain the compatibility.
darktable has seen some major changes in the past few years, moving away from a "display-referred" to a "scene-referred" workflow. Aurélien contributed a lot of code to make that work, most significantly, the Filmic module. darktable is not as user friendly and as polished as other commercial tools (Lightroom, Affinity, Capture One) but it is capable if you take the time to learn it.
You can make due with only a couple of good knots. Very short list: the reef knot (square knot, avoid the granny version) and the alpine butterfly (don't use reef knot for joining two ropes, i.e. a "bend"). The alpine butterfly is more useful to know than the bowline, IMHO.
If you want to expand your list a little, here are some additional useful ones: double fisherman's, adjustable grip hitch, sheet bend, trucker's hitch.
Edit: I suppose this is more useful with a little additional commentary. The reef knot is so common that you should know it and know how to avoid the granny knot and also when not to use it (e.g. as a bend). You can use the alpine butterfly as a bend and also for quite few other things. It is more versatile than the bowline (e.g. if you need a loop that doesn't slip) and works fine as a bend (very smiilar to the Zeppelin bend).
The 41C came out about 10 years before the 42S. Each would have their fans. The 42S doesn't have the hardware expand-ability but is generally faster and a bit more refined. If I wanted a nice handheld calculator today, I'd prefer the HP-42S or the Swiss Micro version. However, Swiss Micros have a 41C clone as well, if you prefer that.
Nothing insurmountable. You need a receiver that supports RTK. Typically the hardware receiver can do it but you have pay to unlock the functionality (typically about 3000 USD per device). You need an RTK base station (or one you can use that's not too far away) and a way to get the correction signal (local radio system or over Internet with cellular data).
With DGPS corrections, like you get with the satellite that failed, you get about 10 cm positional accuracy. For dryland crop farming, that's often good enough. It is more accurate than what most human operators can achieve and reduces operator fatigue. So many ag GPS systems are setup to use it out of the box.
There are other solutions, in addition to RTK. Trimble has "CenterPoint". There are Omnistar corrections (different sats, better accuracy than DGPS). Novatel has "GLIDE" but I've never seen it in use.
This is great and was a huge effort by Eric Snow and collaborators to make it happen.
To be clear, this is not "PEP 703 – Making the Global Interpreter Lock Optional in CPython", by Sam Gross. PEP 703 is more ambitious and add quite a bit of complexity to the CPython implementation. PEP 684 mostly cleans things up and encapsulates global state better. The most distruptive change is to allow immortal objects. I hope PEP 703 can go in too, even with the downsides (complexity, bit slower single threaded performance).
The reference cycle httpx creates is kind of a worst-case scenario for the incremental GC issue. Both the generational (3.13 and older) and incremental GC are triggered by the net new "container" objects (objects that have references to others, like lists and not like ints and floats). The short summary is that you need to create more container objects before the incremental GC triggers. In the case of the httpx reference cycle, you have a relatively small number of container objects hanging on to a lot of memory, due the SSL context data (which is a big memory hog).
Reverting back to the generational GC was the wise thing to do, even though it's a bit scary to do in a bugfix release. The incremental GC works for most people but in the minority of cases it doesn't, it uses quite a lot more memory. I'm pretty sure with some additional tuning, the incremental GC would be fine too but it just didn't get that tuning. The generational GC has literal decades of real-world use (Guido merged my patch on Jun 2000, Tim Peters did a bunch of tuning after that to optimize it).