Golang Build & Run Tooling Quiz

0 Passed

0% acceptance

35 comprehensive questions on Go's build and run tooling, covering go build, go run, go test, cross-compiling, and build tags — with 15 code examples demonstrating practical build configurations and testing scenarios.

35 Questions

~70 minutes

Question 1

What does the 'go build' command do?

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

// Command line:
// go build hello.go
// or
// go build .
// or
// go build -o myapp .

// This creates an executable binary

Compiles Go source files into an executable binary

Runs the Go program

Runs tests

Formats Go code

Question 2

How do you specify the output filename with go build?

bash

// Build with custom output name
// go build -o myapp main.go

// Build entire package
// go build -o server .

// Build for current directory
// go build
// Creates executable with directory name

// Cross-platform naming
// On Windows: go build -o app.exe .
// On Linux/Mac: go build -o app .

Use the -o flag: go build -o output_name .

Use the -out flag

Use the -name flag

Cannot specify output filename

Question 3

What is the difference between 'go build' and 'go run'?

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

// go run main.go
// Compiles and runs in one step, no binary created

// go build main.go
// Creates executable binary
// ./main (or main.exe on Windows)

// go run is equivalent to:
// go build -o /tmp/go-run-123 main.go
// /tmp/go-run-123
// rm /tmp/go-run-123

go build creates a binary; go run compiles and executes without saving the binary

go run creates a binary; go build executes it

No difference

go build is for testing, go run is for production

Question 4

How do you build for a different operating system?

bash

// Build for Linux on AMD64
// GOOS=linux GOARCH=amd64 go build .

// Build for Windows on AMD64
// GOOS=windows GOARCH=amd64 go build .

// Build for macOS on ARM64 (Apple Silicon)
// GOOS=darwin GOARCH=arm64 go build .

// Build for Linux on ARM (Raspberry Pi)
// GOOS=linux GOARCH=arm go build .

// Check current values
// go env GOOS GOARCH

Set GOOS and GOARCH environment variables: GOOS=target_os GOARCH=target_arch go build

Use -os and -arch flags

Use the -target flag

Cannot cross-compile

Question 5

How do you run Go tests?

package main

import "testing"

func Add(a, b int) int {
    return a + b
}

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

// Command line:
// go test
// go test -v
// go test -run TestAdd
// go test ./...

Use go test command in the package directory

Use go run with test files

Use go build with test flag

Cannot run tests

Question 6

What are build tags and how do you use them?

// +build linux

package main

import "fmt"

func main() {
    fmt.Println("This only compiles on Linux")
}

// Alternative syntax:
//go:build linux

package main

// Usage:
// go build .  // Only builds on Linux
// GOOS=linux go build .  // Forces Linux build

// Multiple tags:
// +build linux darwin
//go:build linux || darwin

Comments that control conditional compilation: //go:build tag

Runtime flags

Package names

Cannot control compilation

Question 7

How do you run verbose tests?

bash

func TestExample(t *testing.T) {
    t.Log("This will only show with -v")
    // Test logic
}

// Command line:
// go test -v
// Output:
// === RUN   TestExample
//     file_test.go:4: This will only show with -v
// --- PASS: TestExample (0.00s)
// PASS

// Without -v:
// PASS

Use go test -v flag

Use go test --verbose

Use go test -log

Cannot run verbose tests

Question 8

How do you build for multiple platforms at once?

bash

#!/bin/bash

# Build script for multiple platforms
platforms="linux/amd64 linux/arm64 darwin/amd64 darwin/arm64 windows/amd64"

for platform in $platforms; do
    IFS='/' read -r -a array <<< "$platform"
    GOOS="${array[0]}"
    GOARCH="${array[1]}"
    
    output_name="myapp-${GOOS}-${GOARCH}"
    if [ "$GOOS" = "windows" ]; then
        output_name+='.exe'
    fi
    
    echo "Building for $GOOS/$GOARCH..."
    GOOS=$GOOS GOARCH=$GOARCH go build -o $output_name .
    echo "Created $output_name"
