src/

Modify the `echo` program to also allow print `os.Args[0]`, the name of the command that invoked it.

Try `fetchall` with longer argument lists, such as samples from the top million web sites available at `alexa.com`.

Modify the Lissajous server to read parameter values from the URL.

Modify the `echo` program to print the index and value of each of its arguments, one per line.

Experiment to measure the difference in running time between our potentially inefficient versions and the one that uses `strings.Join`.

Modify `dup2` to print the names of all files in which each duplicated line occurs.

Change the Lissajous program's color palette to green on black, for added authenticity.

Modify the Lissajous program to produce images in multiple colors by adding more values to `palette` and then displaying them by changing the third argument of `SetColorIndex` in some interesting way.

The function call `io.Copy(dst, src)` reads from `src` and writes to `dst`.

Modify `fetch` to add the prefix `http://` to each argument URL, if it is missing.

Modify `fetch` to also print the HTTP status code, found in `resp.Status`.

Add types, constants, and functions to `tempconv` for processing temperatures in the Kelvin scale, where Kelvin is -273.15°C and a difference of 1K has the same magnitude as 1°C.

Write a general purpose unit-conversion program analogous to `cf` that reads numbers from its command-line arguments or from the standard imput if there are no arguments, and converts each nunber into units like temperature in Celsius and Fahrenheit, length in feet and meters, weight in pounds, kilograms, and the like.

Write a general purpose unit-conversion program analogous to `cf` that reads numbers from its command-line arguments or from the standard imput if there are no arguments, and converts each nunber into units like temperature in Celsius and Fahrenheit, length in feet and meters, weight in pounds, kilograms, and the like.

Rewrite `PopCount` to use a loop instead of a single expression.

Rewrite `PopCount` to use a loop instead of a single expression.

Write a version of `PopCount` that counts bits by shifting its argument through 64 bit positions, testing the rightmost bit each time.

Write a version of `PopCount` that counts bits by shifting its argument through 64 bit positions, testing the rightmost bit each time.

The expression `x&(x-1)` clears the rightmost non-zero bit of x.

The expression `x&(x-1)` clears the rightmost non-zero bit of x.

If the function `f` returns a non-finite `float64` value, the SVG file will contain invalid `<polygon>` elements (although many SVG renderers handle this gracefully).

Write a non-recursive version of `comma`, using `bytes.Buffer` instead of string concatenation.

Enhance `comma` so it deals correctly with floating-point numbers and an optional sign.

Write a function that reports whether two strings are anagrams of each other, that is, they contain the same letters in a different order.

Write const declarations for KB, MB, up through YB as compactly as you can.

Experiment with vizualizations of other functions from the `math` package.

Color each polygon based on its height, so that the peaks are colored red (`#ff0000`) and the valleys blue ('#0000ff').

Following the approach of the Lissajous example in Section 1.7, construct a web server that computes surfaces and writes SVG data to the client.

Implement a full-color Mandelbrot set using the function `image.NewRBA` and the type `color.RGBA` or `color.YCbCr`.

Supersampling is a technique to reduce the effect of pixelation by computing the color value at several points within each pixel and taking the average.

Another simple fractal uses Newton's method to find complex solutions to a function such as `z^4-1 = 0`.

Rendering fractals at high zoom levels demands great arithmetic precision.

Rendering fractals at high zoom levels demands great arithmetic precision.

Write a web server that renders fractals and writes the image data to the client.

Write a function that counts the number of bits that are different in two SHA256 hashes.

Write a function that counts the number of bits that are different in two SHA256 hashes.

Issues prints a table of GitHub issues matching the search terms and reports the results in age categories of this month, this year, and older than a year.

Package github provides a Go API for the GitHub issue tracker.

Build a tool that lets users create, read, update, and close GitHub i̶s̶s̶u̶e̶s̶ pull requests from the command line, invoking their preferred text editor when substantial text input is required.

The JSON-based web service of the Open Movie Database lets you search https://omdbapi.com/ for a movie by name and download its poster image.

Create a web server that queries GitHub once and then allows navigation of the list of bug reports, milestones, and users.

Write a program that prints the SHA256 hash of it standard input by default but supports a command-line flag to print the SHA384 or SHA512 hash instead.

Write an in-place function to eliminate adjacent duplicates in a []string slice.

Modify charcount to count letters, digits, and so on in their Unicode categories, using functions like `unicode.IsLetter`.

Change the findlinks program to traverse the `n.FirstChild` linked list using recursive calls to `visit` instead of a loop.

Rewrite `toposort` to use maps instead of slices and eliminate the initial sort.

