liveBookmanning.com

What you will learn in Learn Go with Pocket-Sized Projects

by Aliénor Latour, Donia Chaiehloudj, and Pascal Bertrand
Foreword by Ron Evans

Read it on liveBook Get the book at manning.com

Chapter by chapter

Concepts explained in this book

• HTTP response codeAn HTTP status code is a standardized numeric response indicator describing the result of an HTTP request.
• testA test case is a defined test scenario containing inputs and the expected result of execution.
• httptesthttptest is Go's standard-library package for testing HTTP clients and servers with in-memory or local test infrastructure.
• contractAn API is a defined interface through which software components or services communicate and request functionality or data.
• endpointAn HTTP endpoint is a server-accessible interface identified by an HTTP method and request target that processes web requests.
• http.ResponseWriterhttp.ResponseWriter is a Go interface through which an HTTP handler constructs a response, including its headers, status, and body.
• net/http packagenet/http is Go's standard-library package providing HTTP client and server implementations.
• channelA channel is a Go communication mechanism that allows goroutines to exchange typed values and synchronize execution.
• MapAn associative array is a collection that associates keys with values rather than using only positional indexes.
• handlerAn HTTP handler is a function or component that receives an HTTP request and produces an HTTP response.
• routingA multiplexer is a web-serving component or library that matches incoming requests to handlers and manages their routing.
• templateA template is a structured representation that combines static text with placeholders for dynamic values and can be parsed and executed to produce output.
• http.HandleFuncHandleFunc is a ServeMux method that registers a function as the handler for a specified HTTP pattern.
• currencyA currency is a monetary system whose units and denomination rules determine how amounts are represented and valued.
• habit entityA habit entity is a tracked behavior represented by a name and a weekly frequency.
• cachingA cache is a data store that retains reusable results or data to reduce access time or computational cost.
• RESTREST is an architectural style that defines resources and interactions with them through uniform representations and HTTP semantics.
• internal directoryAn internal package is a Go package that can be imported only by code within its permitted parent directory tree.
• precisionNumeric precision is the degree of detail or significant accuracy with which a numerical value is represented or computed.
• request messagePOST is an HTTP method for submitting data or requesting a server-side action that may change state.
• goroutineA goroutine is a lightweight independently executing function managed by the Go runtime.
• currency exchange rateAn exchange rate is a numeric ratio specifying how much of one currency corresponds to a unit of another currency.
• curlcurl is a command-line tool for transferring data to and from network services, including HTTP servers.
• httptest.ResponseRecorderResponseRecorder is a Go HTTP testing utility that records the status, headers, and body produced by a handler.
• WriteHeaderWriteHeader is an HTTP response-writer method that sends a specified status code and headers to the client.
• integration testIntegration testing evaluates interactions between multiple components or a component and an external dependency as an integrated system.
• serverAn HTTP server is software that accepts HTTP requests and returns responses over the HTTP protocol.
• race conditionA race condition is a correctness fault in which the result depends on the timing or interleaving of concurrent operations.
• clientA client is a computer or software process that requests services or resources from a server over a network.
• lockingMutual exclusion is the property that prevents more than one execution context from accessing a protected resource at the same time.
• HTTP methodAn HTTP method identifies the intended operation of an HTTP request, such as retrieving or submitting a resource.
• failureAn error as a value is an explicit value representing an operation failure that code returns and handles directly.
• monetary amountAn amount is a monetary value whose numeric representation is interpreted with a currency and subject to supported precision constraints.
• genericsA parameterized type is a type declaration that includes type parameters and can be instantiated with concrete types.
• text/template packageA Go template is a text-processing specification whose actions are evaluated against supplied data to produce formatted output.
• range clauseA range action is a Go template directive that iterates over a rangeable value and optionally binds an index or key and an element value within a scoped block.
• contextcontext.Context is a Go interface carrying cancellation signals, deadlines, and request-scoped values across function and service boundaries.
• http.ServeMuxServeMux is the net/http request multiplexer that matches requests to registered handlers.
• couplingCoupling is the degree to which software components depend on one another and therefore must change together.
• testifytestify is a Go testing library that provides assertions, requirements, and related test utilities.
• testify/asserttestify/assert is a Go assertion library that reports failed test conditions without immediately stopping the test.
• testify/requiretestify/require is a package providing fatal test assertions that stop the current test when a condition fails.
• user-defined typeA custom type is a programmer-defined Go type that gives a distinct name and type identity to an underlying representation.
• html/template packagehtml/template is Go's standard-library package for parsing and executing HTML templates with contextual escaping of HTML-sensitive content.
• template dotThe dot operator in Go templates denotes the current data value passed to the template or action.
• for-select patternThe for-select pattern repeatedly waits for channel communication or control signals within a loop.
• json.DecoderA JSON decoder is a stateful component that reads JSON input and populates Go values from it.
• table-driven testTable-driven testing is a testing technique that represents multiple input-output scenarios as structured test cases processed by shared test logic.
• flashingFlashing is the process of deploying a compiled executable to a programmable hardware device's persistent memory.
• errors.Iserrors.Is is a Go standard-library function that reports whether an error matches a target error through direct or wrapped identity.
• parameterA query parameter is an optional key-value component of a URL that supplies filtering or other request options to an API.
• HTMLHTML is the standard markup language used to structure documents and applications displayed by web browsers.
• close functionThe close function is a Go built-in that marks a channel as closed so that no more values can be sent on it and receivers can detect completion.
• GoGo is a statically typed programming language designed for readable, maintainable, compiled software, especially concurrent and networked systems.
• zero valueA zero value is the default value assigned to a Go variable or returned for an absent or uninitialized value of its type.
• go:embed directivego:embed is a Go compiler directive that embeds the contents of files into variables during compilation.
• stubA stub is a minimal test double that provides a simplified implementation of a dependency, typically with predetermined behavior.
• LoggerA logger is a software component that records application messages, typically with severity levels and formatted output.
• repository patternThe repository pattern is an abstraction that mediates between an application’s domain model and persistent data storage.
• build tagA build tag is a source-file constraint that controls whether the file is included for a particular build configuration.
• protocol bufferProtobuf is a language-neutral, platform-neutral mechanism for serializing structured data using defined message schemas.
• anticorruption layerAn anti-corruption layer is an integration boundary that translates an external model into a domain's internal model while preventing unwanted coupling.
• UpsertUpsert is the example cache operation that inserts a key-value entry or replaces the existing entry for that key.
• ExecuteExecute is a Go template API method that evaluates a parsed template against supplied data and writes the rendered result.
• hexagonal architectureHexagonal architecture is a software architecture pattern that isolates core application logic from external systems through defined interfaces.
• pixelA pixel is an individual picture element occupying one position in a raster image grid and carrying a value such as a color.
• http.HandlerFunchttp.HandlerFunc is Go's net/http function adapter type for handling an HTTP request and writing its response.
• TinyGo playgroundTinyGo playground is a web-based environment for compiling and simulating TinyGo programs on virtual microcontroller boards.
• route parameterA path parameter is a required value encoded as part of a URL path and used to identify or select a resource.
• struct tagA struct tag is metadata attached to a Go struct field that directs packages such as encoding/xml or encoding/json how the field maps to encoded data.
• go testThe Go test framework is the standard framework that discovers, executes, and reports Go package tests.
• embedThe embed package is Go's standard-library package for embedding files and directories into a compiled program.
• enumAn enumeration is a finite set of named values representing alternatives of the same conceptual kind.
• select statementA select statement is a Go control-flow construct that chooses among channel send, channel receive, and optional default cases that are ready to proceed.
• decimalDecimal is the book's custom Go type for representing the numeric quantity of a monetary amount independently of its currency.
• minimockMinimock is a Go mocking library that generates mock implementations and supports configurable expectations and behavior.
• Arduino Nano 33 IoTArduino Nano 33 IoT is a microcontroller development board based on the SAMD21 microcontroller and providing wireless connectivity and accessible I/O pins.
• thread safetyThread safety is the property that permits concurrent execution by multiple threads without causing incorrect behavior or data races.
• syscall/jsThe js package is the Go WebAssembly interoperability package that represents JavaScript values and exposes calls between Go and JavaScript.
• errorsThe errors package is Go's standard-library package for creating, wrapping, comparing, and inspecting error values.
• regular expressionA regular expression is a pattern notation for matching and extracting text according to specified character and sequence rules.
• go mod edit -replaceA module replacement is a Go module configuration that makes dependency resolution use an alternate module path or local directory, optionally at a specified version.
• case statementA switch statement selects among multiple execution branches by evaluating an expression against case conditions.
• api callAn HTTP request is a message sent by an HTTP client to ask a server to perform an operation or provide a resource.
• payloadA request body is the content-bearing part of an HTTP request that carries data submitted to a server.
• image.RGBAAn RGBA image is a raster image whose pixels contain red, green, blue, and alpha components.
• PathValuePathValue is an HTTP request method that returns the value associated with a named wildcard path parameter.
• buffered channelA buffered channel is a Go channel that can hold a bounded number of values without an immediately corresponding receive.
• bufio.Readerbufio.Reader is a Go buffered reader that reduces underlying read operations by buffering input.
• StringerThe Stringer interface is the fmt convention satisfied by a type with a parameterless String method returning a string.
• JSONJSON is a text-based data interchange format that represents structured values such as objects, arrays, strings, numbers, booleans, and null.
• WaitGroupsync.WaitGroup is a Go synchronization type that allows one goroutine to wait for a collection of goroutines to finish.
• mazeA maze is a spatial puzzle consisting of connected and obstructed routes arranged so that a path must be found between designated locations.
• comparablecomparable is Go's predeclared generic constraint satisfied by types whose values can be compared with == or !=.
• data raceA data race is a concurrency defect in which multiple execution contexts access the same memory concurrently and at least one access modifies it without adequate synchronization.
• dependency injectionDependency injection is a technique in which an object or component receives its required dependencies from outside rather than constructing them internally.
• anonymous structAn anonymous struct is a Go struct type declared without a named type identifier.
• crypto/rand packagecrypto/rand is Go's standard-library package for generating cryptographically secure random values from system entropy sources.
• math/randmath/rand is a Go standard-library package for generating pseudorandom values for non-security-sensitive uses.
• errgroup.Grouperrgroup.Group is a Go synchronization type that coordinates goroutines and reports an error from a failed goroutine.
• validationInput validation is the process of checking submitted data against required formats, types, and value constraints before processing it.
• proto fileA .proto file is a text file that declares Protobuf message schemas and service interfaces for code generation.
• HTTP GETGet is a url.Values method that returns the first value associated with a specified query parameter key.
• gRPCgRPC is a remote procedure call framework for communicating between distributed services.
• sentinel errorA sentinel error is a predefined error value or type that callers can compare or check to identify a specific domain condition.
• standard inputStandard input is the conventional input stream from which a command-line process reads textual or other data.
• timeoutA timeout is a configured limit on how long an operation may wait before it is interrupted or reported as failed.
• loopA for loop is Go's looping construct for repeatedly executing a block with optional initialization, condition, and post-iteration expressions.
• slicingA slice is a dynamically sized view over the elements of an underlying Go array, represented by a pointer, length, and capacity.
• encoding/xmlencoding/xml is Go's standard-library package for encoding and decoding XML data.
• snapshot comparisonA golden file is a test fixture containing expected output that is compared with output produced by software.
• monitoringLogging is the practice of recording information about a program's execution for later inspection or analysis.
• type constraintA type constraint is an interface-based restriction specifying which types may be used as a generic type argument.
• errors.Aserrors.As is a Go function that finds an error assignable to a target type and stores it through the supplied target pointer.
• arrayAn array is a Go sequence of a fixed number of values of one type whose length is part of its type.
• iotaiota is a Go predeclared identifier that produces successive integer constants within a constant declaration.
• serializationMarshal is an operation that converts a structured program value into an encoded byte sequence.
• GIFGIF is an image file format that supports palette-based graphics and animation through multiple frames.
• entry pointThe main function is the parameterless Go entry-point function executed when a program runs.
• template actionA template action is a delimited instruction in a template that evaluates data, control flow, definitions, or function calls.
• makemake is a Go built-in function that initializes slices, maps, or channels with specified size-related parameters.
• deferdefer is a Go language feature that schedules a function call to execute when the surrounding function returns.
• deadlineDeadline is a context.Context method that reports whether a deadline is set and returns its time when present.
• exported fieldAn exposed field is a structure field whose visibility permits a template to access its value.
• js.FuncOfjs.FuncOf is a syscall/js function that wraps a Go function so it can be called from JavaScript.
• constructor methodA constructor is a mechanism or operation that creates and initializes an instance of a type.
• grpcurlgrpcurl is a command-line tool for interacting with gRPC services similarly to how curl interacts with HTTP services.
• go:generate directiveA go:generate directive is a specially formatted Go source comment that specifies a command for go generate to execute.
• golang.org/x/image/drawgolang.org/x/image/draw is a Go image-drawing package that provides scaling and interpolation operations beyond the standard image/draw package.
• interpolationPixel interpolation estimates output pixel colors when an image is resized to a different resolution.
• paletted imageA paletted image stores each pixel as an index into a finite color palette rather than as direct color components.
• context packageThe context package is Go's standard-library package providing context types and functions for cancellation, deadlines, and request-scoped values.
• RGBA colorRGBA is a color representation that specifies red, green, blue, and alpha channels for each pixel.
• packageA Go package is a collection of related source files in one directory that share a package name and provide a scope for declarations.
• Document Object ModelThe DOM, or Document Object Model, is a programming interface representing an HTML or XML document as an object tree that scripts can inspect and modify.
• UTF-8UTF-8 is a variable-width Unicode encoding that represents characters as sequences of one to four bytes.
• stringA string is a Go value type representing a sequence of bytes, conventionally used for textual data.
• maze entranceA maze entrance is the designated starting point from which a maze is traversed.
• immutable collectionImmutability is the property of a value or object whose state cannot be changed after construction.
• logging levelA log level is a category indicating the importance or severity of a recorded log message.
• define actionA define action is a Go template action that declares a named template body terminated by an end action.
• ExecuteTemplateExecuteTemplate is a Go template API method that renders a specifically named template with supplied data.
• flag packageThe flag package is a Go standard-library package for parsing command-line flags and converting their values to supported types.
• with actionA with action is a template control-flow action that conditionally changes the current dot to a specified value within a block.
• compiler directiveA compiler directive is a source-level instruction that affects compilation or directs related tooling without being an ordinary executable statement.
• regexp packageregexp is Go's standard-library package for compiling and applying regular expressions.
• timestampA timestamp is a value representing a specific point in time, typically including date, time, and time-zone offset information.
• command-line argumentA command-line parameter is an argument supplied to a program when it is invoked from a command-line interface.
• structA struct is a Go composite data type that groups named fields of potentially different types into one value.
• parallelismParallel programming is a programming technique in which multiple computations execute concurrently to perform work at the same time.
• go generatego generate is a Go command that executes source-code generation directives found in comments.
• protocprotoc is the Protocol Buffers compiler that parses .proto schemas and invokes generators to produce source code.
• port numberA network port is a numbered endpoint that identifies a service or connection on a host.
• test fixtureA test fixture is prepared input or reference data used to evaluate software under test.
• TinyGoTinyGo is a Go compiler designed to produce small binaries for resource-constrained systems and environments.
• deadlockA deadlock is a concurrency failure in which execution cannot make progress because goroutines remain blocked waiting for events that cannot occur.
• encoding/jsonencoding/json is Go's standard-library package for encoding and decoding JSON data.
• ListenAndServeListenAndServe is a Go server API that starts accepting network connections and returns an error when serving stops or fails.
• concurrencyConcurrency is the structuring and execution of multiple computational activities that can make progress during overlapping periods.
• missing valuenil is Go's predeclared zero-like value representing the absence of a valid reference, interface value, or other applicable value.
• methodA method is a function associated with a type or object that can operate on its data or behavior.
• decodeDecode is a JSON decoder method that reads JSON input and stores the decoded result in a supplied Go value.
• queueFirst-in-first-out eviction removes entries from a cache in the order in which they were inserted, evicting the oldest entry first.
• Hello, World programA hello, world program is a minimal introductory program that outputs a greeting message.
• generalized forThe for keyword introduces Go's looping construct for repeated or range-based execution.
• testing packageThe Go testing package provides support for automated tests, benchmarks, and related test execution features.
• synchronization pointA synchronization point is a program event at which concurrent execution activities coordinate or signal completion.
• value receiverA value receiver is a method receiver passed as a value, so invoking the method operates on a copy of the receiver.
• ParseFSParseFS is a Go template API method that parses templates from files obtained through an io/fs file system.
• type inferenceType inference is the compiler's deduction of a generic type argument from the types of a function's input arguments.
• os.ReadFileos.ReadFile is a Go standard-library function that reads an entire file and returns its contents as bytes or an error.
• flag.Parseflag.Parse is a Go flag-package function that parses command-line arguments and stores the resulting values in registered flag variables.
• multiple template argumentsMultiple template arguments are several logically distinct values combined into one data value so a template can access them during execution.
• timeThe time package is Go's standard-library package for measuring and displaying time and handling calendar-based calculations.
• mockingA mock is a test double that imitates a component's interface while allowing interactions or outputs to be controlled and inspected.
• domain errorA domain error is an error representing an invalid condition or exceptional outcome specific to an application's problem domain.
• subunitA subunit is a fractional monetary unit used to represent a currency amount more precisely than the principal unit.
• HTML escapingHTML escaping transforms characters with special meaning in HTML into safe representations that are treated as text rather than markup or code.
• whitespace trimmingWhitespace trimming is a template syntax feature that removes whitespace adjacent to an action delimiter.
• example functionA Go example function is a specially named function that demonstrates code usage and can be executed by Go's test tooling when it declares expected output.
• go commandGo tooling is the integrated suite of Go development tools for formatting, linting, testing, benchmarking, building, and execution.
• runeA rune is Go's value type representing a single Unicode code point.
• gRPC serviceA gRPC service is a Protocol Buffers declaration that groups remotely callable methods and defines their service interface.
• template engineA template engine is software that processes templates by evaluating embedded actions and substituting resulting values into output text.
• pseudocodePseudocode is an informal, language-independent notation for expressing an algorithm's logic.
• slicesslices is Go's standard-library package providing generic operations for slice values.
• PNGPNG is a lossless raster image file format that supports indexed, grayscale, and truecolor images with optional transparency.
• closed channelA closed channel is a Go channel on which no further sends are permitted and receives can continue until buffered values are exhausted.
• quit channelA quit channel is a channel dedicated to signaling concurrent operations that they should stop.
• command-line toolA command-line tool is a software program operated by entering commands and arguments through a command-line interface.
• expiration dateA time to live is a duration after which stored data is considered expired and should no longer be used.
• text boxAn input element is an HTML form control that accepts user-entered data.
• referenceA pointer is a Go value that represents the memory address of another value.
• go moduleA Go module is a versioned collection of Go packages defined by a go.mod file.
• benchmarkBenchmarking is the measurement and comparison of program performance across implementations or versions.
• testdata directoryA testdata directory is the conventional Go folder for ancillary test data, and its contents are ignored by the go tool.
• strings.Builderstrings.Builder is a Go standard-library type that efficiently accumulates string data while minimizing allocations.
• pipelineA template pipeline is a sequence of template commands in which each command's output becomes input to the next command.
• loop variableA loop variable is a variable whose value identifies or controls the current iteration of a loop.
• pointer receiverA pointer receiver is a method receiver whose parameter points to the receiver value, allowing method operations to access the original value.
• image.Imageimage.Image is a Go standard-library interface representing a two-dimensional image that can provide color values at coordinates.
• image/pngimage/png is Go's standard-library package for decoding and encoding PNG images.
• sort packagesort is Go's standard-library package for sorting slices and other ordered collections.
• sort.Slicesort.Slice is a Go function that sorts a slice in place according to a supplied less-than comparison function.
• floating-point errorA floating-point error is an inaccuracy caused by the finite binary representation and arithmetic of floating-point numbers.
• os.Fileos.File is a Go standard-library type representing an open file and providing file-related operations.
• os.Openos.Open is a Go os-package function that opens a named file for reading and returns an os.File pointer or an error.
• os.OpenFileos.OpenFile is a Go os-package function that opens or creates a file according to supplied access flags and permissions.
• os packageThe os package is a Go standard-library package that provides operating-system-related functionality, including access to process arguments.
• backward compatibilityBackward compatibility is the ability of a newer software version to continue working with existing users, integrations, or client code.
• sync packagesync is Go's standard-library package providing synchronization primitives such as mutexes, wait groups, and once-only execution controls.
• exported identifierAn exported symbol is a Go declaration whose identifier begins with an uppercase letter and is accessible from another package.
• unsigned integeruint is Go's unsigned integer type whose size is implementation-dependent and corresponds to the native word size.
• error typeA custom error is an application-defined error value or type representing a specific failure condition.
• example syntaxExample syntax is Go's convention for defining executable documentation examples and associating them with optional expected output.
• output commentAn output directive is a Go example comment that marks the following text as the expected standard output for test comparison.
• union interfaceA union interface is a Go generic constraint whose type set combines multiple permitted types or underlying types.
• errgrouperrgroup is a Go package for synchronizing goroutines while collecting errors from their functions.
• main packageThe main package is the special Go package that defines an executable program's entry point.
• black-box testingClosed-box testing evaluates a software system from outside its implementation, typically through its externally accessible interface.
• struct embeddingEmbedding is a Go struct feature that incorporates an unnamed field's type and promotes its methods and fields to the containing type.
• currency codeA currency code is a standardized three-letter identifier for a currency, such as USD or EUR.
• goarchGOARCH is the Go build setting that specifies the target processor architecture for compiled code.
• goosGOOS is the Go build setting that specifies the target operating system for compiled code.
• floating-point arithmeticA floating-point number is a numeric value represented using a finite significand and an exponent, allowing a wide range of magnitudes with limited precision.
• separation of concernsSeparation of concerns is a design principle that assigns distinct responsibilities to separate software components.
• logA structured log message represents log information as machine-parseable fields with defined meanings rather than as unstructured prose.
• error propagationError propagation is the practice of passing an error to an upper program layer when the current layer cannot resolve it.
• error wrappingA wrapped error is an error that retains an underlying error while adding contextual information for higher-level handling.
• fmtfmt is Go's standard library package for formatted I/O operations.
• input normalizationInput normalization is the transformation of incoming values into a consistent representation before further processing.
• standard libraryA standard library is the collection of libraries distributed with a programming language implementation.
• clear log messageA clear log message states the relevant event or result precisely enough to explain program behavior later.
• habit statusHabit status is the recorded state of a habit, including information about its completion or progress.
• deployment pipelineContinuous integration is a software development practice in which changes are automatically built and tested when integrated into a shared codebase.
• gRPC serverA gRPC server is a network service that implements gRPC-defined procedures and accepts remote calls from clients.
• domain layerA domain layer is an architectural layer that contains an application's business rules and domain behavior independently of delivery and persistence concerns.
• external testingExternal testing tests a Go package from a separate package context and can access only the package's exposed declarations.
• lambdaAn anonymous function is a function value declared without a name, typically for inline or temporary use.
• bitmap imageA bitmap image represents visual content as a grid of individually colored picture elements.
• image packageThe image package is Go's standard-library package for representing, decoding, encoding, and manipulating images.
• JSON objectA JSON object is an unordered collection of named fields represented as string keys paired with JSON values.
• wallA wall is a maze boundary or obstacle that prevents movement through an adjacent position.
• TestXxx functionA TestXxx function is a Go test function whose name begins with Test and whose parameter is a pointer to testing.T.
• FuncsFuncs is a Go template method that registers named functions available to template actions.
• Context.Donecontext.Context.Done is a method that returns a channel closed when the context is canceled or reaches its deadline.
• context Err methodContext.Err is a method that reports the reason a Context was cancelled or expired.
• code coverageCode coverage is the percentage or proportion of program code executed by a test suite.
• public visibilityVisibility is the rule determining whether a Go identifier can be referenced from outside its package, based on its initial capitalization.
• namespaceA JavaScript namespace is a named scope or object used to organize and expose JavaScript-accessible functions and values.
• global objectGlobal is a js package function that returns the global JavaScript object.
• js.Funcjs.Func is a Go wrapper type representing a JavaScript-callable function in the WebAssembly interoperability API.
• js.Valuejs.Value is the syscall/js representation of a JavaScript value accessible from Go.
• sort.Interfacesort.Interface is a Go interface requiring Len, Less, and Swap methods so a collection can be sorted by the sort package.
• code generationCode generation is the automatic production of source or executable code from schemas, specifications, or other input artifacts.
• forward compatibilityForward compatibility is the ability of existing implementations to continue working when a service or data interface gains supported additions.
• protoc-gen-goprotoc-gen-go is a protoc plugin that generates Go types and related code from Protocol Buffers schemas.
• protoc-gen-go-grpcprotoc-gen-go-grpc is a protoc plugin that generates Go gRPC client and server code from Protocol Buffers service definitions.
• field identifierA field identifier is the unique numeric tag assigned to a Protobuf message field for serialized-data recognition and compatibility.
• protobuf messageA Protobuf message is a schema-defined structured data type composed of named fields with assigned numeric identifiers.
• generationA response message is a Protobuf message containing the output data for an API operation.
• testing.T.Paralleltesting.T.Parallel marks a Go test so that it may execute in parallel with other parallel tests.
• pseudo-random number generatorA random number generator is a procedure or system that produces values intended to follow a specified randomness model.
• conditional logicA conditional action is a template control-flow action that selects output based on one or more conditions.
• empty interfaceany is Go's predeclared constraint that permits any type as a generic type argument and is equivalent to interface{}.
• sorting algorithmSorting is the technique of ordering elements in a collection according to a specified comparison criterion.
• strconvstrconv is Go's standard-library package for converting strings to and from basic numeric and quoted representations.
• key-value storeKey-value storage is a data-storage model that associates each key with a corresponding value for retrieval by key.
• go.mod filego.mod is a Go module definition file that declares a module's path and dependency requirements.
• WebAssemblyWebAssembly is a portable binary instruction format and execution environment for running compiled code on the web and other platforms.
• test helperA test helper is supporting code that simplifies setup, execution, validation, or teardown for software tests.
• HTTP PUT methodPUT is an HTTP request method conventionally used to create or fully replace the representation of a resource at a specified URI.
• rwmutexsync.RWMutex is Go's synchronization type that permits concurrent readers while excluding writers.
• dependencyA dependency is an external component or service that a program component requires to perform its work.
• FP32float32 is Go's 32-bit floating-point type, typically providing approximately six to seven decimal significant digits of precision.
• interface layerAn API layer is an architectural layer that translates external interface representations into domain operations and translates their results back.
• status.Errorstatus.Error and its formatting variant construct errors carrying gRPC status codes and messages.
• Causecontext.Cause is a Go function that returns the specific cancellation cause associated with a context, or its usual cancellation error when none was set.
• context.WithTimeoutCausecontext.WithTimeoutCause is a Go context function that derives a context canceled after a duration and associates a specified cancellation cause with it.

These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.