Go is my hammer, and everything is a nail

• kubernetes

  708 109,628 10.0 Go

  Production-Grade Container Scheduling and Management

  

  - Kubernetes, one of the biggest public-facing Go projects, uses the 3-block style https://github.com/kubernetes/kubernetes/blob/master/pkg/con...

• InfluxDB

  www.influxdata.com featured

  Purpose built for real-time analytics at any scale. InfluxDB Platform is powered by columnar analytics, optimized for cost-efficient storage, and built with open data standards.

  

• tidb

  28 36,858 10.0 Go

  TiDB is an open-source, cloud-native, distributed, MySQL-Compatible database for elastic scale and real-time analytics. Try AI-powered Chat2Query free at : https://www.pingcap.com/tidb-serverless/

  

• minio

  109 46,535 9.9 Go

  MinIO is a high-performance, S3 compatible object store, open sourced under GNU AGPLv3 license.

  

  - MinIO uses 2-block https://github.com/minio/minio/blob/master/internal/grid/con...

  In all of those cases if you make a change and just run 'go fmt' it very well could inject any new imports in the first block, which would be wrong and you wouldn't know until project CI picks it up.

• rebar

  26 221 7.0 Python

  A biased barometer for gauging the relative speed of some regex engines on a curated set of tasks.

  The C#'s regex engine would have ran circles around Go's here though while doing so :)

  https://github.com/BurntSushi/rebar?tab=readme-ov-file#summa...

• starlark-go

  22 2,298 6.8 Go

  Starlark in Go: the Starlark configuration language, implemented in Go

  

• starlark-rust

  12 689 9.8 Rust

  A Rust implementation of the Starlark language

  

• vos

  26 1,924 9.6 V

  Vinix is an effort to write a modern, fast, and useful operating system in the V programming language

  

• SaaSHub

  www.saashub.com featured

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

  

• logrus

  36 24,516 0.0 Go

  Structured, pluggable logging for Go.

  For an internal-only dependency it's possible. But if you've got a lot of active branches, or long-lived feature branches, it'll create chaos in merge conflicts. Even worse if you've got multiple supported versions of a product on release branches (e.g., `main-v1.0`, `main-v1.1`, `main-v1.2`, and `main` itself for the yet-to-be-released `v1.3`) you either make backports awful (by only changing the import path on `main`) or have to change even more things (by changing the import path on the release branches too).

  It's effectively impossible for pubic-facing dependencies. Imagine if https://github.com/sirupsen/logrus wanted to change their Go modules import path, for example to move to another git hosting provider. (Logrus is great by the way, I'm only 'picking' on it as a popular Go library that's used everywhere.) GitHub tells me that almost 200,000 Go projects depend on it (https://github.com/sirupsen/logrus/network/dependents), so all of them would need to change every source file they do logging in (probably most of them) in order to handle that.

  GitHub seems like it's going to be eternal for now, but when the industry moves on in 10 years time every single Go project is going to break. This would be a problem for any source dependency management solution of course, it's not like any of the others are immune to this issue. But because Go has you encode the Git path in every source file you import it into, the level of change to fix it is an order of magnitude higher.

• go-app

  53 7,864 7.3 Go

  A package to build progressive web apps with Go programming language and WebAssembly.

  I like using this great library to build progressive web apps using Declarative Syntax https://github.com/maxence-charriere/go-app

• lwt

  6 704 7.4 OCaml

  OCaml promises and concurrent I/O

  

  > Also, didn't OCaml have weak support for concurrency? Has that changed recently?

  OCaml has had Lwt for concurrent IO for long enough that it is now being deprecated in favor of Eio[1]:

  https://github.com/ocsigen/lwt

  [1] https://github.com/ocaml-multicore/eio

• datasets

  16 18,968 9.6 Python

  🤗 The largest hub of ready-to-use datasets for ML models with fast, easy-to-use and efficient data manipulation tools

  

  This is my (current) favorite list comprehension: https://github.com/huggingface/datasets/blob/871eabc7b23c27d... Someone was feeling awfully clever that day. (Not that I'm not occasionally guilty myself.)

• script

  14 5,309 5.2 Go

  Making it easy to write shell-like scripts in Go

• purego

  23 2,091 8.0 Go

  

  https://ebitengine.org/en/documents/install.html

  For anything other than windows:

  > Installing a C compiler

  > A C compiler is required as Ebitengine uses not only Go but also C.

  I mean, even on platforms without cgo, it's it working magically?

  No; it's using https://github.com/ebitengine/purego, which is:

  > A library for calling C functions from Go without Cgo.

  Like... I mean.... okaaaay, it's not cgo, but it's basically cgo? ...but it's no cgo so you can say 'no cgo' on your banner page?

  Seems kind of like... this is maybe not the right hammer for gamedev.

