From 031797c22fba010212b0f3b4baf839a9c890dd75 Mon Sep 17 00:00:00 2001
From: Mark McGranaghan <mmcgrana@gmail.com>
Date: Wed, 10 Oct 2012 20:00:40 -0700
Subject: [PATCH] publish signals

---
 examples.txt                |  2 +-
 examples/signals/signals.go | 22 +++++++++++++---------
 2 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/examples.txt b/examples.txt
index e7501c6..61e0d79 100644
--- a/examples.txt
+++ b/examples.txt
@@ -66,7 +66,7 @@ Line Filters
 Environment Variables
 Spawning Processes
 Exec'ing Processes
-# Signals
+Signals
 # Exit
 # HTTP Client
 # HTTPS Client
diff --git a/examples/signals/signals.go b/examples/signals/signals.go
index 04515b2..6eed21a 100644
--- a/examples/signals/signals.go
+++ b/examples/signals/signals.go
@@ -1,9 +1,9 @@
 // Sometines we'd like our Go programs to intelligently
-// handle Unix signals. For example, we might want a
-// server to gracefully shutdown when it receives a
-// `SIGTERM`, or a command-line tool to stop processing
-// input if it receives a `SIGINT`. Here's how to handle
-// signals in Go with channels.
+// handle [Unix signals](http://en.wikipedia.org/wiki/Unix_signal).
+// For example, we might want a server to gracefully
+// shutdown when it receives a `SIGTERM`, or a command-line
+// tool to stop processing input if it receives a `SIGINT`.
+// Here's how to handle signals in Go with channels.
 
 package main
 
@@ -13,6 +13,7 @@ import "os/signal"
 import "syscall"
 
 func main() {
+
     // Go signal notification works by sending `os.Signal`
     // values on a channel. We'll create a channel to
     // receive these notifications (we'll also make one to
@@ -23,17 +24,20 @@ func main() {
     // `signal.Notify` registers the given channel to
     // receive notifications of the specified signals.
     signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
+
+    // This goroutine executes a blocking receive for
+    // signals. When it gets one it'll print it out
+    // and then notify the program that it can finish.
     go func() {
-        // This goroutine makes a blocking receive for
-        // signals. When it gets one it'll print it out
-        // and then notify the program that it can finish.
         sig := <-sigs
         fmt.Println()
         fmt.Println(sig)
         done <- true
     }()
+
     // The program will wait here until it gets the
-    // expected signal, and then exit.
+    // expected signal (as indicated by the goroutine
+    // above sending a value on `done`) and then exit.
     fmt.Println("awaiting signal")
     <-done
     fmt.Println("exiting")