page.yaml

header: |
  <h1 align="center">🦩 Go Recipes</h1>
  <p align="center">Handy well-known and <i>lesser</i>-known tools for Go projects</p>

  > _Know some cool tool or one-liner? Have a feature request or an idea?_  
  > _Feel free to edit this page or create an Issue!_  

  [![Hits](https://hits.seeyoufarm.com/api/count/incr/badge.svg?url=https%3A%2F%2Fgithub.com%2Fnikolaydubina%2Fgo-recipes&count_bg=%2379C83D&title_bg=%23555555&icon=&icon_color=%23E7E7E7&title=hits&edge_flat=false)](https://hits.seeyoufarm.com)
  [![go-recipes](https://raw.githubusercontent.com/nikolaydubina/go-recipes/main/badge.svg?raw=true)](https://github.com/nikolaydubina/go-recipes)
  [![Track Awesome List](https://www.trackawesomelist.com/badge.svg)](https://www.trackawesomelist.com/nikolaydubina/go-recipes)
contents:
  title: Contents
entry:
  back: ⏫
  requirements:
    title: Requirements
  example:
    title: Example
groups:
  - title: AI tools
    entries:
      - title: Advanced autocompletion
        name: Copilot
        description: Start typing and after few seconds you will get autocompletion suggestion. Some useful ways to interact with it listed bellow.
        url: https://marketplace.visualstudio.com/items?itemName=GitHub.copilot
        example_image_url: https://user-images.githubusercontent.com/37570492/212964557-8d832278-61bb-4288-a8a7-47f35859e868.gif
        commands:
          - given a function signature and docstring, it will suggest function body
          - given a function body, it will suggest docstring
        requirements:
          - VSCode
          - GitHub account
      - title: Pull requests recommendations
        name: CopilotX
        description: "CopilotX has dedicated solutions for: writing PR description; writing tests; writing PR reviews and replies; applying requested PR changes. As of `2023-06-04`, it is on waitlist. [documentation](https://githubnext.com/projects/copilot-for-pull-requests)."
        url: https://github.com/features/preview/copilot-x
      - title: Code analysis and recommendations
        name: charmbracelet/mods
        description: This is a nice looking CLI wrapper for major LLM APIs from [Charm](https://github.com/charmbracelet) team. It supports OpenAI and [LocalAI](https://github.com/go-skynet/LocalAI). It passes arbitrary human language command string and concatenated with STDIN input. Multiple useful commands are possible.
        url: https://github.com/charmbracelet/mods
        commands:
          - mods -f "what are your thoughts on improving this code?" < main.go | glow
          - mods -f "you are an expert Go programmer. find potential bugs in following Go code." < my_class.go | glow
        example_image_url: https://user-images.githubusercontent.com/25087/237975943-738fe969-1c9f-4849-af8a-cde38156ce92.gif
        requirements:
          - "# OpenAI token or LocalAI model and server"
          - go install github.com/charmbracelet/glow@latest
          - go install github.com/charmbracelet/mods@latest
      - title: Pull request recommendations
        name: gpt-pullrequest-updater
        description: This tool generates GitHub pull request description and review using OpenAI ChatGPT. There is also GitHub Action available.
        url: https://github.com/ravilushqa/gpt-pullrequest-updater
        author: https://github.com/ravilushqa
        example_image_url: ./img/gpt-pullrequest-updater-example.png
        requirements:
          - "# OpenAI token"
          - "# GitHub token"
          - go install github.com/ravilushqa/gpt-pullrequest-updater/cmd/description@latest
          - go install github.com/ravilushqa/gpt-pullrequest-updater/cmd/review@latest
      - title: Commit message recommendation
        description: Short summaries of changes usually work well.
        url: https://github.com/charmbracelet/mods
        commands:
          - git diff | mods "summarize following git diff into short git commit message."
          - git diff | mods "you are expert Go programmer. you are owner of this codebase. think through step by step. summarize following git diff into short git commit message under 10 words."
        example_output: |
          Add new entries for Using AI in Go projects, including Advanced autocompletion with Copilot and Code analysis and recommendations with charmbracelet/mod. Update page.yaml accordingly.
        requirements:
          - "# OpenAI token or LocalAI model and server"
          - go install github.com/charmbracelet/mods@latest
      - title: Test case recommendation
        url: https://github.com/charmbracelet/mods
        description: Concatenate two files and ask to recommend missing test cases. It is not precise, has high false positive and high false negative rate. Often can not detect that tests cases are present at all. However, it can give a fresh perspective on your code. Best results are produced when asking succinct short replies. Example outputs bellow.
        commands:
          - cat fpdecimal.go fpdecimal_test.go | head -c 3600 | mods -f "you are an expert Go programmer. investigate supplied Go program and associated test suite. think through this step by step. make sure you get the right answer. recommend missing test cases. write very succinctly. under 100 words." | glow
          - cat fpdecimal.go fpdecimal_test.go | head -c 4000 | mods -f "investigate supplied Go program and associated test suite. recommend missing test cases." | glow
        example_output: |
          For additional test cases, consider adding tests for negative float values, positive and negative infinity, unsigned
          integers, zero divided by a number greater than zero, and division with only zeros.                       
          ------------------
            Test cases:                                                                                                                                                                                                                             
            • Test for unmarshalling JSON into Decimal                                                                          
            • Test for marshalling Decimal to JSON                                                                              
            • Test for multiplication with zero                                                                                 
            • Test for multiplication identity                                                                                  
            • Test for division with zero                                                                                       
            • Test for all comparison operations for the Decimal struct.                                                        
          ------------------
          Missing test cases for the  fpdecimal  Go program include those for testing the  DivMod  and  FromString  functions.
          Additionally, there should be tests checking that zero division is not allowed, and tests that ensure the           
          FractionDigits  value does not change during the program's runtime. Important test cases include comparing decimals 
          for equality, as well as testing the commutativity, associativity, and identity properties of addition and          
          multiplication. Finally, the program should have a test that verifies the  MarshalJSON  and  UnmarshalJSON          
          functions.
      - title: Time complexity estimate
        url: https://github.com/charmbracelet/mods
        description: This is one of recommended use cases by OpenAI website. It can produce fairly good estimations. However, in its direct form usefulness is questionable, since complex cases are not handled precisely enough, educational potential is limited, and simple cases do not require this. Perhaps, this will be utilized in future work on using models in compiler and programming. Copy function and pipe it to model with prompt asking for time complexity estimation. Bellow is an example.
        commands:
          - pbpaste | mods -f "calculate time complexity of following Go code function." | glow
        example_content_ext: go
        example_content: |
          func AppendFixedPointDecimal(b []byte, v int64, p int) []byte {
            if v == 0 {
              return append(b, '0')
            }

            if p == 0 {
              return strconv.AppendInt(b, v, 10)
            }

            if v < 0 {
              v = -v
              b = append(b, '-')
            }

            s := len(b)
            b = strconv.AppendInt(b, v, 10)

            if len(b)-s > p {
              i := len(b) - p
              b = append(b, 0)
              copy(b[i+1:], b[i:])
              b[i] = '.'
            } else {
              i := 2 + p - (len(b) - s)
              for j := 0; j < i; j++ {
                b = append(b, 0)
              }
              copy(b[s+i:], b[s:])
              copy(b[s:], []byte(zeroPrefix[:i]))
            }

            return b
          }
        example_output: |
          The time complexity of the AppendFixedPointDecimal function is O(N), where N is the length of the input byte slice  
          b. This is because the function performs a constant number of operations for each byte in b, and the largest        
          operation within the function is the loop that appends zeros to the byte slice, which has a length proportional to  
          the input. Other operations, such as integer conversions and comparisons, are considered constant time since the    
          input size is fixed.                 
          ------------------
          The time complexity of the function depends on the input values  v  and  p .    
          • The first three if statements before the main computation take constant time, 
          so they don't contribute to the overall time complexity.                        
          • The  strconv.AppendInt  function used twice has a time complexity of          
          O(log(v)), where v is the integer being converted to a string representation in 
          base 10.                                                                        
          • The condition  len(b)-s > p  has a constant time complexity.                  
          • The  append  and  copy  operations inside the if and else blocks take linear  
          time proportional to  p .                                                       
          • The  for  loop has a constant number of iterations, specifically 2 +  p  - (  
          len(b)-s ). The  append  and  copy  operations inside the loop also take linear 
          time proportional to  p .                                                       
          Therefore, the overall time complexity of the function is O(log(v) + p).
  - title: Testing
    entries:
      - title: Make treemap of coverage
        description: Visualize distribution of code coverage in your project. This helps to identify code areas with high and low coverage. Useful when you have large project with lots of files and packages. This 2D "image-hash" of your project should be more representative than a single number. Also available at https://go-cover-treemap.io.
        example_image_url: ./img/hugo-code-coverage.svg
        name: go-cover-treemap
        url: https://github.com/nikolaydubina/go-cover-treemap
        author: https://github.com/nikolaydubina
        requirements:
          - go install github.com/nikolaydubina/go-cover-treemap@latest
        commands:
          - go test -coverprofile cover.out ./...
          - go-cover-treemap -coverprofile cover.out > out.svg
      - title: Browse coverage
        description: This is very helpful tool from the official Go toolchain. Similar visualization is integrated into VSCode and Goland, but can be used separately.
        example_image_url: ./img/tool-cover-html.png
        commands:
          - go test -coverprofile cover.out ./...
          - go tool cover -html=cover.out
      - title: Browse coverage
        name: gocov-html
        url: https://github.com/matm/gocov-html
        author: https://github.com/matm
        description: Browse code coverage in statically generated HTML page. Multiple styles are supported. You may need to convert coverage report into `gocov` format.
        example_image_url: ./img/gocov-html.png
        commands:
          - gocov test strings | gocov-html -t golang > strings.html
          - gocov test encoding/csv strings | gocov-html -t kit > strings.html
          - "gocov test strings|./gocov-html -cmax 90 > strings.html # show functions with <90% coverage"
        requirements:
          - go install github.com/axw/gocov/gocov@latest
          - go install github.com/matm/gocov-html/cmd/gocov-html@latest
      - title: Browse coverage in terminal
        description: Browse code coverage similarly to HTML provided by official Go toolchain, but in terminal. Other notable features are package level statistics, coverage only for changed files.
        name: gocovsh
        url: https://github.com/orlangure/gocovsh
        author: https://github.com/orlangure
        example_image_url: https://github.com/orlangure/gocovsh/raw/master/examples/general.gif
        commands:
          - go test -cover -coverprofile coverage.out
          - "gocovsh                        # show all files from coverage report"
          - "git diff --name-only | gocovsh # only show changed files"
          - "git diff | gocovsh             # show coverage on top of current diff"
          - "gocovsh --profile profile.out  # for other coverage profile names"
        requirements:
          - go install github.com/orlangure/gocovsh@latest
      - title: Pretty print coverage in terminal
        description: It is similar to `go tool cover -html=cover.out` but in terminal. You can filter by functions, packages, minimum coverage, and more.
        name: nikandfor/cover
        url: https://github.com/nikandfor/cover
        author: https://github.com/nikandfor
        commands:
          - cover
        requirements:
          - go install github.com/nikandfor/cover@latest
        example_image_url: img/cover.png
      - title: Run coverage collector server
        description: This tool allows to collect coverage as soon as code is executed.
        url: https://github.com/qiniu/goc
        author: https://github.com/qiniu
        example_image_url: https://github.com/qiniu/goc/raw/master/docs/images/intro.gif
        name: goc
        commands:
          - goc server
          - goc build
          - goc profile
        requirements:
          - go install github.com/qiniu/goc@latest
      - title: Visualize live coverage in VSCode
        description: Official Go VSCode plugin already has coverage highlighting. In addition to that, this tool shows covered lines as soon as they are executed. This can be useful for running manual integration or system tests or debugging.
        url: https://github.com/qiniu/goc
        author: https://github.com/qiniu
        example_image_url: https://github.com/qiniu/goc/raw/master/docs/images/goc-vscode.gif
        name: goc
        requirements:
          - go install github.com/qiniu/goc@latest
      - title: ":confetti_ball: Shuffle tests"
        description: This is less known option that is disabled by default. However, for robust test suite it is beneficial. More test flags and full description is available at `go help testflag`.
        commands:
          - go test -shuffle=on
      - title: Run tests sequentially
        description: Use when you need to synchronize tests, for example in integration tests that share environment. [Official documentation](https://pkg.go.dev/cmd/go#hdr-Testing_flags).
        commands:
          - go test -p 1 -parallel 1 ./...
      - title: Run tests in parallel
        description: Add `t.Parallel` to your tests case function bodies. As per documentation, by default `-p=GOMAXPROCS` and `-parallel=GOMAXPROCS` when you run `go test`. Different packages by default run in parallel, and tests within package can be enforced to run in parallel too. Make sure to copy test case data to new variable, why explained [here](https://gist.github.com/posener/92a55c4cd441fc5e5e85f27bca008721). [Official documentation](https://pkg.go.dev/cmd/go#hdr-Testing_flags).
        example_content_ext: go
        example_content: |
          ...
          for _, tc := range tests {
              tc := tc
              t.Run(tc.name, func(t *testing.T) {
                  t.Parallel()
                  ...
      - title: Detect goroutine leaks
        description: Instrument your test cases with verification call. Alternatively, you can add single call in `TestMain`. This tool was recommended by Pyroscope in [blog](https://grafana.com/blog/2023/04/19/how-to-troubleshoot-memory-leaks-in-go-with-grafana-pyroscope/).
        url: https://github.com/uber-go/goleak
        author: Uber
        name: goleak
        example_content_ext: go
        example_content: |
          func TestA(t *testing.T) {
            defer goleak.VerifyNone(t)
            ...
          }
        requirements:
          - go get -u go.uber.org/goleak
      - title: Detect goroutine leaks
        description: Refactored, tested variant of the goroutine leak detector found in both `net/http` tests and the cockroachdb source tree. You have to call this library in your tests.
        name: leaktest
        url: https://github.com/fortytw2/leaktest
        author: https://github.com/fortytw2
        example_content: |
          func TestPoolContext(t *testing.T) {
            ctx, cancel := context.WithTimeout(context.Background(), time.Second)
            defer cancel()
            defer leaktest.CheckContext(ctx, t)()

            go func() {
              for {
                time.Sleep(time.Second)
              }
            }()
          }
      - title: Summarize `go test`
        description: This lightweight wrapper around STDOUT of JSON of `go test` will nicely render colorized test status, details of failures, duration, coverage, and package summary.
        name: tparse
        url: https://github.com/mfridman/tparse
        author: https://github.com/mfridman
        example_image_url: ./img/tparse.png
        commands:
          - set -o pipefail && go test ./... -json | tparse -all
        requirements:
          - go install github.com/mfridman/tparse@latest
      - title: Decorate `go test`
        description: Add colors and enrich `go test` output. It can be used in CI pipeline and has lots of alternative visualizations and options.
        name: richgo
        url: https://github.com/kyoh86/richgo
        author: https://github.com/kyoh86
        commands:
          - richgo test ./...
        example_image_url: https://asciinema.org/a/99810.png
        requirements:
          - go install github.com/kyoh86/richgo@latest
      - title: Decorate `go test`
        description: Add colors to `go test` output. Very lightweight wrapper around `go test` STDOUT.
        name: gotest
        url: https://github.com/rakyll/gotest
        author: https://github.com/rakyll
        example_image_url: https://raw.githubusercontent.com/jonasbn/go-test-demo/1.0.0/gotest-go-test-demo.png
        commands:
          - gotest ./...
        requirements:
          - go install github.com/rakyll/gotest@latest
      - title: Decorate `go test`
        description: This wrapper around `go test` renders test output in easy to read format. Also supports JUnit, JSON output, skipping slow tests, running custom binary.
        name: gotestsum
        url: https://github.com/gotestyourself/gotestsum
        author: https://github.com/dnephin
        commands:
          - gotestsum --format dots
        example_image_url: https://user-images.githubusercontent.com/442180/182284939-e08a0aa5-4504-4e30-9e88-207ef47f4537.gif
        requirements:
          - go install gotest.tools/gotestsum@latest
      - title: Format `go test` results as documentation
        name: gotestdox
        description: Decorates `go test` results by converting CamelCaseTestNames into readable sentences.
        url: https://github.com/bitfield/gotestdox
        author: https://github.com/bitfield
        example_image_url: https://github.com/bitfield/gotestdox/raw/main/img/demo.gif
        commands:
          - gotestdox ./...
        requirements:
          - go install github.com/bitfield/gotestdox/cmd/gotestdox@latest
      - title: Get slowest tests
        description: This is subcommand of `gotestsum` that processes JSON output of `go test` to find slowest tests.
        name: gotestsum
        url: https://github.com/gotestyourself/gotestsum
        author: https://github.com/dnephin
        commands:
          - go test -json -short ./... | gotestsum tool slowest --threshold 500ms
        example_output: |
          gotest.tools/example TestSomething 1.34s
          gotest.tools/example TestSomethingElse 810ms
        requirements:
          - go install gotest.tools/gotestsum@latest
      - title: Auto-Instrument skipping slowest tests
        description: This is subcommand of `gotestsum` that processes JSON output of `go test` to find slowest tests and instruments test cases to skip them with `t.Skip()` statements.
        name: gotestsum
        url: https://github.com/gotestyourself/gotestsum
        author: https://github.com/dnephin
        commands:
          - go test -json ./... | gotestsum tool slowest --skip-stmt "testing.Short" --threshold 200ms
        example_output: |
          gotest.tools/example TestSomething 1.34s
          gotest.tools/example TestSomethingElse 810ms
        requirements:
          - go install gotest.tools/gotestsum@latest
      - title: Automatically re-run failed tests
        description: Other useful option of `gotestsum` is to re-run failed tests. For example, if you have flaky tests that are idempotent, then re-running them may be a quick fix.
        name: gotestsum
        url: https://github.com/gotestyourself/gotestsum
        author: https://github.com/dnephin
        commands:
          - gotestsum --rerun-fails --packages="./..."
        requirements:
          - go install gotest.tools/gotestsum@latest
      - title: Make `JSUnit` test report
        description: JUnit is widely used format for test reporting.
        name: gotestsum
        url: https://github.com/gotestyourself/gotestsum
        author: https://github.com/dnephin
        commands:
          - go test -json ./... | gotestsum --junitfile unit-tests.xml
        requirements:
          - go install gotest.tools/gotestsum@latest
      - title: Make `JSUnit` test report
        description: JUnit is widely used format for test reporting. Go benchmark output is also supported.
        url: https://github.com/jstemmer/go-junit-report
        name: go-junit-report
        author: https://github.com/jstemmer
        commands:
          - go test -v 2>&1 ./... | go-junit-report -set-exit-code > report.xml
        requirements:
          - go install github.com/jstemmer/go-junit-report/v2@latest
      - title: Get packages without tests
        description: If code coverage does not report packages without tests. For example for CI or quality control.
        requirements:
          - https://stedolan.github.io/jq/download/
        commands:
          - go list -json ./... | jq -rc 'select((.TestGoFiles | length)==0) | .ImportPath'
        example_output: |
          github.com/gin-gonic/gin/ginS
          github.com/gin-gonic/gin/internal/json
      - title: Perform Mutation Testing
        description: Mutation testing is a technique used to assess the quality and coverage of test suites. It involves introducing controlled changes to the code base, simulating common programming mistakes. These changes are, then, put to test against the test suites. A failing test suite is a good sign. It indicates that the tests are identifying mutations in the code—it "killed the mutant". If all tests pass, we have a surviving mutant. This highlights an area with weak coverage. It is an opportunity for improvement.
        url: https://github.com/gtramontina/ooze
        name: ooze
        author: https://github.com/gtramontina
        requirements:
          - go get github.com/gtramontina/ooze
        commands:
          - go test -v -tags=mutation
        example_image_url: https://github.com/gtramontina/ooze/blob/main/.assets/report.png
      - title: Perform Mutation Testing
        description: This is fork of [zimmski/go-mutesting](https://github.com/zimmski/go-mutesting). It has more mutators and latest updates.
        name: "avito-tech/go-mutesting"
        url: https://github.com/avito-tech/go-mutesting
        author: https://github.com/vasiliyyudin
        requirements:
          - go install github.com/avito-tech/go-mutesting/cmd/go-mutesting@latest
        commands:
          - go-mutesting ./...
        example_content_ext: go
        example_content: |
          for _, d := range opts.Mutator.DisableMutators {
            pattern := strings.HasSuffix(d, "*")

          -	if (pattern && strings.HasPrefix(name, d[:len(d)-2])) || (!pattern && name == d) {
          +	if (pattern && strings.HasPrefix(name, d[:len(d)-2])) || false {
              continue MUTATOR
            }
          }
      - title: Perform Mutation Testing
        description: Find common bugs source code that would pass tests. This is earliest tool for mutation testing in Go. More functions and permutations were added in other mutation Go tools it inspired.
        name: go-mutesting
        url: https://github.com/zimmski/go-mutesting
        author: https://github.com/zimmski
        requirements:
          - go install github.com/zimmski/go-mutesting/cmd/go-mutesting@latest
        commands:
          - go-mutesting ./...
        example_content_ext: go
        example_content: |
          for _, d := range opts.Mutator.DisableMutators {
            pattern := strings.HasSuffix(d, "*")

          -	if (pattern && strings.HasPrefix(name, d[:len(d)-2])) || (!pattern && name == d) {
          +	if (pattern && strings.HasPrefix(name, d[:len(d)-2])) || false {
              continue MUTATOR
            }
          }
      - title: Trace tests
        description: Collect test execution as distributed traces. This is useful for tracking test duration, failures, flakiness. You distributed tracing storage, search, UI, exploration, dashboards, alarms — all will automatically become test status collection. If you run integration tests in your CI, then it is particularly handy to investigate your integration tests same way as real requests, such as Go processes, databases, etc. However, if you do not have distributed traces, it is still useful for adhoc investigations. This tool processes STDOUT of `go test`. No automatic instrumentation is done.
        name: go-test-trace
        url: https://github.com/rakyll/go-test-trace
        author: https://github.com/rakyll
        example_image_url: https://camo.githubusercontent.com/1bbb99d14634e097828aff76e17427c0d834b2b37b7ef6c4b15ad01e5b7ac526/68747470733a2f2f692e696d6775722e636f6d2f45313850596b342e706e67
        commands:
          - go-test-trace ./...
        requirements:
          - "# open telemetry collector"
          - "# traces UI (Datadog, Jaeger, Honeycomb, NewRelic)"
          - go install github.com/rakyll/go-test-trace@latest
      - title: Speedup tests for large codebases
        description: As of 2023-12-11, large codebases may be slow to run tests by default commands. Compiling package test binaries first and executing them later can lead to significant overall speedup.
        commands:
          - go test -c ./pkg/mypackage -o my_pkg_test_binary.bin
          - "./my_pkg_test_binary.bin | ... # normal test output post processing"
  - title: Dependencies
    entries:
      - title: Get Go version of current module
        description: For example, setup correct Go version automatically from `go.mod` in CI.
        requirements:
          - https://stedolan.github.io/jq/download/
        commands:
          - go mod edit -json | jq -r .Go
        example-output: 1.16
      - title: Get Go versions of upstream modules
        description: Use this when upgrading version of Go or finding old modules.
        requirements:
          - https://stedolan.github.io/jq/download/
        commands:
          - go list -deps -json ./... | jq -rc 'select(.Standard!=true and .Module.GoVersion!=null) | [.Module.GoVersion,.Module.Path] | join(" ")' | sort -V | uniq
        example_output: |
          1.11 github.com/ugorji/go/codec
          1.11 golang.org/x/crypto
          1.12 github.com/golang/protobuf
      - title: Get directly dependent modules that can be upgraded
        description: Keep your modules updated. Similar function is integrated in VSCode official Go plugin and GoLand.
        commands:
          - go list -u -m $(go list -m -f '{{.Indirect}} {{.}}' all | grep '^false' | cut -d ' ' -f2) | grep '\['
        example_output: |
          github.com/goccy/go-json v0.5.1 [v0.7.3]
          github.com/golang/protobuf v1.3.3 [v1.5.2]
          github.com/json-iterator/go v1.1.9 [v1.1.11]
      - title: Get upstream modules without Go version
        description: Find outdated modules or imports that you need to upgrade.
        commands:
          - go list -deps -json ./... | jq -rc 'select(.Standard!=true and .Module.GoVersion==null) | .Module.Path' | sort -u
        requirements:
          - https://stedolan.github.io/jq/download/
        example_output: |
          github.com/facebookgo/clock
          golang.org/x/text
          gopkg.in/yaml.v2
      - title: Get available module versions
        description: This works even if you did not download or install module locally. This is useful to check to which version you can upgrade to, what is the latest version, and whether there are v2+ major versions recognized by Go toolchain.
        commands:
          - go list -m -versions github.com/google/gofuzz
        example-output: github.com/google/gofuzz v1.0.0 v1.1.0 v1.2.0
      - title: Make graph of upstream modules
        description: For each module, the node representing the greatest version (i.e., the version chosen by Go's minimal version selection algorithm) is colored green. Other nodes, which aren't in the final build list, are colored grey.
        name: modgraphviz
        url: https://golang.org/x/exp/cmd/modgraphviz
        author: official Go team
        commands:
          - go mod graph | modgraphviz | dot -Tsvg -o mod-graph.svg
        example_image_url: ./img/modgraphviz-go-featureprocessing.svg
        requirements:
          - https://graphviz.org/download/
          - go install golang.org/x/exp/cmd/modgraphviz@latest
      - title: Make graph of upstream modules
        description: Render in browser Go module graphs. Built with D3.js, Javascript, HTTP server in Go.
        name: gmchart
        url: https://github.com/PaulXu-cn/go-mod-graph-chart/gmchart
        author: https://github.com/PaulXu-cn
        commands:
          - go mod graph | gmchart
        example_image_url: https://github.com/PaulXu-cn/go-mod-graph-chart/raw/main/show.gif
        requirements:
          - go install github.com/PaulXu-cn/go-mod-graph-chart/gmchart@latest
      - title: Make graph of upstream packages
        description: Find unexpected dependencies or visualize project. Works best for small number of packages, for large projects use `grep` to narrow down subgraph. Without `-deps` only for current module.
        commands:
          - "go list -deps -json ./... | jq -c 'select(.Standard!=true) | {from: .ImportPath, to: .Imports[]}' | jsonl-graph | dot -Tsvg > package-graph.svg"
        example_image_url: ./img/packages-graph.svg
        name: import-graph
        url: https://github.com/nikolaydubina/import-graph
        author: https://github.com/nikolaydubina
        requirements:
          - https://stedolan.github.io/jq/download/
          - https://graphviz.org/download/
          - go install github.com/nikolaydubina/import-graph@latest
          - go install github.com/nikolaydubina/jsonl-graph@latest
      - title: Scrape details about upstream modules and make graph
        description: Find low quality or unmaintained dependencies.
        commands:
          - go mod graph | import-graph -i=gomod | jsonl-graph -color-scheme=file://$PWD/basic.json | dot -Tsvg > output.svg
        example_image_url: ./img/gin-mod-graph-collected.svg
        name: import-graph
        url: https://github.com/nikolaydubina/import-graph
        author: https://github.com/nikolaydubina
        requirements:
          - https://graphviz.org/download/
          - go install github.com/nikolaydubina/import-graph@latest
          - go install github.com/nikolaydubina/jsonl-graph@latest
      - title: Scrape licenses of upstream dependencies
        description: Collect all the licenses for checking if you can use the project, for example in proprietary or commercial environment.
        name: go-licenses
        url: https://github.com/google/go-licenses
        author: Google
        example_output: |
          github.com/cli/safeexec,https://github.com/cli/safeexec/blob/master/LICENSE,BSD-2-Clause
          github.com/bep/tmc,https://github.com/bep/tmc/blob/master/LICENSE,MIT
          github.com/aws/aws-sdk-go,https://github.com/aws/aws-sdk-go/blob/master/LICENSE.txt,Apache-2.0
          github.com/jmespath/go-jmespath,https://github.com/jmespath/go-jmespath/blob/master/LICENSE,Apache-2.0
          github.com/gorilla/websocket,https://github.com/gorilla/websocket/blob/master/LICENSE,BSD-2-Clause
          github.com/pelletier/go-toml/v2,https://github.com/pelletier/go-toml/blob/master/v2/LICENSE,MIT
          github.com/spf13/cobra,https://github.com/spf13/cobra/blob/master/LICENSE.txt,Apache-2.0
          github.com/kyokomi/emoji/v2,https://github.com/kyokomi/emoji/blob/master/v2/LICENSE,MIT
          go.opencensus.io,Unknown,Apache-2.0
          github.com/Azure/azure-storage-blob-go/azblob,https://github.com/Azure/azure-storage-blob-go/blob/master/azblob/LICENSE,MIT
          github.com/yuin/goldmark-highlighting,https://github.com/yuin/goldmark-highlighting/blob/master/LICENSE,MIT
        commands:
          - go-licenses csv github.com/gohugoio/hugo
        requirements:
          - go install github.com/google/go-licenses@latest
      - title: Explore dependencies
        description: This tool has extensive syntax for filtering dependencies graphs. It can work with packages and modules.
        name: goda
        url: https://github.com/loov/goda
        author: "[Egon Elbre](egonelbre@gmail.com)"
        commands:
          - goda graph . | dot -Tsvg -o graph.svg
          - goda graph -cluster -short "github.com/nikolaydubina/go-cover-treemap:all" | dot -Tsvg -o graph.svg
        requirements:
          - https://graphviz.org/download/
          - go install github.com/loov/goda@latest
        example_image_url: https://github.com/loov/goda/raw/master/graph.svg
      - title: Explore dependencies interactively
        description: Useful in large refactorings, dependency breaking, physical layout changes.
        name: spaghetti
        url: https://github.com/adonovan/spaghetti
        author: "[Alan Donovan](https://github.com/adonovan), official Go team"
        example_image_url: https://github.com/adonovan/spaghetti/blob/main/screenshot.png
        requirements:
          - go install github.com/adonovan/spaghetti@latest
      - title: Use `go mod` directives
        description: Tell Go compiler which versions of upstreams to include in your build. Tell all users of your module how to deal with versions of your module.
        example_content: |
          // Deprecated: use example.com/mod/v2 instead.
          module example.com/mod

          go 1.16

          require example.com/other/thing v1.0.2
          require example.com/new/thing/v2 v2.3.4
          exclude example.com/old/thing v1.2.3
          replace example.com/bad/thing v1.4.5 => example.com/good/thing v1.4.5
          retract [v1.9.0, v1.9.5]
  - title: Code Visualization
    entries:
      - title: Make C4 diagram
        description: This library provides tools to generate [C4](https://c4model.com) diagrams. The process is a bit involved, however you get diagram generated from real Go code automatically. Steps are outlined in [blog](https://threedots.tech/post/auto-generated-c4-architecture-diagrams-in-go/).
        url: https://github.com/krzysztofreczek/go-structurizr
        author: https://github.com/krzysztofreczek
        name: go-structurizr
        example_image_url: https://threedots.tech/post/auto-generated-c4-architecture-diagrams-in-go/tdl-go_structurizr_1_2.png
        requirements:
          - manually defining Go main.go script to invoke library
          - graphviz
          - manual coloring spec (DB, calsses)
      - title: Make graph of function calls
        description: Visualize complex or new project quickly or to study project. Requires `main.go` in module. Supports Graphviz output format. Has many options for filtering and formatting.
        name: callgraph
        url: https://golang.org/x/tools/cmd/callgraph
        author: official Go team
        example_image_url: img/callgraph.svg
        commands:
          - callgraph -format graphviz . | dot -Tsvg -o graph.svg
          - "recommend: grep <package/class/func of interest>"
          - "recommend: grep -v Error since many packages report error"
          - "recommend: adding `rankdir=LR;` to graphviz file for denser graph"
          - "recommend: you would have to manually fix graphviz file first and last line"
        requirements:
          - go install golang.org/x/tools/cmd/callgraph@latest
      - title: Make graph of function calls in package
        description: Quickly track which packages current package is calling and why.
        name: go-callvis
        url: https://github.com/ofabry/go-callvis
        author: https://github.com/ofabry
        commands:
          - go-callvis .
        example_image_url: https://raw.githubusercontent.com/ofabry/go-callvis/master/images/syncthing.png
        requirements:
          - go install github.com/ofabry/go-callvis
      - title: Make PlantUML diagram
        description: Generates class diagram in widely used format with the information on structs, interfaces and their relationships. Render `.puml` files in for example [planttext.com](https://www.planttext.com).
        name: goplantuml
        url: https://github.com/jfeliu007/goplantuml
        author: https://github.com/jfeliu007
        commands:
          - goplantuml -recursive path/to/gofiles path/to/gofiles2
        requirements:
          - go get github.com/jfeliu007/goplantuml/parser
          - go install github.com/jfeliu007/goplantuml/cmd/goplantuml@latest
        example_image_url: https://raw.githubusercontent.com/jfeliu007/goplantuml/master/example/example.png
      - title: Make PlantUML diagram
        description: Automatically generate visualization of classes and interfaces for go packages. Recommend recursive option. Render `.puml` files in for example [planttext.com](https://www.planttext.com).
        name: go-plantuml
        url: https://github.com/bykof/go-plantuml
        author: https://github.com/bykof
        commands:
          - go-plantuml generate -d . -r -o graph.puml
        example_image_url: https://raw.githubusercontent.com/bykof/go-plantuml/master/docs/assets/graph.svg
        requirements:
          - go install github.com/bykof/go-plantuml@latest
      - title: Make 3D chart of Go codebase
        description: Fresh artistic perspective on Go codebase. `GoCity` is an implementation of the Code City metaphor for visualizing source code - folders are districts; files are buildings; structs are buildings on the top of their files. This project has research paper "[GoCity Code City for Go](https://homepages.dcc.ufmg.br/~mtov/pub/2019-saner-gocity.pdf)" at SANER'19. Also available at [go-city.github.io](https://go-city.github.io).
        example_image_url: img/gocity.png
        name: gocity
        url: https://github.com/rodrigo-brito/gocity
        author: https://github.com/rodrigo-brito
        requirements:
          - go install github.com/rodrigo-brito/gocity@latest
      - title: Make histogram of Go files per package
        description: Find when package is too big or too small. Adjust histogram length to maximum value.
        requirements:
          - https://stedolan.github.io/jq/download/
        commands:
          - go list -json ./... | jq -rc '[.ImportPath, (.GoFiles | length | tostring)] | join(" ")' | perl -lane 'print (" " x (20 - $F[1]), "=" x $F[1], " ", $F[1], "\t", $F[0])'
        example_output: |
          ================== 18	github.com/gin-gonic/gin
               ============= 13	github.com/gin-gonic/gin/binding
                           = 1	github.com/gin-gonic/gin/internal/bytesconv
                           = 1	github.com/gin-gonic/gin/internal/json
                 =========== 11	github.com/gin-gonic/gin/render
      - title: Explore Go code in browser powered by `go-guru`
        description: "Explore Go source code in browser. It provides exported symbols summary for navigation. It answers questions like: definition; callers; implementers. It is browser frontend based on [go-guru](https://docs.google.com/document/d/1_Y9xCEMj5S-7rv2ooHpZNH15JgRT5iM742gJkw5LtmQ/edit), which was developed by Go core team from Google."
        url: https://github.com/fzipp/pythia
        name: pythia
        author: https://github.com/fzipp
        example_image_url: https://camo.githubusercontent.com/a7baec2bada145869272edf97d1123d1717ed68922c159b027d261bd6e1faeff/68747470733a2f2f7261772e6769746875622e636f6d2f667a6970702f7079746869612f67682d70616765732f696d616765732f7079746869615f73637265656e73686f742e706e67
        commands:
          - pythia net/http
        requirements:
          - go install github.com/fzipp/pythia@latest
          - go install golang.org/x/tools/cmd/guru@latest
      - title: ":derelict_house: Interactively visualize packages"
        description: Based on `go-callvis`, this tool is an interactive package explorer of packages. This tool have not been updated for a long time.
        url: https://github.com/ofabry/goexplorer
        name: goexplorer
        author: https://github.com/ofabry
        example_image_url: https://github.com/ofabry/goexplorer/raw/master/images/screen.png
  - title: Code Generation
    entries:
      - title: Run `go:generate` in parallel
        description: Official Go team [encourages](https://github.com/golang/go/issues/20520) to run sequentially. However, in certain situations, such as lots of mocks, parallelization helps a lot, albeit, you should consider including your generated files in git. The solution bellow spawns multiple processes, each per pkg.
        commands:
          - grep -rnw "go:generate" -E -l "${1:-*.go}" . | xargs -L1 dirname | sort -u | xargs -P 8 -I{} go generate {}
      - title: Generate `String` method for enum types
        description: This is an official tool for generating `String` for enums. It supports overrides via comments.
        author: official Go team
        example_content_ext: go
        example_content: |
          package painkiller

          //go:generate stringer -type=Pill -linecomment

          type Pill int

          const (
            Placebo Pill = iota
            Ibuprofen
            Paracetamol
            PillAspirin   // Aspirin
            Acetaminophen = Paracetamol
          )

          // "Acetaminophen"
          var s string = Acetaminophen.String()
        requirements:
          - go install golang.org/x/tools/cmd/stringer@latest
      - title: Generate enums encoding
        name: go-enum-encoding
        description: Generate encoding code for enums. This follows json struct tag notation.
        author: https://github.com/nikolaydubina
        url: https://github.com/nikolaydubina/go-enum-encoding
        commands:
          - go generate ./...
        example_content_ext: go
        example_content: |
          type Color struct{ c uint }

          //go:generate go-enum-encoding -type=Color
          var (
            Undefined = Color{}  // json:"-"
            Red       = Color{1} // json:"red"
            Green     = Color{2} // json:"green"
            Blue      = Color{3} // json:"blue"
          )
        requirements:
          - go install github.com/nikolaydubina/go-enum-encoding@latest
      - title: Generate enums
        name: goenums
        description: Genereate strict and fast enums. Generated code is much more tightly typed than just iota defined enums. You will get JSON decoder and encoder as well. This tool allows to generate extra fields and default values in enum structs.
        author: https://github.com/zarldev
        url: https://github.com/zarldev/goenums
        commands:
          - goenums <file-with-iota.go>
        example_content_ext: go
        requirements:
          - go install github.com/zarldev/goenums@latest 
        example_content: |
          package milkyway

          type planet int // Gravity[float64],RadiusKm[float64],MassKg[float64],OrbitKm[float64],OrbitDays[float64],SurfacePressureBars[float64],Moons[int],Rings[bool]

          //go:generate goenums planets.go
          const (
            unknown planet = iota // invalid
            mercury               // Mercury 0.378,2439.7,3.3e23,57910000,88,0.0000000001,0,false
            venus                 // Venus 0.907,6051.8,4.87e24,108200000,225,92,0,false
            earth                 // Earth 1,6378.1,5.97e24,149600000,365,1,1,false
            mars                  // Mars 0.377,3389.5,6.42e23,227900000,687,0.01,2,false
            jupiter               // Jupiter 2.36,69911,1.90e27,778600000,4333,20,4,true
            saturn                // Saturn 0.916,58232,5.68e26,1433500000,10759,1,7,true
            uranus                // Uranus 0.889,25362,8.68e25,2872500000,30687,1.3,13,true
            neptune               // Neptune 1.12,24622,1.02e26,4495100000,60190,1.5,2,true
          )
      - title: ":confetti_ball: Generate data types from JSON Schema"
        url: https://github.com/omissis/go-jsonschema
        author: https://github.com/omissis
        name: go-jsonschema
        requirements:
          - go get github.com/atombender/go-jsonschema/...
          - go install github.com/atombender/go-jsonschema@latest
        description: JSON Schema is widely used standard for definition of structured data types. This tool will generate Go struct, decoder and validation based on JSON Schema spec.
        commands:
          - go-jsonschema -p main myschema.jsonschema
        example_output: |
          {
                "$id": "https://example.com/arrays.schema.json",
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "description": "A representation of a person, company, organization, or place",
                "type": "object",
                "properties": {
                      "fruits": {
                            "type": "array",
                            "items": {
                                  "type": "string"
                            }
                      },
                      "vegetables": {
                            "type": "array",
                            "items": {
                                  "$ref": "#/$defs/veggie"
                            }
                      }
                },
                "$defs": {
                      "veggie": {
                            "type": "object",
                            "required": [
                                  "veggieName",
                                  "veggieLike"
                            ],
                            "properties": {
                                  "veggieName": {
                                        "type": "string",
                                        "description": "The name of the vegetable."
                                  },
                                  "veggieLike": {
                                        "type": "boolean",
                                        "description": "Do I like this vegetable?"
                                  }
                            }
                      }
                }
          }
        example_content_ext: go
        example_content: |
          // Code generated by github.com/atombender/go-jsonschema, DO NOT EDIT.

          package main

          import "encoding/json"
          import "fmt"

          type Veggie struct {
                  // Do I like this vegetable?
                  VeggieLike bool `json:"veggieLike" yaml:"veggieLike" mapstructure:"veggieLike"`

                  // The name of the vegetable.
                  VeggieName string `json:"veggieName" yaml:"veggieName" mapstructure:"veggieName"`
          }

          // UnmarshalJSON implements json.Unmarshaler.
          func (j *Veggie) UnmarshalJSON(b []byte) error {
                  var raw map[string]interface{}
                  if err := json.Unmarshal(b, &raw); err != nil {
                          return err
                  }
                  if v, ok := raw["veggieLike"]; !ok || v == nil {
                          return fmt.Errorf("field veggieLike in Veggie: required")
                  }
                  if v, ok := raw["veggieName"]; !ok || v == nil {
                          return fmt.Errorf("field veggieName in Veggie: required")
                  }
                  type Plain Veggie
                  var plain Plain
                  if err := json.Unmarshal(b, &plain); err != nil {
                          return err
                  }
                  *j = Veggie(plain)
                  return nil
          }

          // A representation of a person, company, organization, or place
          type A2Schema struct {
                  // Fruits corresponds to the JSON schema field "fruits".
                  Fruits []string `json:"fruits,omitempty" yaml:"fruits,omitempty" mapstructure:"fruits,omitempty"`

                  // Vegetables corresponds to the JSON schema field "vegetables".
                  Vegetables []Veggie `json:"vegetables,omitempty" yaml:"vegetables,omitempty" mapstructure:"vegetables,omitempty"`
          }
      - title: ":confetti_ball: Generate constructor for a struct"
        description: Constructor is a widely used useful pattern. This tool generates basic version of it that passes arguments to struct. It also supports intializer method.
        url: https://github.com/moznion/gonstructor
        name: gonstructor
        author: https://github.com/moznion
        example_content_ext: go
        example_content: |
          //go:generate gonstructor --type=Structure --constructorTypes=allArgs
          type Structure struct {
            foo string
            bar io.Reader
            Buz chan interface{}
          }
        example-output: |
          func NewStructure(foo string, bar io.Reader, buz chan interface{}) *Structure {
            return &Structure{foo: foo, bar: bar, Buz: buz}
          }
        requirements:
          - go install golang.org/x/tools/cmd/goimports@latest
          - go install github.com/moznion/gonstructor/cmd/gonstructor@latest
      - title: Generate Table Driven Tests
        description: This tool generates basic test placeholder. It is included into official Go plugin in VSCode and other major code editors.
        name: gotests
        url: https://github.com/cweill/gotests
        author: https://github.com/cweill
        example_image_url: https://github.com/cweill/GoTests-Sublime/raw/master/gotests.gif
      - title: Generate mocks
        description: This mocking framework integrates well with Go `testing` package.
        author: Go Core team
        name: mockgen
        url: https://github.com/golang/mock
        commands:
          - mockgen . Conn,Driver
        example_content_ext: go
        example_content: |
          # foo.go
          type Foo interface {
            Bar(x int) int
          }

          func SUT(f Foo) {
          // ...
          }
          # foo_test.go
          func TestFoo(t *testing.T) {
            ctrl := gomock.NewController(t)
            defer ctrl.Finish()

            m := NewMockFoo(ctrl)

            // Does not make any assertions. Executes the anonymous functions and returns
            // its result when Bar is invoked with 99.
            m.
              EXPECT().
              Bar(gomock.Eq(99)).
              DoAndReturn(func(_ int) int {
                time.Sleep(1*time.Second)
                return 101
              }).
              AnyTimes()

            // Does not make any assertions. Returns 103 when Bar is invoked with 101.
            m.
              EXPECT().
              Bar(gomock.Eq(101)).
              Return(103).
              AnyTimes()

            SUT(m)
          }
        requirements:
          - go install github.com/golang/mock/mockgen@v1.6.0
      - title: Generate interface for a struct
        description: This is a development helper program that generates a Golang interface by inspecting the structure methods of an existing .go file. The primary use case is to generate interfaces for [gomock](https://github.com/golang/mock), so that [gomock](https://github.com/golang/mock) can generate mocks from those interfaces. This makes unit testing easier.
        url: https://github.com/vburenin/ifacemaker
        name: ifacemaker
        author: https://github.com/vburenin
        commands:
          - 'ifacemaker -f human.go -s Human -i HumanIface -p humantest -y "HumanIface makes human interaction easy" -c "DONT EDIT: Auto generated"'
        example_content_ext: go
        example_content: |
          # human.go
          package main

          import "fmt"

          type Human struct {
            name string
            age  int
          }

          // Returns the name of our Human.
          func (h *Human) GetName() string {
            return h.name
          }

          // Our Human just had a birthday! Increase its age.
          func (h *Human) Birthday() {
            h.age += 1
            fmt.Printf("I am now %d years old!\n", h.age)
          }

          // Make the Human say hello.
          func (h *Human) SayHello() {
            fmt.Printf("Hello, my name is %s, and I am %d years old.\n", h.name, h.age)
          }

          func main() {
            human := &Human{name: "Bob", age: 30}
            human.GetName()
            human.SayHello()
            human.Birthday()
          }

          # human_interface.go
          // DONT EDIT: Auto generated
          package humantest

          // HumanIface makes human interaction easy
          type HumanIface interface {
            // Returns the name of our Human.
            GetName() string
            // Our Human just had a birthday! Increase its age.
            Birthday()
            // Make the Human say hello.
            SayHello()
          }
        requirements:
          - go install github.com/vburenin/ifacemaker@latest
      - title: Generate interface for a struct
        description: This tool generates interface for a struct. Can be invoked in `go:generate`.
        url: https://github.com/rjeczalik/interfaces
        name: interfacer
        author: https://github.com/rjeczalik
        commands:
          - interfacer -for os.File -as mock.File
        example_content_ext: go
        example_content: |
          // Created by interfacer; DO NOT EDIT

          package mock

          import (
                  "os"
          )

          // File is an interface generated for "os".File.
          type File interface {
                  Chdir() error
                  Chmod(os.FileMode) error
                  Chown(int, int) error
                  Close() error
                  Fd() uintptr
                  Name() string
                  Read([]byte) (int, error)
                  ReadAt([]byte, int64) (int, error)
                  Readdir(int) ([]os.FileInfo, error)
                  Readdirnames(int) ([]string, error)
                  Seek(int64, int) (int64, error)
                  Stat() (os.FileInfo, error)
                  Sync() error
                  Truncate(int64) error
                  Write([]byte) (int, error)
                  WriteAt([]byte, int64) (int, error)
                  WriteString(string) (int, error)
          }
        requiremnets:
          - go install github.com/rjeczalik/interfaces/cmd/interfacer@latest
      - title: Generate interface for a struct
        description: This is alternative tool for interface generation that is aimed to be faster and leaner. It generates only pointer method receiver methods for a struct.
        url: https://github.com/reflog/struct2interface
        author: https://github.com/reflog
        name: struct2interface
        commands:
          - struct2interface -f . -i IDecimal -p fpdecimal -s Decimal -o idecimal.go
        requirements:
          - go install github.com/reflog/struct2interface@latest
      - title: Generate interface for `CSV` file
        description: This tool generates struct that can read and write `CSV` file of this struct. Order of fields is hardcoded.
        url: https://github.com/rjeczalik/interfaces
        name: structer
        author: https://github.com/rjeczalik
        commands:
          - structer -f aws-billing.csv -tag json -as billing.Record
        example_content_ext: go
        example_content: |
          # aws-billing.csv
          # "InvoiceID","PayerAccountId","LinkedAccountId","RecordType","RecordID","BillingPeriodStartDate","BillingPeriodEndDate","InvoiceDate"
          # "Estimated","123456","","PayerLineItem","5433212345","2016/01/01 00:00:00","2016/01/31 23:59:59","2016/01/21 19:19:06"          

          # record.go
          // Record is a struct generated from "aws-billing.csv" file.
          type Record struct {
                  InvoiceID              string    `json:"invoiceID"`
                  PayerAccountID         int64     `json:"payerAccountID"`
                  LinkedAccountID        string    `json:"linkedAccountID"`
                  RecordType             string    `json:"recordType"`
                  RecordID               int64     `json:"recordID"`
                  BillingPeriodStartDate time.Time `json:"billingPeriodStartDate"`
                  BillingPeriodEndDate   time.Time `json:"billingPeriodEndDate"`
                  InvoiceDate            time.Time `json:"invoiceDate"`
          }

          // MarshalCSV encodes r as a single CSV record.
          func (r *Record) MarshalCSV() ([]string, error) {
              ...
          }

          // UnmarshalCSV decodes a single CSV record into r.
          func (r *Record) UnmarshalCSV(record []string) error {
              ...
          }
        requiremnets:
          - go install github.com/rjeczalik/interfaces/cmd/structer@latest
      - title: Modify struct field tags
        description: "This tool makes it easy to update, add or delete the tags and options in a struct field. You can add new tags, update existing tags (such as appending a new key, i.e: db, xml, etc..) or remove existing tags. It's intended to be used by an editor, but also has modes to run it from the terminal."
        name: gomodifytags
        author: https://github.com/fatih
        url: https://github.com/fatih/gomodifytags
        example_image_url: https://user-images.githubusercontent.com/438920/32691304-a1c7e47c-c716-11e7-977c-f4d0f8c616be.gif
        requirements:
          - go install github.com/fatih/gomodifytags@latest
  - title: Refactoring
    entries:
      - title: Replace symbol
        description: I found this in announcement [notice](https://github.com/golang/go/commit/2580d0e08d5e9f979b943758d3c49877fb2324cb) of Go 1.18 for changes to `interface{}` to `any`. This can be useful for other refactorings too.
        name: gofmt
        commands:
          - gofmt -w -r 'interface{} -> any' .
      - title: ":confetti_ball: Apply refactoring patches"
        description: With this tool it is very easy to perform refactorings. It is also possible to organize and maintan your refactoring procedures through patches.
        url: https://github.com/uber-go/gopatch
        author: Uber
        name: gopatch
        example_content_ext: go
        example_content: |
          @@
          @@
          -import "errors"

          -errors.New(fmt.Sprintf(...))
          +fmt.Errorf(...)
        example_output: |
          return errors.New(fmt.Sprintf("invalid port: %v", err))
          // becomes
          return fmt.Errorf("invalid port: %v", err)
      - title: Keep consistent ordering of imports
        description: This is official tool for for grouping and sorting imports. However, it has only basic grouping functionality.
        url: https://pkg.go.dev/golang.org/x/tools/cmd/goimports
        name: goimports
        author: Go Core team
        commands:
          - goimports -w -local .
        requirements:
          - go install golang.org/x/tools/cmd/goimports@latest
      - title: Keep consistent ordering of imports
        description: "This tool splits all import blocks into different sections, now support five section types: standard (e.g. 'fmt'); custom; default; blank; dot. It will keep each section sorted and keep ordering of sections consistent."
        name: gci
        author: https://github.com/daixiang0
        url: https://github.com/daixiang0/gci
        commands:
          - gci write -s standard -s default -s "prefix(github.com/daixiang0/gci)" main.go
        example_content_ext: go
        example_content: |
          // before
          package main
          import (
            "golang.org/x/tools"
            
            "fmt"
            
            "github.com/daixiang0/gci"
          )

          // after
          package main
          import (
              "fmt"

              "golang.org/x/tools"

              "github.com/daixiang0/gci"
          )
        requirements:
          - go install github.com/daixiang0/gci@latest
      - title: Keep consistent ordering of imports
        description: This tool groups and sorts imports within groups. It keeps consitent ordering of groups. Detection of groups may be not always accurate.
        name: goimportx
        author: https://github.com/anqiansong
        url: https://github.com/anqiansong/goimportx/tree/main
        commands:
          - goimportx --file /path/to/file.go --group "system,local,third"
        example_content_ext: go
        example_content: |
          package main

          import (
            "flag"
            "io"
            "log"
            "os"

            "github.com/nikolaydubina/mdpage/page"
            "github.com/nikolaydubina/mdpage/render"
            yaml "gopkg.in/yaml.v3"
          )
        requirements:
          - go install github.com/anqiansong/goimportx@latest
      - title: ":confetti_ball: Replace unkeyed struct literals into keyed ones"
        description: You may want to do this as preparation for other refactoring steps. This tool has good emacs integration, otherwise may it be hard to use.
        url: https://github.com/dominikh/go-tools/tree/master/cmd/keyify
        author: https://github.com/dominikh
        name: keyify
        example_content_ext: go
        example_content: |
          # before
          myFunc(T{1, 2, 3})

          # after
          myFunc(T{A: 1, B: 2, C: 3})
        requirements:
          - go install honnef.co/go/tools/cmd/keyify@2022.1
  - title: Errors
    entries:
      - title: ":confetti_ball: Errors with return traces"
        description: Return trace is the path that error took to return to user. This can be more illustrative than typical stack trace that procuded the error. This tool have conenienve automatic instrumentation CLI to update your code.
        url: https://github.com/bracesdev/errtrace
        name: errtrace
        author: https://github.com/bracesdev
        commands:
          - git ls-files -- '*.go' | xargs errtrace -w
        requirements:
          - use packae "braces.dev/errtrace"
          - instrument code by wrapping errors through all functions with this library
      - title: Errors with stack traces and source fragments
        description: This library collects stack traces and pretty prints code fragments. Stack traces induce performance penalty.
        url: https://github.com/ztrue/tracerr
        name: tracerr
        author: https://github.com/ztrue
        example_image_url: https://github.com/ztrue/tracerr/raw/master/output.png
        example_content_ext: go
        example_content: |
          package main

          import (
            "io/ioutil"

            "github.com/ztrue/tracerr"
          )

          func main() {
            if err := read(); err != nil {
              tracerr.PrintSourceColor(err)
            }
          }

          func read() error {
            return readNonExistent()
          }

          func readNonExistent() error {
            _, err := ioutil.ReadFile("/tmp/non_existent_file")
            // Add stack trace to existing error, no matter if it's nil.
            return tracerr.Wrap(err)
          }
      - title: Pretty print `panic` messages
        description: Read `panic` messages easier. Need to redirect STDERR to this tool with `panic` stack traces. The tool has HTML output and does lots of deduplication and enhancements. Refer to examples in original repo.
        name: panicparse
        url: https://github.com/maruel/panicparse
        author: https://github.com/maruel
        commands:
          - go test -v |& pp
        example_image_url: https://raw.githubusercontent.com/wiki/maruel/panicparse/parse.gif
        requirements:
          - go install github.com/maruel/panicparse/v2/cmd/pp@latest
  - title: Building
    entries:
      - title: Show compiler optimization decisions on heap and inlining
        description: Building with `-m` flag will show decisions of compiler on inlining and heap escape. This can help you to validate your understanding of your code and optimize it.
        commands:
          - go build -gcflags="-m -m" . 2>&1 | grep inline
        example_output: |
          ...
          ./passengerfp.go:25:6: cannot inline (*PassengerFeatureTransformer).Fit: function too complex: cost 496 exceeds budget 80
          ...
          ./passengerfp.go:192:6: can inline (*PassengerFeatureTransformer).NumFeatures with cost 35 as: method(*PassengerFeatureTransformer) func() int { if e == nil { return 0 }; count := 6; count += (*transformers.OneHotEncoder).NumFeatures(e.Sex); count += (*transformers.OneHotEncoder).NumFeatures(e.Embarked); return count }
          ...
          ./passengerfp.go:238:43: inlining call to transformers.(*OneHotEncoder).FeatureNames
          ./passengerfp.go:238:43: inlining call to transformers.(*OneHotEncoder).NumFeatures
          ...
          ./passengerfp.go:151:7: parameter e leaks to {heap} with derefs=0:
          ./passengerfp.go:43:11: make(map[string]uint) escapes to heap
      - title: Disable inlining
        description: Usually you may not need it, but can reduce binary size and even improve performance.
        commands:
          - go build -gcflags="-l" .
      - title: Aggressive inlining
        description: Usually you may not need it, but can improve performance. This includes mid-stack inlining.
        commands:
          - go build -gcflags="-l -l -l -l" .
      - title: Profile-guided optimization
        description: Starting go 1.20 compiler supports Profile-gudied optimization. You need to collect profiles and then supply in compulation to compiler. You can get improvement in performance by around 4%. Officual [guideline](https://go.dev/doc/pgo).
        commands:
          - 1. store a `pprof` CPU profile with filename default.pgo in the main package directory of the profiled binary
          - 2. build with `go build -pgo=auto``, which will pick up `default.pgo` files automatically.
      - title: Manually disable or enable `cgo`
        description: Disable `cgo` with `CGO_ENABLED=0` and enable with `CGO_ENABLED=1`. If you don't, `cgo` may end-up being enabled or code dynamically linked if, for example, you use some `net` or `os` packages. You may want to disable `cgo` to improve performance, since complier and runtime would have easier job optimizing code. This also should reduce your image size, as you can have alpine image with less shared libraries.
      - title: Include metadata in binary during compilation with `ldflags`
        description: You can pass metadata through compiler to your binary. This is useful for including things like git commit, database schema version, integrity hashes. Variables can only be strings.
        commands:
          - go build -v -ldflags="-X 'main.Version=v1.0.0'"
          - go build -v -ldflags="-X 'my/pkg/here.Variable=some-string'"
        example_content_ext: go
        example_content: |
          package main

          var Version string

          func main() {
            // Version here has some value
            ...
          }
      - title: Make treemap breakdown of Go executable binary
        description: Useful for studying Go compiler, large projects, projects with C/C++ and `cgo`, 3rd party dependencies, embedding. However, total size may not be something to worry about for your executable.
        name: go-binsize-treemap
        url: https://github.com/nikolaydubina/go-binsize-treemap
        author: https://github.com/nikolaydubina
        commands:
          - go tool nm -size <binary finename> | go-binsize-treemap > binsize.svg
        example_image_url: https://github.com/nikolaydubina/go-binsize-treemap/blob/main/docs/hugo.svg
        requirements:
          - go install github.com/nikolaydubina/go-binsize-treemap@latest
      - title: Custom import path
        description: "Go can automatically fetch from custom http/https servers using `<meta>` tag to discover how to fetch code. There are multiple tools that can help set this up. This can help for security and analytics. This is also known as vanity URLs. [documentation](https://pkg.go.dev/cmd/go#hdr-Remote_import_paths)."
        example_content: |
          # some notable examples
          golang.org/x/exp
          go.uber.org/multierr
          honnef.co/go/tools/cmd/staticcheck
      - title: Custom import path
        name: govanityurls
        description: Simple HTTP server that lets you host custom import paths for your Go packages.
        url: https://github.com/GoogleCloudPlatform/govanityurls
        author: Google
        commands:
          - govanityurls
        requirements:
          - go install github.com/GoogleCloudPlatform/govanityurls@latest
      - title: Custom import path
        name: sally
        description: Simple HTTP server that lets you host custom import paths for your Go packages.
        url: https://github.com/uber-go/sally
        author: Uber
        commands:
          - sally
        requirements:
          - go install go.uber.org/sally@latest
      - title: Custom import path
        name: "kkn.fi/vanity"
        description: Simple HTTP server that lets you host custom import paths for your Go packages.
        url: https://kkn.fi/vanity
        author: https://github.com/kare
        commands:
          - vanity
        requirements:
          - go get kkn.fi/vanity
      - title: Custom import path enforcement
        description: "When import path is using custom domain, it is possible to block code from compilation unless it is used. This can help ensure security and prevent breaking changes. [documentation](https://pkg.go.dev/cmd/go#hdr-Import_path_checking)."
        example_content_ext: go
        example_content: |
          package pdf // import "rsc.io/pdf"
      - title: ":confetti_ball: Manage multiple Go versions"
        description: This tool makes it easier for managing multiple Go versions on same host. This works through intercepting Go commands and directing them to the right Go version bin and directory. Official Go [documentation](https://go.dev/doc/manage-install) on this topic.
        url: https://github.com/Norwik/Goenv
        author: https://github.com/clivern
        name: Goenv
        example_image_url: https://github.com/Norwik/Goenv/raw/main/static/screenshot-1.png
  - title: Assembly
    entries:
      - title: Get assembly of Go code snippets online
        description: Use [godbolt.org](https://godbolt.org) to compile and see assembly of short Go code. You can check different platforms and compilers including `cgo`. This tool is commonly used by C++ community.
        example_image_url: ./img/godbolt.png
        author: https://github.com/mattgodbolt
      - title: Get Go SSA intermediary representation
        description: Check what does Go compiler do. Might be useful if you trying to optimize some code or learn more about compiler. https://golang.design/gossa.
        name: ssaplayground
        url: https://github.com/golang-design/ssaplayground
        example_image_url: https://github.com/golang-design/ssaplayground/blob/main/public/assets/screen.png
        author: https://github.com/changkun
      - title: View Go assembly interactively
        description: Understand how Go is compiled better.
        name: lensm
        url: https://github.com/loov/lensm
        author: https://github.com/egonelbre
        example_image_url: https://github.com/loov/lensm/raw/main/screenshot.gif
        requirements:
          - go install loov.dev/lensm@main
      - title: ":confetti_ball: View Go assembly with color annotation"
        url: https://github.com/maruel/pat
        author: https://github.com/maruel
        name: pat/disfunc
        requirements:
          - go install github.com/maruel/pat/cmd/...@latest
        description: This tool shows assmebly of functions and what lines mean by color.
        example_image_url: https://github.com/maruel/pat/wiki/disfunc.png
        commands:
          - disfunc -f 'nin\.CanonicalizePath$' -pkg ./cmd/nin | less -R
      - title: Generate Go assembly in Go
        description: Write better quality Go assembly quicker in Go language itself. This tool conveniently generates stub for Go code to call your generated assembly. Used by Go core.
        name: avo
        url: https://github.com/mmcloughlin/avo
        author: https://github.com/mmcloughlin
        example_content_ext: go
        example_content: |
          //go:build ignore
          // +build ignore

          package main

          import . "github.com/mmcloughlin/avo/build"

          func main() {
            TEXT("Add", NOSPLIT, "func(x, y uint64) uint64")
            Doc("Add adds x and y.")
            x := Load(Param("x"), GP64())
            y := Load(Param("y"), GP64())
            ADDQ(x, y)
            Store(y, ReturnIndex(0))
            RET()
            Generate()
          }
      - title: Generate AST for code snippets
        description: Access Go core AST mechanism to generate AST.
        name: go/ast
        example_content_ext: go
        example_content: |
          package main

          import (
            "go/ast"
            "go/parser"
            "go/token"
          )

          func main() {
            fs := token.NewFileSet()
            tr, _ := parser.ParseExpr("(3-1) * 5")
            ast.Print(fs, tr)
          }
        example_output: |
          0  *ast.BinaryExpr {
          1  .  X: *ast.ParenExpr {
          2  .  .  Lparen: -
          3  .  .  X: *ast.BinaryExpr {
          4  .  .  .  X: *ast.BasicLit {
          5  .  .  .  .  ValuePos: -
          6  .  .  .  .  Kind: INT
          7  .  .  .  .  Value: "3"
          8  .  .  .  }
          9  .  .  .  OpPos: -
          10  .  .  .  Op: -
          11  .  .  .  Y: *ast.BasicLit {
          12  .  .  .  .  ValuePos: -
          13  .  .  .  .  Kind: INT
          14  .  .  .  .  Value: "1"
          15  .  .  .  }
          16  .  .  }
          17  .  .  Rparen: -
          18  .  }
          19  .  OpPos: -
          20  .  Op: *
          21  .  Y: *ast.BasicLit {
          22  .  .  ValuePos: -
          23  .  .  Kind: INT
          24  .  .  Value: "5"
          25  .  }
          26  }
      - title: Generate AST for code snippets
        description: This is a wrapper around `go/ast` machinery that makes generating `AST` easier.
        url: https://github.com/reflog/go2ast
        author: https://github.com/reflog
        name: go2ast
        commands:
          - echo "a := 1" | go2ast
        example_output: |
          []ast.Stmt {
            &ast.AssignStmt {
              Lhs: []ast.Expr {
                &ast.Ident {
                  Name: "a",
                },
              },
              Tok: :=,
              Rhs: []ast.Expr {
                &ast.BasicLit {
                  ValuePos: 32,
                  Kind: INT,
                  Value: "1",
                },
              },
            },
          }
        requirements:
          - go install github.com/reflog/go2ast@latest
      - title: Visualize Go SSA function using Graphviz
        description: "This tool provides a visual overview of Go SSA function using Graphviz. This is especially useful in SSA-based static analysis. This tool generates an HTML page that is easy to navigate. [demo](https://silverrainz.me/go-ssaviz/)."
        name: go-ssaviz
        author: https://github.com/SilverRainZ
        url: https://github.com/SilverRainZ/go-ssaviz
        commands:
          - go-ssaviz ./...
        example_image_url: ./img/go-ssaviz.png
        requirements:
          - "# get graphviz"
          - go install github.com/SilverRainZ/go-ssaviz@latest
      - title: ":derelict_house: Make graph of AST"
        description: This tool visualizes AST as graph, which may be useful to navigate and undertand Go AST. This tool has not been maintaned for a while.
        name: astgraph
        author: https://github.com/xiazemin
        url: https://github.com/xiazemin/ast_graph
        example_image_url: https://github.com/xiazemin/ast_graph/raw/master/tree.svg
        requirements:
          - graphviz
      - title: ":derelict_house: Convert C assembly to Go assembly"
        url: https://github.com/minio/c2goasm
        author: https://github.com/fwessels
        name: c2goasm
        description: This tool can convert C assembly `.s` into Go assbmely `.s` files. This is useful for reusing compiler optimizations such as SIMD or loop unrolling in C, which can lead to 10x speedups. However, project has been archieved 4+ years ago.
        requirements:
          - go install github.com/minio/c2goasm@latest
        commands:
          - gcc -O3 -march=native -S -o c_code.s c_code.c
          - c2goasm -a c_code.s go_c_code.s
          - go build -o go_c_code.o -gcflags="-S" go_c_code.s
  - title: Execution
    entries:
      - title: Embed Go Playground to your blog
        description: "Embed interactive Go Playground component into your blog. [Hugo](https://gohugo.io), [Docusaurus](https://docusaurus.io), [Ghost](https://ghost.org) are supported. There is also another tool [soksan](https://github.com/bbalet/soksan), however it is discontinued. Live [demo](https://ggicci.me/goplay-embed-go-playground-on-your-website/) with guideline. Other resources — GitLab considering to add it in [issue](https://gitlab.com/gitlab-org/gitlab/-/issues/212769); alternative implementation [guideline](https://hrishikeshpathak.com/blog/golang-code-playground/)."
        name: goplay
        url: https://github.com/ggicci/goplay
        author: https://github.com/ggicci
        example_content: |
          ## Sample Code

          {{% goplay %}}
          '''go
          package main

          func main() {
            println("hello world")
          }
          '''
          {{% /goplay %}}
        requirements:
          - reverse proxy server to https://play.golang.org
          - bloging playform with support for embedding javascript
      - title: Run alternative Go Playground
        description: Improved Go Playground featuring dark theme, code autocomplete, vim mode, WebAssembly. Available at [https://goplay.tools/](https://goplay.tools/).
        name: goplay.tools
        url: https://github.com/x1unix/go-playground
        author: https://github.com/x1unix
        example_image_url: https://github.com/x1unix/go-playground/raw/master/docs/demo.gif
      - title: Run interactive Go kernels in Jupyter Notebook
        description: Run interactive Go interpreter in Jupyter Notebook browser. As of `2023-06-04`, it is using `gomacro` interpreter and can have issues with loading 3rd party pacakges.
        url: https://github.com/gopherdata/gophernotes
        name: gophernotes
        author: https://github.com/gopherdata
        example_image_url: https://github.com/gopherdata/gophernotes/raw/master/files/jupyter.gif
        requirements:
          - "# jupyter notebook"
          - go install github.com/gopherdata/gophernotes@v0.7.5
          - "# more instructions on how to install Jupyter Notebook Go kernel in original repo"
      - title: Run interactive Go interpreter
        description: This interpreter works with 3rd party pacakges located in `$GOPATH/src`. It can also be triggered within Go programmatically via `Eval()`. Works everywhere Go works.
        url: https://github.com/traefik/yaegi
        name: yaegi
        author: https://github.com/traefik
        commands:
          - yaegi
        example_output: |
          $ yaegi
          > import "github.com/nikolaydubina/fpdecimal"
          : 0x140000faaf0
          > a, _ := fpdecimal.FromString("10.12") 
          : {0}
          > b, _ := fpdecimal.FromString("5.38")
          : {0}
          > c := a.Add(b)   
          : {15500}
          > c.String()
          : 15.500
          >
        requirements:
          - go install github.com/traefik/yaegi@latest
      - title: Run interactive Go interpreter
        description: "This is interactive Go interpreter and debugger with REPL, Eval, generics and Lisp-like macros. You can run functions, import 3rd patry packages. Can be useful for learning and experimentation. Some nice features: autocomplete; constant expressions arithmetics. As of `2023-06-02`, issues with importing 3rd paty package are possible."
        url: https://github.com/cosmos72/gomacro
        name: gomacro
        author: https://github.com/cosmos72
        commands:
          - gomacro
        example_output: |
          $ gomacro
          gomacro> import "fmt"
          gomacro> fmt.Println("hello, world!")
          hello, world!
          14      // int
          <nil>   // error
          gomacro>
        requirements:
          - go install github.com/cosmos72/gomacro@latest
      - title: Run Go function in shell
        description: Run Go one-liners. This tool will print to STDOUT the return of a function call.
        name: gorram
        url: https://github.com/natefinch/gorram
        author: https://github.com/natefinch
        requirements:
          - go install github.com/natefinch/gorram@latest
        commands:
          - cat README.md | gorram crypto/sha1 Sum
          - echo 12345 | gorram encoding/base64 StdEncoding.EncodeToString
          - gorram net/http Get https://google.com
      - title: Run Go function in shell
        description: Run Go functions in shell. You can also pass parameters directly from shell.
        name: gosh
        url: https://github.com/nickwells/utilities/blob/master/gosh/_gosh.DOC.md
        author: https://github.com/nickwells
        requirements:
          - go install github.com/nickwells/utilities/gosh@latest
        commands:
          - gosh -pln '"Hello, World!"'
          - gosh -pln 'math.Pi'
          - gosh -n -b 'count := 0' -e 'count++' -a-pln 'count'
          - 'gosh -http-handler ''http.FileServer(http.Dir("/tmp/xxx"))'''
          - "gosh -n -b-p '\"Radius: \"' -e 'r, err := strconv.ParseFloat(_l.Text(), 64)' -e-s iferr -pf '\"Area: %9.2f\n\", r*r*math.Pi' -p '\"Radius:\"'"
      - title: Run simple fileserver
        name: net/http
        description: It takes one line to run HTTP file server in Go. Akin to famous oneliner in Python `python3 -m http.server` and `python -m SimpleHTTPServer`. Run this file as usually `go run <filename>`.
        example_image_url: ./img/simple-fs.png
        example_content_ext: go
        example_content: |
          package main

          import "net/http"

          func main() { http.ListenAndServe(":9000", http.FileServer(http.Dir("."))) }
      - title: Create 3D visualization of concurrency traces
        description: Fresh artistic perspective on coroutines execution. There is no advanced functions and it is hard to analyze production systems. However, it could be interesting for educational purposes.
        name: gotrace
        url: https://github.com/divan/gotrace
        author: https://github.com/divan
        example_image_url: https://github.com/divan/gotrace/blob/master/images/demo.png
        requirements:
          - go install github.com/divan/gotrace@latest
          - patch Go compiler, available via Docker
          - more instructions in original repo
      - title: Wrap command
        name: os/exec
        description: Orignally posted in [blog](https://www.dolthub.com/blog/2022-11-28-go-os-exec-patterns/).
        example_content_ext: go
        example_content: |
          cmd := exec.Command("ls", "/usr/local/bin")
          cmd.Stdout = os.Stdout
          cmd.Stderr = os.Stderr
          return cmd.Run()
      - title: Capture output of command to file
        description: Orignally posted in [blog](https://www.dolthub.com/blog/2022-11-28-go-os-exec-patterns/).
        author: Aaron Son
        name: os/exec
        example_content_ext: go
        example_content: |
          log, err := os.Create("output.log")
          if err != nil {
            return err
          }
          defer log.Close()
          cmd := exec.Command("ls", "/usr/local/bin")
          cmd.Stdout = log
          cmd.Stderr = log
          return cmd.Run()
      - title: Capture output of command and process it
        description: Orignally posted in [blog](https://www.dolthub.com/blog/2022-11-28-go-os-exec-patterns/).
        author: Aaron Son
        name: os/exec
        example_content_ext: go
        example_content: |
          cmd := exec.Command("ls", "/usr/local/bin")
          stdout, err := cmd.StdoutPipe()
          if err != nil {
            return err
          }
          scanner := bufio.NewScanner(stdout)
          err = cmd.Start()
          if err != nil {
            return err
          }
          for scanner.Scan() {
            // Do something with the line here.
            ProcessLine(scanner.Text())
          }
          if scanner.Err() != nil {
            cmd.Process.Kill()
            cmd.Wait()
            return scanner.Err()
          }
          return cmd.Wait()
      - title: Piping between processes
        description: "`ls /usr/local/bin | grep pip`. Orignally posted in [blog](https://www.dolthub.com/blog/2022-11-28-go-os-exec-patterns/)."
        author: Aaron Son
        name: os/exec
        example_content_ext: go
        example_content: |
          r, w, err := os.Pipe()
          if err != nil {
            return err
          }
          defer r.Close()

          ls := exec.Command("ls", "/usr/local/bin")
          ls.Stdout = w
          err = ls.Start()
          if err != nil {
            return err
          }
          defer ls.Wait()
          w.Close()

          grep := exec.Command("grep", "pip")
          grep.Stdin = r
          grep.Stdout = os.Stdout
          return grep.Run()
      - title: "`errgroup` and CommandContext"
        description: Orignally posted in [blog](https://www.dolthub.com/blog/2022-11-28-go-os-exec-patterns/).
        author: Aaron Son
        name: os/exec
        example_content_ext: go
        example_content: |
          eg, ctx := errgroup.WithContext(context.Background())
          sleeps := make([]*exec.Cmd, 3)
          sleeps[0] = exec.CommandContext(ctx, "sleep", "100")
          sleeps[1] = exec.CommandContext(ctx, "sleep", "100")
          sleeps[2] = exec.CommandContext(ctx, "sleep", "notanumber")
          for _, s := range sleeps {
            s := s
            eg.Do(func() error {
              return s.Run()
            })
          }
          return eg.Wait()
  - title: Monitoring
    entries:
      - title: Monitor goroutines
        description: Command line monitoring for goroutines.
        url: https://github.com/bcicen/grmon
        author: https://github.com/bcicen
        name: grmon
        example_image_url: https://camo.githubusercontent.com/ff8303d0b302fcfaf670846eb4168ac3e70522a8d739491d5509abc6ffb236b8/68747470733a2f2f627261646c65792e636f6465732f7374617469632f696d672f67726d6f6e2e676966
        commands:
          - grmon
        requirements:
          - "# start pprof server or grmon in your Go process"
          - go install github.com/bcicen/grmon@latest
      - title: Monitor Go processes
        description: Monitoring memory of Go processes, forcing GC, getting version of Go of processes.
        name: gops
        url: https://github.com/google/gops
        author: Google
        requirements:
          - go install github.com/google/gops@latest
        commands:
          - gops
        example_output: |
          983   980    uplink-soecks  go1.9   /usr/local/bin/uplink-soecks
          52697 52695  gops           go1.10  /Users/jbd/bin/gops
          4132  4130   foops        * go1.9   /Users/jbd/bin/foops
          51130 51128  gocode         go1.9.2 /Users/jbd/bin/gocode
      - title: Visualise Go runtime metrics in browser
        description: This tool exposes HTTP endpoint with charts for Go runtime such as heap, objects, goroutines, GC pauses, scheduler. This is useful drop-in solution for visualization of Go runtime.
        url: https://github.com/arl/statsviz
        author: https://github.com/arl
        name: statsviz
        example_image_url: https://raw.githubusercontent.com/arl/statsviz/readme-docs/window.png
        requirements:
          - go get github.com/arl/statsviz@latest
      - title: Auto-Instrument all functions
        description: Automatically instrument all functions with Open Telemetry Spans by code generation. Inserts errors into Spans.
        name: go-instrument
        url: https://github.com/nikolaydubina/go-instrument
        author: https://github.com/nikolaydubina
        example_image_url: https://github.com/nikolaydubina/go-instrument/raw/master/docs/fib-error.png?raw=true
        commands:
          - find . -name "*.go" | xargs -I{} go-instrument -app my-service -w -filename {}
        requirements:
          - go install github.com/nikolaydubina/go-instrument@latest
      - title: Auto-Instrument all functions
        description: Automatically instrument all functions with Open Telemetry Spans by code generation. Inserts errors into Spans. Supports custom templates and can be used for Open Tracing or any custom insertions.
        name: otelinji
        url: https://github.com/hedhyw/otelinji
        author: https://github.com/hedhyw
        example_image_url: https://github.com/hedhyw/otelinji/blob/main/assets/diff.png?raw=true
        commands:
          - otelinji -w -filename input_file.go
          - otelinji -filename input_file.go > input_file.go
          - find . -name "*.go" | grep -v "vendor/\|.git/\|_test.go" | xargs -n 1 -t otelinji -w -filename
        requirements:
          - go install github.com/hedhyw/otelinji/cmd/otelinji@latest
      - title: ":confetti_ball: Auto-Instrument functions for DataDog"
        description: This is official Datadog tool for automatic instrumentation of code. It has very convenient compiler directives for instrumentation.
        author: https://github.com/DataDog
        name: orchestrion
        url: https://github.com/DataDog/orchestrion
        requirements:
          - go install github.com/datadog/orchestrion@latest
        commands:
          - orchestrion -w ./
        example_content_ext: go
        example_content: |
          //dd:span my:tag
          func GetSomeData(ctx context.Context) ([]byte, error) {
            ...
      - title: Continious Profiling
        name: Pyroscope
        description: This tool allows to injest profiling data from your application. You would need to add integration in your main file that will sample in-process data and send it to Pyroscope. Here are useful resources [blog-go-memory-leaks](https://grafana.com/blog/2023/04/19/how-to-troubleshoot-memory-leaks-in-go-with-grafana-pyroscope/).
        url: https://github.com/grafana/pyroscope
        author: Grafana Labs
        example_image_url: https://user-images.githubusercontent.com/23323466/143324845-16ff72df-231e-412d-bd0a-38ef2e09cba8.gif
  - title: Benchmarking
    entries:
      - title: Run benchmarks
        description: Start here. This is the standard tool for benchmarking. It can also do advanced features like mutex profiles. More flags are in Go [documentation](https://pkg.go.dev/cmd/go#hdr-Testing_flags) and `go help testflag`.
        commands:
          - go test -bench=. -benchmem -benchtime=10s ./...
        example_output: |
          goos: darwin
          goarch: arm64
          pkg: github.com/nikolaydubina/fpmoney
          BenchmarkArithmetic/add_x1-10                     1000000000             0.5 ns/op           0 B/op           0 allocs/op
          BenchmarkArithmetic/add_x100-10                     18430124            64.6 ns/op           0 B/op           0 allocs/op
          BenchmarkJSONUnmarshal/small-10                      3531835           340.7 ns/op         198 B/op           3 allocs/op
          BenchmarkJSONUnmarshal/large-10                      2791712           426.9 ns/op         216 B/op           3 allocs/op
          BenchmarkJSONMarshal/small-10                        4379685           274.4 ns/op         144 B/op           4 allocs/op
          BenchmarkJSONMarshal/large-10                        3321205           345.8 ns/op         192 B/op           5 allocs/op
          PASS
          ok      github.com/nikolaydubina/fpmoney    62.744s
      - title: Table-driven benchmarks
        description: Similar to tests, Go supports table-driven benchmarks, which is very helpful for fine gradation of meta-parameters. More details in the Go [blog](https://go.dev/blog/subtests).
        example_content: |
          func benchIteratorSelector(b *testing.B, n int) {
            // ... setup here
            b.ResetTimer()
            for n := 0; n < b.N; n++ {
              err := myExpensiveFunc()
              if err != nil {
                b.Error(err)
              }
            }
          }

          func BenchmarkIteratorSelector(b *testing.B) {
            for _, q := range []int{100, 1000, 10000, 100000} {
              b.Run(fmt.Sprintf("n=%d", q), func(b *testing.B) {
                benchIteratorSelector(b, q)
              })
            }
          }
        example_output: |
          BenchmarkIteratorSelector/n=100-10    	  297792	      4265 ns/op	    5400 B/op	      13 allocs/op
          BenchmarkIteratorSelector/n=1000-10   	   31400	     38182 ns/op	    9752 B/op	      16 allocs/op
          BenchmarkIteratorSelector/n=10000-10  	    3134	    380777 ns/op	   89112 B/op	      24 allocs/op
          BenchmarkIteratorSelector/n=100000-10 	     310	   3827292 ns/op	  912410 B/op	      32 allocs/op
      - title: Generate benchmak CPU and Memory profiles
        description: This is useful for identifying most time or memory consuming parts. Recommended to run for single benchmark at a time and with `-count` or `-benchtime` for better accuracy.
        name: go test
        commands:
          - go test -bench=<my-benchmark-name> -cpuprofile cpu.out -memprofile mem.out ./...
      - title: Visualize callgraph of profiles
        description: Once you generate profiles, visualize them with `pprof`. Both memory and CPU profiles are supported. Many options are available. Refer to the link you get in SVG to how to interpret this graph. More official documentation [blog](https://go.dev/blog/pprof), [pkg-doc](https://pkg.go.dev/net/http/pprof).
        name: pprof
        author: official Go team
        commands:
          - go tool pprof -svg cpu.out > cpu.svg
          - go tool pprof -svg mem.out > mem.svg
        example_image_url: img/pprof_callgraph_cpu.png
      - title: Visualize flamegraphs of profiles
        description: Latest versions of `pprof` can also render [Flamegraphs](https://www.brendangregg.com/flamegraphs.html) for profiles. Make sure you set `-http` to start webserver. Then it is available in "View > Graph" in at http://0.0.0.0:80.
        name: pprof
        author: Google
        commands:
          - pprof -http=0.0.0.0:80 cpu.out
        example_image_url: img/pprof_flamegraph_cpu.png
        requirements:
          - go install github.com/google/pprof@latest
      - title: Visualize profiles online
        description: You can also visualize profiles with online tools are aloso available https://www.speedscope.app (cpu).
        example_image_url: img/speedscope_cpu_profile.png
      - title: Get delta between two benchmarks
        description: This is standard way to compare two benchmark outputs. Names of benchmarks should be the same. Generate benchmarks as per usual. You would get multiple tables per dimension. If no output, then pass `-split="XYZ"`. If you do not see `delta`, then pass `-count=2` or more in benchmark generation. It is recommended to have alternative implementations in different packages, to keep benchmark names the same.
        name: benchstat
        url: https://golang.org/x/perf/cmd/benchstat
        author: official Go team
        commands:
          - benchstat -split="XYZ" old.txt new.txt
        example_output: |
          name                    old time/op    new time/op    delta
          JSONUnmarshal/small-10     502ns ± 0%     331ns ± 0%   -33.99%  (p=0.008 n=5+5)
          JSONUnmarshal/large-10     572ns ± 0%     414ns ± 0%   -27.64%  (p=0.008 n=5+5)
          JSONMarshal/small-10       189ns ± 0%     273ns ± 0%   +44.20%  (p=0.008 n=5+5)
          JSONMarshal/large-10       176ns ± 0%     340ns ± 0%   +93.29%  (p=0.008 n=5+5)

          name                    old alloc/op   new alloc/op   delta
          JSONUnmarshal/small-10      271B ± 0%      198B ± 0%   -26.94%  (p=0.008 n=5+5)
          JSONUnmarshal/large-10      312B ± 0%      216B ± 0%   -30.77%  (p=0.008 n=5+5)
          JSONMarshal/small-10       66.0B ± 0%    144.0B ± 0%  +118.18%  (p=0.008 n=5+5)
          JSONMarshal/large-10       72.0B ± 0%    192.0B ± 0%  +166.67%  (p=0.008 n=5+5)

          name                    old allocs/op  new allocs/op  delta
          JSONUnmarshal/small-10      6.00 ± 0%      3.00 ± 0%   -50.00%  (p=0.008 n=5+5)
          JSONUnmarshal/large-10      7.00 ± 0%      3.00 ± 0%   -57.14%  (p=0.008 n=5+5)
          JSONMarshal/small-10        2.00 ± 0%      4.00 ± 0%  +100.00%  (p=0.008 n=5+5)
          JSONMarshal/large-10        2.00 ± 0%      5.00 ± 0%  +150.00%  (p=0.008 n=5+5)
        requirements:
          - go install golang.org/x/perf/cmd/benchstat@latest
      - title: Get summary of benchmarks
        description: Compare multiple benchmarks. Names of benchmarks should be the same. Generate benchmarks as per usual. You would get multiple tables per dimension. If no output, then pass `-split="XYZ"`. It is recommended to have alternative implementations in different packages, to keep benchmark names the same.
        name: benchstat
        url: https://golang.org/x/perf/cmd/benchstat
        author: official Go team
        commands:
          - benchstat -split="XYZ" int.txt float32.txt fpmoney.txt
        example_output: |
          name \ time/op          int.bench   float32.bench  fpmoney.bench
          JSONUnmarshal/small-10  481ns ± 2%     502ns ± 0%     331ns ± 0%
          JSONUnmarshal/large-10  530ns ± 1%     572ns ± 0%     414ns ± 0%
          JSONMarshal/small-10    140ns ± 1%     189ns ± 0%     273ns ± 0%
          JSONMarshal/large-10    145ns ± 0%     176ns ± 0%     340ns ± 0%

          name \ alloc/op         int.bench   float32.bench  fpmoney.bench
          JSONUnmarshal/small-10   269B ± 0%      271B ± 0%      198B ± 0%
          JSONUnmarshal/large-10   288B ± 0%      312B ± 0%      216B ± 0%
          JSONMarshal/small-10    57.0B ± 0%     66.0B ± 0%    144.0B ± 0%
          JSONMarshal/large-10    72.0B ± 0%     72.0B ± 0%    192.0B ± 0%

          name \ allocs/op        int.bench   float32.bench  fpmoney.bench
          JSONUnmarshal/small-10   6.00 ± 0%      6.00 ± 0%      3.00 ± 0%
          JSONUnmarshal/large-10   7.00 ± 0%      7.00 ± 0%      3.00 ± 0%
          JSONMarshal/small-10     2.00 ± 0%      2.00 ± 0%      4.00 ± 0%
          JSONMarshal/large-10     2.00 ± 0%      2.00 ± 0%      5.00 ± 0%
        requirements:
          - go install golang.org/x/perf/cmd/benchstat@latest
      - title: ":confetti_ball: Benchmark against git commit"
        url: https://github.com/maruel/pat
        author: https://github.com/maruel
        name: pat/ba
        requirements:
          - go install github.com/maruel/pat/cmd/...@latest
        description: This tool runs benchmarks and shows delta between git commits. It can also be useful in GitHub Actions.
        example_output: |
          $ ba -against HEAD~1
          warming up
          go test -bench . -benchtime 100ms -count 1 -run ^$ -cpu 1 ./...
          git checkout HEAD~1
          go test -bench . -benchtime 100ms -count 1 -run ^$ -cpu 1 ./...
          git checkout 02152d698f7d548c
          02152d698f7d548c...HEAD~1 (1 commits), 100ms x 2 times/batch, batch repeated 3 times.
          go test -bench . -benchtime 100ms -count 2 -run ^$ -cpu 1 ./...
          git checkout HEAD~1
          go test -bench . -benchtime 100ms -count 2 -run ^$ -cpu 1 ./...
          git checkout 02152d698f7d548c
          go test -bench . -benchtime 100ms -count 2 -run ^$ -cpu 1 ./...
          git checkout HEAD~1
          go test -bench . -benchtime 100ms -count 2 -run ^$ -cpu 1 ./...
          git checkout 02152d698f7d548c
          go test -bench . -benchtime 100ms -count 2 -run ^$ -cpu 1 ./...
          git checkout HEAD~1
          go test -bench . -benchtime 100ms -count 2 -run ^$ -cpu 1 ./...
          git checkout 02152d698f7d548c
          name                  old time/op    new time/op    delta
          HashCommand             69.0ns ± 2%    67.7ns ± 2%  -1.91%  (p=0.041 n=6+6)
          CLParser                 281µs ± 1%     281µs ± 1%    ~     (p=0.699 n=6+6)
          LoadManifest             437ms ± 7%     430ms ± 3%    ~     (p=0.937 n=6+6)
          CanonicalizePathBits    85.9ns ± 1%    86.2ns ± 0%    ~     (p=1.000 n=6+6)
          CanonicalizePath        83.9ns ± 1%    84.6ns ± 0%    ~     (p=0.058 n=6+6)

          name                  old alloc/op   new alloc/op   delta
          HashCommand              0.00B          0.00B         ~     (all equal)
          CLParser                 164kB ± 0%     164kB ± 0%    ~     (all equal)
          LoadManifest             298MB ± 0%     295MB ± 0%  -0.78%  (p=0.002 n=6+6)
          CanonicalizePathBits     80.0B ± 0%     80.0B ± 0%    ~     (all equal)
          CanonicalizePath         80.0B ± 0%     80.0B ± 0%    ~     (all equal)

          name                  old allocs/op  new allocs/op  delta
          HashCommand               0.00           0.00         ~     (all equal)
          CLParser                 1.64k ± 0%     1.64k ± 0%    ~     (all equal)
          LoadManifest             2.61M ± 0%     2.57M ± 0%  -1.71%  (p=0.002 n=6+6)
          CanonicalizePathBits      1.00 ± 0%      1.00 ± 0%    ~     (all equal)
          CanonicalizePath          1.00 ± 0%      1.00 ± 0%    ~     (all equal)
      - title: Continuous benchmarking
        description: Track how benchmarks change in codebase over time. This is accomplished by running benchmarks for git commits, storing results, and visualizing difference. Running benchmarks can be in GitHub Actions or locally, storage can be in same repository `master` or dedicated branch, or standalone servers. It should be straightforward to setup this manually. Example of GitHub Action [spec](https://github.com/swaggest/rest/blob/master/.github/workflows/bench.yml) and [blog](https://dev.to/vearutop/continuous-benchmarking-with-go-and-github-actions-41ok) from [@vearutop](https://github.com/vearutop), and an example on how it produces a PR [comment](https://github.com/swaggest/rest/pull/88#issuecomment-1271540878).
        example_image_url: img/cont-bench-vearutop.png
      - title: Continuous benchmarking
        description: This tool uses `go test -bench` data in GitHub. It runs benchmarks, and uploads it as GitHub Pages for visualization. It is available as GitHub Action [gobenchdata](https://github.com/marketplace/actions/continuous-benchmarking-for-go). This is useful to see benchmark trends.
        example_image_url: https://github.com/bobheadxi/gobenchdata/raw/main/.static/demo-chart.png
        name: gobenchdata
        url: https://github.com/bobheadxi/gobenchdata
        author: https://github.com/bobheadxi
        requirements:
          - go install go.bobheadxi.dev/gobenchdata@latest
      - title: Continuous benchmarking
        description: Automates comparing benchmarks with `benchstat` of two git references. It is available as GitHub Action [benchdiff](https://github.com/marketplace/actions/benchdiff) which runs `benchstat` of HEAD vs base branch. This is useful to see how benchmarks change with PRs in CI.
        name: benchdiff
        url: https://github.com/willabides/benchdiff
        author: https://github.com/WillAbides
        example_image_url: img/cont-bench-willabides.png
        requirements:
          - go install github.com/willabides/benchdiff/cmd/benchdiff
      - title: Continuous benchmarking
        description: Automate comparing benchmarks with `benchstat` between `HEAD` and `HEAD^1`. It can be used to block CI pipelines if benchmarks deteriorate. It reports output as text in CLI. This cane be useful in CI or in local development.
        name: cob
        url: https://https://github.com/knqyf263/cob
        example_image_url: https://github.com/knqyf263/cob/raw/master/img/usage.png
        author: https://github.com/knqyf263
        requirements:
          - go install github.com/knqyf263/cob@latest
      - title: Generate live traces
        description: This will add endpoints to your your server. If you don't have server running already in your process, you can start one. Then you can point `pprof` tool to this data. For production, hide this endpoint in separate port and path. More details in documentation [trace](https://pkg.go.dev/cmd/trace), [net/http/pprof](https://pkg.go.dev/net/http/pprof).
        name: net/http/trace
        example_content: |
          package main

          import (
            "log"
            "net/http"
            "net/http/pprof"
          )

          func main() {
            mux := http.NewServeMux()
            mux.HandleFunc("/custom_debug_path/profile", pprof.Profile)
            log.Fatal(http.ListenAndServe(":7777", mux))
          }
        example_output: |
          go tool pprof http://localhost:6060/debug/pprof/heap
          go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30
          curl -o trace.out http://localhost:6060/debug/pprof/trace?seconds=5
      - title: Generate traces
        description: Produce a trace of execution of tests in pacakge.
        name: "go test"
        commands:
          - go test -trace trace.out .
      - title: View traces
        description: You can view traces interactively in browser with standard Go tooling. This web tool also shows network blocking profile, synchronization blocking profile, syscall blocking profile, scheduler latency profile.
        name: "go tool trace"
        commands:
          - go tool trace trace.out
        example_image_url: img/go_tool_trace_web.png
      - title: Get wallclock traces
        description: This tool can be more illustrative of Go traces than standard Go traces.
        name: fgtrace
        url: https://github.com/felixge/fgtrace
        author: https://github.com/felixge
        example_content_ext: go
        example_content: |
          package main

          import (
            "net/http"

            "github.com/felixge/fgtrace"
          )

          func main() {
            http.DefaultServeMux.Handle("/debug/fgtrace", fgtrace.Config{})
            http.ListenAndServe(":1234", nil)
          }
        example_image_url: https://github.com/felixge/fgtrace/raw/main/assets/fgtrace-example.png
      - title: Get on/off CPU profiles
        description: This tool can be more illustrative of Go profiles than standard Go profiling.
        author: https://github.com/felixge
        name: fgprof
        url: https://github.com/felixge/fgprof
        example_content_ext: go
        example_content: |
          package main

          import (
            "log"
            "net/http"
            _ "net/http/pprof"

            "github.com/felixge/fgprof"
          )

          func main() {
            http.DefaultServeMux.Handle("/debug/fgprof", fgprof.Handler())
            go func() {
              log.Println(http.ListenAndServe(":6060", nil))
            }()

            // <code to profile>
          }
        example_image_url: https://github.com/felixge/fgprof/raw/master/assets/fgprof_pprof.png
      - title: Collect and visualize in-process traces
        description: This experimental approach illustrates collection of traces, intsrumentation, and visualization. It does not handle distributed traces. Likely useful for special cases or educational or research purposes.
        url: https://github.com/peterbourgon/trc
        name: trc
        author: https://github.com/peterbourgon
        example_image_url: https://github.com/peterbourgon/trc/raw/main/ui.png
        requirements:
          - instrument your code with `trc` package
          - start UI server at port within same process
  - title: Documentation
    entries:
      - title: Make alternative documentation
        description: It has additional information like implementations of interface; promoted methods. The tool has nice minimalistic aesthetics.
        name: golds
        url: https://github.com/go101/golds
        author: "[Tapir Liu](https://www.tapirgames.com)"
        commands:
          - golds ./...
        example_image_url: img/golds.png
        requirements:
          - go install go101.org/golds@latest
      - title: Read Go binary documentation in `man` format
        description: This tool fetches the repo's readme as a man page replacement.
        name: goman
        url: https://github.com/appliedgocode/goman
        example_image_url: https://github.com/appliedgocode/goman/raw/master/goman.gif
        commands:
          - goman <mypackage>
        author: https://github.com/christophberger
        requirements:
          - go install github.com/appliedgocode/goman@latest
      - title: Generate badge
        description: This tool will generate instructions for [shields.io](https://shields.io) to generate badge. It can read `coverprofile`. There is also GitHub Action that utilizes it and stores badge in the same repo, [coverage-badge-go](https://github.com/tj-actions/coverage-badge-go).
        url: https://github.com/AlexBeauchemin/gobadge
        name: gobadge
        author: https://github.com/AlexBeauchemin
        example_image_url: https://camo.githubusercontent.com/641e107dce1dc01655110b327ff8c95121ad34dd9e5c8a33b4c03aff109a6038/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f436f7665726167652d37362e352532352d627269676874677265656e
        commands:
          - gobadge -filename=coverage.out
          - gobadge -label="Go Coverage" -value=55.6% -color=blue -target=OTHER_README.md
          - gobadge -yellow=60 -green=80
          - gobadge -color=ff69b4
          - gobadge -link=https://github.com/project/repo/actions/workflows/test.yml
        requirements:
          - go install github.com/AlexBeauchemin/gobadge@latest
  - title: Education
    entries:
      - title: Run Turtle Graphics online
        description: This absolutely adorable visualization is an excellent online resource to learn programming.
        url: https://goplay.space/#wT_eZWJT69
        author: https://github.com/iafan
        name: goplay.space
        example_image_url: https://user-images.githubusercontent.com/1728158/29108287-12dfd26a-7c93-11e7-966d-713356bce3d3.gif
        example_content_ext: go
        example_content: |
          package main

          import (
            "fmt"
          )

          func main() {
            fmt.Println(`
              draw mode
              
              say Let's start...
              right 18
              color red

              forward 7
              say One...
              right 144

              forward 7
              say Two...
              right 144

              forward 7
              say Three...
              right 144

              forward 7
              say Four...
              right 144

              forward 7
              say We've got a star!
              right 144
            `)
          }
  - title: Style Guide
    type: md-list
    entries:
      - title: Google
        url: https://google.github.io/styleguide/go
      - title: Uber
        url: https://github.com/uber-go/guide
      - title: Go Code Review Comments
        url: https://github.com/golang/go/wiki/CodeReviewComments
  - title: Security
    entries:
      - title: Run official vulnerability check
        description: It uses static analysis of source code or a binary's symbol table to narrow down reports to only those that could affect the application. By default, govulncheck makes requests to the Go vulnerability database at https://vuln.go.dev. Requests to the vulnerability database contain only module paths, not code or other properties of your program. See https://vuln.go.dev/privacy.html for more.
        name: govulncheck
        author: Go Core team
        url: https://pkg.go.dev/golang.org/x/vuln/cmd/govulncheck
        commands:
          - govulncheck ./...
        example_output: |
          vulnerability data from https://vuln.go.dev (last modified 2023-06-01 21:27:40 +0000 UTC).

          Scanning your code and 1952 packages across 202 dependent modules for known vulnerabilities...
          Your code is affected by 2 vulnerabilities from 1 module.

          Vulnerability #1: GO-2023-1571
            A maliciously crafted HTTP/2 stream could cause excessive CPU
            consumption in the HPACK decoder, sufficient to cause a denial
            of service from a small number of small requests.

            More info: https://pkg.go.dev/vuln/GO-2023-1571

            Module: golang.org/x/net
              Found in: golang.org/x/net@v0.1.1-0.20221027164007-c63010009c80
              Fixed in: golang.org/x/net@v0.7.0

              Call stacks in your code:
                cmd/kube-controller-manager/app/controllermanager.go:216:40: k8s.io/kubernetes/cmd/kube-controller-manager/app.Run calls k8s.io/apiserver/pkg/server.SecureServingInfo.Serve, which eventually calls golang.org/x/net/http2.ConfigureServer
                  requirements:
                    - go install golang.org/x/vuln/cmd/govulncheck@latest
      - title: Perform Taint Analysis
        description: Taint analysis is a technique for identifying the flow of sensitive data through a program. It can be used to identify potential security vulnerabilities, such as SQL injection or cross-site scripting (XSS) attacks, by understanding how this data is used and transformed as it flows through the code. This package provides tools to performs such analysis. Included tool is performing SQL injection taint analysis.
        url: https://github.com/picatz/taint
        author: https://github.com/picatz
        name: taint
        requirements:
          - go install github.com/picatz/taint/cmd/sqli@latest
        commands:
          - sqli main.go
        example_content_ext: go
        example_content: |
          package main

          import (
                  "database/sql"
                  "net/http"
          )

          func business(db *sql.DB, q string) {
                  db.Query(q) // potential sql injection
          }

          func run() {
                  db, _ := sql.Open("sqlite3", ":memory:")

                  mux := http.NewServeMux()

                  mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
                          business(db, r.URL.Query().Get("sql-query"))
                  })

                  http.ListenAndServe(":8080", mux)
          }

          func main() {
                  run()
          }
        example_output: |
          ./sql/injection/testdata/src/example/main.go:9:10: potential sql injection
  - title: Static Analysis
    entries:
      - title: Run default static analysis
        description: Official tool for static analysis of Go programs, with 27+ static analyzers.
        author: official Go team
        name: "go vet"
        commands:
          - go vet ./...
      - title: Run custom static analysis tool
        description: Standard `go vet` can be used to run custom analyzers binaries. Third party analyzers are supported. Lots of official analyzers not included by default into `go vet`. Analyzer has to satisfy interface and command described here https://pkg.go.dev/golang.org/x/tools/go/analysis. Refer for https://pkg.go.dev/golang.org/x/tools/go/analysis/passes for full list of official Go analyzers.
        author: official Go team
        name: "go vet"
        commands:
          - go install golang.org/x/tools/go/analysis/passes/shadow/cmd/shadow
          - go vet -vettool=$(which shadow)
      - title: Run official static analyzers not included in `go vet`
        description: There are many analyzers not included in `go vet`. These tools are experimental and may not work as expected (e.g. `usesgenerics` does not work). Refer to for full list https://pkg.go.dev/golang.org/x/tools/go/analysis.
        author: official Go team
        example_content_ext: go
        example_content: |
          package main

          import (
            "golang.org/x/tools/go/analysis/multichecker"

            "golang.org/x/tools/go/analysis/passes/atomicalign"
            "golang.org/x/tools/go/analysis/passes/deepequalerrors"
            "golang.org/x/tools/go/analysis/passes/fieldalignment"
            "golang.org/x/tools/go/analysis/passes/nilness"
            "golang.org/x/tools/go/analysis/passes/reflectvaluecompare"
            "golang.org/x/tools/go/analysis/passes/shadow"
            "golang.org/x/tools/go/analysis/passes/sortslice"
            "golang.org/x/tools/go/analysis/passes/unusedwrite"
            "golang.org/x/tools/go/analysis/passes/usesgenerics"
          )

          func main() {
            multichecker.Main(
              atomicalign.Analyzer,         // checks for non-64-bit-aligned arguments to sync/atomic functions
              deepequalerrors.Analyzer,     // checks for the use of reflect.DeepEqual with error values
              fieldalignment.Analyzer,      // detects structs that would use less memory if their fields were sorted
              nilness.Analyzer,             // inspects the control-flow graph of an SSA function and reports errors such as nil pointer dereferences and degenerate nil pointer comparisons
              reflectvaluecompare.Analyzer, // checks for accidentally using == or reflect.DeepEqual to compare reflect.Value values
              shadow.Analyzer,              // checks for shadowed variables
              sortslice.Analyzer,           // checks for calls to sort.Slice that do not use a slice type as first argument
              unusedwrite.Analyzer,         // checks for unused writes to the elements of a struct or array object
              usesgenerics.Analyzer,        // checks for usage of generic features added in Go 1.18
            )
          }
      - title: Detect most common issues
        description: Start custom linters with this well-known linter. It contains 150+ high quality low false positive rate linters. It is widely adopted by Open Source and tech companies. [staticcheck.io](https://staticcheck.io/).
        url: https://github.com/dominikh/go-tools
        name: staticcheck
        author: https://github.com/dominikh
        commands:
          - staticcheck ./...
        requirements:
          - go install honnef.co/go/tools/cmd/staticcheck@latest
      - title: ":confetti_ball: Detect potential Nil panics"
        description: This tool employs sophisticated static analysis techniques to catch Nil dereferences. More details in [blog](https://www.uber.com/en-IN/blog/nilaway-practical-nil-panic-detection-for-go/).
        url: https://github.com/uber-go/nilaway
        author: Uber
        name: nilaway
        commands:
          - nilaway ./...
        example_image_url: https://blog.uber-cdn.com/cdn-cgi/image/width=2048,quality=80,onerror=redirect,format=auto/wp-content/uploads/2023/11/figure_4.jpg
        requirements:
          - go install go.uber.org/nilaway/cmd/nilaway@latest
      - title: Detect most common issues
        description: This linting aggregator and runner is similar to staticcheck. It has 100+ linting rules. It is based on Go [Code Review Comments](https://github.com/golang/go/wiki/CodeReviewComments) style guide that is used in core Go project itself. It has styling, security, performance rules. It has minimal dependencies and implements rules itself. It exports all analysers into `golang.org/x/tools/go/analysis` toolchain.
        url: https://github.com/go-critic/go-critic
        author: https://github.com/quasilyte
        name: go-critic
        commands:
          - gocritic check ./...
        requirements:
          - go install -v github.com/go-critic/go-critic/cmd/gocritic@latest
      - title: Reference and run common linters
        description: This tool has comprehensive list of linters. Owners of this aggregator keep track of active linters, their versions, and optimal configs. It contains many optimizations to make linters run fast by paralleism, distributing binaries and Docker images, utilising `golang.org/x/tools/go/analysis` toolchain.
        url: https://github.com/golangci/golangci-lint
        name: golangci
      - title: Detect non-exhaustive switch and map
        description: This `go vet` compatible analyzer checks for exhaustive switch statemnts and map literals. It works for enums with underyling integer, float, or string types (struct based enums are not supported).
        name: exhaustive
        url: https://github.com/nishanths/exhaustive
        author: https://github.com/nishanths
        commands:
          - exhaustive ./...
        example_content_ext: go
        example_content: |
          package token

          type Token int

          const (
            Add Token = iota
            Subtract
            Multiply
            Quotient
            Remainder
          )

          package calc

          import "token"

          func f(t token.Token) {
            switch t {
            case token.Add:
            case token.Subtract:
            case token.Multiply:
            default:
            }
          }

          func g(t token.Token) string {
            return map[token.Token]string{
              token.Add:      "add",
              token.Subtract: "subtract",
              token.Multiply: "multiply",
            }[t]
          }
        example_output: |
          calc.go:6:2: missing cases in switch of type token.Token: Quotient, Remainder
          calc.go:15:9: missing map keys of type token.Token: Quotient, Remainder
        requirements:
          - go install github.com/nishanths/exhaustive/cmd/exhaustive@latest
      - title: Detect structs with uninitialized fields
        description: This tool finds instatiations of structs with zero values. It supports struct tags to mark fields as optional. This may help to prevent unexpected zero values.
        url: https://github.com/GaijinEntertainment/go-exhaustruct
        name: go-exhaustruct
        author: https://github.com/xobotyi
        commands:
          - exhaustruct ./...
        example_content_ext: go
        example_content: |
          type Shape struct {
            Length int
            Width  int
            volume    int
            Perimeter int `exhaustruct:"optional"`
          }

          // valid
          var a Shape = Shape{
            Length: 5,
            Width:  3,
            volume: 5,
          }

          // invalid, `volume` is missing
          var b Shape = Shape{
            Length: 5,
            Width:  3,
          }
        requirements:
          - go get -u github.com/GaijinEntertainment/go-exhaustruct/v3/cmd/exhaustruct
      - title: Detect unsafe code
        description: Find incorrect uses of `reflect.SliceHeader`, `reflect.StringHeader`, and unsafe casts between structs with architecture-sized fields. Reseach paper ["Uncovering the Hidden Dangers Finding Unsafe Go Code in the Wild"](https://arxiv.org/abs/2010.11242) presented at 19th IEEE International Conference on Trust, Security and Privacy in Computing and Communications (TrustCom 2020).
        name: go-safer
        url: https://github.com/jlauinger/go-safer
        author: https://github.com/jlauinger
        commands:
          - go-safer ./...
        example_output: |
          # github.com/jlauinger/go-safer/passes/sliceheader/testdata/src/bad/composite_literal
          composite_literal/composite_literal.go:10:9: reflect header composite literal found
          composite_literal/composite_literal.go:10:9: reflect header composite literal found
          # github.com/jlauinger/go-safer/passes/sliceheader/testdata/src/bad/header_in_struct
          header_in_struct/header_in_struct.go:16:2: assigning to reflect header object
        requirements:
          - go install github.com/jlauinger/go-safer@latest
      - title: Detect unnecessary type conversions
        description: Identify expressions like `T(x)` where `x` is already has type `T`. This tool can identify conversions that force intermediate rounding. It also can overwrite files with fix. This tool is not using `golang.org/x/tools/go/analysis` toolchain.
        name: unconvert
        author: https://github.com/mdempsky
        url: https://github.com/mdempsky/unconvert
        example_content: |
          $ unconvert -v bytes fmt
          GOROOT/src/bytes/reader.go:117:14: unnecessary conversion
                          abs = int64(r.i) + offset
                                    ^
          GOROOT/src/fmt/print.go:411:21: unnecessary conversion
                  p.fmt.integer(int64(v), 16, unsigned, udigits)
                                    ^
        commands:
          - unconvert ./...
        requirements:
          - go install github.com/mdempsky/unconvert@latest
      - title: Detect global variables
        description: Global variables are an input to functions that is not visible in the functions signature, complicate testing, reduces readability and increase the complexity of code. However, sometimes global varaibles make sense. This tool skips such common scenarios. This tool can be used in CI, albeit it is very strict. This tool is useful for investigations.
        name: gochecknoglobals
        url: https://github.com/leighmcculloch/gochecknoglobals
        author: https://github.com/leighmcculloch
        commands:
          - gochecknoglobals ./...
        example_output: |
          /Users/nikolaydubina/Workspace/hugo/common/paths/path.go:64:5: fpb is a global variable
          /Users/nikolaydubina/Workspace/hugo/common/paths/url.go:50:5: pb is a global variable
          /Users/nikolaydubina/Workspace/hugo/common/text/position.go:52:5: positionStringFormatfunc is a global variable
          /Users/nikolaydubina/Workspace/hugo/common/text/transform.go:26:5: accentTransformerPool is a global variable
          /Users/nikolaydubina/Workspace/hugo/common/herrors/error_locator.go:40:5: SimpleLineMatcher is a global variable
        requirements:
          - go install 4d63.com/gochecknoglobals@latest
      - title: Detect slices that could be preallocated
        description: Preallocating slices can sometimes significantly improve performance. This tool detects common scenarions where preallocating can be beneficial. This tool is not using `golang.org/x/tools/go/analysis` toolchain.
        url: https://github.com/alexkohler/prealloc
        author: https://github.com/alexkohler
        name: prealloc
        commands:
          - prealloc ./...
        example_output: |
          tools/gopls/internal/lsp/source/completion/completion.go:1484 Consider preallocating paths
          tools/gopls/internal/lsp/source/completion/package.go:54 Consider preallocating items
          tools/gopls/internal/lsp/template/symbols.go:205 Consider preallocating ans
          tools/gopls/internal/lsp/template/completion.go:199 Consider preallocating working
          tools/gopls/internal/lsp/tests/util.go:32 Consider preallocating notePositions
          tools/gopls/internal/lsp/tests/util.go:240 Consider preallocating paramParts
          tools/gopls/internal/lsp/tests/util.go:282 Consider preallocating result
          tools/gopls/internal/lsp/tests/util.go:309 Consider preallocating got
        requirements:
          - go install github.com/alexkohler/prealloc@latest
      - title: Detect unnecessary import aliases
        description: It is common guideline to avoid renaming imports unless there are collisions. This tool detects where original pacakge name would not collide. This tool is useful for investigations. This tool is not using `golang.org/x/tools/go/analysis` toolchain.
        url: https://github.com/alexkohler/unimport
        author: https://github.com/alexkohler
        name: unimport
        commands:
          - unimport ./...
        example_output: |
          pkg/apis/apiserverinternal/v1alpha1/zz_generated.conversion.go:29 unnecessary import alias runtime
          pkg/apis/apiserverinternal/v1alpha1/zz_generated.conversion.go:30 unnecessary import alias apiserverinternal
          pkg/apis/apps/v1/zz_generated.conversion.go:25 unnecessary import alias unsafe
          pkg/apis/apps/v1/zz_generated.conversion.go:30 unnecessary import alias conversion
          pkg/apis/apps/v1/zz_generated.conversion.go:31 unnecessary import alias runtime
          pkg/apis/apps/v1/zz_generated.conversion.go:32 unnecessary import alias intstr
          pkg/apis/apps/v1/zz_generated.conversion.go:33 unnecessary import alias apps
          pkg/apis/apps/v1/zz_generated.conversion.go:34 unnecessary import alias core
          pkg/apis/apps/v1beta1/zz_generated.conversion.go:25 unnecessary import alias unsafe
          pkg/apis/apps/v1beta1/zz_generated.conversion.go:27 unnecessary import alias v1beta1
          pkg/apis/apps/v1beta1/zz_generated.conversion.go:30 unnecessary import alias conversion
          pkg/apis/apps/v1beta1/zz_generated.conversion.go:31 unnecessary import alias runtime
        requirements:
          - go install github.com/alexkohler/unimport@latest
      - title: Detect unexpected import aliases
        description: Ensure that import aliases take one of the allowed values.
        url: https://github.com/julz/importas
        name: importas
        author: https://github.com/julz
        example_content_ext: go
        example_content: |
          package main

          import (
            v1alpha1 "knative.dev/serving/pkg/apis/autoscaling/v1alpha1" // want `import "knative.dev/serving/pkg/apis/autoscaling/v1alpha1" imported as "v1alpha1" but must be "autoscalingv1alpha1" according to config`
            v1 "knative.dev/serving/pkg/apis/serving/v1"                 // want `import "knative.dev/serving/pkg/apis/serving/v1" imported as "v1" but must be "servingv1" according to config`
          )

          func main() {
          ...
        commands:
          - importas -alias knative.dev/serving/pkg/apis/autoscaling/v1alpha1:autoscalingv1alpha1 -alias knative.dev/serving/pkg/apis/serving/v1:servingv1 ./...
        requirements:
          - go install github.com/julz/importas/cmd/importas@latest
      - title: Detect inconsistent import aliases
        description: It greatly helps to navigate large codebases when imports have the same aliases.
        name: consistentimports
        url: https://github.com/nikolaydubina/consistentimports
        author: https://github.com/nikolaydubina
        commands:
          - consistentimports ./...
        example_output: |
          -: "k8s.io/utils/net" netutils:4 netutil:1
          -: "k8s.io/client-go/listers/core/v1" corelisters:1 listersv1:1 v1listers:1
          -: "k8s.io/client-go/informers/core/v1" coreinformers:1 informers:1
          -: "k8s.io/api/rbac/v1" rbacv1:4 v1:2
          -: "k8s.io/apimachinery/pkg/runtime" runtime:3 kruntime:1
          -: "k8s.io/api/imagepolicy/v1alpha1" imagepolicyv1alpha1:1 v1alpha1:1
          -: "k8s.io/kubernetes/plugin/pkg/admission/podtolerationrestriction/apis
        requirements:
          - go install github.com/nikolaydubina/consistentimports@latest
      - title: Detect naked returns
        description: "It is common guideline to avoid [naked returns](https://github.com/golang/go/wiki/CodeReviewComments#named-result-parameters). Naked return is when function has named return, and return statement does not specify value. This tool is useful for investigations."
        url: https://github.com/alexkohler/nakedret
        author: https://github.com/alexkohler
        name: nakedret
        commands:
          - nakedret ./...
        example_output: |
          /kubernetes/pkg/controller/podautoscaler/replica_calculator.go:421:2: naked return in func `groupPods` with 44 lines of code
          /kubernetes/pkg/kubelet/container/helpers.go:374:2: naked return in func `MakePortMappings` with 36 lines of code
          /kubernetes/pkg/kubelet/config/config.go:350:2: naked return in func `filterInvalidPods` with 17 lines of code
          /kubernetes/pkg/kubelet/config/config.go:449:3: naked return in func `checkAndUpdatePod` with 38 lines of code
          /kubernetes/pkg/kubelet/config/config.go:471:2: naked return in func `checkAndUpdatePod` with 38 lines of code
          /kubernetes/cmd/kube-controller-manager/app/controllermanager.go:717:2: naked return in func `createClientBuilders` with 19 lines of code
          /kubernetes/pkg/proxy/topology.go:77:3: naked return in func `CategorizeEndpoints` with 98 lines of code
          /kubernetes/pkg/proxy/topology.go:111:3: naked return in func `CategorizeEndpoints` with 98 lines of code
          /kubernetes/pkg/proxy/topology.go:119:3: naked return in func `CategorizeEndpoints` with 98 lines of code
          /kubernetes/pkg/proxy/topology.go:137:2: naked return in func `CategorizeEndpoints` with 98 lines of code
        requirements:
          - go install github.com/alexkohler/nakedret/cmd/nakedret@latest
      - title: Detect mixing pointer and value method receivers
        description: "Mixing pointer and value method receivers for the same type is discouraged, as per commong guideline [Go wiki](https://github.com/golang/go/wiki/CodeReviewComments#receiver-type) and [Google Go style guide](https://google.github.io/styleguide/go/decisions#receiver-type)."
        name: smrcptr
        url: https://github.com/nikolaydubina/smrcptr
        author: https://github.com/nikolaydubina
        commands:
          - smrcptr ./...
        example_content_ext: go
        example_content: |
          type Pancake struct{}

          func NewPancake() Pancake { return Pancake{} }

          func (s *Pancake) Fry() {}

          func (s Pancake) Bake() {}
        example_output: |
          smrcptr/internal/bakery/pancake.go:7:1: Pancake.Fry uses pointer
          smrcptr/internal/bakery/pancake.go:9:1: Pancake.Bake uses value
        requirements:
          - go install github.com/nikolaydubina/smrcptr@latest
      - title: Detect vertical function ordering
        description: Vertical function ordering is declaring functions before they are used. Based on 'Clean Code' by Robert.C.Martin.
        name: vertfn
        url: https://github.com/nikolaydubina/vertfn
        author: https://github.com/nikolaydubina
        commands:
          - vertfn --verbose ./...
        example_image_url: https://github.com/nikolaydubina/vertfn/blob/master/doc/code-dep-viz.png
        requirements:
          - go install github.com/nikolaydubina/vertfn@latest
      - title: Detect vertical symbol ordering
        description: This tool goes beyond just vertical ordering of function declarations, it also tracks many other types of symbols.
        name: refdir
        url: https://github.com/devnev/refdir
        author: https://github.com/devnev
        commands:
          - refdir --verbose ./...
        example_image_url: https://github.com/devnev/refdir/raw/main/doc/code-dep-viz.png
        requirements:
          - go install github.com/devnev/refdir@latest
      - title: Detect tests with wrong `t.Parallel()` usage
        description: This linter checks for incorroect usage of `t.Parallel()` calls. It will detect if `t.Parallel()` is missing.
        url: https://github.com/kunwardeep/paralleltest
        name: paralleltest
        author: https://github.com/kunwardeep
        commands:
          - paralleltest ./...
        example_output: |
          /kubernetes/pkg/scheduler/framework/plugins/nodeunschedulable/node_unschedulable_test.go:28:1: Function TestNodeUnschedulable missing the call to method parallel
          /kubernetes/pkg/scheduler/framework/plugins/nodevolumelimits/csi_test.go:68:1: Function TestCSILimits missing the call to method parallel
          /kubernetes/pkg/scheduler/framework/plugins/nodevolumelimits/csi_test.go:480:2: Range statement for test TestCSILimits missing the call to method parallel in test Run
          /kubernetes/pkg/scheduler/framework/plugins/nodevolumelimits/non_csi_test.go:81:1: Function TestEphemeralLimits missing the call to method parallel
        requirements:
          - go install github.com/kunwardeep/paralleltest@latest
      - title: Detect tests with wrong `t.Parallel()` usage
        description: This linter checks for incorroect usage of `t.Parallel()` calls.
        url: https://github.com/moricho/tparallel
        name: tparallel
        author: https://github.com/moricho
        commands:
          - go vet -vettool=`which tparallel` ./...
        example_output: |
          testdata/src/sample/table_test.go:7:6: Test_Table1 should use t.Cleanup
          testdata/src/sample/table_test.go:7:6: Test_Table1 should call t.Parallel on the top level as well as its subtests
          testdata/src/sample/table_test.go:30:6: Test_Table2's subtests should call t.Parallel
        requirements:
          - go install github.com/moricho/tparallel/cmd/tparallel@latest
      - title: Detect magic numbers
        description: This tool has heuristics to detect magic numbers.
        name: mnd
        url: https://github.com/tommy-muehle/go-mnd
        author: https://github.com/tommy-muehle
        commands:
          - mnd ./...
        example_output: |
          /go-mnd/examples/bad/main.go:18:23: Magic number: 200, in <condition> detected
          /go-mnd/examples/bad/main.go:11:12: Magic number: 2, in <assign> detected
        requirements:
          - go install github.com/tommy-muehle/go-mnd/v2/cmd/mnd@latest
      - title: ":confetti_ball: Detect magic strings"
        description: This tool detects repeated strings.
        name: goconst
        url: https://github.com/jgautheron/goconst
        author: https://github.com/jgautheron
        commands:
          - goconst -min-occurrences 5 -output json ./... | jq
        example_output: |
          "not reached": [                                                                                                                                          
            {                                                                                                                                                       
              "Filename": "tpl/internal/go_templates/texttemplate/hugo_template.go",                                                                                
              "Offset": 7916,
              "Line": 267,
              "Column": 8
            },
            {
              "Filename": "tpl/internal/go_templates/texttemplate/exec.go",
              "Offset": 15056,
              "Line": 525,
              "Column": 8
            },
            {
              "Filename": "tpl/internal/go_templates/texttemplate/exec.go",
              "Offset": 21354,
              "Line": 699,
              "Column": 8
            },
            {
              "Filename": "tpl/internal/go_templates/texttemplate/exec.go",
              "Offset": 28145,
              "Line": 903,
              "Column": 8
            },
            ...
        requirements:
          - go install github.com/jgautheron/goconst/cmd/goconst@latest
      - title: ":confetti_ball: Detect bound checks"
        url: https://github.com/maruel/pat
        author: https://github.com/maruel
        name: pat/boundcheck
        requirements:
          - go install github.com/maruel/pat/cmd/...@latest
        description: This tool detects bound checks in source code by anaylisng compiled code. This is useful for audit.
        example_image_url: https://github.com/maruel/pat/wiki/boundcheck.png
        commands:
          - boundcheck -pkg ./cmd/nin | less -R
      - title: Calculate Cognitive Complexity
        description: Congitive Complexity as defined in this tool can be more illustrative than Cyclometric Complexity. Research paper ["Cognitive Complexity - a new way of measuring understandability"](https://www.sonarsource.com/docs/CognitiveComplexity.pdf), 2021.
        name: gocognit
        url: https://github.com/uudashr/gocognit
        author: https://github.com/uudashr
        commands:
          - gocognit .
        example_content_ext: go
        example_content: |
          // Complexity Cyclomatic=4 Cognitive=7
          // Cognitive complexity give higher score compare to cyclomatic complexity.
          func SumOfPrimes(max int) int {         // +1
              var total int
              for i := 1; i < max; i++ {          // +1 (cognitive +1, nesting)
                  for j := 2; j < i; j++ {        // +1 (cognitive +2, nesting)
                      if i%j == 0 {               // +1
                          continue OUT
                      }
                  }
                  total += i
              }
              return total
          }

          // Complexity Cyclomatic=4 Cognitive=1
          // Cognitive complexity give lower score compare to cyclomatic complexity.
          func GetWords(number int) string {      // +1
              switch number {
                  case 1:                         // +1 (cognitive 0)
                      return "one"
                  case 2:                         // +1 (cognitive 0)
                      return "a couple"
                  case 3:                         // +1 (cognitive 0)
                      return "a few"
                  default:
                      return "lots"
              }
          }
        example_output: |
          21 main (BasicSymtabConverter).SymtabFileToTreemap basic_converter.go:23:1
          12 symtab parseGoSymtabLine symtab/go_symtab_parser.go:37:1
          11 main main main.go:30:1
          8 symtab EqSymbolName symtab/symbol_name_parser.go:12:1
          7 symtab ParseSymbolName symtab/symbol_name_parser.go:32:1
          7 symtab Test_parseGoSymtabLine symtab/go_symtab_parser_private_test.go:5:1
          4 symtab Test_ParseSymbolName symtab/symbol_name_parser_private_test.go:5:1
          3 main updateNodeNamesWithByteSize main.go:99:1
          3 main unique basic_converter.go:119:1
          3 symtab (GoSymtabParser).ParseSymtab symtab/go_symtab_parser.go:14:1
          2 fmtbytecount ByteCountIEC fmtbytecount/format_bytecount.go:3:1
        requirements:
          - go install github.com/uudashr/gocognit/cmd/gocognit@latest
      - title: Calculate Cyclomatic Complexity
        description: Cyclomatic complexity is a code quality metric which can be used to identify code that needs refactoring. It measures the number of linearly independent paths through a function's source code. For example, excessive usage of nested `if` and `for` leads to increased cyclomatic complexity. This tool can report `top-N` and `over`, which makes it suitable for CI as a linter and manual investigation.
        name: gocyclo
        author: https://github.com/fzipp
        url: https://github.com/fzipp/gocyclo
        commands:
          - gocyclo .
        example_output: |
          $ gocyclo -over=5 .
          34 examplemodule (*With32FieldsFeatureTransformer).Fit cmd/generate/tests/with32fieldsfp.go:48:1
          24 main parseCode cmd/generate/parser.go:83:1
          13 examplemodule (*AllTransformersFeatureTransformer).Fit cmd/generate/tests/alltransformersfp.go:27:1
          12 examplemodule (*EmployeeFeatureTransformer).Fit cmd/generate/tests/employeefp.go:26:1
          11 transformers (*CountVectorizer).TransformInplace transformers/textprocesors.go:84:1
          11 structtransformer (*StructTransformer).Transform structtransformer/structtransformer.go:38:1
          11 examplemodule (*LargeMemoryTransformerFeatureTransformer).Fit cmd/generate/tests/largememorytransformerfp.go:25:1
          10 examplemodule (*WeirdTagsFeatureTransformer).Fit cmd/generate/tests/weirdtagsfp.go:24:1
          8 transformers (*SampleNormalizerL2).TransformInplace transformers/samplenormalizers.go:58:1
        requirements:
          - go install github.com/fzipp/gocyclo/cmd/gocyclo@latest
      - title: Calculate Cyclomatic Complexity
        description: This linter calculates cyclomatic copmlexity of functions or packages. It can select minimum compexlity and act as blocking linter in CI pipelines. The key offering from this linter is that it can calculate avg cyclomatic compelxity on package.
        url: https://github.com/bkielbasa/cyclop
        name: cyclop
        author: https://github.com/bkielbasa
        commands:
          - cyclop ./...
          - "# to find packages with avg cyclomatic copmlexity above maximum"
          - cyclop -packageAverage 5 -maxComplexity 10000 ./...
        example_output: |
          /kubernetes/test/integration/scheduler/scoring/priorities_test.go:17:1: the average complexity for the package scoring is 6.100000, max is 5.000000
          /kubernetes/test/integration/serviceaccount/service_account_test.go:17:1: the average complexity for the package serviceaccount is 10.666667, max is 5.000000
          /kubernetes/test/integration/volume/persistent_volumes_test.go:17:1: the average complexity for the package volume is 6.157895, max is 5.000000
          /kubernetes/test/list/main_test.go:17:1: the average complexity for the package main is 5.461538, max is 5.000000
          /kubernetes/test/typecheck/main_test.go:17:1: the average complexity for the package main is 5.916667, max is 5.000000
          /kubernetes/third_party/forked/golang/net/dnsclient_test.go:10:1: the average complexity for the package net is 5.333333, max is 5.000000
        requirements:
          - go install github.com/bkielbasa/cyclop@latest
      - title: Calculate age of comments
        description: This go vet compatible tool analyses AST and git and collects details on how far comments drift from code they describe.
        name: go-commentage
        url: https://github.com/nikolaydubina/go-commentage
        author: https://github.com/nikolaydubina
        commands:
          - go-commentage -min-days-behind 360 ./...
        example_output: |
          kubernetes/pkg/util/ipset/ipset.go:283:1: "CreateSet": doc_last_updated_behind_days(1336.83)
          kubernetes/pkg/util/ipset/ipset.go:296:1: "createSet": doc_last_updated_behind_days(1603.17)
          kubernetes/pkg/util/ipset/ipset.go:320:1: "AddEntry": doc_last_updated_behind_days(1578.10)
          kubernetes/pkg/util/ipset/ipset.go:332:1: "DelEntry": doc_last_updated_behind_days(1578.10)
          kubernetes/pkg/util/ipset/ipset.go:340:1: "TestEntry": doc_last_updated_behind_days(450.07)
        requirements:
          - "# get latest version of git"
          - go install github.com/nikolaydubina/go-commentage@latest
      - title: ":derelict_house: Ensure `if` statements using short assignment"
        name: ifshort
        author: https://github.com/esimonov
        status: archive-not-working
        url: https://github.com/esimonov/ifshort
        description: Linter for checking that your code uses short syntax for `if` statements whenever possible. However, as of `2023-05-26`, it is not maitaned and is not working.
        commands:
          - ifshort ./...
        example_content_ext: go
        example_content: |
          // bad
          func someFunc(k string, m map[string]interface{}) {
            _, ok := m[k]
            if !ok {
              return
            }

            err := otherFunc1()
            if err != nil {
              otherFunc2(err)
            }
          }

          // good
          func someFunc(k string, m map[string]interface{}) {
            if _, ok := m[k]; !ok {
              return
            }

            if err := otherFunc1(); err != nil {
              otherFunc2(err)
            }
          }
        requirements:
          - go install github.com/esimonov/ifshort@latest
      - title: Visualize struct layout
        description: Display the byte offset and size of each field, respecting alignment/padding.
        name: structlayout
        url: https://github.com/dominikh/go-tools/tree/master/cmd/structlayout
        author: https://github.com/dominikh
        commands:
          - structlayout -json bytes Buffer | structlayout-svg -t "bytes.Buffer" > /tmp/struct.svg
        example_image_url: https://github.com/dominikh/go-tools/blob/master/images/screenshots/struct.png
        requirements:
          - go install github.com/ajstarks/svgo/structlayout-svg@latest
          - go install honnef.co/go/tools/cmd/structlayout@latest
      - title: Rely on compiler for stricter Enums
        description: "For compile time blocking of: accidental arithmetics; implicit cast of untyped constants; all operators except `==` and `!=`; — simply wrap into a struct in separate package and do not export field. [example](http://github.com/nikolaydubina/go-enum-example)."
        example_content_ext: go
        example_content: |
          package color

          type Color struct{ c uint }

          var (
            Undefined = Color{}
            Red       = Color{1}
            Green     = Color{2}
            Blue      = Color{3}
          )
      - title: Analyze function callsites
        description: Scrape callsite information about functions to lern better how functions are beign used. This can help in refactoring, naming, OOP. This tool calcuates frequency of names on assignments in returns and frequency of names in arguments. This can be used to detect ignored returns as well.
        author: https://github.com/nikolaydubina
        url: https://github.com/nikolaydubina/go-callsite-stats
        name: go-callsite-stats
        commands:
          - go-callsite-stats ./...
        requirements:
          - go install github.com/nikolaydubina/go-callsite-stats@latest
        example_content: |
          x16:       (no assignments)                  = execHostnameTest(serviceAddress:7)
                                                                        (nodePortAddress:3)
                                                                        (nodePortAddress0:3)
                                                                        (nodePortAddress1:2)
                                                                        (clusterIPAddress:1)
          x16:       pod:10, err:12                    = CreatePod(client:11, namespace:10, nil:9, pvclaims:6, false:7, execCommand:2)
                    clientPod:1                                  (c:2, ns:2, podCount:2, true:3)
                    _:1                                          (pod:1, pod:1, pvclaims:2, false:2)
                    err:1                                        (ctx:1, nil:1, createdClaims:1, pvcClaims:1)
                                                                  (namespace:1, nameSpace:1, podTemplate:1)
                                                                  (, basePod:1)
          x16:       (no assignments)                  = GET()
          x16:       deployment:11, err:14             = UpdateDeploymentWithRetries(c:14, ns:14, deploymentName:3, applyUpdate:1, poll:1,pollShortTimeout:1)                                                         
                    _:2                                                            (client:1, namespace:1, pollTimeout:1)
                    deploymentWithUpdatedReplicas:1                                (applyUpdate:1, pollInterval:1, name:1)
          x16:       err:16                            = waitForDefinition(schemaFoo:12
                                                                          (schemaWaldo:3)
                                                                          (expect:1)