DEV Community: Nobuo Miura

I Got Tired of Recreating GitHub Rulesets, So I Built a GitHub CLI Extension

Nobuo Miura — Mon, 20 Jul 2026 10:41:38 +0000

Every time I created a new repository, I found myself configuring the same rules for its default branch again:

Require changes to go through pull requests
Block force pushes
Prevent branch deletion
Require status checks when needed

None of this is difficult for a single repository. But as the number of repositories grows, repeatedly opening the same settings page and recreating the same ruleset becomes tedious. It also becomes harder to tell which repositories still share the same configuration.

I wanted a way to save one repository ruleset as a reusable template, apply it elsewhere, and check whether the deployed rulesets still matched it.

So I built gh-rulekit, an open-source GitHub CLI extension for saving, editing, and reusing repository rulesets.

nobuo-miura / gh-rulekit

GitHub CLI extension to save, edit, and bulk-apply repository rulesets across all your repos

gh-rulekit

English | 日本語

A gh extension for saving GitHub repository rulesets locally, editing them, and applying the same ruleset across multiple repositories.

Features

Export repository rulesets to a local library
Review and edit saved rulesets as JSON
Preview changes before applying them
Create or update a ruleset in one or many repositories
Compare repository rulesets with locally saved versions

Requirements

GitHub CLI installed and authenticated with gh auth login
Read access to repositories you export or inspect
Repository admin access, or a custom role with permission to edit repository rules, when applying rulesets
Go is required only when installing from source

Install

From a release (recommended)

After the first release with prebuilt binaries is published:

gh extension install nobuo-miura/gh-rulekit

From source

git clone https://github.com/nobuo-miura/gh-rulekit.git
cd gh-rulekit
go build -o gh-rulekit .
gh extension install .

Quick start

# 1. Save one ruleset under a convenient local name
gh rulekit

…

View on GitHub

What gh-rulekit Does

gh-rulekit provides a small local library for GitHub repository rulesets. It can:

Export an existing repository ruleset
Store and edit the exported ruleset as JSON
Preview target repositories and whether each ruleset will be created or updated
Apply the same ruleset to one or many repositories
Compare rulesets on GitHub with locally saved versions

The basic workflow looks like this:

# 1. Save a ruleset under a convenient local name
gh rulekit export owner/source-repo --name main --as protect-default

# 2. Preview the targets and actions
gh rulekit apply protect-default --all --dry-run

# 3. Apply the ruleset
gh rulekit apply protect-default --all

# 4. Check whether the deployed rulesets still match
gh rulekit status

Installation

gh-rulekit requires GitHub CLI and an authenticated session created with gh auth login.

Install the extension with:

gh extension install nobuo-miura/gh-rulekit

Then check the available commands:

gh rulekit --help

The help text follows your locale: Japanese locales receive Japanese help, while other locales receive English help.

Exporting a Ruleset

Start by creating the ruleset you want in one repository through GitHub. Then export it into the local library.

For example, this command exports the main ruleset from owner/source-repo and saves it locally as protect-default:

gh rulekit export owner/source-repo --name main --as protect-default

The --as option changes only the name in the local library. It does not rename the ruleset on GitHub. When the saved ruleset is applied elsewhere, its GitHub name remains main.

You can inspect and manage saved rulesets with:

gh rulekit list
gh rulekit show protect-default
gh rulekit edit protect-default

edit opens the JSON file in $EDITOR and validates the file after it is saved. This makes it possible to review or adjust the API representation directly without maintaining a separate configuration format.

Previewing a Bulk Apply

Applying configuration across many repositories is useful, but it is also an operation worth reviewing first.

With --dry-run, gh-rulekit lists each target and shows whether it would create a new ruleset or update an existing ruleset with the same name. It does not modify anything.

gh rulekit apply protect-default --all --dry-run

Targets can be filtered by visibility:

gh rulekit apply protect-default --all --public --dry-run
gh rulekit apply protect-default --all --private --dry-run

You can also target an organization:

gh rulekit apply protect-default --all --owner my-org --dry-run

Archived repositories are skipped because they are read-only.

Always review the output of --dry-run before using --all. A bulk apply can modify many repositories.

Applying the Ruleset

After reviewing the targets, remove --dry-run to apply the ruleset:

gh rulekit apply protect-default --all

If a repository already has a ruleset with the same GitHub name, gh-rulekit updates it. Otherwise, it creates a new one.

To change only one repository, use --repo:

gh rulekit apply protect-default --repo owner/repo

Rulesets that target GitHub's ~DEFAULT_BRANCH placeholder can be reused without knowing whether each repository uses main, master, or another default branch name. There is no need to rewrite the saved JSON for every repository.

Detecting Configuration Drift

Bulk application solves only half of the problem. I also wanted to know whether repository rulesets still matched the version I had saved locally.

The status command compares ruleset contents with the local library:

gh rulekit status

Its output uses three states:

== local:<name> — the content matches a locally saved ruleset
!= local:<name> — a local ruleset with the same name exists, but its content differs
-- (no local match) — no corresponding local ruleset was found

The first comparison is content-based, so it can find a match even when the local saved name differs from the ruleset name on GitHub.

To inspect a single repository:

gh rulekit status --repo owner/repo

This provides a quick way to spot repositories whose settings have diverged after a manual change.

Why Not Use Organization Rulesets?

GitHub already supports organization-level rulesets, and they are the natural choice when you want centralized enforcement across repositories in one organization and your plan supports them.

gh-rulekit is aimed at a different set of cases:

You maintain multiple repositories under a personal account
You want to reuse a repository ruleset across different owners or organizations
You want the ruleset available locally as editable JSON
You want to compare current repository settings with a saved reference

It does not replace GitHub Rulesets. It makes repository-level rulesets easier to save, reuse, and inspect.

Notes for v0.1.0

Exporting and inspecting rulesets requires read access to the target repositories
Applying rulesets requires repository admin access or a custom role with permission to edit repository rules
Rulesets on private repositories require an eligible GitHub paid plan
--dry-run previews targets and create/update actions, but it does not show a field-by-field diff
A bulk operation continues after individual failures and reports a non-zero exit status at the end
Successful changes are not automatically rolled back if another repository fails

For a first run, I recommend filtering the targets, checking --dry-run, and applying the ruleset to a small number of repositories before using it more broadly.

Closing

gh-rulekit came from a very small annoyance: configuring the same default-branch rules every time I created a repository.

The settings themselves were not complicated. They were simply repetitive. Turning that repetition into a reusable CLI workflow has made creating and reviewing repositories much easier for me.

gh-rulekit is still at v0.1.0. If you try it and find a bug or have an idea for improving the workflow, feedback and issues are welcome.

nobuo-miura / gh-rulekit

GitHub CLI extension to save, edit, and bulk-apply repository rulesets across all your repos

gh-rulekit

English | 日本語

A gh extension for saving GitHub repository rulesets locally, editing them, and applying the same ruleset across multiple repositories.

Features