done

Use shell scripts to iterate over GOOS/GOARCH combinations

Use go build -all flag

Use go build -multi flag

Cannot build for multiple platforms

Question 9

How do you run specific tests?

bash

func TestAdd(t *testing.T) {
    // Test addition
}

func TestSubtract(t *testing.T) {
    // Test subtraction
}

func TestMultiply(t *testing.T) {
    // Test multiplication
}

// Run specific test:
// go test -run TestAdd

// Run tests matching pattern:
// go test -run "Test(Add|Subtract)"

// Run all tests in package:
// go test

Use go test -run TestName or -run "pattern"

Use go test -only TestName

Use go test -filter TestName

Cannot run specific tests

Question 10

How do you create build tags for different environments?

//go:build debug

package main

import "fmt"

func main() {
    fmt.Println("Debug mode enabled")
    // Additional debug logging
}

//go:build !debug

package main

import "fmt"

func main() {
    fmt.Println("Production mode")
    // Optimized production code
}

// Build commands:
// go build -tags debug .
// go build .  // Production build

Use //go:build tags and go build -tags flag

Use environment variables

Use runtime flags

Cannot create environment-specific builds

Question 11

How do you run benchmarks in Go?

package main

import "testing"

func Fibonacci(n int) int {
    if n <= 1 {
        return n
    }
    return Fibonacci(n-1) + Fibonacci(n-2)
}

func BenchmarkFibonacci(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Fibonacci(10)
    }
}

// Command line:
// go test -bench=.
// go test -bench=BenchmarkFibonacci
// go test -bench=. -benchmem

Use go test -bench flag with Benchmark functions

Use go bench command

Use go test -perf flag

Cannot run benchmarks

Question 12

How do you build statically linked binaries?

bash

// Build statically linked binary
// CGO_ENABLED=0 go build -a -ldflags '-extldflags "-static"' .

// For scratch Docker images
// CGO_ENABLED=0 GOOS=linux go build -a -ldflags '-extldflags "-static"' .

// Check if binary is statically linked
// ldd ./myapp
// Should show "not a dynamic executable" or "statically linked"

// On macOS:
// go build -ldflags '-extldflags "-static"' .

Use CGO_ENABLED=0 and -ldflags '-extldflags "-static"'

Use go build -static flag

Use go build -link static

Cannot build statically linked binaries

Question 13

How do you use build tags for optional features?

//go:build json

package config

import "encoding/json"

func LoadJSON(data []byte) (Config, error) {
    var c Config
    return c, json.Unmarshal(data, &c)
}

//go:build !json

package config

func LoadJSON(data []byte) (Config, error) {
    return Config{}, fmt.Errorf("JSON support not compiled in")
}

// Usage:
// go build .                    // No JSON support
// go build -tags json .        // With JSON support

Use build tags to conditionally compile optional features

Use runtime feature flags

Use environment variables

Cannot implement optional features

Question 14

How do you run tests with race detection?

bash

func TestConcurrentMap(t *testing.T) {
    m := make(map[int]int)
    
    // This might have race conditions
    go func() {
        m[1] = 1
    }()
    
    go func() {
        m[2] = 2
    }()
    
    // Wait
    time.Sleep(time.Millisecond)
}

// Command line:
// go test -race
// Output: ==================
// WARNING: DATA RACE
// ...
// ==================

Use go test -race flag

Use go test -detect-race

Use go test -concurrency

Cannot detect race conditions

Question 15

How do you build with custom ldflags?

bash

// Set version info
// go build -ldflags "-X main.version=1.2.3 -X main.buildTime=$(date -u +'%Y-%m-%dT%H:%M:%SZ')" .

// Strip debug info for smaller binaries
// go build -ldflags "-s -w" .

// In code:
var (
    version   string
    buildTime string
)

func main() {
    fmt.Printf("Version: %s, Built: %s\n", version, buildTime)
}

Use -ldflags with linker flags like -X for variable injection