The instructor of the linear algebra course decides that calculus is now a prerequisite.

The `startElement` and `endElement` functions in gopl.io/ch5/outline2 (§5.5) share a global variable, `depth`.

Modify crawl to make local copies of the pages it finds, creating directories as necessary.

Use the `breadthFirst` function to explore a different structure.

Write variadic functions `max` and `min`, analogous to `sum`.

Write a variadic version of `strings.Join`.

Write a variadic function `ElementsByTagName` that, given an HTML node tree and zero or more names, returns all the elements that match one of those names.

Without changing its behavior, rewrite the fetch function to use defer to close the writable file.

Use `panic` and `recover` to write a function that contains no return statement yet returns a non-zero value.

Change the findlinks program to traverse the `n.FirstChild` linked list using recursive calls to `visit` instead of a loop.

Extend the `visit` function so that it extracts other kinds of links from the document, such as images, scripts, and style sheets.

Implement `countWordsAndImages`.

Surface computes an SVG rendering of a 3-D surface function.

Outline prints the outline of an HTML document tree.

Modify `forEachNode` so that the `pre` and `post` functions return a boolean result indicating whether to continue the traversal.

Write a function `expand(s string, f func(string) string) string` that replaces each substring `$foo` within `s` by the text returned by `f("foo")`.

Implement these additional methods:

Define a variadic `(*IntSet).AddAll(...int)` method that allows a list of values to be added, such as `s.AddAll(1, 2, 3)`.

`(*IntSet).UnionWith` computes the union of two sets using `|`, the word-parallel bitwise OR operator.

Add a method `Elems` that returns a slice containing the elements of the set, suitable for iterating over with a range loop.

The type of each word used by `IntSet` is `uint64`, but 64-bit arithmetic may be inefficient on a 32-bit platform.

Using the ideas from `ByteCounter`, implement counters for words and for lines.

The `sort.Interface` type can be adapted to other uses.

Add additional handlers so that clients can create, read, update, and delete database entries.

Change the handler for `/list` to print its output as an HTML table, not text.

Add a `String` method to `Expr` to pretty-print the syntax tree.

Add a `String` method to `Expr` to pretty-print the syntax tree.

Define a new concrete type that satisfies the `Expr` interface and provides a new operation such as computing the minimum value of its operands.

Write a program that reads a single expression from the standard input, prompts the user to provide values for any variables, then evaluates the expression in the resulting environment.

Define a new concrete type that satisfies the `Expr` interface and provides a new operation such as computing the minimum value of its operands.

Write a web-based calculator program.

Extend `xmlselect` so that elements may be selected not just by name, but by their attributes too, in the manner of CSS, so that, for instance, an element like `<div id="page" class="wide">` could be selected by matching `id` or `class` as well as its name.

Write a function `CountingWriter` with the signature below that, given an `io.Writer`, returns a new `Writer` that wraps the original, and a pointer to an `int64` variable that any moment contains the number of bytes written to the new `Writer`.

Write a `String` method for the `*tree` type in `gopl.io/ch4/treesort` (§4.4) that reveals the sequence of values in the tree.

Write a `String` method for the `*tree` type in `gopl.io/ch4/treesort` (§4.4) that reveals the sequence of values in the tree.

The `strings.NewReader` function returns a value that satisfies the `io.Reader` interface (and others) by reading from its argument, a string.

The `LimitReader` function in the `io` package accepts an `io.Reader r` and a number of bytes `n`, and returns another `Reader` that reads from `r` but reports an end-of-file condition after `n` bytes.

Add support for Kelvin temperatures to `tempFlag`.

Add support for Kelvin temperatures to `tempFlag`.

Many GUIs provide a table widget with a stateful multi-tier sort: the primary sort key is the most recently clicked column head, the secondary sort key is the second most clicked column head, and so on.

Use the `html/template` package (§4.6) to replace `printTracks` with a function that displays the tracks as an HTML table.

Modify `clock2` to accept a port number, and write a program, `clockwall`, that acts as a client of clock servers at once, reading the times from each one and displaying the results in a table, akin to the wall of clocks seen in some business offices.

Modify `clock2` to accept a port number, and write a program, `clockwall`, that acts as a client of clock servers at once, reading the times from each one and displaying the results in a table, akin to the wall of clocks seen in some business offices.

Implement a concurrent File Transfer Protocol (FTP) server.

In `netcat3`, the interface value `conn` has the concrete type `*net.TCPConn`, which represents a TCP connection.

Modify the `reverb2` server to use a `sync.WaitGroup` per connection to count the number of active echo goroutines.