javascript

> I hope that's not literally incrementing a sequence It's literally incrementing it by one: https://github.com/ulid/javascript/blob/11c2067821ee19e4dc78... https://github.com/ulid/javascript/blob/11c2067821ee19e4dc78...

The spec as written on that page is confusing on that point, but the incrementing-counter-within-the-same-millisecond-behavior only happens if you explicitly specify a "monotonicFactory", https://github.com/ulid/javascript#monotonic-ulids. The default behavior (just using the ulid() function) doesn't do that, it generates a completely random value regardless of the millisecond value.

https://github.com/ulid/spec isn't timeflake, but is a good spec, and there are implementations in multiple languages. there are 2 listed for js. https://github.com/aarondcohen/id128 and https://github.com/ulid/javascript

ULIDs are a much better answer than type-4 GUIDs. You get insertion-order sorting with a large random component to prevent collisions/guessing. A similar solution called COMB identifiers dates back at least 15 years in the MSSQL community. Watch out for sort order in MSSQL with binary ULIDs cast to UNIQUEIDENTIFIERs; they sort with the last 4 bytes as most significant, so some byte swapping is necessary to prevent the performance degradation caused by index page splitting (I wrote a ULID implementation for MSSQL that handles this). https://github.com/alizain/ulid

Does anyone use ULIDs [1] instead of UUIDs for stuff like this? I like that they're sortable. [1] https://github.com/alizain/ulid

I really like the ulid library. Does what I want, compact representation, and lexicographically sorting ulids in time order is great. The character subset is URL friendly, so this is my go-to when I'm making nonces if I am not worried about super-double-secure prngs. https://github.com/alizain/ulid

I pick UUIDs because experience has taught me that even for the smallest workloads, I'll inevitably have to shard my DB (to partition a shared public cloud from N isolated "enterprise" deployments), and then will inevitably want to do statistical-analysis things that involve ingesting rows from the shards (or log entries referencing those rows), and deduplicating them by ID, without generating false-positive collisions in the process. The simplest way to do that is to just throw UUID at all problems from the start. (https://github.com/alizain/ulid s are better, but there aren't libraries to generate them in literally every language + RDBMS.)

I've started using ULIDs when I need IDs that are time-sortable while still retaining the advantages of a UUID. Read more here: https://github.com/alizain/ulid The ultra-quick summary: 48 bits of timestamp followed by 80 bits of randomness. Also, when representing as strings, they use Crockford Base32 encoding, meaning 26 characters instead of a UUID's 36. (I'd argue that UUIDs should use this encoding as well.)

The repo in the comment parent to yours has a list that includes the one you mentioned and several others in various languages :) https://github.com/alizain/ulid#implementations-in-other-lan...

There's also "ULID" in this neo-UUID space: https://github.com/alizain/ulid 48-bit timestamp plus 80 bits randomness, base32 encoding (no hyphens), and lexicographic sort order.

Yeah, which is why I'm toying with using ulid identifiers, which won't face timestamp issues until around 10900 AD. Source here: https://github.com/alizain/ulid/

My guess is that the README was mostly copied from here: https://github.com/alizain/ulid Which has a similar list, but presents them as features/facts, not advantages. Edit: Perhaps it was noted to specifically call out that it maintains case insensitivity, even though it's choosing a more dense approach than just hex.