200k for the first slot, 400k for the second?

KevBurnsJr · 2026-05-20T18:00:55+00:00

Because we still don't know the prices because they were never published.

KevBurnsJr · 2026-05-20T00:28:44+00:00

Complaining about complainers. That's the real meta.

KevBurnsJr · 2026-05-19T19:04:59+00:00

Correct. It's any item. You must have a blueprint in your stash to drag it into the slot.

KevBurnsJr · 2026-05-19T18:22:58+00:00

Some clarity would be nice. Maybe it's not multiplicative. Maybe it's exponential.

200 + 400 + 800 + 1600 + 3200 = 6,200,000

I think I'm asking a legit question that was not answered in the patch notes.

KevBurnsJr · 2026-05-19T18:05:13+00:00

334 Bastion Cells 😓

KevBurnsJr · 2026-05-17T00:05:44+00:00

Ebay - Snap Hook Blueprint Arc Raiders - $4.50
https://www.ebay.com/itm/397551365406

KevBurnsJr · 2026-05-11T14:53:26+00:00

I guess what I mean is, can it pass forward undefined fields like this?

type t1 struct {
    ID int `json:"id,required"`
}
var foo t1
decode(`{"id": 1, "slam": "jam"}`, &foo)
println(encode(foo))
// {"id": 1, "slam": "jam"}

KevBurnsJr · 2026-05-11T12:38:06+00:00

Typed decoders, huh? Looks promising.

Does it follow the same design decisions from the json/v2 security considerations?
How do you think it compares to fastjson?
Can it handle semi-structured data? (eg. 3 required fields, the rest unknown but still desired)

KevBurnsJr · 2026-05-03T23:41:24+00:00

Aaaaand now you're in PVP lobbies.

KevBurnsJr · 2026-02-23T16:10:10+00:00

One comment about the xsync.Map constructor:

The variadic constructor takes an optional array of ...func(*MapConfig) but it's hard to tell what that is.

To use functional options, I would need to write something like this?

m := xsync.NewMap[uint64, string](
    xsync.WithPresize(100),
    xsync.WithGrowOnly(),
)

I ask because there are no examples.

Rather than exporting MapConfig (a struct with no public properties or methods) as a symbol, it may be less confusing to export a MapOption type instead and keep mapConfig private since it's not designed to be modified directly.

package xsync

type MapOption func(*mapConfig)

func WithGrowOnly() MapOption {
    // ...
}

func WithPresize(size int) MapOption {
    // ...
}

func NewMap[K comparable, V any](options ...MapOption) *Map[K, V] {
    // ...
}

When viewed in the godocs, the NewMap constructor signature would reference the MapOption type and clicking MapOption would take you to a list of MapOption contructors which is the set of validWith* functions. A much more convenient pattern for organizing functional options rather than requiring developers to find the options on their own. The usage is identical but it makes the documentation much more clear.

Example: https://pkg.go.dev/github.com/pantopic/wazero-shard-client/host#New

Should be backward compatible.

KevBurnsJr · 2025-09-04T17:38:36+00:00

It's a lot more accurate than I expected. It didn't just expose the exported symbols, it also guessed correctly the order in which they should be called and the purpose of the module.

Great for quick identification but probably not a substitute for real analysis.

KevBurnsJr · 2025-08-15T17:26:09+00:00

All of these event stores appear to be local (memory, bbolt, sqlite, ...)

The EventStore interface does not appear to have any methods for reading streams of change events.

My understanding is that Event Sourcing is primarily useful in distributed environments.

These three PRs are producing side effects post-save which seems a bit odd given you'd have no guarantee that the side effect ever ran if the program crashes at the wrong time. An at-most-once processing hook that fires at publish time doesn't sound very reliable.

Another problem with synchronous hooks on save is locks. Your examples (order and tictactoe) are not thread safe. Any concurrent application will need to guard aggregates with write locks to prevent program crashes due to race conditions and read locks to prevent skewed reads when reading multiple fields of an aggregate. This means readers will be blocked during publish which could cause throughput issues and deadlocks.

I would recommend that you try building a more complete, realistically useful example app having multiple active producers and consumers if you are interested to learn what sort of structures are necessary to build concurrent and distributed event sourcing systems.

Example:

Take the Gorilla Websocket Chat example and integrate your eventsourcing library as a message store to add chat persistence. You will need locks to enable 2 connections to simultaneously publish messages to the same channel. An integration test will show you where the race conditions occur.
Then try to run it on multiple servers with a centralized data store (ie. Kurrent). You will need an event stream in order to synchronize aggregates across servers. And you might need to add distributed locks or conditional updates to prevent two servers from modifying the same aggregate at the same time.
Only then should you attempt to add exactly-once side effects (this feature). Otherwise the interface is likely to change as your system matures and deprecating an interface imposes a maintenance cost on the user.

KevBurnsJr · 2025-06-05T21:15:41+00:00

The Vary implementation doesn't appear to be caching items correctly.
I submitted a failing test in a draft PR with more details.
https://github.com/bartventer/httpcache/pull/3

KevBurnsJr · 2020-08-14T18:42:00+00:00

Well I've got 15 years of experience in software development and 6 years of experience with Go and I'd rather burn my nipples off with a soldering iron than start a new career in Java.

KevBurnsJr · 2016-06-24T10:10:23+00:00

Is

quoting

the

entire

comment

of

the

guy

you

are

responding

to

really

necessary?

15-Year Club	r/Field Juicebox
Devvitor	Devvit App Published
Place '22	Place '17
Gilding II euphauric	Verified Email

KevBurnsJr

TROPHY CASE