I needed deterministic map iteration order
for my deterministic simulation testing (using the
new testing/synctest package -- experimental in go1.24, but
proposal approved to move forward, yay!) so I wrote a "dmap" which
provides repeatably ordered full range scan for keys
that can be turned into
It's a tour de force. You might especially enjoy the 18:00+ minute in
discussion of the premature
declarations about the death of Moore's law. He argues that if your design
today
makes the CPU wait on the network, then in two years you'll be waiting
twice as long; this
leads to a fascinating d
One other point, my quick research shows the fastest processors can only process about 256 gb/sec with most around 100 gb/sec. I’m not saying that ultra fast networks don’t change the dynamics, but it’s been this way for a while. I plan on watching the video so maybe I am missing something and I’ll
That last part is what is incorrect in my opinion. Even if the network bandwidth exceeds the memory bandwidth there is the IO overhead - which means that remote memory will be slower than local memory - as the remote memory still goes through the bus plus the overhead. On May 24, 2025, at 8:01 PM,
He does claim that bandwidth for peer to peer, saying
> 800 Gbps on a single link
and https://www.tomshardware.com/news/800-gigabit-ethernet-gbe-spec-standard
seems to confirm that, if I'm reading it right.
You seem to be saying that memory is always the bottleneck. I don't think
we disagree ther
To elaborate, the entire way the “cloud” works - is by multiplexing jobs and
their data across multiple machines - this is how Google BigQuery achieves
sub-second responses searching terabytes of data.
But this paradigm has been around for a long time - nothing new.
Maybe I misread, but the gis
I understand, but it makes no practical sense. The 800GB/sec is the throughput
the fabric, not a peer to peer rate. So yes, the network can support multiple
clients at a TOTAL rate greater than the speed of an individual machine -
eventually the data goes through the memory bus of a machine.
>
In the video, https://www.infoq.com/presentations/redesign-oltp/ at 14:00
minutes in
is what I was referring to. Greef shows a graph from Roland Dreier and
cites his
blog post, see Figure 1 of that blog. He points out the flip from 2020 to
2023.
https://blog.enfabrica.net/the-next-step-in-high
That doesn’t make sense. Memory can’t be slower than disk - disk is either
physical, or memory backed - which means its upper speed limit is the memory
speed limit.
If the presentation means to imply that ethernet is so fast - faster than
memory busses themselves - that you could fan out to ach
This is an amazing talk from last year 2024 March 22 Qcon from
the TigerBeetle CEO, Joran Greef. Zig has lessons for Go.
"Redesigning OLTP for a New Order of Magnitude"
https://www.infoq.com/presentations/redesign-oltp/
Early on the talks covers that latest trends in memory vs network vs disk,
(h
The problem starts with these two lines:
> var i = []i_t{{help}}
> var t = []i_t{{fish}}
You are initializing the structs with the values stored in `help` and
`fish`, not references to those variables. Thus, when you change the value
stored in the struct it has no effect on the variables from whi
Bingo! This solves the problem. You win the prize!
I hope this discussion helps other people facing similar problems.
Jon
--
You received this message because you are subscribed to the Google Groups
"golang-nuts" group.
To unsubscribe from this group and stop receiving emails from it, send an
Sorry, I seem to have copy-pasted your Go Playground link instead of
mine, assuming "share" would place it in my clipboard automatically.
https://go.dev/play/p/8XajdwXDdqW
This is what I meant to share.
It outputs the following:
```
before: help = falsestruct = [{%!t(*bool=0xc1006d)}]
Thanks for your and Brian's replies.
But, unless I'm missing something, neither solve the problem. I ran both of
them in the Go Playground and they both produced the same incorrect result.
The result I'm looking for would be:
before: help = false struct = [{false}]
after: help = true struct =
As far as I can tell, they're asking for a way for `var help`/`var fish`
etc. to get updated alongside the attribute `i_t.arg` in the update methods.
This example accomplishes this.
https://go.dev/play/p/7y5COCLU5EP
Do note that it crashes and burns if the pointer is not of the expected
type, a
Or you can use a setter method:
https://go.dev/play/p/W9Cz2PO8NeK
On Saturday, 24 May 2025 at 03:39:34 UTC+1 Def Ceb wrote:
> You're creating new copies of the values and modifying the copies, rather
> than storing a reference and then modifying the original data through it.
> You'd use *string
16 matches
Mail list logo
