roth1002 / golang1training

Solutions to The Go Programming Language exercises

This repository contains the solutions of the exercises in the book Go Programming Language.

Similar to #gopl-solutions

How to run

1.3 $ go run main.go

1.4 $ go run main.go t1 t2 t3

1.5 & go build ./1.5 > out.gif

1.6 & go build ./1.6 > out.gif

1.7 $ go build ./1.7 http://gopl.io

1.8 $ go build ./1.8 http://gopl.io ./1.8 gopl.io

1.9 $ go build ./1.9 http://gopl.io ./1.9 gopl.io

1.10 $ go build ./1.10 http://gopl.io

1.11 ./1.10 http://Google.Com http://Youtube.Com http://Facebook.Com http://Wikipedia.Org http://Yahoo.Com http://Twitter.Com http://Amazon.Com http://Instagram.Com

1.12 $ go run main.go http://localhost:8000/?cycles=20;res=0.001;size=100;nframes=64;delay=8

2.1 //add $GOPATH variable: GOPATH="/home/alex/go" //test the package tempconv$ go build //install the package tempconv$ go install //run code from the package go run main.go

2.2 //using package without compiling: go build main.go ./main -40 //altarnative way without build: go run main.go 30 50

3.1 //using SVG standard for XML line drawings (advanced) go run main.go //result file is in tmp/yourfile folder //insert result here: https://www.w3schools.com/graphics/tryit.asp?filename=trysvg_myfirst

3.2 //same as 3.1 //eggbox folder //moguls folder //saddle folder

3.3 //same as 3.1

3.4 go run main.go http://localhost:8000/?width=1000;height=540;cells=49;fill=black

3.5 go run main.go

3.6 go run main.go

3.7 go run main.go

3.8 go run main.go //21.08s elapsed go run mainC64.go //5.85s elapsed go run mainBigFloat.go //56.61s elapsed go run mainBigRat.go //28.51s elapsed

3.9 go run main.go http://localhost:8000/?xmin=-2;ymin=-2;zoom=1

3.10 $ go run main.go 123456 1234567890

3.11 $ go run main.go -46237123.456 -123.4567890 -12.3 -46237123.456765

3.12 $ go run main.go

3.13 $ go run main.go

4.1 $ go run main.go

4.2 $go build $./4.2 < main.go SHA512 or $./4.2 input text manually

4.3 $go run main.go

4.4 $go run main.go

4.5 $go run main.go

4.6 $go run main.go

4.7 $go run main.go

4.8 $go run main.go

4.9 $go run main.go < main.go

4.10 $go run main.go repo:golang/go is:open json decoder

4.11 $go run main.go create $go run main.go read $go run main.go update $go run main.go delete $go run main.go search repo:golang/go is:open json decoder

4.11 borrowed $go run main.go go run *.go read Julineo golang1training 1 //not working go run *.go create Julineo golang1training 2 go run *.go delete Julieno golang1training 2

4.12 $go run main.go //idx will be created

$go run xkcd.go

4.13 Became a patreon at https://omdbapi.com/ Generay API keys at https://omdbapi.com/apikey.aspx

$go run poster.go [your key here] Batman

4.14 //run webserver $go run main.go repo:golang/go is:open json open browser and navigate to users, issues, milestones http://localhost:8000

5.1 $ go build golang1training/5.1/findlinksr $ ./fetch https://golang.org | ./findlinksr

5.2 $ go build golang1training/5.2/popmap $ ./fetch https://golang.org | ./popmap

5.3 $ go build golang1training/5.3/htmltext $ ./fetch https://golang.org | ./htmltext

5.4 $ go run main.go https://golang.org

5.5 $ go run main.go https://golang.org/doc/

5.6 $ go run main.go //result file is in yourfile //insert result here: https://www.w3schools.com/graphics/tryit.asp?filename=trysvg_myfirst

5.7 $ go run outline.go https://golang.org $ go test

5.8 $ go run getbyid.go topbar https://golang.com https://golang.org/project/

5.9 $ go test

5.10

5.11 //not solved, will get back later

5.12 $ go run outline.go http://www.golang.com

5.13 go run findlinks.go https://www.derekshoemaker.com http://www.alexfast.org http://www.bradfitz.com https://www.calhoun.io

