AWS China is a completely separate partition under separate Chinese management, with no dependencies on us-east-1. It also greatly lags in feature deployments as a result.
Well, was. Then Facebook AI made a side-step, and stopped focusing on downloadable LLM models, and Ollama is now trying to squeeze their users so they can show profits. r/LocalLlama is also a former shadow of itself, with the top moderator trying to move the community off reddit.
Seems Llamas will disappear as quickly as they became trendy.
I'm not too offended by this answer. We all reach for it before we seriously think about the debugger. But debugging should be treated as a specialist skill that's almost as complex as programming, and just as empowering. There are two ways I can think of right away, in which the mastery of debuggers can enrich us.
The first is that it gives you an unparalleled insight into the real stuff behind the scenes. You'll never stop learning new things about the machine with a debugger. But at the minimum, it will make you a much better programmer. With the newly found context, those convoluted pesky programming guidelines will finally start to make sense.
The second is that print is an option only for a program you have the source code for. A debugger gives you observability and even control over practically any program, even one already in flight or one that's on a different machine altogether. Granted, it's hard to debug a binary program. But in most cases on Linux or BSD, that's only because the source code and the debugging symbols are too large to ship with the software. Most distros and BSDs actually make them available on demand using the debuginfod software. It's a powerful tool in the hands of anyone who wishes to tinker with it. But even without it, Linux gamers are known to ship coredumps to the developers when games crash. Debugging is the doorway to an entirely different world.
In my experience, it's a superior approach for code you wrote yourself in a repeatable crash. You have the whole programming language at your disposal for building a condition corresponding to your bug, and any kind of data dumping.
I fall back on debuggers when the environment is hostile: Half understood code from someone else, unreliable hardware (like embedded), or debugging memory dumps.
But before both, the initial approach is thinking deep and hard, and reviewing all available evidence like logs. If this is not enough, I try to add better troubleshooting abilities for the future.
Minecraft as an example of desirable graphic properties :D
It sure has its style and I stand by what I've always maintained about gameplay being infinitely more important than polished graphics, but that does sound ironic to my ears!
To the end user, this looks exactly the same as "updating".
If replacing a "regular" program that's just an executable and then restarting it is "updating", why isn't it the same for containers? Except theb the "executable" is the container image and the "running program" is the actual container.
Another level would be "immutable" distributions: would you say they don't "update", they just "download a fresh image to boot from"?
Fascinating. I just looked up a bit of research on it, and it seems there are two contradicting phenomena at play. Flashing helps in seeing cyclists further away and helps with visibility generally -- but it also makes it harder to estimate speed and distance.
Apparently, the absolute safest solution is to have two rear lights side-by-side -- one that is always on and one that is always flashing.
It doesn't seem like there's clear data on which is safer if you have to pick only one. Different countries/states have chosen differently.
Flashing on-off and always on aren't the only options. I wish more designers went with flashing bright-dim, because it solves a lot of problems.
I once worked on a device where we were required to blink the Important Safety Light™ on-off. I often glanced at this light out of the corner of my eye, and saw that it was off, so we were Safe™. We were not Safe™: it was just in the off phase of its blink.
I am very glad I never got hurt by trusting that light.
I wanted to blink it bright-dim but was denied by people who said that IEC 61010 required it to blink, and blinking bright-dim isn't blinking. I didn't quite understand that objection.
If a safety indicator needs to be visible at a glance, why did it blink at all?
Blinking only works for things that are in your vision and need to be the primary focus.
It seems like blinking to begin with is terrible design for something like this, or else having it be in the corner of your eye is the terrible design decision.
> If a safety indicator needs to be visible at a glance, why did it blink at all?
Beats me! But they've apparently flashed for ages and ages on these things, and somewhere along the line it got standardized.
> It seems like blinking to begin with is terrible design for something like this, or else having it be in the corner of your eye is the terrible design decision.
This is benchtop equipment, not cars, so "corner of your eye" has a little bit different context here. But, yes, I kind of agree.
It is also really important to get this one right since for this particular type of device, conditions are lethal (yes, genuinely lethal, no exaggeration) if you get cavalier with it.
This is a strong point. Nobody likes a rapidly flashing light (extra annoying, seems broken, can be hard to differentiate from "on but dim"). Then again if you flash slowly then you'll have some appreiable amount of time when it's off and that can include the entire opportunity you have to look at something.
Ideally (for me) you could have smooth high-low alternation or colour alternation.
(I recognize that something that looks like emergency services, e.g. alternating blue/white may be illegal, and that colour-blindness may limit this approach.)
reply