Use -flags

Use -linker

Cannot customize linking

Question 16

How do you run tests in parallel?

func TestParallel1(t *testing.T) {
    t.Parallel()  // Mark as parallel
    // Test logic
}

func TestParallel2(t *testing.T) {
    t.Parallel()  // Mark as parallel
    // Test logic
}

// Command line:
// go test -parallel 4  // Run 4 tests in parallel
// Default is GOMAXPROCS

// Package level parallel limit
func TestMain(m *testing.M) {
    // Setup
    code := m.Run()  // Runs tests
    // Cleanup
    os.Exit(code)
}

Use t.Parallel() in tests and go test -parallel flag

Use go test -concurrent

Use go test -multi

Cannot run tests in parallel

Question 17

How do you create build tags for operating system detection?

//go:build windows

package main

import (
    "fmt"
    "os/exec"
)

func openBrowser(url string) error {
    return exec.Command("cmd", "/c", "start", url).Run()
}

//go:build linux || darwin

package main

import (
    "fmt"
    "os/exec"
)

func openBrowser(url string) error {
    return exec.Command("xdg-open", url).Run()
}

// Usage:
// go build .  // Uses appropriate implementation

Use //go:build with GOOS values like windows, linux, darwin

Use runtime OS detection

Use environment variables

Cannot detect operating system at build time

Question 18

How do you run tests with coverage?

bash

func TestAdd(t *testing.T) {
    if Add(2, 3) != 5 {
        t.Fail()
    }
}

func TestSubtract(t *testing.T) {
    if Subtract(5, 3) != 2 {
        t.Fail()
    }
}

// Command line:
// go test -cover
// go test -coverprofile=coverage.out
// go tool cover -html=coverage.out

// Coverage output:
// PASS
// coverage: 75.0% of statements

Use go test -cover and -coverprofile flags

Use go test -coverage

Use go cover command

Cannot measure test coverage

Question 19

How do you build with specific Go versions?

// Specify Go version in go.mod
module example.com/myapp

go 1.21

// Or use GOTOOLCHAIN
// GOTOOLCHAIN=go1.21.0 go build .

// Check version
// go version
// Output: go version go1.21.0 ...

// Build with specific toolchain
// go build -ldflags "-X 'main.GoVersion=$(go version)'" .

Use go.mod go directive and GOTOOLCHAIN environment variable

Use go build -version flag

Use go build -go flag

Cannot specify Go version

Question 20

How do you use build tags for architecture-specific code?

//go:build amd64

package mathops

func Add(a, b int64) int64 {
    // AMD64 optimized version
    return a + b  // Could use SIMD instructions
}

//go:build arm64

package mathops

func Add(a, b int64) int64 {
    // ARM64 optimized version
    return a + b  // ARM-specific optimizations
}

// Usage:
// GOARCH=amd64 go build .  // Uses AMD64 version
// GOARCH=arm64 go build .  // Uses ARM64 version

Use //go:build with GOARCH values like amd64, arm64

Use runtime architecture detection

Use environment variables

Cannot optimize for specific architectures

Question 21

How do you run integration tests separately from unit tests?

// Unit test file: math_test.go
func TestAdd(t *testing.T) {
    // Unit test
}

// Integration test file: math_integration_test.go
//go:build integration

func TestDatabaseConnection(t *testing.T) {
    // Integration test
}

// Command line:
// go test .                    // Runs unit tests only
// go test -tags integration .  // Runs integration tests

// Or use build constraints:
// +build integration

func TestExternalAPI(t *testing.T) {
    // Integration test
}

Use build tags and separate test files for integration tests

Use go test -integration flag

Use different test functions

Cannot separate integration tests

Question 22

How do you create reproducible builds?

bash

# Reproducible build script
#!/bin/bash

# Set consistent environment
unset GOPATH
unset GOBIN

export CGO_ENABLED=0
export GOOS=linux
export GOARCH=amd64

# Use specific Go version
# GOTOOLCHAIN=go1.21.0

