FreeHugs

At the core of Web3 projects is the idea that one can own their identity via cryptographic proof.

Over time, this concept will find its way into many projects. Especialy into open source projects which try to make the web a better place.

For example, as soon as browsers support a DNS based on cryptographic proofs like ENS, other technologies which have URL based identities (like ActivityPub) will automatically support cryptographic identities. Which would bring it to projects like Mastodon and Bluesky automatically.

Why is Termux not on the Google Play Store?

I don't think it's the loop implementation. The stuff in the loop should take multiple orders of magnitude more time than the loop itself:

    for poly in polygon_subset:
        if np.linalg.norm(poly.center - point) < max_dist:
            close_polygons.append(poly)

The rest is not a fair comparison, because it rewrites the used libraries, not the application code.

You can always speed up an application if you rewrite the used libraries to match your specific use case.

The time is spent in this 3-line loop:

    for poly in polygon_subset:
        if np.linalg.norm(poly.center - point) < max_dist:
            close_polygons.append(poly)

I don't think the entire feature set of the Python runtime is involved in this.

The most important part of the article seems to be that this Python code is taking "an avg of 293.41ms per iteration":

        def find_close_polygons(
            polygon_subset: List[Polygon], point: np.array, max_dist: float
        ) -> List[Polygon]:
            close_polygons = []
            for poly in polygon_subset:
                if np.linalg.norm(poly.center - point) < max_dist:
                    close_polygons.append(poly)

            return close_polygons

And after replacing it with this Rust code, it is taking "an avg of 23.44ms per iteration":

        use pyo3::prelude::*;
        use ndarray_linalg::Norm;
        use numpy::PyReadonlyArray1;

        #[pyfunction]
        fn find_close_polygons(
            py: Python<'_>,
            polygons: Vec<PyObject>,
            point: PyReadonlyArray1<f64>,
            max_dist: f64,
        ) -> PyResult<Vec<PyObject>> {
            let mut close_polygons = vec![];
            let point = point.as_array();
            for poly in polygons {
                let center = poly
                    .getattr(py, "center")?
                    .extract::<PyReadonlyArray1<f64>>(py)?
                    .as_array()
                    .to_owned();

                if (center - point).norm() < max_dist {
                    close_polygons.push(poly)
                }
            }

            Ok(close_polygons)
        }

Why is the Rust version 13x faster than the Python version?

Even just "anemia in dogs" is sufficient.

The first Google hit goes to a page that lists IMHA right away.

I am sure LLMs already are helpful to do medical research. But this case seems not to be a great example to show their superiority to old fashioned googling.

Not by the definition of money I am using when I refer to "the money supply" or the term "printing money".

I am referring to sum of money the FED has created.

    Wyre Payments, the company’s upstream payment
    processor, terminated SpankPay’s account because
    Wyre’s new payment processor, Checkout.com
    doesn’t allow processing for payments related
    to sexual businesses

SpankPay, Wyre, Checkoutcom ... How does this all work? What does the person who wants to pay a sex worker via SpankPay do? Do they use their usual Visa credit card or is the process different?

Nothing in this description contradicts my view that printing more of a currency will lower its value.

You showed me a currency that lost 80% of its value while the amount of it was doubled. Not surprising. The plums don't change that.