Export repository rulesets to a local library
Review and edit saved rulesets as JSON
Preview changes before applying them
Create or update a ruleset in one or many repositories
Compare repository rulesets with locally saved versions

Requirements

GitHub CLI installed and authenticated with gh auth login
Read access to repositories you export or inspect
Repository admin access, or a custom role with permission to edit repository rules, when applying rulesets
Go is required only when installing from source

Install

From a release (recommended)

After the first release with prebuilt binaries is published:

gh extension install nobuo-miura/gh-rulekit

From source

git clone https://github.com/nobuo-miura/gh-rulekit.git
cd gh-rulekit
go build -o gh-rulekit .
gh extension install .

Quick start

# 1. Save one ruleset under a convenient local name
gh rulekit

…

View on GitHub

Building a Local-Only Browser Extension That Translates GitHub's UI—Not Your Content

Nobuo Miura — Sat, 11 Jul 2026 01:51:23 +0000

Built-in browser translation is convenient, but it is often too broad for developer tools. It can translate repository content along with the interface, turning terms such as "branch" into awkward words and making technical pages harder to read.

There is also a more serious concern in corporate environments: depending on the translation feature or service being used, page content may be sent to an external translation provider. That can be unacceptable when a page contains private repository code, internal issue discussions, or other confidential information.

I wanted a narrower and more predictable solution:

Translate only GitHub's fixed interface labels
Leave README files, issues, comments, and source code untouched
Never send text to an external translation API or cloud translation service
Perform the entire translation locally in the browser

So I built GitHub UI Translator, an open-source browser extension for Chrome and Firefox.

nobuo-miura / github-ui-translator

A Chrome extension that translates the GitHub UI into multiple languages using local dictionaries.

GitHub UI Translator

English | 日本語

GitHub UI Translator is a browser extension (Chrome and Firefox) that translates GitHub's English UI into Japanese using a local dictionary It does not rely on external translation APIs or cloud services; all translation runs locally in the browser.

This project is currently an MVP (Minimum Viable Product).

Features

Runs entirely locally, with no external network requests
Translates fixed GitHub UI text such as navigation items and buttons while avoiding content areas such as READMEs, issues, comments, and code blocks
Lets you turn translation on or off from the extension popup

Current Limitations

Only Japanese is supported.
Dynamic text that includes numbers, dates, or user names, such as "3 commits" or "opened 2 days ago", is not translated.
Only github.com is supported. GitHub Enterprise and other custom domains are not supported.
Tested on Chrome and Firefox. Other Chromium-based browsers (Edge, Brave, etc.) should also…

View on GitHub

The initial bundled dictionary translates GitHub's interface into Japanese, but the design is not tied to any particular language.

The Main Design Goal: Decide What Not to Translate

A straightforward translation extension could scan every text node on the page and replace matching strings. The problem is that GitHub pages contain both interface text and user-generated content.

Translating the whole page could modify:

README files
Issue and pull request descriptions
Comments
Code blocks
Repository file content

For this extension, leaving those areas untouched is more important than translating every possible label.

Instead of scanning the entire document, the extension starts with an allowlist of semantic UI elements:

const BASE_SELECTOR = [
  'nav',
  'header',
  'button',
  'input[type="submit"]',
  'input[type="button"]',
  'input[type="reset"]',
  '[role="tab"]',
  '[role="menuitem"]',
  '[role="menuitemradio"]',
  '[role="menuitemcheckbox"]',
  '[role="menu"]',
  '[role="dialog"]',
  '[role="listbox"]',
  '[role="button"]',
  '[aria-label]'
];

These selectors describe the meaning of an element rather than GitHub's visual implementation. CSS class names and data-testid values can change during a refactor, while elements such as nav and ARIA roles are more closely tied to how the interface works.

Some GitHub pages, including Settings and Issue or Pull Request screens, contain fixed interface text in headings, labels, and links. On those pages, the extension expands the allowlist based on the URL. Content containers such as .markdown-body are still explicitly excluded.

This approach is intentionally conservative. Missing a label is preferable to modifying content written by a user.

Exact Matches Instead of Machine Translation

The extension does not use a machine translation model. It replaces text only when the complete string matches an entry in its bundled dictionary.

For example:

{
  "language": "ja",
  "name": "日本語",
  "translations": {
    // Repository navigation
    "Code": "コード",
    "Issues": "イシュー",
    "Pull requests": "プルリクエスト",

    // Repository actions
    "Watch": "ウォッチ",
    "Star": "スター"
  }
}

Dynamic strings such as 3 commits or opened 2 days ago do not match a dictionary entry, so they remain in English.

That limits translation coverage, but it also provides a useful safety property: unknown text is displayed exactly as GitHub provided it. There is no generated translation that can unexpectedly change the meaning of a technical term.

Translation is not limited to visible text nodes: matching aria-label values, placeholder attributes, and button value attributes are also translated, so relevant labels used by assistive technologies are covered as well.

Keeping Confidential Content Away from Translation Services

The dictionary is bundled with the extension. Translation is a local string-matching operation performed inside the browser.

The extension does not send page text to an external translation API or cloud translation service. It does not need to upload a README, issue discussion, pull request description, or source file to produce a translation.

This distinction matters in organizations where private repositories contain confidential code or internal discussions. Even when an external translation service is useful, company policy may prohibit sending repository content to it.

GitHub UI Translator reduces that concern in two complementary ways:

User-generated content is excluded from translation targets.
The interface text that is translated is processed locally with a bundled dictionary.

The goal is not to replace general-purpose translation. It is to provide a small, auditable tool for one specific job: translating predictable interface labels without involving repository content.

Why the Dictionary Uses Commented Sections

The Japanese dictionary contains nearly 1,000 entries. A flat JSON file quickly becomes difficult to maintain because it is not obvious which GitHub screen each label belongs to.

The dictionary therefore uses JSON with line comments to group entries by screen or feature. Before parsing the file, the extension removes the comment lines and passes the remaining content to JSON.parse.

This makes it easier to find and update the relevant section when GitHub changes an interface label. It also keeps language contributions approachable: adding another language mainly involves supplying another dictionary rather than changing the translation logic.

Current Trade-Offs

The conservative design comes with some limitations:

Japanese is currently the only included language.
Dynamic labels containing numbers, dates, or usernames remain in English.
GitHub Enterprise domains are not currently supported.
The extension has been tested on Chrome and Firefox, but not on other Chromium-based browsers.
GitHub can introduce new UI structures or labels that are not yet in the allowlist or dictionary.

These are acceptable trade-offs for the initial version. The fallback is always the original GitHub text, not a guessed translation.

What's Next

I would like to expand the dictionary coverage and add more languages while keeping the same local-only, UI-only approach.

If you are interested in contributing a dictionary, reporting an untranslated GitHub label, or reviewing the implementation, the project is available on GitHub:

nobuo-miura / github-ui-translator

A Chrome extension that translates the GitHub UI into multiple languages using local dictionaries.

GitHub UI Translator

English | 日本語

This project is currently an MVP (Minimum Viable Product).

Features

