nas

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.

I get:

3.9: 2.78

3.14: 3.86

3.14t: 3.91

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:

https://old.reddit.com/r/OutOfTheLoop/comments/1itd7xq/whats...

https://docs.google.com/spreadsheets/d/1RHMnJmuv82n6OuY8KYmJ...

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.

Every PyObject structure has a ob_type pointer.

You should probably just read the PEP, which explains these things:

https://peps.python.org/pep-0703/#reference-counting

If by GC you mean the cyclic GC, free-threaded Python currently stops all threads while the cyclic GC is running.

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.

Very encouraging news!

I think it means it could be a title from a Monty Python skit, not that it necessarily is taken from one.

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).

A variable is not a container. That would imply you can only put an object in one container. In Python, a variable is a label for an object. There can be multiple labels on a single object. If the object is mutable, you can tell it's the same object (or use id()).

Pablo (the release manager) did his PhD on black hole physics.

ZODB is awesome and overlooked, IMHO. I'm biased I guess because I was involved in making Durus which is inspired by ZODB. The ZODB model is not appropriate for all applications (optimistic concurrency control) but for the applications it works for, it's great. Very easy to develop with (no relational-to-OO mismatch) and performance can be great if you design your model carefully. The client caching of data is great. It is a bit like memcache but the data is already there as objects in RAM. The database server will invalidate the cache for you, no manual invalidation needed.

I'm pretty sure the decision on how to address the bug (and the determination of even if it's a bug) was not done by one dev. Other devs were involved and the determination was made as a team to make the change. Having a better fix, e.g. something like what is suggested in #90716 is not precluded. As yet, no one has actually stepped up with a better int-to-str implementation. I.e. something that can be reviewed, tested and then maintained in the long term As discussed in #90716, there is not much point in trying to do something similar to what GMP does. People can just install that library and use it.

I'm not sure why people are so excited about this issue. It's not much different than sys.setrecursionlimit(). We know how to implement tail recursion. Python doesn't do it though and so there is a limit, set high enough that most people don't care. It seems a perfectly practical approach to me.

It's an interesting article but probably needs "2019" in the title.

The major problem, IMHO, was the licensing of C-Kermit. Yes, if you used C-Kermit and set it up properly, it was as fast or faster than ZModem. However, ZModem had free implementations and was relatively ubiquitous. Columbia University was trying to use the license terms to extract enough money to maintain and improve C-Kermit. Compared with Zmodem or Ymodem, it wasn't a success. At least, that's how I remember things.

Use "dmypy", it is fast.

I've found that it's pretty easy to slowly enable mypy checking. You can mark modules with "type:ignore" to make mypy ignore them. Then, you can move to marking individual statements with "type:ignore". Finally, you can start marking modules with "mypy: disallow-any-generics" at the top. That requires that functions are annotated with types.

In a large code base, our team has found type annotations and mypy to be quite helpful. If you are writing a quick-and-dirty script, forget about wasting time with type annotations. However, for long-lived and important code, it seems to be worth adding the types.

Another thing I noticed, if your type annotations are hard to write, e.g. lots "Union", "Optional" or deeply nested type expressions, it's probably a sign that your code is poorly designed. Think about what types you actually want to consume and return. Define new containers using dataclasses or attrs to keep the types simple, if required.

It's an interesting idea but a lot of care is needed to avoid parsing bugs. I.e. the code you are feeding to the shell via "eval" doesn't not get parsed in some way you don't expect. Also, parsing the script source code, need to be careful and clear about the parse rules. In that case, it's not as dangerous since the script source code is presumably not provided by an attacker (otherwise they could just directly run the commands they want).

No, I mean unlike a gift card, you can get your balance back from the card without the merchant's cooperation. Once you pay a merchant, it's not reversible.

It's functional but not ready for prime time yet, IMHO. Buying things on Bitrefill using Lightning works well. It is better than a credit card, I think. Really fast and low fees. Imagine a gift card that works for any merchant that opts into the open protocol. Also, if you want to refund the money on the card, you can do that without the cooperation of any merchant.

There are a number of improvements in the pipeline. Taproot just got enabled. It seems we need something like SIGHASH_ANYPREVOUT (BIP-118) in order to implement eltoo. eltoo would be like the next generation of Lightning, making it easier for users.

I suspect Tim's meaning was that ordinary users don't need to know how metaclasses work in detail. It is enough that people know they exist (i.e. do something at time class is defined). If you need them, you are doing deep enough magic that you can take the time to learn how they work.

Maybe he was also suggesting that people should generally not be using them. In my experience, it is exceedingly rare to need them. In 29 years of writing Python code, I think I've used them once or twice.

It's a term for the nature of a problem, not a library or software package. It looks like they have designed the API so that "embarrassingly parallel" problems can naturally be computed using Polars. That would be fantastic, much better than Pandas. The way they write it sounds like marketing fluff to me and that's a shame because Polars looks like a useful thing.