5.15 $ go test

5.16 $ go test

5.17 $ go run main.go

5.18 $ go run main.go https://www.golang.com https://www.golang.com/doc

6.1 $ go run main.go

6.2 $ go run main.go

7.1 $ go run main.go

7.2 $ go run main.go

7.3 $ go test

7.6 $ go run tempflag.go -temp 273.15K

The Go Programming Language Exercises:

chapter.exercise

Index

01.01 Modify the echo program to also print @c(os.Args[0]) 01.02 echo program to print the index and value of each of its arguments, one per line. 01.03 str += VS strings.Join 01.04 dup2 to print the names of all files in which each duplicated line occurs 01.05 Change the Lissajous program’s color palette to green on black 01.06 Modify the Lissajous program to produce images in multiple colors 01.07 Use io.Copy(dst, src) it instead of ioutil.ReadAll to copy the response http.Body to os.Stdout 01.08 Modify fetch to add the prefix "http://" to each argument URL if it is missing. 01.09 Modify fetch to also print the HTTP status code, found in resp.Status. 01.10 Find a web site that produces a large amount of data. Investigate caching by running @c(fetchall) twice in succession to see whether the reported time changes much. Do you get the same content each time? Modify @c(fetchall) to print its output to a file so it can be examined. 01.11 Try fetchall) with longer argument lists, such as samples from the top million web sites available at http://www.alexa.com/. How does the program behave if a web site just doesn’t respond? (Section 8.9 describes mechanisms for coping in such cases.) 01.12 Modify the Lissajous server to read parameter values from the URL. For example, you might arrange it so that a URL like http://localhost:8000/?cycles=20 sets the number of cycles to 20 instead of the default 5. Use the strconv.Atoi function to convert the string parameter into an integer. You can see its documentation with go doc strconv.Atoi. 02.01 Add types, constants, and functions to tempconv for processing temperatures in the Kelvin scale, where zero Kelvin is -273.15°C and a difference of 1K has the same magnitude as 1°C. 02.02 Write a general-purpose unit-conversion program analogous to cf that reads numbers from its command-line arguments or from the standard input if there are no arguments, and converts each number into units like temperature in Celsius and Fahrenheit, length in feet and meters, weight in pounds and kilograms, and the like. 02.03 Rewrite PopCount to use a loop instead of a single expression. Compare the performance of the two versions. (#Section 11.4 shows how to compare the performance of different implementations systematically.) 02.04 Write a version of PopCount that counts bits by shifting its argument through 64 bit positions, testing the rightmost bit each time. Compare its performance to the tablelookup version. 02.05 The expression x&(x-1) clears the rightmost non-zero bit of x. Write a version of PopCount that counts bits by using this fact, and assess its performance. 03.01 If the function f returns a non-finite float64 value, the SVG file will contain invalid elements (although many SVG renderers handle this gracefully). Modify the program to skip invalid polygons. 03.02 Experiment with visualizations of other functions from the math package. Can you produce an egg box, moguls, or a saddle? 03.03 Color each polygon based on its height, so that the peaks are colored red (#ff0000) and the valleys blue (#0000ff). 03.04 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. The server must set the Content-Type header like this: 03.05 Implement a full-color Mandelbrot set using the function image.NewRGBA and the type color.RGBA or color.YCbCr. 03.06 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. The simplest method is to divide each pixel into four subpixels. Implement it. 03.07 Another simple fractal uses Newton’s method to find complex solutions to a function such as z4-1 = 0. Shade each starting point by the number of iterations required to get close to one of the four roots. Color each point by the root it approaches. 03.08 Rendering fractals at high zoom levels demands great arithmetic precision. Implement the same fractal using four different representations of numbers: complex64, complex128, big.Float, and big.Rat. (The latter two types are found in the math/big package. Float uses arbitrary but bounded-precision floating-point; Rat uses unbounded-precision rational numbers.) How do they compare in performance and memory usage? At what zoom levels do rendering artifacts become visible? 03.09 Write a web server that renders fractals and writes the image data to the client. Allow the client to specify the x, y, and zoom values as parameters to the HTTP request. 03.10 Write a non-recursive version of comma, using bytes.Buffer instead of string concatenation. 03.11 Enhance comma so that it deals correctly with floating-point numbers and an optional sign. 03.12 Write a function that reports whether two strings are anagrams of each other, that is, they contain the same letters in a different order. 03.13 Write const declarations for KB, MB, up through YB as compactly as you can. 04.01 Write a function that counts the number of bits that are different in two SHA256 hashes. (See PopCount from Section 2.6.2.) 04.02 Write a program that prints the SHA256 hash of its standard input by default but supports a command-line flag to print the SHA384 or SHA512 hash instead. 04.03 Rewrite reverse to use an array pointer instead of a slice. 04.04 Write a version of rotate that operates in a single pass. 04.05 Write an in-place function to eliminate adjacent duplicates in a []string slice. 04.06 Write an in-place function that squashes each run of adjacent Unicode spaces (see unicode.IsSpace) in a UTF-8-encoded []byte slice into a single ASCII space. 04.07 Modify reverse to reverse the characters of a []byte slice that represents a UTF-8-encoded string, in place. Can you do it without allocating new memory? 04.08 Modify charcount to count letters, digits, and so on in their Unicode categories, using functions like unicode.IsLetter. 04.09 Write a program wordfreq to report the frequency of each word in an input text file. Call input.Split(bufio.ScanWords) before the first call to Scan to break the input into words instead of lines. 04.10 Modify issues to report the results in age categories, say less than a month old, less than a year old, and more than a year old. 04.11 Build a tool that lets users create, read, update, and delete GitHub issues from the command line, invoking their preferred text editor when substantial text input is required. 04.12 The popular web comic xkcd has a JSON interface. For example, a request to https://xkcd.com/571/info.0.json produces a detailed description of comic 571, one of many favorites. Download each URL (once!) and build an offline index. Write a tool xkcd that, using this index, prints the URL and transcript of each comic that matches a search term provided on the command line. 04.13 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. Write a tool poster that downloads the poster image for the movie named on the command line. 04.14 Create a web server that queries GitHub once and then allows navigation of the list of bug reports, milestones, and users. 05.01 Change the findlinks program to traverse the n.FirstChild linked list using recursive calls to visit instead of a loop. 05.02 Write a function to populate a mapping from element names—p, div, span, and so on—to the number of elements with that name in an HTML document tree. 05.03 Write a function to print the contents of all text nodes in an HTML document tree. Do not descend into <script> or <style> elements, since their contents are not visible in a web browser. 05.04 Extend the visit function so that it extracts other kinds of links from the document, such as images, scripts, and style sheets. 05.05 Implement countWordsAndImages. (See Exercise 4.9 for word-splitting.) 05.06 Modify the corner function in gopl.io/ch3/surface (Section 3.2) to use named results and a bare return statement. 05.07 Develop startElement and endElement into a general HTML pretty-printer. Print comment nodes, text nodes, and the attributes of each element (). Use short forms like instead of when an element has no children. Write a test to ensure that the output can be parsed successfully. (See #Chapter 11.) 05.08 Modify forEachNode so that the pre and post functions return a boolean result indicating whether to continue the traversal. Use it to write a function ElementByID with the following signature that finds the first HTML element with the specified id attribute. The function should stop the traversal as soon as a match is found. 05.09 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"). 05.10 Rewrite topoSort to use maps instead of slices and eliminate the initial sort. Verify that the results, though nondeterministic, are valid topological orderings. 05.11 The instructor of the linear algebra course decides that calculus is now a prerequisite. Extend the topoSort function to report cycles. 05.12 The startElement and endElement functions in gopl.io/ch5/outline2 (Section 5.5) share a global variable, depth. Turn them into anonymous functions that share a variable local to the outline function. 05.13 Modify crawl to make local copies of the pages it finds, creating directories as necessary. Don’t make copies of pages that come from a different domain. For example, if the original page comes from https://golang.org, save all files from there, but exclude ones from https://vimeo.com. 05.14 Use the breadthFirst function to explore a different structure. For example, you could use the course dependencies from the topoSort example (a directed graph), the file system hierarchy on your computer (a tree), or a list of bus or subway routes downloaded from your city government’s web site (an undirected graph). 05.15 Write variadic functions max and min, analogous to sum. What should these functions do when called with no arguments? Write variants that require at least one argument. 05.16 Write a variadic version of strings.Join. 05.17 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. Here are two example calls: 05.18 Without changing its behavior, rewrite the fetch function to use defer to close the writable file. 05.19 Use panic and recover to write a function that contains no return statement yet returns a non-zero value. 06.01 Implement these additional methods: 06.02 Define a variadic (*IntSet).AddAll(...int) method that allows a list of values to be added, such as s.AddAll(1, 2, 3). 06.03 (*IntSet).UnionWith computes the union of two sets using |, the word-parallel bitwise OR operator. Implement methods for IntersectWith, DifferenceWith, and SymmetricDifference for the corresponding set operations. (The symmetric difference of two sets contains the elements present in one set or the other but not both.) 06.04 Add a method Elems that returns a slice containing the elements of the set, suitable for iterating over with a range loop. 06.05 The type of each word used by IntSet is uint64, but 64-bit arithmetic may be inefficient on a 32-bit platform. Modify the program to use the uint type, which is the most efficient unsigned integer type for the platform. Instead of dividing by 64, define a constant holding the effective size of uint in bits, 32 or 64. You can use the perhaps too-clever expression 32 << (^uint(0) >> 63) for this purpose. 07.01 Using the ideas from ByteCounter, implement counters for words and for lines. You will find bufio.ScanWords useful. 07.02 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 at any moment contains the number of bytes written to the new Writer. 07.03 Write a String method for the *tree type in gopl.io/ch4/treesort (Section 4.4) that reveals the sequence of values in the tree. 07.04 The strings.NewReader function returns a value that satisfies the io.Reader interface (and others) by reading from its argument, a string. Implement a simple version of NewReader yourself, and use it to make the HTML parser (Section 5.2) take input from a string. 07.05 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. Implement it. 07.06 Add support for Kelvin temperatures to tempflag. 07.07 Explain why the help message contains °C when the default value of 20.0 does not. 07.08 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 recently clicked column head, and so on. Define an implementation of sort.Interface for use by such a table. Compare that approach with repeated sorting using sort.Stable. 07.09 Use the html/template package (Section 4.6) to replace printTracks with a function that displays the tracks as an HTML table. Use the solution to the previous exercise to arrange that each click on a column head makes an HTTP request to sort the table. 07.10 The sort.Interface type can be adapted to other uses. Write a function IsPalindrome(s sort.Interface) bool that reports whether the sequence s is a palindrome, in other words, reversing the sequence would not change it. Assume that the elements at indices i and j are equal if !s.Less(i, j) && !s.Less(j, i). 07.11 Add additional handlers so that clients can create, read, update, and delete database entries. For example, a request of the form /update?item=socks&price=6 will update the price of an item in the inventory and report an error if the item does not exist or if the price is invalid. (Warning: this change introduces concurrent variable updates.) 07.12 Change the handler for /list to print its output as an HTML table, not text. You may find the html/template package (Section 4.6) useful. 07.13 Add a String method to Expr to pretty-print the syntax tree. Check that the results, when parsed again, yield an equivalent tree. 07.14 Define a new concrete type that satisfies the Expr interface and provides a new operation such as computing the minimum value of its operands. Since the Parse function does not create instances of this new type, to use it you will need to construct a syntax tree directly (or extend the parser). 07.15 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. Handle all errors gracefully. 07.16 Write a web-based calculator program. 07.17 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