Runs entirely locally, with no external network requests
Translates fixed GitHub UI text such as navigation items and buttons while avoiding content areas such as READMEs, issues, comments, and code blocks
Lets you turn translation on or off from the extension popup

Current Limitations

Only Japanese is supported.
Dynamic text that includes numbers, dates, or user names, such as "3 commits" or "opened 2 days ago", is not translated.
Only github.com is supported. GitHub Enterprise and other custom domains are not supported.
Tested on Chrome and Firefox. Other Chromium-based browsers (Edge, Brave, etc.) should also…

View on GitHub

Protect Non-Email Domains from Spoofing with DNS Records

Nobuo Miura — Wed, 24 Jun 2026 14:18:58 +0000

Domains used exclusively for web services, or acquired for future use through domain parking, can still be used in phishing and email-spoofing campaigns, even when they neither send nor receive email.

This article explains how to configure three DNS records — MX / SPF / DMARC — to prevent abuse of non-email domains.

Why Non-Email Domains Are Targeted

Attackers scan for domains with missing or weak SPF and DMARC records to use in the From: address. Domains that never send email are the most likely to be unconfigured, making them easy targets.

A common attack scenario:

example.com is a web-only domain — no email is ever sent from it
An attacker sends phishing emails with From: support@example.com
Because SPF / DMARC are not configured, receiving servers have no policy to apply and the message may be delivered

Records to Configure

Record	Value	Purpose
MX	`0 .`	Explicitly declare that this domain accepts no mail (null MX)
SPF (TXT)	`v=spf1 -all`	Declare no authorized senders exist
DMARC (TXT)	`v=DMARC1; p=reject; sp=reject; adkim=s; aspf=s; rua=mailto:...`	Enforce policy and collect reports

Setting Up Each Record

1. MX Record — Null MX (RFC 7505)

example.com.  MX  0  .

0 . (zero, dot) is the standard way to explicitly signal that this domain accepts no mail (RFC 7505).
Publishing an explicit null MX is preferable to omitting the MX record entirely, as it removes ambiguity for sending servers.
Note that a null MX must not coexist with any other MX records — it must be set as the sole MX record for the domain.

2. SPF Record — Declare No Authorized Senders

example.com.  TXT  "v=spf1 -all"

-all (hard fail) declares that no authorized mail servers exist for this domain, resulting in an SPF evaluation of Fail.
This produces a stronger result than ~all (soft fail, SoftFail), making it easier for receivers to apply policy.
However, the final decision to reject a message is left to the receiving server.

3. DMARC Record — Policy Enforcement

_dmarc.example.com.  TXT  "v=DMARC1; p=reject; sp=reject; adkim=s; aspf=s; rua=mailto:dmarc-reports@yourdomain.com"

Tag breakdown:

Tag	Value	Meaning
`p`	`reject`	Request that receivers reject messages failing DMARC evaluation
`sp`	`reject`	Apply the same policy to subdomains (same value as `p=reject`, but explicit)
`adkim`	`s` (strict)	DKIM `d=` tag must exactly match the From domain
`aspf`	`s` (strict)	SPF `MAIL FROM` must exactly match the From domain
`rua`	`mailto:...`	Destination for aggregate reports

About `rua` (Report Destination)

Setting up reporting is recommended especially for non-email domains.
Aggregate reports are sent in periodic batches by DMARC-compliant receivers — immediate detection is not guaranteed — but they can help you identify patterns of spoofing attempts.
Use an email address you can monitor, or an external DMARC reporting service, to receive and review these reports.

If your reporting address is on a different domain, you need to authorize it with a TXT record in that domain's DNS zone:

example.com._report._dmarc.yourdomain.com.  TXT  "v=DMARC1"

Note: This TXT record must be added to the DNS zone of yourdomain.com (the report receiver), not to example.com (the protected domain).

A Note on `adkim=s` / `aspf=s` (strict)

In strict mode, DKIM aligns only when its d= domain exactly matches the RFC5322.From domain; SPF aligns only when its MAIL FROM domain exactly matches it. For example, a DKIM signature with d=example.com will not satisfy alignment for From: sub.example.com under strict mode.
If you ever start sending legitimate email from this domain in the future, consider switching to adkim=r; aspf=r (relaxed).

Optional: Revoking DKIM Keys for Past Selectors

If the domain previously sent email and the DKIM selectors used at that time are known, you can explicitly revoke those keys.

default._domainkey.example.com.  TXT  "v=DKIM1; p="

An empty p= signals key revocation (RFC 6376), causing any DKIM signature referencing that selector to be treated as invalid.
Note that there is no verification difference between a revoked record and a deleted record, and this provides no defense against unknown selectors.
Consider this only when you want to explicitly retire a selector that was actively used in the past.

Verifying Your Configuration

Use dig to confirm the records are live:

# MX
dig MX example.com

# SPF
dig TXT example.com

# DMARC
dig TXT _dmarc.example.com

Expected output:

;; ANSWER SECTION:
example.com.        300  IN  MX   0  .
example.com.        300  IN  TXT  "v=spf1 -all"
_dmarc.example.com. 300  IN  TXT  "v=DMARC1; p=reject; sp=reject; adkim=s; aspf=s; rua=mailto:dmarc-reports@yourdomain.com"

Summary

These three records form a recommended baseline for protecting a non-email domain from spoofing:

example.com.         MX   0  .
example.com.         TXT  "v=spf1 -all"
_dmarc.example.com.  TXT  "v=DMARC1; p=reject; sp=reject; adkim=s; aspf=s; rua=mailto:dmarc-reports@yourdomain.com"

On receivers that implement DMARC and enforce policies, messages spoofing this domain can be expected to be rejected.
Take a few minutes to audit all the domains you own — the ones you're not actively using are the most likely to be missing these records.

Go 1.26 Cheat Sheet

Nobuo Miura — Tue, 23 Jun 2026 12:29:32 +0000

This cheat sheet is based on Go 1.26.

Program structure
Variables, constants, and types
Control flow
Functions
Arrays, slices, and maps
Structs, methods, and tags
Interfaces
Errors
Goroutines, channels, and synchronization
Context
Generics
Iterators
Testing
Standard-library quick reference
Tips and common mistakes
Modules and packages
Further reading

Program structure

package main  // Every executable must be in package main.

import (
    "fmt"
    "os"
)

func main() {
    fmt.Println("Hello, Go 1.26")
    os.Exit(0)
}

Every Go source file starts with a package declaration.
An executable program uses package main and a main function.
Group standard-library and third-party imports separately.

Variables, constants, and types

Variable declarations and inference

// var can infer the type from an initializer.
var name = "Gopher" // string
var age int          // No initializer: specify a type. Zero value: 0.
var id int64 = 42    // Use an explicit type when int is not what you want.

// Short declaration: inside functions only.
city := "Tokyo"

// Declare multiple variables in a block.
var (
    x, y int = 1, 2
    msg  string
)

Use var name = "Gopher" when an initializer makes the type clear. Without an initializer, write the type explicitly. A := declaration is only valid inside a function, and at least one name on its left side must be new.