• go

  2,136 122,633 10.0 Go

  The Go programming language

  

  There was a detailed proposal to introduce encoding/json/v2 last year but I don't know how far it's progressed since then (which you probably already know about but mentioning it here for others):

  https://github.com/golang/go/discussions/63397

• mapstructure

  17 7,867 0.0 Go

  Discontinued Go library for decoding generic map values into native Go structures and vice versa.

  Well, one used to have https://github.com/mitchellh/mapstructure which assisted here, but the lib then got abandoned.

• go-d3d

  1 28 3.0 Go

  Implements some d3d11 and dxgi interfaces for use with e.g. IDXGIOutputDuplication

  Also anything that requires interop/FFI, syscalls, and lower level stuff. It's extremely hard to record your screen on Go, for example. On Rust this is much more doable and there even are crates for it

  It's not impossible with Go, though. There's an amazing windows impl here: https://github.com/kirides/go-d3d

  ...but if you look at the code, it's clear that you have to work against the language in some capacity

• initializr

  284 3,424 9.0 Java

  A quickstart generator for Spring projects

  

  that might just be inherent complexity when have to deal with a webservice. personally I dislike have to configure security

  So basically go to Spring Initializr (https://start.spring.io/) pick the latest LTS Java&Maven (or Kotlin&Gradle-Kotlin) and You're off to the races.

• SDKMan

  163 6,052 4.8 Gherkin

  The SDKMAN! Command Line Interface

  

• apimachinery

  6 818 9.0 Go

  

  Its more like 20 lines of code without the prints. However, one generally should code generic functions for this. The k8s apimachinery module has helper functions which is useful for this sort of stuff. Ex: `NestedFieldNoCopy` and its wrapper functions.

  https://github.com/kubernetes/apimachinery/blob/95b78024e3fe...

• mapstructure

  1 105 7.7 Go

  Go library for decoding generic map values into native Go structures and vice versa. (by go-viper)

  

• ergo

  34 2,769 0.0 Go

  An actor-based Framework with network transparency for creating event-driven architecture in Golang. Inspired by Erlang. Zero dependencies.

  

  I haven't looked too deeply into it but I came across https://github.com/ergo-services/ergo not too long ago and thought it could be pretty interesting to try using OTP in Golang

  Packaging a Go service in Docker and dumping it into k8s is probably the easier/better understood path but also deploying Go services onto an Erlang node just sounds more fun

• dnadesign

  2 23 7.8 Go

  A Go package for designing DNA.

  For me, this is very true. Most bioinformatics is done in python, but over the last ~4 years I've ported everything I do over to Go: https://github.com/koeng101/dnadesign

  I'm just massively more productive, and the fact that I can read code I wrote years ago and fully understand what I was thinking at the time is amazing, and I haven't experienced that in other languages. I've learned other languages quite in depth, but with Go it is simple enough that when I write code, I'm not thinking about code, it is purely the problem being solved, and the code just comes out onto the keyboard.

  Ironically enough, I've recently started porting my entirely-go bioinformatics package to be a python package, mainly because I realize I'm not gonna convince everyone else in my field that Go > python

• Silk.NET

  39 4,009 5.2 C#

  The high-speed OpenGL, OpenCL, OpenAL, OpenXR, GLFW, SDL, Vulkan, Assimp, WebGPU, and DirectX bindings library your mother warned you about.

  

  Note that Go has very different GC behavior to .NET and what likely GC in Unreal does. At low allocation rates it might be desirable, but it has poor scaling with allocation rate and cores and as the object graph becomes and allocation patterns become more complex it will start pausing and throttling allocations, producing unacceptable performance[0].

  It also has weaker compiler that prevents or makes difficult efficient implementation of performance-sensitive code paths the way C# allows you to. It is unlikely game studios would be willing to compensate for that with custom Go ASM syntax.

  Almost every game is also FFI heavy by virtue of actively interacting with user input and calling out to graphics API. Since the very beginning, .NET was designed for fast FFI and had runtime augmentations to make it work well with its type system and GC implementations. FFI call that does not require marshalling (which is the norm for rendering calls as you directly use C structs) in .NET costs ~0.5-2ns, sometimes as cheap as direct C call + branch. In GoGC it costs 50ns or more. This is a huge difference that will dominate a flamegraph for anything that takes, for example, 30ns to execute and is called in a loop.

  It is also more difficult to do optimal threading with Go in FFI context as it has no mechanism to deal with runtime worker threads being blocked or spending a lot of time in FFId code - .NET threadpool has hill-climbing algorithm which scales active worker thread count (from 1 to hundreds) and blocked workers detection to make it a non-issue.

  Important mention goes to .NET having rich ecosystem of media API bindings: https://github.com/dotnet/Silk.NET and https://github.com/terrafx cover practically everything (unless you are on macOS) you would ever need to call in a game or a game engine, and do so with great attention paid to making the bindings efficient and idiomatic.

  For less intensive 2D games none of these are a dealbreaker. It will work, but unless the implementation details change and Go evolves in these areas, it will remain a language that is poorly suited for implementing games or game engines.

  [0]: https://gist.github.com/neon-sunset/72e6aa57c6a4c5eb0e2711e1...

• megaparsec

  5 909 6.0 Haskell

  Industrial-strength monadic parser combinator library

  I know that foo2 does not print anything to the terminal, wipe the database or launch the missiles! It doesn't have access to any effect handles, so it can't. foo1 might though! It does pass an I/O effect handle to bar1, so in principle it might do anything!

  But again, although I think this makes Haskell a better language, that's just my personal opinion. I don't expect anyone else to agree, necessarily. But if someone else says Haskell is not general purpose I would like them to explain how it can not be, even though it has all these useful features.

  > In all three of the cases that you mention, I can see a sort of aesthetic beauty to the Haskell solution, which I appreciate. But my clients don't look at my code, they look at the results of running my code.

  Me too, and the results they see are better than if I wrote code in another language, because Haskell is the language that allows me to most clearly see what results will be produced by my code.

  > The fact that you need a blog post to tell people how to resolve an issue exemplifies my point that this is not resolved. Nobody needs to be told how to turn off laziness in Python, because it's not turned on.

  Hmm, do you use that line of reasoning for everything? For example, if there were a blogpost about namedtuple in Python[1] would you say "the fact that you need a blog post to tell people how to use namedtuple exemplifies that it is not a solved problem"? I really can't understand why explaining how to do something exemplifies that that thing is not solved. To my mind it's the exact opposite!

  Indeed in Python laziness is not turned on, so instead if you want to be lazy you need blog posts to tell people how to turn it on! For example [2].

  > The fact is, Haskell does the wrong thing by default here

  I agree. My personal take is that data should be by default strict and functions should be by default lazy. I think that would have the best ergonomic properties. But there is no such language. Does that mean that every language is not general purpose?

  > even if you write your code to evaluate eagerly, you're going to end up interfacing with libraries where someone didn't do that.

  Ah, but that's the beauty of the solution. It doesn't matter whether others wrote "lazy code". If you define your data types correctly then your data types are free of space leaks. It doesn't matter what anyone else writes. Of course, other libraries may use laziness internally in a bad way. I've fixed my fair share of such issues, such as [3]. But other libraries can always be written in a bad way. In Python a badly written library may cause an exception and bring down your worker thread when you weren't expecting it, for example. That's a weakness of Python, but it doesn't mean it's not a general purpose language!

  > Laziness still gets advertised up front as being one of the awesome things about Haskell

  Hmm, maybe. "Pure and functional" is the main thing that people emphasizes as awesome. You yourself earlier brought up SPJ saying that the next Haskell will be strict, so we both know that Haskellers know that laziness is a double edged sword. I'm trying to point out that even though one edge of the sword of laziness points back at you it's not actually too hard to manage and having to manage it doesn't make Haskell not a general purpose language.

  > and while experience Haskell developers are usually disillusioned with laziness, many Haskell developers well into the intermediate level still write lazy code because they were told early on that it's great, and haven't yet experienced enough pain with it to see the problems.

  Hmm, maybe. I don't think people deliberately write lazy (or strict) code. They just write code. The code will typically happen to have a lot of laziness, because Haskell is lazy by default. I think that we agree that that laziness is not the best default, but we disagree about how difficult it is to work around that issue.

  I would be interested to hear whether you have more specific ideas you can share about why Haskell is not a general purpose language, in light of my responses.

  [1] https://blog.teclado.com/pythons-namedtuples/

  [2] https://www.tothenew.com/blog/exploring-pythons-itertools-mo...

  [3] https://github.com/mrkkrp/megaparsec/issues/486

• SaaSHub

  www.saashub.com featured

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

  

Suggest a related project