Golang Packages & Modules Quiz

0 Passed

0% acceptance

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.

35 Questions

~70 minutes

Question 1

What is a package in Golang?

A collection of Go source files in the same directory

A single .go file

A compiled binary

A Go module

Question 2

How do you declare a package?

package main

import "fmt"

func main() {
    fmt.Println("Hello")
}

package packagename at top of every .go file

package "name" in go.mod

Use import statement

No declaration needed

Question 3

What is the difference between exported and unexported identifiers?

Exported: starts with capital letter, visible outside package

Exported: starts with lowercase, visible outside

No difference in visibility

Depends on package name

Question 4

What happens when you try to access an unexported identifier from another package?

package main

import "mypackage"

func main() {
    mypackage.unexportedFunc()  // Error
}

Compilation error - identifier not exported

Works at runtime

Warning but compiles

Depends on build tags

Question 5

What is a Go module?

A collection of Go packages with dependency management

A single package

A compiled library

A Go workspace

Question 6

How do you initialize a Go module?

bash

go mod init example.com/myproject

go mod init module-path

go init module-path

go mod create module-path

No initialization needed

Question 7

What is the go.mod file?

module example.com/myproject

go 1.21

require (
    github.com/some/lib v1.0.0
)

Module definition with dependencies and Go version

Package source code

Build configuration

Test file

Question 8

How do you add a dependency to a module?

bash

go get github.com/some/[email protected]

go get package@version

go add package@version

Edit go.mod manually

Use go mod add

Question 9

What does go mod tidy do?

Adds missing dependencies, removes unused ones

Formats go.mod file

Updates all dependencies

Creates vendor directory

Question 10

What is semantic versioning in Go modules?

vMAJOR.MINOR.PATCH with breaking changes in MAJOR

Any version numbering scheme

Only patch versions allowed

No versioning required

Question 11

In a team project, you're creating a shared utility package. How should you name exported functions?

Start with capital letter: ValidateEmail, not validateEmail

Use lowercase for all functions

Use underscores: validate_email

Name doesn't affect export

Question 12

What is the difference between internal and regular packages?

text

project/
├── internal/
│   └── utils/
│       └── helper.go
└── pkg/
    └── api/
        └── client.go

internal packages only importable by parent directories

internal packages are hidden

No difference

internal is deprecated

Question 13

How do you import a package?

package main

import (
    "fmt"
    "github.com/user/mylib"
)

func main() {
    fmt.Println(mylib.SomeFunc())
}

import "module/path" or "standard/package"

include "package"

use "package"

No import needed

Question 14

What is vendoring in Go?

Copying dependencies into vendor/ directory

Selling Go packages

Creating package documentation

Publishing to pkg.go.dev

Question 15

How do you update a dependency to latest version?

bash

go get github.com/some/package@latest

go get package@latest

go update package

go mod upgrade package

Edit go.mod manually

Question 16

What is the go.sum file?

Cryptographic checksums of dependencies

Summary of go.mod

Build output

Test results

Question 17

In a library you're publishing, how should you version releases?

Use git tags like v1.2.3 for releases

Use any tagging scheme

No tagging needed

Use branches for versions

Question 18

What is a replace directive in go.mod?

module example.com/myproject

go 1.21

require github.com/some/lib v1.0.0

replace github.com/some/lib => ./local/fork

Replace dependency with local version

Rename a dependency

Update dependency version

Remove dependency

Question 19

How do you create a package with multiple files?

text

mypackage/
├── utils.go
├── types.go
└── constants.go

Put all .go files in same directory with same package declaration

Use one file per package

Use subdirectories

Cannot split packages

Question 20

In a microservices architecture, you're creating shared packages. Should you use internal/ or pkg/ for shared utilities?

pkg/ for public APIs, internal/ for private implementation

internal/ for all shared code

pkg/ for all shared code

No difference

Question 21

What is the GOPROXY environment variable?

URL of Go module proxy for downloading dependencies

Path to Go installation

Go workspace directory

Go binary path

Question 22

How do you handle incompatible dependency versions?

bash

go mod edit -require=github.com/[email protected]

Use go mod edit to specify exact versions

Use replace directive

Cannot handle incompatible versions

Use go get with force flag

Question 23

What is the difference between go.mod and go.sum?

go.mod: dependencies, go.sum: checksums for security

go.mod: checksums, go.sum: dependencies

They are identical

go.sum is optional

Question 24

How do you publish a Go module?

bash

git tag v1.0.0
git push origin v1.0.0

Create git tag with v prefix and push

Upload to pkg.go.dev

Use go mod publish

No publishing needed

Question 25

What is a major version change in semantic versioning?

Breaking API changes require v2, v3, etc.

Any new features

Bug fixes only

No major versions in Go

Question 26

How do you organize a large Go project?

text

project/
├── cmd/
│   └── server/
├── internal/
│   └── database/
├── pkg/
│   └── api/
└── go.mod

cmd/ for binaries, internal/ for private, pkg/ for public

All code in root directory

Use submodules

No organization needed

Question 27

What happens when you import an unused package?

package main

import (
    "fmt"
    "unused/package"  // Not used
)

func main() {
    fmt.Println("Hello")
}

Compilation error - unused import

Warning but compiles

Works fine

Runtime error

Question 28

How do you import for side effects only?

import _ "github.com/lib/drivers"

import _ "package" - blank identifier ignores import

import "package" as usual

Cannot import for side effects

Use import side "package"

Question 29

What is the GOSUMDB environment variable?

Checksum database for verifying dependencies

Go source directory

Module cache location

Go binary database

Question 30

In a CI/CD pipeline, how should you cache Go dependencies?

Cache $GOPATH/pkg/mod and go.sum

Cache entire GOPATH

No caching needed

Cache source code only

Question 31

What is the difference between require and replace in go.mod?

require github.com/lib v1.0.0
replace github.com/lib => ./fork

require: needed dependency, replace: use different version/path

require: local path, replace: remote

They are identical

replace is deprecated

Question 32

How do you work with private modules?

bash

go env -w GOPRIVATE=example.com/private/*

Set GOPRIVATE to skip proxy/checksum for private repos

Use go mod private

Private modules not supported

Use different module path

Question 33

What is minimal module compatibility?

Modules work with newer Go versions than specified

Modules require exact Go version match

Modules don't specify Go version

Backward compatibility only

Question 34

How do you debug module issues?

bash

go mod why github.com/some/package
go list -m all

go mod why shows why dependency is needed

go mod debug

Check go.mod manually

Cannot debug modules

Question 35

What is the most important principle for Go package design?

Clear API boundaries, consistent naming, minimal dependencies

Maximize exported functions

Use global variables

Avoid interfaces

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

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

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.

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 Packages & Modules 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 Packages & Modules 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