Types and zero values

Category	Types	Zero value
Numbers	integers, floats, complex numbers	`0` (`0 + 0i` for complex)
Strings	`string`	`""`
Booleans	`bool`	`false`
Arrays	`[N]T`	every element is `T`'s zero value
Structs	`struct`	every field has its zero value
Reference-containing types	pointers, slices, maps, channels, functions, interfaces	`nil`
Defined types	e.g. `type UserID int`	the underlying type's zero value

Category	Types	Notes
Boolean	`bool`	`true` or `false`
String	`string`	immutable sequence of bytes (usually UTF-8, but invalid UTF-8 is allowed)
Signed integers	`int`, `int8`, `int16`, `int32`, `int64`	`int` is platform-sized (32 or 64 bit)
Unsigned integers	`uint`, `uint8`, `uint16`, `uint32`, `uint64`, `uintptr`	`uintptr` holds a pointer's raw bits
Aliases	`byte`, `rune`	aliases for `uint8` and `int32`
Floating point	`float32`, `float64`	IEEE 754
Complex	`complex64`, `complex128`	float32 or float64 real and imaginary parts

var i8 int8 = 127             // -128 to 127
var f64 float64 = 3.141592653589793
var c complex128 = 1 + 2i

s := "こんにちは"
runes := []rune(s) // Unicode code points
bytes := []byte(s) // raw bytes

// rune = int32 alias for a Unicode code point
var ch rune = '🐹'

Conversion and constants

i := 42
f := float64(i)              // Conversions are always explicit; no implicit coercion.
text := fmt.Sprintf("%d", i) // Number to string.
n, err := strconv.Atoi("123") // String to number.

const Pi = 3.14159

// iota: auto-incremented integer constant.
type Weekday int

const (
    Sunday Weekday = iota // 0
    Monday                // 1
    Tuesday               // 2
)

// Bit-flag pattern.
type Permission uint

const (
    Read    Permission = 1 << iota // 1
    Write                          // 2
    Execute                        // 4
)

Pointers

x := 10
p := &x  // Take the address of x.
*p = 20  // Dereference the pointer.
fmt.Println(x) // 20

p1 := new(int) // *int; the pointed-to value is 0.

// Go 1.26+: new accepts an expression as well as a type.
// This does not compile with Go 1.25 or earlier.
p2 := new(42)               // *int; the pointed-to value is 42.
p3 := new(Person{Name: "Alice"}) // *Person initialized with a literal.

Control flow

if

// An initialization statement is scoped to this if/else chain.
if err := doSomething(); err != nil {
    return fmt.Errorf("do something: %w", err)
}

if x > 0 {
    fmt.Println("positive")
} else if x < 0 {
    fmt.Println("negative")
} else {
    fmt.Println("zero")
}

for

// C-style loop.
for i := 0; i < 5; i++ {
}

// Go has no while keyword; use for instead.
for n > 0 {
    n--
}

// Infinite loop.
for {
    if done {
        break
    }
}

// range returns an index and a value for slices and arrays.
for i, v := range []int{10, 20, 30} {
    fmt.Println(i, v) // 0 10 / 1 20 / 2 30
}

// Discard the index.
for _, v := range slice {
}

// Strings range over Unicode code points (runes), not bytes.
for i, r := range "日本語" {
    fmt.Printf("%d: %c\n", i, r)
}

// Maps.
for k, v := range m {
    fmt.Println(k, v) // Iteration order is unspecified.
}

switch

// Expression switch (fallthrough requires an explicit keyword).
switch os := runtime.GOOS; os {
case "darwin":
    fmt.Println("macOS")
case "linux":
    fmt.Println("Linux")
default:
    fmt.Println("Other")
}

// Condition-less switch is a cleaner alternative to a long if-else chain.
switch {
case x > 100:
    fmt.Println("big")
case x > 10:
    fmt.Println("medium")
default:
    fmt.Println("small")
}

// Type switch: identify the dynamic type of an interface value.
func describe(i any) {
    switch v := i.(type) {
    case int:
        fmt.Printf("int: %d\n", v)
    case string:
        fmt.Printf("string: %q\n", v)
    default:
        fmt.Printf("unknown: %T\n", v)
    }
}

defer

defer schedules a call to run just before the surrounding function returns. Use it for cleanup: closing files, response bodies, mutexes, and contexts. Deferred calls run in LIFO order.

func writeFile(path string) error {
    f, err := os.Create(path)
    if err != nil {
        return err
    }
    defer f.Close() // Runs when writeFile returns, regardless of how.

    defer fmt.Println("third")
    defer fmt.Println("second")
    defer fmt.Println("first")
    // Prints: first, second, third.
    return nil
}

Note
Deferred call arguments are evaluated when defer is encountered. In a long-running loop, a deferred cleanup does not run until the function returns, so resources accumulate. Close them promptly or move the loop body into a helper function.

Functions

Basic

// Multiple return values.
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

result, err := divide(10, 3)

// Named return values (useful as documentation for short functions).
func minMax(nums []int) (min, max int) {
    min, max = nums[0], nums[0]
    for _, n := range nums[1:] {
        if n < min {
            min = n
        }
        if n > max {
            max = n
        }
    }
    return // Naked return.
}

Variadic functions

func sum(nums ...int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}

sum(1, 2, 3)
nums := []int{1, 2, 3}
sum(nums...) // Spread a slice into variadic arguments.

First-class functions and closures

Functions are values in Go: you can assign them to variables, pass them as arguments, and return them. A closure captures variables from its surrounding scope and keeps them alive after the outer function returns.

// Assign a function to a variable.
add := func(a, b int) int { return a + b }

// Pass a function as an argument.
apply := func(f func(int, int) int, x, y int) int {
    return f(x, y)
}
fmt.Println(apply(add, 3, 4)) // 7

// This closure captures n.
func counter() func() int {
    n := 0
    return func() int {
        n++
        return n
    }
}

c := counter()
c() // 1
c() // 2

init

An init function runs automatically while a package is initialized, before main. A package may have more than one init function. Prefer explicit initialization in main for ordinary application setup; reserve init for package-level registration.

// Runs automatically at package initialization.
func init() {
    // Register a driver or handler.
}

Arrays, slices, and maps

Memory layout

Array (fixed length, value type)
┌───┬───┬───┬───┬───┐
│ 0 │ 1 │ 2 │ 3 │ 4 │  ← contiguous memory (placement decided by the compiler)
└───┴───┴───┴───┴───┘

Slice (variable-length view)
┌────────┬──────┬──────┐
│ ptr    │ len  │ cap  │  ← 3-word slice header
└────┬───┴──────┴──────┘
     ↓
┌───┬───┬───┬───┬───┬───┐
│ 0 │ 1 │ 2 │ 3 │   │   │  ← underlying array
└───┴───┴───┴───┴───┴───┘
     ↑           ↑
    len=4       cap=6

Note: actual placement (stack/heap) is decided by escape analysis.

Arrays

