jsw

Interesting! We interact with the low-level APIs too vs the SDK, also: an IO scheduler for request batching and conn management, request hedging, full MVCC transactions, etc. We store raw bytes in DDB and manage schema/etc elsewhere. Curious if there is other low-hanging fruit, or not so low, you found that we haven't discovered yet.

Curious how the DB startup with Dynamo at its core went. We use it heavily. The primary tricky thing for us at the moment is aligning pricing with workload value.

Do you have any of your fixes publicly available?

Regardless, that’s kind of the beauty of this project: term-keys generates the terminal config file based on all your bespoke keybindings for you. Would probably be easier to setup than you imagine.

MacOS user here. So many times over the last decade I’ve journeyed to get terminal Emacs working with my litany of weird keybindings. But I always end up back in the GUI.

I switched to Colemak about 15 years ago and thought it would be a good idea to rethink all my Emacs keybindings, since my muscle memory was shot in that transition. (I don’t recommend this in hindsight.)

I have yet to get a terminal working fully like the GUI. Partly because I refuse to install a third-party key mapper.

Anyway, just tried this and Alacritty. It’s the closest I’ve got to fully working. My guess is another hour of tweaking and I could maybe get all the way there.

For simple high-frequency time deltas, I've found this function wins on the perf front:

  //go:linkname nanotime runtime.nanotime
  func nanotime() int64

Love the simplicity and elegance of the design to address this problem.

I mentioned this in another place on this thread, but a simple AIMD algorithm paired with a token bucket is surprisingly effective at dynamically adjusting to available capacity, even across a fleet of services not sharing state other than the contended resource.

Pretty easy to pair AIMD with token bucket (eg https://github.com/webriots/rate)

I’ve found the AIMD algo (additive increase, multiplicative decrease) paired with a token bucket gives a nice way to have a distributed set of processes adapt to backend capacity without centralized state.

Also found that AIMD is better than a circuit breaker in a lot of circumstances too.

Golang lib of the above https://github.com/webriots/rate

Bazel is a fully reproducible and hermetic build system. A lot of painstaking work goes into it producing the exact same artifacts build after build. And that provides some interesting properties that you can leverage for artifact caching, deployments, and CICD.

We very happily runny a polyglot monorepo w/ 5+ languages, multiple architectures, with fully reproducible artifacts and deployment manifests, all deployed to almost all AWS regions on every build. We update tens of thousands of resources in every environment for every build. The fact that Bazel is creating reproducible artifacts allow us to manage this seamlessly and reliably. Clean builds take an hour+, but our GH self-hosted runners often complete commit to green build for our devs in less than a minute.

The core concept of Bazel is very simple: explicitly declare the input you pass to a rule/tool and explicitly declare the output it creates. If that can click, you're half way there.

I wish “Prevailing Time” would catch on. Eg PPT

Mergify just introduced a “speculative merge queues[1]” feature that does something very similar.

[1] https://blog.mergify.io/announcing-speculative-merge-queues

That sweet, sweet traffic data.

I've always been curious about the general directory structure they use for this. Does anyone have insight?

I’m firmly on team monorepo, and I agree great tooling is an absolute requirement. We use Bazel + AWS CodeBuild with local caching. We have an average incremental CI build of our monorepo that’s under 45 seconds. Clean build 30+ minutes.

The AWS Cognito User Pool Authentication Flow utilizes an augmented PAKE (SRP). I imagine there are a number of major sites that use Cognito along with the SRP auth flows baked into their std libs. I know I've used it a number of times.

TLA+ specs explore all state spaces of concurrent processes. Avoiding state explosions is something you need to be conscious of when building those. The modeling required also takes some learning investment. Curious if this can really pull off something like a TLA+ state exploration and invariant violation detection with real-world code.