# Build with consistent flags
go build \
    -a \
    -ldflags "-s -w -X main.version=1.0.0" \
    -o myapp \
    .

# Calculate checksum
sha256sum myapp > myapp.sha256

Control environment variables, use consistent flags, and version pinning

Use random build flags

Use different Go versions

Cannot create reproducible builds

Question 23

How do you use build tags for feature flags?

//go:build enterprise

package features

func AdvancedAnalytics() {
    // Enterprise-only feature
    fmt.Println("Advanced analytics enabled")
}

//go:build !enterprise

package features

func AdvancedAnalytics() {
    fmt.Println("Advanced analytics requires enterprise license")
}

// Main application
package main

func main() {
    features.AdvancedAnalytics()
}

// Build commands:
// go build .                          // Community edition
// go build -tags enterprise .         // Enterprise edition

Use build tags to conditionally compile feature sets

Use runtime feature toggles

Use configuration files

Cannot implement feature flags

Question 24

How do you run benchmarks with memory allocation tracking?

bash

func BenchmarkStringConcat(b *testing.B) {
    var s string
    for i := 0; i < b.N; i++ {
        s += "x"  // Inefficient
    }
}

func BenchmarkStringBuilder(b *testing.B) {
    for i := 0; i < b.N; i++ {
        var sb strings.Builder
        for j := 0; j < 100; j++ {
            sb.WriteString("x")
        }
        _ = sb.String()
    }
}

// Command line:
// go test -bench=. -benchmem
// Output:
// BenchmarkStringConcat-8    1000000    1234 ns/op    2000 B/op    1000 allocs/op
// BenchmarkStringBuilder-8   2000000     567 ns/op     100 B/op       2 allocs/op

Use go test -benchmem flag to show memory allocations

Use go test -memory

Use go bench -alloc

Cannot track memory allocations

Question 25

How do you build minimal Docker images?

dockerfile

# Dockerfile for minimal Go image
FROM golang:1.21-alpine AS builder

WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download

COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -a -ldflags '-extldflags "-static"' -o main .

FROM scratch
COPY --from=builder /app/main /main

EXPOSE 8080
CMD ["/main"]

# Build command:
# docker build -t myapp .
# docker run -p 8080:8080 myapp

Use multi-stage builds with scratch base image and static linking

Use full Ubuntu images

Use dynamic linking

Cannot create minimal Docker images

Question 26

How do you use build tags for testing different implementations?

//go:build fast

package sort

func Sort(data []int) {
    // Fast but memory-intensive algorithm
    // Implementation...
}

//go:build !fast

package sort

func Sort(data []int) {
    // Slow but memory-efficient algorithm
    // Implementation...
}

// Test file
test_test.go
func TestSort(t *testing.T) {
    // Test both implementations
}

// Build and test:
// go test .              // Tests slow implementation
// go test -tags fast .   // Tests fast implementation

Use build tags to switch between different algorithm implementations

Use runtime switches

Use different packages

Cannot test different implementations

Question 27

How do you run tests with custom timeouts?

bash

func TestSlowOperation(t *testing.T) {
    if testing.Short() {
        t.Skip("Skipping slow test in short mode")
    }
    
    // Slow operation that might timeout
    time.Sleep(30 * time.Second)
}

// Command line:
// go test -timeout 60s          // 60 second timeout
// go test -short                 // Skip slow tests
// go test -timeout 10s -short    // Quick test run

// Default timeout is 10 minutes for long tests

Use go test -timeout flag and testing.Short() for conditional tests

Use go test -time flag

Use go test -duration

Cannot set test timeouts

Question 28

How do you create build tags for version-specific code?

//go:build go1.21

package main

import "fmt"

func main() {
    // Uses Go 1.21+ features
    fmt.Println("Using Go 1.21 features")
}

//go:build !go1.21

package main

import "fmt"

func main() {
    // Compatible with older Go versions
    fmt.Println("Compatible with older Go")
}

// Check Go version:
// go version
// Build automatically uses appropriate version

