Comments URL: https://news.ycombinator.com/item?id=48774917

Points: 3

# Comments: 0

I always check DownDetector and Updog whenever something seems strange about GitHub behavior, they tend to pick up issues before the official status page.

Comments URL: https://news.ycombinator.com/item?id=47876498

Points: 5

# Comments: 1

More info:

* https://research.google/blog/looking-back-at-speculative-dec...

* https://pytorch.org/blog/hitchhikers-guide-speculative-decod...

To be fair, I haven't messed around with video encoding settings yet. I've seen claims the Pi 5 can do 1080p60 with 50% of the CPU. I could trade off quality for faster encoding, but with a mini PC I could get high quality encoding at real-time speeds.

I'm feeling some buyer's remorse with the Pi 5 right now...

On the other hand, validating a predicted protein structure to a good level of accuracy is much easier (solvent accessibility, mutagenesis, etc.). So having a complex model that can be trained on a small dataset drastically expands the set of accurate protein structure samples available to future models, both through direct predictions and validated protein structures.

So technically yes, this dataset could have been collected solely experimentally, but in practice, AlphaFold is now part of the experimental process. Without it, the world would have less protein structure data, in terms of both directly predicted and experimentally verified protein structures

I agree that it's unfortunate that the power usage isn't better tuned out of the box. An especially annoying aspect of GNOME's "Power Saver" mode is that it disables automatic software updates, so you can't have both automatic updates and efficient power usage at the same time (AFAIK)

https://typer.tiangolo.com/tutorial/arguments/envvar/

It's especially nice for secrets. Best of both worlds :)

One of my favorite features of loguru is the ability to contextualize logging messages using a context manager.

  with logger.contextualize(user_name=user_name):
    handle_request(...)

One downside of loguru is that it doesn't include messages from Python's standard logging system, but it can be integrated as a logging handler for the standard logging system. At the company where I work we've created a helper similar to Datadog's ddtrace-run executable to automatically set up these integrations and log message formatting with loguru

    git checkout main
    git pull
    git checkout feature-branch-1
    git rebase -i -
    git checkout feature-branch-2
    git rebase -i -
    ...

It seems like consistent hashing is much more popular though, which definitely makes it worthwhile to learn.

[1] https://en.wikipedia.org/wiki/Rendezvous_hashing

Solvvy is a next-gen chatbot and customer support automation platform built with AI, ML, and Natural Language Processing technology.

Solvvy is looking for a Pythoneer passionate about applying cutting-edge developments in the Python programming language and ecosystem to build amazing support experiences. You'll be responsible for coaching other team members to use advanced Python features effectively, designing system architectures for new features and products and building backend APIs for machine learning and data analytics services.

You'll be tasked with challenging technical problems and be responsible for developing innovative solutions. You'll work closely with a team of high-contributing engineers and product managers to solve user needs and work together to ensure that end-users enjoy a truly delightful support experience.

If this role sounds like a good fit for you, please apply through the job posting here: https://solvvy.com/open-positions/?gh_jid=5482901002

Docs: https://docs.python.org/3/tutorial/modules.html#importing-fr...

    from __future__ import annotations


    class X:
        def __init__(self, value: int) -> None:
            self.value = value

        def to_y(self) -> Y:
            return Y(self.value)


    class Y:
        def __init__(self, value: int) -> None:
            self.value = value

        def to_x(self) -> X:
            return X(self.value)


    x = X(10).to_y().to_x()
    print(x.value)