Arrays have a fixed length, and that length is part of their type: [3]int and [4]int are different types. Arrays are values, so assigning or passing one copies all its elements.

var a [3]int              // [0 0 0]
b := [3]int{1, 2, 3}
c := [...]int{4, 5, 6}   // Length inferred from the literal.

// Arrays are copied by value.
d := b
d[0] = 99 // b is unchanged.

Slices

A slice is a variable-length view over part or all of an underlying array. Unlike an array, its length is not part of its type. Assigning a slice copies only its header, so two slices may share elements.

// Create a slice.
s := []int{1, 2, 3}
s2 := make([]int, 5)     // len=5, cap=5
s3 := make([]int, 3, 10) // len=3, cap=10

// append may allocate a new backing array when cap is exceeded.
s = append(s, 4, 5)
s = append(s, []int{6, 7}...)

// Slicing shares the backing array.
sub := s[1:3]            // s[1] and s[2]; shares s's array.
limited := s[1:3:3]      // Third index limits the resulting cap.

// copy produces an independent slice.
clone := make([]int, len(s))
copy(clone, s)

// Delete element at index i while preserving order.
i := 2
s = append(s[:i], s[i+1:]...)

fmt.Println(len(s), cap(s))

Caution
A subslice shares its backing array with the original. Mutating one can mutate the other. Use copy when an independent slice is required.

Maps

Maps associate keys with values. Iteration order is unspecified. Keys must be comparable; slices, maps, and functions cannot be map keys.

// Create a map.
m := map[string]int{"a": 1, "b": 2}
m2 := make(map[string]int)

m["c"] = 3
delete(m, "a") // delete is a built-in function.

// Check for key existence.
v, ok := m["missing"] // ok is false when the key is absent.
if ok {
    fmt.Println(v)
}

// Iteration order is unspecified.
for k, v := range m {
    fmt.Println(k, v)
}

Caution
The zero value of a map is nil. Reading from a nil map is safe, but writing to one panics. Initialize it with make or a map literal first.

Structs, methods, and tags

Structs and embedding

type Person struct {
    Name string // Exported: accessible from other packages.
    Age  int
    addr string // Unexported: package-private.
}

// Named-field initialization (preferred).
p1 := Person{Name: "Alice", Age: 30}
p2 := new(Person) // *Person; all fields are zero values.

// Embedding promotes fields and methods.
type Employee struct {
    Person            // Fields and methods of Person are promoted.
    Department string
}

e := Employee{Person: Person{Name: "Carol", Age: 28}, Department: "Eng"}
fmt.Println(e.Name) // Transparent access to Person.Name.

Methods

// Value receiver: p is a copy of the caller.
func (p Person) Greet() string {
    return "Hi, I'm " + p.Name
}

// Pointer receiver: can modify the original Person.
func (p *Person) Birthday() {
    p.Age++
}

p := Person{Name: "Dave", Age: 20}
p.Birthday()       // Go automatically passes &p.
fmt.Println(p.Age) // 21

When to use pointer receivers

The method needs to modify the receiver → pointer receiver.

The struct is large (avoid copy overhead) → pointer receiver.

Otherwise, either works.

Keep receiver kinds consistent across all methods of one type.

Struct tags

Struct tags are metadata attached to fields. The language does not interpret them; packages such as encoding/json and ORMs read them through reflection.

type User struct {
    ID    int    `json:"id" db:"user_id"`
    Email string `json:"email,omitempty"` // Omitted from JSON when empty.
}

// encoding/json reads tags through reflection.
data, _ := json.Marshal(User{ID: 1, Email: ""})
// → {"id":1}   (Email omitted by omitempty)

Interfaces

An interface defines a set of methods. A type satisfies an interface implicitly — no implements keyword. This lets code depend on behavior rather than a concrete type.

interface value layout (the internal representation is not part of the spec)

var s Shape = Circle{Radius: 5}

  s (interface value)
  ┌──────────────┬──────────────┐
  │  type info   │  value/ptr   │
  │  (Circle)    │  {Radius:5}  │
  └──────────────┴──────────────┘

  If either part is nil while the other is not, the interface value itself is not nil.
  (See nil interface trap in Tips.)

type Shape interface {
    Area() float64
    Perimeter() float64
}

type Circle struct{ Radius float64 }

func (c Circle) Area() float64      { return math.Pi * c.Radius * c.Radius }
func (c Circle) Perimeter() float64 { return 2 * math.Pi * c.Radius }

// Circle implicitly satisfies Shape.
var s Shape = Circle{Radius: 5}
fmt.Println(s.Area())

Type assertions and type switches

// Safe type assertion; the single-result form panics on failure.
c, ok := s.(Circle)
if ok {
    fmt.Println("radius:", c.Radius)
}

// any is an alias for interface{} (Go 1.18+).
func printAny(v any) {
    fmt.Printf("%T: %v\n", v, v)
}

Small interfaces used everywhere

// io.Reader and io.Writer are the most widely used interfaces in the stdlib.
type Reader interface { Read(p []byte) (n int, err error) }
type Writer interface { Write(p []byte) (n int, err error) }

// Implementing fmt.Stringer controls how fmt.Println prints a value.
type Stringer interface { String() string }

func (p Person) String() string {
    return fmt.Sprintf("%s (%d)", p.Name, p.Age)
}

fmt.Println(Person{Name: "Eve", Age: 22}) // Eve (22)

Errors

// error is a built-in interface: type error interface { Error() string }

f, err := os.Open("file.txt")
if err != nil {
    return fmt.Errorf("open file: %w", err) // %w wraps err for errors.Is/As.
}
defer f.Close()

Custom errors

type NotFoundError struct {
    Resource string
    ID       int
}

func (e *NotFoundError) Error() string {
    return fmt.Sprintf("%s (id=%d) not found", e.Resource, e.ID)
}

func findUser(id int) (*User, error) {
    if id <= 0 {
        return nil, &NotFoundError{Resource: "user", ID: id}
    }
    // ...
    return nil, nil
}

errors package

import "errors"

// Sentinel error for errors.Is comparisons.
var ErrNotFound = errors.New("not found")

func fetchUser(id int) (*User, error) {
    if id <= 0 {
        return nil, fmt.Errorf("fetchUser: %w", ErrNotFound) // Wrap with %w.
    }
    return nil, nil
}

_, err := fetchUser(-1) // fetchUser returns (*User, error); discard the value.

// errors.Is traverses the error chain to find a matching sentinel.
if errors.Is(err, ErrNotFound) {
    fmt.Println("not found")
}

// errors.As traverses the chain and extracts a value of the target type.
func findItem(id int) error {
    return fmt.Errorf("findItem: %w", &NotFoundError{Resource: "item", ID: id})
}

var nfe *NotFoundError
if errors.As(findItem(42), &nfe) {
    fmt.Println("resource:", nfe.Resource) // "item"
}

// Go 1.26+: a type-safe generic alternative to errors.As.
if nfe, ok := errors.AsType[*NotFoundError](findItem(42)); ok {
    fmt.Println("resource:", nfe.Resource) // "item"
}

