752 karma · joined September 3, 2025
Curiously, it is exactly the opposite in many video games. In video games water often protects you from the explosion. I wonder, where did this trope came from...
Narrator's voice: They will do it again.
I, actually, do enjoy the exercise itself. Although, it doesn't prevents me from procrastinating going to the gym and being in terrible shape.
According to Wikipedia, plague responds to antibiotics very well, since it is a bacteria, not a virus and it hasn't been widespread since the development of antibiotics, so it didn't develop any resistance to antibiotics.
If she knew that she broke a flask with plague (and, as I understand, she did know that), why don't start a course of antibiotics immediately, before any symptoms? Wouldn't she be totally fine it this case?
I suspect that someone's running a script that looks for public (-ish, Eugene has a Wikipedia page at least) figures without active social media presence and creates fake donation websites with AI-generated texts and pictures.
If my suspicion is correct, this is one of the most evil scams I can imagine.
This is a valid point.
> And in my experiments even Qwen 3.8 has a hard time to consistenly conform to a schema, requiring retries, JSON cleanup etc, so to have a model of similar quality (SemIf et al) that simply cannot deviate from the schema by construction could be very helpful.
Literally every inference framework supports constrained encoding. You can make the model choose only from allowed tokens and you can infer only the first diverging token.
It's baffling to me that no inference provider actually exposes this functionality, so you have to run the model yourself to do it.
> model and manifest bytes together pick the class
What?
How hard is it to write something like "your weight class is determined by the total size of the model and manifest" (if I understood it correctly).
Current version both sounds very AI-sloppy and is ambiguous.
The doc page [0] is even more painful to read.
Heh, you got me :) IPFS is one of those things that I love reading and about and thinking about using someday, but somehow never get around to it.
I'm still kinda sad that Pyston didn't happen
> but it has been dead for years partially because it hit many of these walls
Maybe this is one of the reasons. But I've also heard that Dropbox (which was making Pyston [0]), that used to heavily rely on Python, just decided that gradual migration to Go [1] is a more feasible approach than creating a faster Python implementation.
[0] https://dropbox.tech/infrastructure/introducing-pyston-an-up...
[1] "About a year ago, we decided to migrate our performance-critical backends from Python to Go to leverage better concurrency support and faster execution speed." - https://dropbox.tech/infrastructure/open-sourcing-our-go-lib...
An ML pipeline will probably rely on numpy to do all the heavy lifting.
A web backend will probably use something like psycopg, which is a wrapper around libpq (official postgres client lib, written in C).
etc
Of course, a "Japanese Minimal Poster" has a sakura and a stylized flag of Japan, duh
A human designer would probably think that "Japan -> sakura" and "Japan -> Japanese flag" are way too obvious, too banal, too stereotypical, and, most importantly too boring. And then they would probably sit for a while and try to think of something fresher and less clichéd.
But AI has absolutely no problem with going with the cheesiest, most overused trope.
Even before coding harnesses become mainstream, a lot of tools offered to automatically generate commit messages based on the diff (I think JetBrains IDEs started to offer it very early) and I always cringed when I've seen it.
The reason why I don't like diff-base commit messages is because they are redundant. If I want an LLM-generated summary of the diff, I can easily generate it myself, there is absolutely no reason to put it in the commit message.
What I would like to see in the commit message is some additional context that is not a part of the diff. I don't need to read what has changed, because I can already can see it in the diff (or get an LLM to summarize it for me). But I often do need to understand why this change was made. What were they trying to achieve? That's the important part that is not contained in the diff itself. And this is the part that diff-base commits rarely contain.
I think that even something simple like a link to a Jira (or other bugtracker ticket) is much more helpful than diff summary. Maybe instead of "fix" or "update" you could write just a couple of words about what are you trying to fix and why does it need updated. Still better, than a diff-summary.
Please, just explain in your own words, how the pricing works, without using made up terms invented by an LLM.
[0] https://en.wikipedia.org/wiki/Sokol_space_suit#Use_by_countr...
It appears that just hanging out in the orbit is relatively safe, going up there and going down is risky.
Same with aircraft, btw, most accidents happen during take-off, shortly after take-off or during landing. Cruising at a stable altitude is very safe.
[0] https://en.wikipedia.org/wiki/List_of_spaceflight-related_ac...
[1] https://en.wikipedia.org/wiki/Soyuz_11#Re-entry_and_death
> grok-imagine-image-quality
I find it curious that a 2026 model still occasionally makes same type of mistakes that 2018 StyleGAN made.
1. Give "strong" LLM the task formulation and some labeled examples. Ask it to generate a prompt for the "weak" LLM.
2. Run "weak" LLM on the training set with generated prompt from 1, use replies as features for a smaller ML model (logreg, decision tree etc).
3. Pick examples from the training set that your small model is most wrong about and ask "strong" LLM to generate one more prompt (like in 1), except this time you are using the misclassified examples instead of random.
4. Run "weak" LLM on generated prompt from 3, add results as one more feature for your model.
5. Repeat 2 - 4 until your token budget for this task is exhausted or required score on cross validation set is reached.
I was thinking about creating an open source library that implements this, but I'm not sure if anyone really needs it. I suspect that people who need something like this already made their own implementation.
Anyway, my "Luciana Roberts" [0] has an artifact around her hair very similar to what older GANs often produced.
It's not a complaint, just a curious observation.
lst = [1, 2, 3]
acc = 0
[acc := acc + item for item in lst] # this is the actual reduce
print(acc)
It should be possible to optimize away the creation of the temporary list and avoid wasting CPU and memory on it. But I don't know if CPython actually has this optimization, that's why I didn't mention it initially. I would love someone more knowledgeable in CPython internals to tell me how this would work.
First, I will need to steal a "consume" function from Itertools Recipes [0]:
from collections import deque
from itertools import islice
def consume(iterator, n=None):
"Advance the iterator n-steps ahead. If n is None, consume entirely."
# Use functions that consume iterators at C speed.
if n is None:
deque(iterator, maxlen=0)
else:
next(islice(iterator, n, n), None)
lst = [1, 2, 3]
acc = 0
consume((acc := acc + item for item in lst)) # this is the actual reduce
print(acc)
consume((acc := acc + item for item in lst))
Is it more readable then normal reduce? I'm not sure. If I seen it in the actual production code, it would certainly raised my eyebrows. It is not a part of the normal Python "vocab" - a set of idioms that are considered "pythonic" and that you expect every Python dev to intuitively understand, so I would be very cautious in using it in the code that is intended to be read by other people.
Why did I do it? I don't know, just a fun "what if?" thought experiment.
[0] https://docs.python.org/3/library/itertools.html#itertools-r...
Two notes:
1. reduce if a part of functional programming vocab, so, obviously, a Clojure dev has to internalize it to be able to use the language properly. For other mentioned languages it is not that necessary.
2. As a (mostly) Python dev, I think that list comprehensions and generator expressions are much easier to read and understand than map and filter. Although, people coming from other languages and having limited experience with Python specifically might disagree with me. Perhaps, we should think about inventing some nice syntax sugar that around the concept of `reduce`ing and `fold`ing, similar to what list comp/gen expr in Python did to concepts of `map`ing and `filter`ing.
[0] https://news.ycombinator.com/item?id=49694296
In fact, the article says
> With this (rather primitive) format I managed to encode 128 flags with varying success.
Which means that, actually, 7 bits would be enough.
So, this comment is (correctly) pointing out that requirements are imprecise.
You may find such "rules lawyering" obnoxious, but I think that in the real world tasks it is often useful to clarify such things, because it let's you avoid doing hard and complex work that is actually not needed.
I think that every experienced developer has this automatic response to reading a list of requirements: "here is a shortcut that will technically fulfill all the requirements. Please, either tell me that it is okay to do it, or update your requirements to close this loophole".
[0] https://read.vantezzen.io/miniflags#3d8e32040c2a808e8d95c8a0...