Use //go:build go1.X for version-specific code

Use runtime version checks

Use environment variables

Cannot create version-specific code

Question 29

How do you build with embedded files?

import _ "embed"

//go:embed static/*
var staticFiles embed.FS

//go:embed templates/*.html
var templates embed.FS

func main() {
    data, _ := staticFiles.ReadFile("static/style.css")
    fmt.Println("Embedded file size:", len(data))
}

// Build command:
// go build .
// Binary includes embedded files

// Without embedding:
// go build -ldflags "-X main.staticPath=./static" .

Use //go:embed directives and embed.FS

Use go build -embed flag

Use external files

Cannot embed files

Question 30

How do you optimize build times?

bash

# Build optimization tips

# Use build cache
# go build -o /tmp/cache .

# Parallel builds (default)
# go build .

# Disable CGO for faster builds
# CGO_ENABLED=0 go build .

# Use go build -x to see commands
# go build -x .

# Pre-download dependencies
# go mod download

# Use go.work for multi-module workspaces
go.work

use (
    ./module1
    ./module2
)

Use build cache, disable CGO, pre-download dependencies, use workspaces

Use slow build flags

Use single-threaded builds

Cannot optimize build times

Question 31

How do you run tests with custom test main?

func TestMain(m *testing.M) {
    // Setup code
    db := setupDatabase()
    defer db.Close()
    
    // Run tests
    code := m.Run()
    
    // Cleanup code
    cleanup()
    
    os.Exit(code)
}

func TestDatabaseOperation(t *testing.T) {
    // Test uses database set up in TestMain
}

// Command line:
// go test .  // TestMain runs automatically

// TestMain is called instead of default test runner

Implement TestMain function for custom setup and cleanup

Use go test -main flag

Use go test -setup

Cannot customize test execution

Question 32

How do you create build tags for CI/CD environments?

bash

//go:build ci

package main

import "fmt"

func main() {
    fmt.Println("Running in CI environment")
    // CI-specific logging, monitoring, etc.
}

//go:build !ci

package main

import "fmt"

func main() {
    fmt.Println("Running in development")
    // Development-specific behavior
}

// CI/CD pipeline:
# Build for CI
# go build -tags ci .

# Or set in environment:
# GOFLAGS="-tags=ci" go build .

Use build tags like 'ci' for environment-specific behavior

Use runtime environment detection

Use configuration files

Cannot differentiate CI/CD environments

Question 33

How do you run fuzz tests?

func FuzzAdd(f *testing.F) {
    f.Add(1, 2)  // Seed corpus
    f.Add(0, 0)
    f.Add(-1, 1)
    
    f.Fuzz(func(t *testing.T, a, b int) {
        result := Add(a, b)
        // Test properties
        if a > 0 && b > 0 && result <= 0 {
            t.Errorf("Positive + positive should be positive")
        }
    })
}

// Command line:
// go test -fuzz=FuzzAdd
// go test -fuzz=FuzzAdd -fuzztime=30s

// Fuzzing generates random inputs to find bugs

Use FuzzXXX functions and go test -fuzz flag

Use go test -fuzzing

Use go fuzz command

Cannot run fuzz tests

Question 34

How do you build with symbol table stripping?

bash

// Strip debug symbols for smaller binaries
// go build -ldflags "-s -w" .

// -s: Omit symbol table
// -w: Omit DWARF debug info

// Check binary size before/after
// ls -lh myapp

// For debugging builds:
// go build .  // Includes debug info

// Production builds:
// go build -ldflags "-s -w" .

Use -ldflags "-s -w" to strip symbols and debug info

Use go build -strip

Use go build -minimal

Cannot strip symbols

Question 35

What is the most important consideration for Go build tooling?

Choose appropriate tools for development vs production, understand cross-compilation, use build tags wisely, ensure reproducible builds

Always use default settings

Never use build tags

Only build for current platform

Other Quiz Categories

JavaScript

47 quizzes

Basics

Variables & Data Types