// errors.Join combines multiple errors into one (Go 1.20+).
err1 := errors.New("err1")
err2 := errors.New("err2")
combined := errors.Join(err1, err2)

panic and recover

Use panic for broken program invariants or truly unrecoverable situations; return error for expected failures. recover only works when called directly from a deferred function.

func mustPositive(n int) int {
    if n <= 0 {
        panic(fmt.Sprintf("must be positive, got %d", n))
    }
    return n
}

func safeDiv(a, b int) (result int, err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("recovered: %v", r)
        }
    }()
    return a / b, nil
}

Goroutines, channels, and synchronization

GMP model (Go runtime scheduler)

G = Goroutine (lightweight thread; initial stack ~2 KB, grows as needed)
M = OS thread
P = Processor (controlled by GOMAXPROCS)

  P1                P2
  ┌────────────┐   ┌────────────┐
  │ G1 running │   │ G3 running │
  │ ┌────────┐ │   │ ┌────────┐ │
  │ │ G2     │ │   │ │ G4     │ │ ← local run queue
  │ │ G5     │ │   └────────────┘
  └────────────┘
       M1               M2        ← OS threads

Goroutines

// go keyword: start a function concurrently.
go func() {
    fmt.Println("goroutine")
}()

// Wait for goroutines to finish.
var wg sync.WaitGroup
for i := 0; i < 5; i++ {
    wg.Add(1)
    go func(n int) {
        defer wg.Done()
        fmt.Println(n)
    }(i) // Pass i as an argument to avoid closure capture issues.
}
wg.Wait()

Channels

ch := make(chan int)       // Unbuffered: send blocks until a receiver is ready.
bch := make(chan int, 10)  // Buffered: send blocks only when the buffer is full.

// Unbuffered: send and receive must be in separate goroutines.
go func() { ch <- 42 }()
v := <-ch

// Buffered: send and receive can be in the same goroutine within capacity.
bch <- 1
bch <- 2
fmt.Println(<-bch, <-bch) // 1 2

// Receiving from a closed, drained channel returns (zero, false).
v, ok := <-ch // ok is false when the channel is closed and empty.

// range receives values until the channel is closed and drained.
ch2 := make(chan int, 3)
ch2 <- 1; ch2 <- 2; ch2 <- 3
close(ch2) // The sender closes the channel.
for v := range ch2 {
    fmt.Println(v) // 1, 2, 3
}

Channel direction

// Directional types make intent explicit and catch mistakes at compile time.
func producer(ch chan<- int) { // Send-only.
    for i := 0; i < 5; i++ {
        ch <- i
    }
    close(ch)
}

func consumer(ch <-chan int) { // Receive-only.
    for v := range ch {
        fmt.Println(v)
    }
}

ch := make(chan int)
go producer(ch)
consumer(ch)

select

// select waits on multiple channel operations simultaneously.
// It picks one ready case at random when several are ready.
select {
case v := <-ch1:
    fmt.Println("ch1:", v)
case v := <-ch2:
    fmt.Println("ch2:", v)
case ch3 <- data:
    fmt.Println("sent to ch3")
case <-time.After(1 * time.Second):
    fmt.Println("timeout")
default:
    fmt.Println("no channel ready") // Non-blocking.
}

sync and atomic

// Mutex: protect shared state from concurrent access.
var mu sync.Mutex
var count int

mu.Lock()
count++
mu.Unlock()

// RWMutex: more efficient when reads are much more frequent than writes.
var rw sync.RWMutex
rw.RLock()  // Multiple goroutines can read simultaneously.
// ... read ...
rw.RUnlock()

// Once: run an initialization function exactly once.
var once sync.Once
once.Do(func() { /* called only the first time */ })

// atomic: low-overhead operations for simple counters and flags.
var n atomic.Int64
n.Add(1)
fmt.Println(n.Load())

Avoid goroutine leaks
When a goroutine sends on a channel, always give it a way to stop if the receiver exits early.

select {
case ch <- result:
case <-ctx.Done(): // Exit when the caller cancels.
    return
}

Context

Context tree

context.Background()
    └── WithCancel → ctx, cancel
            └── WithTimeout(ctx, 5s) → ctx2, cancel2
                    └── WithValue(ctx2, key, val) → ctx3
                                    ↓
                       Cancellation and deadlines propagate to child contexts.

Use context.Context to propagate deadlines, cancellation, and request-scoped metadata. Call the returned cancel function even when a timeout will eventually fire.

import "context"

// Timeout context.
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel() // Always call cancel to release resources.

req, err := http.NewRequestWithContext(ctx, http.MethodGet, "https://example.com", nil)
if err != nil {
    return err
}

resp, err := http.DefaultClient.Do(req)
if err != nil {
    if errors.Is(err, context.DeadlineExceeded) {
        fmt.Println("timeout")
    }
    return err
}
defer resp.Body.Close()

// Cancellable context.
ctx2, cancel2 := context.WithCancel(context.Background())
go func() {
    <-ctx2.Done() // Block until cancelled.
    fmt.Println("cancelled:", ctx2.Err())
}()
cancel2()

// context.WithValue carries request-scoped metadata.
// Use it only for small amounts of data; never as a substitute for function parameters.
type ctxKey string
const userKey ctxKey = "user"

ctx3 := context.WithValue(context.Background(), userKey, "alice")
user, ok := ctx3.Value(userKey).(string) // Type-assert with an ok check.

Generics

Go 1.18 introduced type parameters for reusable, type-safe code.

Type parameters

// T and U can be any type.
func Map[T, U any](s []T, f func(T) U) []U {
    result := make([]U, len(s))
    for i, v := range s {
        result[i] = f(v)
    }
    return result
}

doubled := Map([]int{1, 2, 3}, func(n int) int { return n * 2 })
// [2 4 6]

Type constraints

import "cmp"

// cmp.Ordered allows <, >, ==  (int, float64, string, etc.).
func Min[T cmp.Ordered](a, b T) T {
    if a < b {
        return a
    }
    return b
}

Min(3, 5)       // 3 (int)
Min(3.14, 2.71) // 2.71 (float64)
Min("b", "a")   // "a" (string)

// Custom constraint with ~ for underlying types.
type Number interface {
    ~int | ~int64 | ~float64
}

func Sum[T Number](nums []T) T {
    var total T
    for _, n := range nums {
        total += n
    }
    return total
}

Generic types

type Stack[T any] struct {
    items []T
}

func (s *Stack[T]) Push(v T) {
    s.items = append(s.items, v)
}

func (s *Stack[T]) Pop() (T, bool) {
    if len(s.items) == 0 {
        var zero T
        return zero, false // Return the zero value of T.
    }
    v := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return v, true
}

s := Stack[string]{}
s.Push("Go")
s.Push("Generics")
v, _ := s.Pop() // "Generics"

Iterators

Since Go 1.23, a function returning iter.Seq can be ranged over directly. When the caller breaks early, yield returns false so the producer can stop.

import "iter"

