3,448 karma · joined November 4, 2013
formerly: Principal Engineer of "Core Technologies" at Discord. https://discord.com/
[ my public key: https://keybase.io/jhgg; my proof: https://keybase.io/jhgg/sigs/NfC1mAm4fGJgKsLzYcshaSlYAfvMnxgLUZgee3nWqzI ]
Either way the incremental improvements here are great - and it's important to consider optimization both from transport level (compression, encoding) and also from a protocol level (the messages actually sent over the wire.)
Also one thing not mentioned is client side decompression on desktop used to use a JS implementation of zlib (pako) to a native implementation, that's exposed to the client via napi bindings.
Yes: https://github.com/golang/go/blob/27093581b2828a2752a6d2711d...
> The old language specification did not define the order of iteration for maps, and in practice it differed across hardware platforms. This caused tests that iterated over maps to be fragile and non-portable, with the unpleasant property that a test might always pass on one machine but break on another.
> In Go 1, the order in which elements are visited when iterating over a map using a for range statement is defined to be unpredictable, even if the same loop is run multiple times with the same map. Code should not assume that the elements are visited in any particular order.
> This change means that code that depends on iteration order is very likely to break early and be fixed long before it becomes a problem. Just as important, it allows the map implementation to ensure better map balancing even when programs are using range loops to select an element from a mapl.
[1]: https://github.com/etcd-io/etcd/blob/main/client/v3/watch.go
[2]: https://github.com/etcd-io/etcd/blob/main/client/v3/lease.go
Blog post from 2018: https://discord.com/safety/terms-of-service-feedback-and-cha... Archived version of ToS from may 2020: https://discord.com/terms/terms-of-service-may-2020
As well, you get a lot of things for free:
- user is familiar with the phone UI, and knows how to mute/use speaker phone.
- put the call on hold if another incoming call comes in,
- able to call someone and make it into a conference call, - more reliable on shitty internet.
One idea that would mitigate against this, while also not imposing significant burden to the customer is to have the procedure be that the app simply instructs you to hang up your call, and then after dials a randomly selected number from a large pool of numbers the bank controls, that has been wired up to (given your phone number) connect you back to the bank and directly to the agent that has called you. If your phone number dials any other number from the pool during this time (the attacker is trying to race you to call back the bank while spoofing your number), then the account flagged as being potentially under attack.
In fact, visual challenges like this are a mostly solved problem, and the real magic is the classification that happens behind the scenes.
Things literally have just worked.
We are about to do a scale up operation of about 6 nodes each for 16 clusters (total of 96 ES data nodes being added.) This was editing a variable in a config file, and pushing that config to kubernetes. The operation will probably take a day to complete as we throttle the speed at which data transfers to new nodes to not adversely affect latency or ingest rate.
The amount of "human time" to kick off this operation and begin the scale up is measured in minutes, then it's just letting it do its thing.
At work, we moved from hosting elastic search on bare VMs to kubernetes. By leveraging scheduler policies we are able to pack / over-provision ES node pods of different clusters onto the same Kubernetes nodes, allowing for far greater resource efficiency, while being able to handle node failure while maintaining availability across all clusters. Additionally, this simplified operations significantly as we can now leverage the operator to do cluster wide operations (e.g rolling restarts, node OS upgrades, ES version upgrades, etc...) fairly easily.
We did, however, go 6 years (and several hundred million users and trillions of documents indexed) without needing to use Kubernetes!
We will blog about this at some point this year.