could be selected by a matching id or class as well as its name. 07.18 Using the token-based decoder API, write a program that will read an arbitrary XML document and construct a tree of generic nodes that represents it. Nodes are of two kinds: CharData nodes represent text strings, and Element nodes represent named elements and their attributes. Each element node has a slice of child nodes. 08.01 Modify clock2 to accept a port number, and write a program, clockwall, that acts as a client of several 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. If you have access to geographically distributed computers, run instances remotely ; otherwise run local instances on different ports with fake time zones. 08.02 Implement a concurrent File Transfer Protocol (FTP) server. The server should interpret commands from each client such as cd to change directory, ls to list a directory, get to send the contents of a file, and close to close the connection. You can use the standard ftp command as the client, or write your own. 08.03 In netcat3, the interface value conn has the concrete type *net.TCPConn, which represents a TCP connection. A TCP connection consists of two halves that may be closed independently using its CloseRead and CloseWrite methods. Modify the main goroutine of netcat3 to close only the write half of the connection so that the program will continue to print the final echoes from the reverb1 server even after the standard input has been closed. (Doing this for the reverb2 server is harder; see Exercise 8.4.) 08.04 Modify the reverb2 server to use a sync.WaitGroup per connection to count the number of active echo goroutines. When it falls to zero, close the write half of the TCP connection as described in Exercise 8.3. Verify that your modified netcat3 client from that exercise waits for the final echoes of multiple concurrent shouts, even after the standard input has been closed. 08.05 Take an existing CPU-bound sequential program, such as the Mandelbrot program of Section 3.3 or the 3-D surface computation of Section 3.2, and execute its main loop in parallel using channels for communication. How much faster does it run on a multiprocessor machine? What is the optimal number of goroutines to use? 08.06 Add depth-limiting to the concurrent crawler. That is, if the user sets -depth=3, then only URLs reachable by at most three links will be fetched. 08.07 Write a concurrent program that creates a local mirror of a web site, fetching each reachable page and writing it to a directory on the local disk. Only pages within the original domain (for instance, https://golang.org) should be fetched. URLs within mirrored pages should be altered as needed so that they refer to the mirrored page, not the original. 08.08 Using a select statement, add a timeout to the echo server from Section 8.3 so that it disconnects any client that shouts nothing within 10 seconds. 08.09 Write a version of du that computes and periodically displays separate totals for each of the root directories. 08.10 HTTP requests may be cancelled by closing the optional Cancel channel in the http.Request struct. Modify the web crawler of Section 8.6 to support cancellation. 08.11 Following the approach of mirroredQuery in Section 8.4.4, implement a variant of fetch that requests several URLs concurrently. As soon as the first response arrives, cancel the other requests. 08.12 Make the broadcaster announce the current set of clients to each new arrival. This requires that the clients set and the entering and leaving channels record the client name too. 08.13 Make the chat server disconnect idle clients, such as those that have sent no messages in the last five minutes. Hint: calling conn.Close() in another goroutine unblocks active Read calls such as the one done by input.Scan(). 08.14 Change the chat server’s network protocol so that each client provides its name on entering. Use that name instead of the network address when prefixing each message with its sender’s identity. 08.15 Failure of any client program to read data in a timely manner ultimately causes all clients to get stuck. Modify the broadcaster to skip a message rather than wait if a client writer is not ready to accept it. Alternatively, add buffering to each client’s outgoing message channel so that most messages are not dropped; the broadcaster should use a non-blocking send to this channel. 09.01 Add a function Withdraw(amount int) bool to the gopl.io/ch9/bank1 program. The result should indicate whether the transaction succeeded or failed due to insufficient funds. The message sent to the monitor goroutine must contain both the amount to withdraw and a new channel over which the monitor goroutine can send the boolean result back to Withdraw. 09.02 Rewrite the PopCount example from Section 2.6.2 so that it initializes the lookup table using sync.Once the first time it is needed. (Realistically, the cost of synchronization would be prohibitive for a small and highly optimized function like PopCount.) 09.03 Extend the Func type and the (*Memo).Get method so that callers may provide an optional done channel through which they can cancel the operation (Section 8.9). The results of a cancelled Func call should not be cached. 09.04 Construct a pipeline that connects an arbitrary number of goroutines with channels. What is the maximum number of pipeline stages you can create without running out of memory? How long does a value take to transit the entire pipeline? 09.05 Write a program with two goroutines that send messages back and forth over two unbuffered channels in ping-pong fashion. How many communications per second can the program sustain? 09.06 Measure how the performance of a compute-bound parallel program (see Exercise 8.5) varies with GOMAXPROCS. What is the optimal value on your computer? How many CPUs does your computer have? 10.01 Extend the jpeg program so that it converts any supported input format to any output format, using image.Decode to detect the input format and a flag to select the output format. 10.02 Define a generic archive file-reading function capable of reading ZIP files (archive/zip) and POSIX tar files (archive/tar). Use a registration mechanism similar to the one described above so that support for each file format can be plugged in using blank imports. 10.03 Using fetch http://gopl.io/ch1/helloworld?go-get=1, find out which service hosts the code samples for this book. (HTTP requests from go get include the go-get parameter so that servers can distinguish them from ordinary browser requests.) 10.04 Construct a tool that reports the set of all packages in the workspace that transitively depend on the packages specified by the arguments. Hint: you will need to run go list twice, once for the initial packages and once for all packages. You may want to parse its JSON output using the encoding/json package (Section 4.5). 11.01 Write tests for the charcount program in Section 4.3. 11.02 Write a set of tests for IntSet (Section 6.5) that checks that its behavior after each operation is equivalent to a set based on built-in maps. Save your implementation for benchmarking in Exercise 11.7. 11.03 TestRandomPalindromes only tests palindromes. Write a randomized test that generates and verifies non-palindromes. 11.04 Modify randomPalindrome to exercise IsPalindrome’s handling of punctuation and spaces. 11.05 Extend TestSplit to use a table of inputs and expected outputs. 11.06 Write benchmarks to compare the PopCount implementation in Section 2.6.2 with your solutions to Exercise 2.4 and Exercise 2.5. At what point does the table-based approach break even? 11.07 Write benchmarks for Add, UnionWith, and other methods of *IntSet (Section 6.5) using large pseudo-random inputs. How fast can you make these methods run? How does the choice of word size affect performance? How fast is IntSet compared to a set implementation based on the built-in map type? 12.01 Extend Display so that it can display maps whose keys are structs or arrays. 12.02 Make display safe to use on cyclic data structures by bounding the number of steps it takes before abandoning the recursion. (In Section 13.3, we’ll see another way to detect cycles.) 12.03 Implement the missing cases of the encode function. Encode booleans as t and nil, floating-point numbers using Go’s notation, and complex numbers like 1+2i as #C(1.0 2.0). Interfaces can be encoded as a pair of a type name and a value, for instance ("[]int" (1 2 3)), but beware that this notation is ambiguous: the reflect.Type.String method may return the same string for different types. 12.04 Modify encode to pretty-print the S-expression in the style shown above. 12.05 Adapt encode to emit JSON instead of S-expressions. Test your encoder using the standard decoder, json.Unmarshal. 12.06 Adapt encode so that, as an optimization, it does not encode a field whose value is the zero value of its type. 12.07 Create a streaming API for the S-expression decoder, following the style of json.Decoder (Section 4.5). 12.08 The sexpr.Unmarshal function, like json.Marshal, requires the complete input in a byte slice before it can begin decoding. Define a sexpr.Decoder type that, like json.Decoder, allows a sequence of values to be decoded from an io.Reader. Change sexpr.Unmarshal to use this new type. 12.09 Write a token-based API for decoding S-expressions, following the style of xml.Decoder (Section 7.14). You will need five types of tokens: Symbol, String, Int, StartList, and EndList. 12.10 Extend sexpr.Unmarshal to handle the booleans, floating-point numbers, and interfaces encoded by your solution to Exercise 12.3. (Hint: to decode interfaces, you will need a mapping from the name of each supported type to its reflect.Type.) 12.11 Write the corresponding Pack function. Given a struct value, Pack should return a URL incorporating the parameter values from the struct. 12.12 Extend the field tag notation to express parameter validity requirements. For example, a string might need to be a valid email address or credit-card number, and an integer might need to be a valid US ZIP code. Modify Unpack to check these requirements. 12.13 Modify the S-expression encoder (Section 12.4) and decoder (Section 12.6) so that they honor the sexpr:"..." field tag in a similar manner to encoding/json (Section 4.5). 13.01 Define a deep comparison function that considers numbers (of any type) equal if they differ by less than one part in a billion. 13.02 Write a function that reports whether its argument is a cyclic data structure. 13.03 Use sync.Mutex to make bzip2.writer safe for concurrent use by multiple goroutines. 13.04 Depending on C libraries has its drawbacks. Provide an alternative pure-Go implementation of bzip.NewWriter that uses the os/exec package to run /bin/bzip2 as a subprocess.