@samber
Software Engineer | Go Open-sourcer | GenAI community leader
46 skills1 repository 3.6K
Build GraphQL APIs in Go with gqlgen or graphql-go. Covers schemas, resolvers that fetch field data, authentication, and live subscriptions, plus request-level data batching and query limits to address excessive database calls and resource use.
Design how Go requests carry cancellation signals, time limits, and request metadata through application layers. Helps investigate work that continues after cancellation, choose suitable context types, and separate background tasks from the request lifecycle.
Restructure existing Go code while preserving its behavior. Uses gopls, Go's code analysis tool, to map affected code and apply changes, with targeted tests and small pull requests for renaming, extracting functions, and moving code between packages.
Write, review, audit, and debug Go tests that check observable behavior. Covers named test cases, integration test isolation, concurrent execution, race and goroutine leak detection, and finding causes of intermittent failures or gaps in test coverage.
Build Go services with uber-go/fx by connecting components and managing startup and shutdown. This skill covers dependency injection, which supplies components with what they need, plus reusable modules, signal handling, logging, and tests with substitute dependencies.
Helps wire Go applications with uber-go/dig using dependency injection, which supplies the components each function needs. Covers constructor registration, named values, groups, and validation so startup dependencies can be organized and checked in tests.
Add production monitoring to Go services using structured logs, metrics, request traces, continuous performance profiles, and user events. Connect these signals with alerts and dashboards to understand service behavior and investigate operational problems.
Choose Go libraries and frameworks for web, database, testing, logging, and messaging tasks. Compare candidates with standard library options, checking maintenance, licenses, adoption, and dependency complexity before deciding what to add to a project.
Helps implement structured error handling in Go with samber/oops. Add diagnostic attributes, stack traces showing the call path, and error codes, while keeping user-facing messages separate from technical details and integrating errors with logging.
Build and extend Go command-line tools with spf13/cobra. Organizes commands and options, validates arguments, adds shell completion suggestions, customizes help, and tests command behavior with captured output and isolated command instances.
Navigate and refactor Go code with gopls, the official service for understanding Go source. Find definitions, references, and package APIs, then rename or restructure code and check diagnostics against the locally resolved project and dependencies.
Use samber/mo in Go to represent missing values, failures, and alternative value types explicitly. Learn to choose Option, Result, or Either and combine processing steps, including pipelines where each step changes the value's type.
Manage dependencies in Go projects, from evaluating a new package to updating versions and resolving conflicts. It covers module files, known vulnerability checks, dependency size audits, and workspaces for developing multiple modules together.
Measure Go performance by writing benchmarks, examining CPU and memory profiles, and comparing repeated runs with benchstat. Use the results to assess code changes, detect slowdowns in CI, and investigate production performance.
Write, review, and debug Go database access code with guidance on parameterized queries, transactions, connection pools, and tests. Covers database/sql, sqlx, and pgx, while leaving schema creation and migration SQL outside its scope.
Design Go services with dependency injection: passing required components in from outside. Compare manual wiring with DI libraries, generate setup code, and plan changes to tightly coupled services so their dependencies and lifecycle are explicit.
Write and review Go error handling so failures carry useful context and are handled once. Covers error creation, wrapping, inspection, panic usage, and structured logging, where named fields help organize and search production logs.
Review older Go code and plan updates to language features, standard libraries, tests, and CI. The skill checks the project's Go version, prioritizes safety and correctness, and guides changes with linting and tests.
Look up published Go packages with godig, a client for pkg.go.dev. Retrieve function signatures, documentation, examples, available versions, licenses, known vulnerabilities, and importing packages through read-only queries that require no authentication.
Organize Go projects with directory layouts, naming rules, and configuration files suited to their size and purpose. Supports command-line tools, libraries, services, and workspaces for developing several related modules together.
Review Go code for accidental crashes and silent data corruption. This skill guides safer handling of nil values, shared slice storage, numeric conversions, resource cleanup, and types that work safely without explicit initialization.
Implement Go collection transformations with samber/lo, including filtering, grouping, aggregation, and deduplication. Choose between standard library functions and helpers, and assess parallel processing, input mutation, or lazy evaluation when data size and measured performance justify them.
Build Go pipelines with samber/ro for events that arrive over time. Choose how consumers share data, combine multiple sources, and handle retries, timeouts, errors, and cancellation while managing the resources used by ongoing streams.
Implement layered configuration in Go with spf13/viper, combining command flags, environment variables, and configuration files under a fixed priority order. Covers mapping values into structs, reloading changed files, and keeping configuration state separate across tests.
Is this your account? Link GitHub to bring it onto your creator page (Japanese)