Operators & Expressions

Rust

30 quizzes

Cargo and Project Setup

Variables and Mutability

Data Types

Python

29 quizzes

Introduction & Core Fundamentals

Variables & Data Types

Operators & Expression

Java

22 quizzes

Java Basics & JVM Fundamentals

Variables, Data Types & Type Casting

Operators & Expressions

Matlab

21 quizzes

Basics & Environment

Variables and Data Type

Arrays and Matric

TypeScript

19 quizzes

Introduction and Overview

Installation and Configuration

Basic Types and Type Annotations

SQL Database

15 quizzes

Foundations and Basics

Basic Query Selection

Filter, Sort, and Alias Essentials

PHP

15 quizzes

Syntax Building Blocks

Node Structure and Pointer Fundamentals

Singly Linked List

QUIZZES IN Golang

Basics & Syntax

40 in-depth questions covering Go's fundamentals, packages, imports, syntax rules, variables, constants, comments, and formatting — with 10 code examples to solidify understanding.

Data Types & Zero Values

40 comprehensive questions on Go's built-in types, zero values, type inference, conversions vs casting, and aliased types — with 20 code examples to master type safety and initialization.

Operators & Expressions

40 comprehensive questions on Go's operators and expressions, covering arithmetic, comparison, logical, and bitwise operations — with 12 code examples exploring operator precedence, short-circuit evaluation, and practical usage patterns.

Control Flow

40 comprehensive questions on Golang's control flow statements, covering if-else, switch expressions, for loops, break/continue, and labeled statements — with 20 code examples demonstrating practical usage patterns and edge cases.

Functions

35 comprehensive questions on Golang functions, covering declarations, multiple returns, named returns, variadic functions, and pass-by-value semantics — with 18 code examples exploring function design patterns and parameter passing.

Pointers

50 comprehensive questions on Golang pointers, covering pointer basics, types, nil pointers, receiver semantics, and common pitfalls — with 15 code examples demonstrating pointer operations and memory management.

Structs

40 comprehensive questions on Golang structs, covering struct creation, methods, embedded structs, anonymous structs, and value vs reference behavior — with 20 code examples demonstrating struct operations and composition.

Interfaces

35 comprehensive questions on Golang interfaces, covering interface basics, implicit implementation, empty interface, type assertions, and type switches — with 18 code examples demonstrating interface usage and polymorphism.

Methods & Receivers

35 comprehensive questions on Golang methods and receivers, covering value vs pointer receivers, method sets, interface satisfaction, and practical usage patterns — with 18 code examples demonstrating method behavior and common scenarios.

Arrays & Slices

40 comprehensive questions on Golang arrays and slices, covering fixed-size arrays, slice creation, capacity & length, internals, and copying operations — with 18 code examples demonstrating array and slice behavior.

Maps

35 comprehensive questions on Golang maps, covering map creation, key existence checking, entry deletion, iteration order, and reference behavior — with 18 code examples demonstrating map operations and common patterns.

Strings & Runes

35 comprehensive questions on Golang strings and runes, covering UTF-8 basics, rune vs byte differences, string immutability, manipulation techniques, and conversion operations — with 18 code examples demonstrating string handling patterns.

Error Handling

40 comprehensive questions on Golang error handling, covering error values, custom error types, fmt.Errorf with wrapping, sentinel vs typed errors, and errors.Is & errors.As — with 18 code examples demonstrating error handling patterns.

Packages & Modules

35 comprehensive questions on Golang packages and modules, covering package creation, exported vs unexported identifiers, Go modules usage, dependency management, and versioning rules — with 18 code examples demonstrating package organization and module management.

Concurrency Goroutines

40 comprehensive questions on Golang goroutines, covering goroutine creation, spawning, stack management, leaks, and best practices — with 18 code examples demonstrating concurrent programming patterns and common pitfalls.

Concurrency Channels

35 comprehensive questions on Golang channels, covering unbuffered and buffered channels, directions, closing, and patterns — with 18 code examples demonstrating channel usage in concurrent programming.

