Go 1.20 Released

• go

  2,152 123,211 10.0 Go

  The Go programming language

  

  Those are good points about some of them being nontrivial.

  Though part of why they’re optimized and in the stdlib in the first place is because they’re such common patterns. So without them people would end up writing trivial, unperformant, custom versions. So now that more routines can be moved into the stdlib, they can benefit from optimization later.

  (I’m not sure how much the maps routines specifically can be optimized, but stdlib routines routines can generally be more aggressive with unsafe or asm or being coupled to the runtime and its quirks, like bytes.Clone, strings.Builder, etc.)

  And there are still plenty of ubiquitous patterns that have been worth including in the stdlib even if they’re usually just simple loops that aren’t very optimizable. Like strings.Index is an easy loop to write, but it comes up so often. Or strings.Cut is basically just an if-statement. But it makes code clearer about its intentions; and optimizations to these down the road benefit everyone.

  It’s also true that maps.Keys and maps.Values allocate slices, and that you could avoid this with a loop, but strings.Split, bytes.Split, regexp.FindAll, os.ReadDir return slices and are still worthwhile as opposed to specialized iterators for each one. As with any code, you’re conscious of memory allocations where it counts, and optimize as needed.

  In fact, now that generics make it possible, the Go team has discussed using iterators (https://github.com/golang/go/discussions/54245), which would benefit strings.Split even further in addition to all the other slice-returning functions.

  So generally you have three options for those slice-returning functions:

  - Custom inline loop for some of them. More verbose, will probably be naive and not benefit from stdlib optimizations.

• SaaSHub

  www.saashub.com featured

  SaaSHub - Software Alternatives and Reviews. SaaSHub helps you find the best software and product alternatives

  

• VictoriaMetrics

  102 12,050 9.9 Go

  VictoriaMetrics: fast, cost-effective monitoring solution and time series database

  

  No. I suppose, maintainers of popular open source projects couldn't justify introducing generics into their code. This is exactly my story - I was actively seeking places in VictoriaMetrics codebase, which could benefit from switching to generics. Unfortunately, not a single place has been found yet. The was a promising place for generics [1], but it has been appeared that it is better from readability and maintainability PoV to use plain old interfaces instead.

  [1] https://github.com/VictoriaMetrics/VictoriaMetrics/blob/mast...

• hashmap

  8 1,751 2.9 Go

  A Golang lock-free thread-safe HashMap optimized for fastest read access.

  Glad to see this make it into the core.

  I've been using this library for ages now...

  https://github.com/cornelk/hashmap

  Always entertains me to see developers write all the lock/unlock code when they could just use that.

• portable_get_random

  1 0 10.0 C

  Get cryptographically random bytes on various operating systems.

  To get cryptographically grade randomness you can use one of these C functions:

  BSD, newer macOS, and GNU libc: int getentropy(void buffer, size_t length);

  Linux 3.19+: ssize_t getrandom(void buf, size_t buflen, unsigned int flags);

  iOS and macOS 10.7+: int SecRandomCopyBytes(SecRandomRef, size_t, uint8_t );

  Fuchsia: void zx_cprng_draw(void* buffer, size_t buffer_size);

  Any *nix: Read from "/dev/random" (or "/dev/urandom" under the assumption that your system has already enough entropy).

  Windows: There are different functions/libraries depending on the Windows version and some of them are a complicated multi-step mess.

  Some time ago I wrote a C library that abstracts that away just for fun: https://github.com/panzi/portable_get_random

• go-cli

  1 0 10.0 Go

  A small library to handle CLI commands/subcommands (by cpuguy83)

  Tacking on generics on a working code base is difficult.

  I effectively used it in this little experimental CLI library: https://github.com/cpuguy83/go-cli/blob/main/command.go

  It's pretty simple, but the nice thing is it can use any flag library you want (stdlib flag package, pflag, whatever).

• prometheus

  413 55,112 9.9 Go

  The Prometheus monitoring system and time series database.

  

  Well there’s this: https://github.com/prometheus/prometheus/pull/11054

• holo

  2 95 10.0 Go

  Minimalistic configuration management (by holocm)

  

  That's not the same. `go test -c` builds a binary that runs your tests, whereas (if I understand correctly) the new thing builds a binary that runs your main(). If it works as I understand, that would be fantastic because then I could get rid of this monstrosity: https://github.com/holocm/holo/blob/master/main_test.go

Suggest a related project