anandvarma / namegen

🌈 A unique(ish) random name and id generator

namegen

What's this?

Go package and associated command line utility to generate random yet human-readable names and identifiers. Somewhat inspired by the random names that Docker gives its containers and GCP uses as project-ids.

Use it to generate email-ids, gamer-tags, component-ids, passwords or startup names.

For instance, it came up with gems like: boujee-coorgi, young-flamingo, articulate-otter-92, ancient-mako-7ab1g3 and mighty-pale-pikachu-7133.

Features

• 1 Million+ unique possibilities with just names and nearly infinite named ids
• Zero Allocations! No additional memory allocations other than the string returned
• Blazing fast!! (10,000,000+ Op/s)

API & Usage

Generate names using default config.

ngen := namegen.New()
fmt.Println(ngen.Get()) // twisted-flamingo

Configure name generator to generate named ids of the form "adjective-color-animal-xxxx".

name_schema := []namegen.DictType{
	namegen.Adjectives,
	namegen.Colors,
	namegen.Animals,
}
ngen := namegen.NewWithPostfixId(name_schema, namegen.Numeric, 4)
fmt.Println(ngen.Get()) // energetic-pink-pug-3729

Go Reference

---

Benchmarks

goos: linux
goarch: amd64
pkg: github.com/anandvarma/namegen
cpu: AMD Ryzen 5 3600 6-Core Processor              
BenchmarkNew-12                 1000000000               0.2561 ns/op          0 B/op          0 allocs/op
BenchmarkGet-12                 14617033                82.80 ns/op           18 B/op          1 allocs/op
BenchmarkGetForId-12            21623218                51.25 ns/op           16 B/op          1 allocs/op
BenchmarkGetWithPostfix-12      10882941               111.7 ns/op            26 B/op          1 allocs/op
BenchmarkGetPostfixId-12        31611556                37.07 ns/op           20 B/op          0 allocs/op
PASS
ok      github.com/anandvarma/namegen   5.293s

namegen's Issues

Use custom delim in name generator

Hello, I've spotted a bug where you cannot change the default delim for the name generator.
I will send over a PR soon

Extend the dictionary_test to spot duplicates across dictionaries

Today there exists logic to detect duplicates within a given dictionary of words. We need to add a test to spot duplicates across dictionaries too. For instance colors might show up in the color and adjective dictionaries which when used together could end up creating names with duplicate words in them.

Setup basic CI pipeline

• Github actions to run unit tests after each commit

Add benchmarks

Add benchmarks and optimize runtime and memory allocations.

Preallocate strings.Builder

Since we know the size of all the random strings as well as the postfix before hand, we can preallocate the builder to cut down on resizes and to make the memory allocations more deterministic.

Evaluate reusing the strings.Builder object

Every call to GetForId() creates a new strings.Builder object. Although this allocation should happen on the stack and is not a concern as such, see if it would help to Reset() the builder instead of creating a new one each time. Might come in useful particularly when we need not return the string such as with #9

Colors dictionary needs more entries

With just 3 entries, it is fairly repetitive at this point. Populate the dictionary!

Fix golint issues and release 1.0

Optimize allocations in GetForId()

GetForId() makes 3 allocations without prefix and 5 with. This is mostly down to initialized array appends and the call to strings.Join. Also evaluate and use strings.Builder to cut down on concatenation related allocations.

Benchmark outputs for reference:
BenchmarkGet-4 4428757 256.4 ns/op 65 B/op 3 allocs/op
BenchmarkGetWithPostfix-4 2684820 440.3 ns/op 162 B/op 5 allocs/op

Update README

• Features
• API documentation
• Examples
• CLI screenshots and usage

Implement io.Reader

See if it makes sense to implement the io.Reader interface for zero copy use-cases.

Optimize getPostfixId() memory usage

The getPostfixId implementation first encodes the random number into base-10 or base-36 and then returns a substring of it.
These encoded intermediary strings are 24 Bytes long in the common case. But the returned strings are typically 1-8 Bytes, leading to a large amount of fragmentation and trapped memory.