Select Statement

35 comprehensive questions on Golang's select statement, covering multiplexing channels, timeouts, non-blocking operations, fan-in/fan-out patterns, and handling closed channels — with 18 code examples demonstrating advanced channel operations.

Synchronization Tools

35 comprehensive questions on Golang's synchronization tools, covering sync.Mutex, sync.RWMutex, sync.WaitGroup, sync.Once, and common race-condition mistakes — with 18 code examples demonstrating thread-safe patterns.

Context Package

35 comprehensive questions on Golang's context package, covering context.Background() & TODO(), context cancellation, deadlines & timeouts, passing values, and best practices — with 18 code examples demonstrating proper context usage.

Memory Model

45 comprehensive questions on Golang's memory model, covering stack vs heap allocation, escape analysis, allocation patterns, garbage collection basics, and avoiding unnecessary allocations — with 25 code examples demonstrating memory management techniques.

Testing & Unit Test

40 comprehensive questions on Golang's testing framework, covering the testing package, writing unit tests, table-driven tests, benchmarks with go test -bench, and test coverage tools — with 20 code examples demonstrating testing best practices.

File I/O & OS Interactions

35 comprehensive questions on Golang's file I/O and OS interaction capabilities, covering file reading/writing, os package usage, streams & buffers, directory operations, and environment variables — with 18 code examples demonstrating practical file and OS operations.

Networking & HTTP

40 comprehensive questions on Golang's networking and HTTP capabilities, covering basic HTTP servers, HTTP clients, request/response lifecycle, JSON marshalling/unmarshalling, and REST API patterns — with 20 code examples demonstrating practical networking operations.

Goroutine-Safe Patterns

35 comprehensive questions on Golang's goroutine-safe patterns, covering worker pools, producer/consumer patterns, pipeline design, avoiding shared state, and concurrency design pitfalls — with 15 code examples demonstrating safe concurrent programming practices.

Reflection

35 comprehensive questions on Golang's reflection capabilities, covering reflect.Type & reflect.Value usage, value modification, kind checking, performance considerations, and when to avoid reflection — with 15 code examples demonstrating practical reflection techniques.

Generics

35 comprehensive questions on Go's generics system introduced in Go 1.18, covering type parameters, generic functions, generic types, type constraints, and their benefits and limitations — with 15 code examples demonstrating practical generic programming patterns.

Build & Run Tooling

Modules & Dependency Tools

Test your knowledge of Golang modules and dependency management tools. This quiz covers go mod tidy, go mod vendor, reproducible builds, semantic import versioning, and private modules.

Best Practices & Idioms

Test your knowledge of Golang best practices and idiomatic patterns. This quiz covers idiomatic naming, error-first return style, avoiding global state, composition over inheritance, and profiling & performance tuning.

Golang Build & Run Tooling Quiz

Question 1

Question 2

Question 3

Question 4

Question 5

Question 6

Question 7

Question 8

Question 9

Question 10

Question 11

Question 12

Question 13

Question 14

Question 15

Question 16

Question 17

Question 18

Question 19

Question 20

Question 21

Question 22

Question 23

Question 24

Question 25

Question 26

Question 27

Question 28

Question 29

Question 30

Question 31

Question 32

Question 33

Question 34

Question 35

About This Golang Build & Run Tooling Quiz

What You Will Practise

Other Quiz Categories

QUIZZES IN Golang

Basics & Syntax

Data Types & Zero Values

Operators & Expressions

Control Flow

Functions

Pointers

Structs

Interfaces

Methods & Receivers

Arrays & Slices

Maps

Strings & Runes

Error Handling

Packages & Modules

Concurrency Goroutines

Concurrency Channels

Select Statement

Synchronization Tools

Context Package

Memory Model

Testing & Unit Test

File I/O & OS Interactions

Networking & HTTP

Goroutine-Safe Patterns

Reflection

Generics

Build & Run Tooling

Modules & Dependency Tools

Best Practices & Idioms