// Backward yields n-1 through 0.
func Backward(n int) iter.Seq[int] {
    return func(yield func(int) bool) {
        for i := n - 1; i >= 0; i-- {
            if !yield(i) { // Caller broke out of the loop.
                return
            }
        }
    }
}

for i := range Backward(3) {
    fmt.Println(i) // 2, 1, 0
}

// maps.Keys returns an iter.Seq; slices.Collect converts it to a slice.
keys := slices.Collect(maps.Keys(m))

Testing

// Place tests in xxx_test.go files.
package mypackage_test

import (
    "testing"

    "github.com/yourname/yourproject/mypackage"
)

func TestAdd(t *testing.T) {
    got := mypackage.Add(2, 3)
    if got != 5 {
        t.Errorf("Add(2, 3) = %d; want 5", got)
    }
}

// Table-driven tests are the idiomatic Go pattern.
func TestDivide(t *testing.T) {
    tests := []struct {
        name    string
        a, b    float64
        want    float64
        wantErr bool
    }{
        {"normal", 10, 2, 5, false},
        {"division by zero", 10, 0, 0, true},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            got, err := mypackage.Divide(tt.a, tt.b)
            if (err != nil) != tt.wantErr {
                t.Errorf("unexpected error: %v", err)
            }
            if got != tt.want {
                t.Errorf("got %v, want %v", got, tt.want)
            }
        })
    }
}

// Benchmark: run with go test -bench=.
func BenchmarkAdd(b *testing.B) {
    b.ReportAllocs() // Report memory allocations per operation.
    for i := 0; i < b.N; i++ {
        mypackage.Add(2, 3)
    }
}

Test helpers

// t.Helper makes failures report the caller's line, not the helper's.
func requireNoError(t *testing.T, err error) {
    t.Helper()
    if err != nil {
        t.Fatal(err)
    }
}

func TestWriteFile(t *testing.T) {
    t.Setenv("APP_ENV", "test") // Restored automatically after the test.
    dir := t.TempDir()           // Deleted automatically after the test.
    t.Cleanup(func() {
        // Register arbitrary cleanup: reset mocks, close clients, etc.
    })

    path := filepath.Join(dir, "output.txt")
    requireNoError(t, os.WriteFile(path, []byte("hello"), 0o644))
}

go test ./...          # Run all tests.
go test -race ./...    # Detect data races.
go test -cover ./...   # Show coverage.

Standard-library quick reference

fmt

// Output.
fmt.Print("no newline")
fmt.Println("with newline")
fmt.Printf("formatted %s %d %v\n", "str", 42, true)
fmt.Fprintf(os.Stderr, "error: %v\n", err)

// Build strings.
s := fmt.Sprintf("Hello, %s!", name)
msg := fmt.Errorf("wrap: %w", err)

// Common format verbs.
// %v   default             %+v  struct with field names  %#v  Go syntax
// %T   type name           %d   decimal integer          %f   floating-point
// %s   string              %q   quoted string            %x   hexadecimal
// %p   pointer address     %b   binary                   %e   exponent

strings

import "strings"

strings.Contains("Hello", "ell")                    // true
strings.HasPrefix("Hello", "He")                    // true
strings.HasSuffix("Hello", "lo")                    // true
strings.Count("cheese", "e")                        // 3
strings.Index("Hello", "ll")                        // 2
strings.Replace("oink oink", "oink", "moo", 1)     // "moo oink"
strings.ReplaceAll("oink oink", "oink", "moo")      // "moo moo"
strings.ToUpper("hello")                            // "HELLO"
strings.ToLower("HELLO")                            // "hello"
strings.TrimSpace("  hello  ")                      // "hello"
strings.Trim("##hello##", "#")                      // "hello"
strings.Split("a,b,c", ",")                         // ["a" "b" "c"]
strings.Join([]string{"a", "b"}, "-")               // "a-b"
strings.Fields("a  b\tc")                           // ["a" "b" "c"]

// strings.Builder is efficient for repeated concatenation in a loop.
// A plain + is fine for a small number of concatenations.
var sb strings.Builder
for i := 0; i < 5; i++ {
    fmt.Fprintf(&sb, "%d", i)
}
sb.String() // "01234"

strconv

import "strconv"

strconv.Itoa(42)                       // "42"
strconv.Atoi("42")                     // 42, nil
strconv.ParseFloat("3.14", 64)         // 3.14, nil
strconv.FormatFloat(3.14, 'f', 2, 64)  // "3.14"
strconv.ParseBool("true")              // true, nil
strconv.FormatBool(true)               // "true"

sort and slices

import "sort"

nums := []int{5, 2, 4, 1, 3}
sort.Ints(nums)                              // [1 2 3 4 5]

words := []string{"b", "a", "c"}
sort.Strings(words)

// Custom sort.
sort.Slice(nums, func(i, j int) bool {
    return nums[i] > nums[j] // Descending.
})

import (
    "cmp"
    "slices"
)

slices.Sort(nums)                                            // Ascending.
idx, found := slices.BinarySearch(nums, 3)                  // Requires sorted input.

// cmp.Compare avoids integer overflow in comparison functions.
slices.SortFunc(nums, func(a, b int) int { return cmp.Compare(b, a) }) // Descending.

maps (Go 1.21+)

import (
    "maps"
    "slices"
)

m := map[string]int{"a": 1, "b": 2}
m2 := maps.Clone(m)        // Shallow copy.
maps.Copy(m2, m)            // Copy all entries from m into m2.
delete(m, "a")              // delete is a built-in function.
keys := slices.Collect(maps.Keys(m)) // Collect keys into a slice.

time

import "time"

now := time.Now()
t := time.Date(2026, 6, 1, 12, 0, 0, 0, time.Local)

// Go uses a reference time (Mon Jan 2 15:04:05 MST 2006) as the layout.
now.Format("2006-01-02 15:04:05")
now.Format(time.RFC3339)                      // "2026-06-22T12:00:00+09:00"
parsed, _ := time.Parse("2006-01-02", "2026-06-22")

later := now.Add(24 * time.Hour)
diff := later.Sub(now)     // time.Duration
fmt.Println(diff.Hours())  // 24.0

time.Sleep(100 * time.Millisecond)
ticker := time.NewTicker(500 * time.Millisecond)
defer ticker.Stop()

os and filepath

import (
    "os"
    "path/filepath"
)

// File I/O.
data, err := os.ReadFile("file.txt")
err = os.WriteFile("out.txt", data, 0644)

// Directory operations.
entries, _ := os.ReadDir(".")
for _, e := range entries {
    fmt.Println(e.Name(), e.IsDir())
}
os.MkdirAll("a/b/c", 0755)
os.Remove("file.txt")
os.RemoveAll("dir/")

// Environment variables.
home := os.Getenv("HOME")
os.Setenv("KEY", "value")

// Path manipulation.
filepath.Join("a", "b", "c")       // "a/b/c"
filepath.Base("/a/b/file.txt")      // "file.txt"
filepath.Dir("/a/b/file.txt")       // "/a/b"
filepath.Ext("file.txt")            // ".txt"
abs, _ := filepath.Abs("relative")  // Absolute path.

