Marvell has a source available DDR driver that actually takes care of training on a few of their platforms! https://github.com/MarvellEmbeddedProcessors/mv-ddr-marvell

There’s your answer.

6 days means on a long enough enough timeframe the load will end up evenly distributed across a week.

8 days would result in things getting hammered on specific days of the week.

https://github.com/google-gemini/gemini-cli/issues/12121

It is far too easy to accidentally end up under the wrong privacy agreement, to the point of where some workplaces are banning use of the Gemini CLI!

I think the promotion fails to happen and then an external watchdog notices that it didn’t, and kills everything ASAP as it’s a cluster state mismatch.

The message about the storage subsystem going away is after the other Postgres process was kill -9’d.

https://github.com/cedardb/DOOMQL/blob/f14b5ef9ef0b23045376b...

it's better to evenly distribute water throughout the fluid, than to have it accumulate in a low point

* pre v0.6.6 the project was BSD-3 licensed * v0.6.6 was released under BSD-3 + branding requirements * no CLA was required for contributions prior to the switch * they didn't obtain consent from all contributors prior to the switch

The author is taking the opt-out approach to the licensing change - https://docs.openwebui.com/license/

> If you contributed code pre-v0.6.6 and now wish to have it removed (i.e., you do not consent to the updated project structure or licensing), we will promptly honor your request and excise it from subsequent releases. Just contact us and reference the relevant code.

Is it just me, or does this not pass the smell test?

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

Points: 3

# Comments: 2

RTX 3090: 24GB RAM, 936.2GB/s bandwidth

Tenstorrent p150a: 32GB RAM, 512GB/s bandwidth

an extra 8GB of ram isn't worth nearly halving memory bandwidth.

Now I find it relatable.

(don't install a signal handler in Python for SIGSEGV, especially if it's being triggered by C you're calling)

https://pagure.io/releng/issue/12586#comment-955583

but- a car company that doesn't see the need to have emergency rear door releases has systemic issues. someone, anyone involved in approving that design could have said "no. i will not sign off on this", but they didn't.

it makes me wonder what other corners they cut, and whether those cut corners could kill a driver or passenger- because they're not going to cut corners on anything that would be immediately apparent in daily use: it would be detrimental to sales.

I posited that if you can observe and reconstruct the entire state of a complex system then you can predict future states- score one for determinism and no free will. But, we know there exists places that we cannot directly observe or perceive, aka quantum uncertainty, represented by σxσp ≥ ℏ/2 [1].

So based completely in theory, I figure the only way we square FW & determinism, is that free will exists somewhere/in a form we cannot directly observe, and it manifests as tiny influences that add up, in the complex system that is a brain.

This is the way more speculative part and it's more fun than anything to think about- it doesn't change the way I live my life buuuut-

Folded brains dramatically increase the influence a given region in space-time can have, simply due to the increased number of neurons. So our brains double as an antenna for some unseen influence that manifests through quantum uncertainty.

So when I explained this to ChatGPT it told me that OORT was very similar to this, but even the mechanism they use for it seems to be a stretch for me.

edit: But I do think that in order for neural networks to become anything other than outwardly really really good approximations of human minds, there needs to be a way to introduce a small amount of genuine randomness into their calculations, without utterly breaking them. I could see early attempts at doing this causing a form of LLM schizophrenia because the neural network wasn't resilient enough to the induced error.

[1] the standard deviation of position σx and the standard deviation of momentum σp is greater than or equal to half the reduced planck's constant

The S3 AWS SDK has support for doing chunked/parallel downloads if you can supply an io.WriterAt [1] implementation.

  type WriterAt interface {
   WriteAt(p []byte, off int64) (n int, err error)
  }

I created a WriteAtReader that implements io.WriterAt and io.Reader. You can read up to the first byte that hasn't been written to the internal buffers. If there's nothing new to read but there's still pending writes, calls to Read will block and immediately return after the next WriteTo call. As bytes are read through Read, the WriterAtReader frees the memory associated with them.

It provides the benefits/immediate results you get with a streaming implementation and the performance of parallel download streams (at the cost of increased memory usage at the outset).

The first "chunk" can be a little slow, but because the second chunk is almost ready to be read by the time the first is done? zoom zoom.

[1] https://pkg.go.dev/io#WriterAt

If yamux's keepalive fails/times out, and you're calling Read on a demuxed stream, it blocks forever.

https://github.com/hashicorp/yamux/pull/127

i knew about "preconditioning" for SSDs when it comes to benchmarking, etc. didn't realize this was the why.

thanks!