encoding/json

import "encoding/json"

type Point struct {
    X int `json:"x"`
    Y int `json:"y"`
}

// Encode.
data, err := json.Marshal(Point{X: 1, Y: 2})           // []byte
pretty, err := json.MarshalIndent(Point{X: 1}, "", "  ")

// Decode.
var p Point
err = json.Unmarshal(data, &p)

// Streaming.
enc := json.NewEncoder(os.Stdout)
enc.Encode(p)

dec := json.NewDecoder(os.Stdin) // Accepts any io.Reader.
dec.Decode(&p)

// When the type is unknown.
var v any
json.Unmarshal(data, &v)
m := v.(map[string]any)

net/http

import (
    "bytes"
    "context"
    "errors"
    "io"
    "log"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"
)

// Always set a timeout; the default client has none.
client := &http.Client{Timeout: 10 * time.Second}

// GET request.
resp, err := client.Get("https://example.com")
if err != nil {
    return err
}
defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)

// Custom request with context.
req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(jsonData))
if err != nil {
    return err
}
req.Header.Set("Content-Type", "application/json")
resp2, err := client.Do(req)
if err != nil {
    return err
}
defer resp2.Body.Close()

// HTTP server with timeouts (required in production).
mux := http.NewServeMux()
mux.HandleFunc("GET /hello/{name}", func(w http.ResponseWriter, r *http.Request) {
    name := r.PathValue("name") // Path parameters (Go 1.22+).
    fmt.Fprintf(w, "Hello, %s!", name)
})

server := &http.Server{
    Addr:              ":8080",
    Handler:           mux,
    ReadHeaderTimeout: 5 * time.Second,
    ReadTimeout:       30 * time.Second,
    WriteTimeout:      30 * time.Second,
    IdleTimeout:       60 * time.Second,
}
go func() {
    if err := server.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
        log.Printf("server error: %v", err)
    }
}()

// Graceful shutdown on SIGINT / SIGTERM.
shutdownCtx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer stop()
<-shutdownCtx.Done()

ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
if err := server.Shutdown(ctx); err != nil {
    log.Printf("shutdown error: %v", err)
}

log/slog (Go 1.21+)

import "log/slog"

// Default logger writes text to stderr.
slog.Info("server started", "port", 8080)
slog.Error("request failed", "err", err)

// JSON handler for structured logging (e.g., cloud environments).
logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
    Level: slog.LevelDebug,
}))
logger.Info("user logged in", "userID", 42, "ip", "127.0.0.1")
// {"time":"...","level":"INFO","msg":"user logged in","userID":42,"ip":"127.0.0.1"}

// Add fields shared across multiple log calls.
logger.With("requestID", "abc123").Info("processing")

Tips and common mistakes

Goroutine leak

// Bad: the goroutine blocks forever if no one receives from ch.
go func() {
    ch <- result
}()

// Good: always provide a cancellation path.
go func() {
    select {
    case ch <- result:
    case <-ctx.Done():
        return
    }
}()

nil interface trap

// Bad: even when *MyError is nil, the interface value is non-nil.
func getError() error {
    var err *MyError = nil
    return err // The returned error interface is non-nil!
}

if getError() != nil { // true — this branch is taken unexpectedly.
    fmt.Println("this prints unexpectedly")
}

// Good: return nil directly.
func getError() error {
    return nil
}

Pre-allocate slice capacity

// Bad: append may reallocate the backing array many times.
result := []int{}
for i := 0; i < 10000; i++ {
    result = append(result, i)
}

// Good: allocate the full capacity upfront.
result := make([]int, 0, 10000)
for i := 0; i < 10000; i++ {
    result = append(result, i)
}

for-loop variable capture (fixed in Go 1.22)

// Go 1.21 and earlier: all goroutines share the same i variable.
for i := 0; i < 5; i++ {
    go func() { fmt.Println(i) }() // May print 5 five times.
}

// Go 1.22+: each iteration creates a new i variable.
// The above code now correctly prints 0, 1, 2, 3, 4 in some order.

// Workaround for Go 1.21 and earlier.
for i := 0; i < 5; i++ {
    i := i // Shadow i with a new variable for this iteration.
    go func() { fmt.Println(i) }()
}

Modules and packages

# Initialize a module.
go mod init github.com/yourname/yourproject

# Go 1.26
go get go@1.26

go get github.com/some/package@v1.2.3   # Add a dependency.
go mod tidy                              # Remove unused dependencies.
go mod vendor                            # Vendor dependencies.
go build ./...                           # Build.
go test ./...                            # Test.
go test -race ./...                      # Detect data races.
go vet ./...                             # Static analysis.
go fmt ./...                             # Format.

DEV Community: Nobuo Miura

I Got Tired of Recreating GitHub Rulesets, So I Built a GitHub CLI Extension

nobuo-miura / gh-rulekit

GitHub CLI extension to save, edit, and bulk-apply repository rulesets across all your repos

gh-rulekit

Features

Requirements

Install

From a release (recommended)

From source

Quick start

What gh-rulekit Does

Installation

Exporting a Ruleset

Previewing a Bulk Apply

Applying the Ruleset

Detecting Configuration Drift

Why Not Use Organization Rulesets?

Notes for v0.1.0

Closing

nobuo-miura / gh-rulekit

GitHub CLI extension to save, edit, and bulk-apply repository rulesets across all your repos

gh-rulekit

Features

Requirements

Install

From a release (recommended)

From source

Quick start

Building a Local-Only Browser Extension That Translates GitHub's UI—Not Your Content

nobuo-miura / github-ui-translator

A Chrome extension that translates the GitHub UI into multiple languages using local dictionaries.

GitHub UI Translator

Features

Current Limitations

The Main Design Goal: Decide What Not to Translate

Exact Matches Instead of Machine Translation

Keeping Confidential Content Away from Translation Services

Why the Dictionary Uses Commented Sections

Current Trade-Offs

What's Next

nobuo-miura / github-ui-translator

A Chrome extension that translates the GitHub UI into multiple languages using local dictionaries.

GitHub UI Translator

Features

Current Limitations

Protect Non-Email Domains from Spoofing with DNS Records

Why Non-Email Domains Are Targeted

Records to Configure

Setting Up Each Record

1. MX Record — Null MX (RFC 7505)

2. SPF Record — Declare No Authorized Senders

3. DMARC Record — Policy Enforcement

About rua (Report Destination)

A Note on adkim=s / aspf=s (strict)

Optional: Revoking DKIM Keys for Past Selectors

Verifying Your Configuration

Summary

Go 1.26 Cheat Sheet

Table of Contents

Program structure

Variables, constants, and types

Variable declarations and inference

Types and zero values

Conversion and constants

Pointers

Control flow

if

for

switch

defer

Functions

Basic

Variadic functions

First-class functions and closures

init

Arrays, slices, and maps

Memory layout

Arrays

Slices

About `rua` (Report Destination)

A Note on `adkim=s` / `aspf=s` (strict)