diff --git a/lib/protocol/errors.go b/lib/protocol/errors.go
index 31d27af0d..62df8acc9 100755
--- a/lib/protocol/errors.go
+++ b/lib/protocol/errors.go
@@ -14,10 +14,10 @@ const (
 )
 
 var (
-	ErrNoError    error = nil
-	ErrGeneric          = errors.New("generic error")
-	ErrNoSuchFile       = errors.New("no such file")
-	ErrInvalid          = errors.New("file is invalid")
+	ErrNoError    error
+	ErrGeneric    = errors.New("generic error")
+	ErrNoSuchFile = errors.New("no such file")
+	ErrInvalid    = errors.New("file is invalid")
 )
 
 var lookupError = map[int32]error{
diff --git a/lib/protocol/protocol.go b/lib/protocol/protocol.go
index 4c1364eaf..8947d0ecf 100644
--- a/lib/protocol/protocol.go
+++ b/lib/protocol/protocol.go
@@ -15,10 +15,10 @@ import (
 )
 
 const (
-	// Data block size (128 KiB)
+	// BlockSize is the standard ata block size (128 KiB)
 	BlockSize = 128 << 10
 
-	// We reject messages larger than this when encountered on the wire. (64 MiB)
+	// MaxMessageLen is the largest message size allowed on the wire. (64 MiB)
 	MaxMessageLen = 64 << 20
 )
 
@@ -145,9 +145,11 @@ type isEofer interface {
 }
 
 const (
-	// We make sure to send a message at least this often, by triggering pings.
+	// PingSendInterval is how often we make sure to send a message, by
+	// triggering pings if necessary.
 	PingSendInterval = 90 * time.Second
-	// If we haven't received a message from the other side for this long, close the connection.
+	// ReceiveTimeout is the longest we'll wait for a message from the other
+	// side before closing the connection.
 	ReceiveTimeout = 300 * time.Second
 )
 
diff --git a/lib/protocol/vector.go b/lib/protocol/vector.go
index edd156143..befaf7d9d 100644
--- a/lib/protocol/vector.go
+++ b/lib/protocol/vector.go
@@ -2,21 +2,21 @@
 
 package protocol
 
-// The Vector type represents a version vector. The zero value is a usable
+// The Vector type represents v version vector. The zero value is v usable
 // version vector. The vector has slice semantics and some operations on it
-// are "append-like" in that they may return the same vector modified, or a
+// are "append-like" in that they may return the same vector modified, or v
 // new allocated Vector with the modified contents.
 type Vector []Counter
 
-// Counter represents a single counter in the version vector.
+// Counter represents v single counter in the version vector.
 type Counter struct {
 	ID    uint64
 	Value uint64
 }
 
-// Update returns a Vector with the index for the specific ID incremented by
+// Update returns v Vector with the index for the specific ID incremented by
 // one. If it is possible, the vector v is updated and returned. If it is not,
-// a copy will be created, updated and returned.
+// v copy will be created, updated and returned.
 func (v Vector) Update(ID uint64) Vector {
 	for i := range v {
 		if v[i].ID == ID {
@@ -24,7 +24,7 @@ func (v Vector) Update(ID uint64) Vector {
 			v[i].Value++
 			return v
 		} else if v[i].ID > ID {
-			// Insert a new index
+			// Insert v new index
 			nv := make(Vector, len(v)+1)
 			copy(nv, v[:i])
 			nv[i].ID = ID
@@ -33,43 +33,43 @@ func (v Vector) Update(ID uint64) Vector {
 			return nv
 		}
 	}
-	// Append a new new index
+	// Append v new new index
 	return append(v, Counter{ID, 1})
 }
 
-// Merge returns the vector containing the maximum indexes from a and b. If it
-// is possible, the vector a is updated and returned. If it is not, a copy
+// Merge returns the vector containing the maximum indexes from v and b. If it
+// is possible, the vector v is updated and returned. If it is not, v copy
 // will be created, updated and returned.
-func (a Vector) Merge(b Vector) Vector {
-	var ai, bi int
+func (v Vector) Merge(b Vector) Vector {
+	var vi, bi int
 	for bi < len(b) {
-		if ai == len(a) {
-			// We've reach the end of a, all that remains are appends
-			return append(a, b[bi:]...)
+		if vi == len(v) {
+			// We've reach the end of v, all that remains are appends
+			return append(v, b[bi:]...)
 		}
 
-		if a[ai].ID > b[bi].ID {
+		if v[vi].ID > b[bi].ID {
 			// The index from b should be inserted here
-			n := make(Vector, len(a)+1)
-			copy(n, a[:ai])
-			n[ai] = b[bi]
-			copy(n[ai+1:], a[ai:])
-			a = n
+			n := make(Vector, len(v)+1)
+			copy(n, v[:vi])
+			n[vi] = b[bi]
+			copy(n[vi+1:], v[vi:])
+			v = n
 		}
 
-		if a[ai].ID == b[bi].ID {
-			if v := b[bi].Value; v > a[ai].Value {
-				a[ai].Value = v
+		if v[vi].ID == b[bi].ID {
+			if val := b[bi].Value; val > v[vi].Value {
+				v[vi].Value = val
 			}
 		}
 
-		if bi < len(b) && a[ai].ID == b[bi].ID {
+		if bi < len(b) && v[vi].ID == b[bi].ID {
 			bi++
 		}
-		ai++
+		vi++
 	}
 
-	return a
+	return v
 }
 
 // Copy returns an identical vector that is not shared with v.
@@ -80,27 +80,27 @@ func (v Vector) Copy() Vector {
 }
 
 // Equal returns true when the two vectors are equivalent.
-func (a Vector) Equal(b Vector) bool {
-	return a.Compare(b) == Equal
+func (v Vector) Equal(b Vector) bool {
+	return v.Compare(b) == Equal
 }
 
-// LesserEqual returns true when the two vectors are equivalent or a is Lesser
+// LesserEqual returns true when the two vectors are equivalent or v is Lesser
 // than b.
-func (a Vector) LesserEqual(b Vector) bool {
-	comp := a.Compare(b)
+func (v Vector) LesserEqual(b Vector) bool {
+	comp := v.Compare(b)
 	return comp == Lesser || comp == Equal
 }
 
-// LesserEqual returns true when the two vectors are equivalent or a is Greater
+// GreaterEqual returns true when the two vectors are equivalent or v is Greater
 // than b.
-func (a Vector) GreaterEqual(b Vector) bool {
-	comp := a.Compare(b)
+func (v Vector) GreaterEqual(b Vector) bool {
+	comp := v.Compare(b)
 	return comp == Greater || comp == Equal
 }
 
 // Concurrent returns true when the two vectors are concrurrent.
-func (a Vector) Concurrent(b Vector) bool {
-	comp := a.Compare(b)
+func (v Vector) Concurrent(b Vector) bool {
+	comp := v.Compare(b)
 	return comp == ConcurrentGreater || comp == ConcurrentLesser
 }
 
diff --git a/lib/protocol/vector_test.go b/lib/protocol/vector_test.go
index c01255e7a..55d9fdb93 100644
--- a/lib/protocol/vector_test.go
+++ b/lib/protocol/vector_test.go
@@ -123,12 +123,12 @@ func TestMerge(t *testing.T) {
 func TestCounterValue(t *testing.T) {
 	v0 := Vector{Counter{42, 1}, Counter{64, 5}}
 	if v0.Counter(42) != 1 {
-		t.Error("Counter error, %d != %d", v0.Counter(42), 1)
+		t.Errorf("Counter error, %d != %d", v0.Counter(42), 1)
 	}
 	if v0.Counter(64) != 5 {
-		t.Error("Counter error, %d != %d", v0.Counter(64), 5)
+		t.Errorf("Counter error, %d != %d", v0.Counter(64), 5)
 	}
 	if v0.Counter(72) != 0 {
-		t.Error("Counter error, %d != %d", v0.Counter(72), 0)
+		t.Errorf("Counter error, %d != %d", v0.Counter(72), 0)
 	}
 }
diff --git a/lib/relay/client/client.go b/lib/relay/client/client.go
index 2e1b51e03..658390887 100644
--- a/lib/relay/client/client.go
+++ b/lib/relay/client/client.go
@@ -182,7 +182,7 @@ func (c *ProtocolClient) String() string {
 
 func (c *ProtocolClient) connect() error {
 	if c.URI.Scheme != "relay" {
-		return fmt.Errorf("Unsupported relay schema:", c.URI.Scheme)
+		return fmt.Errorf("Unsupported relay schema: %v", c.URI.Scheme)
 	}
 
 	t0 := time.Now()
diff --git a/lib/relay/client/methods.go b/lib/relay/client/methods.go
index ced788b8a..8c07001af 100644
--- a/lib/relay/client/methods.go
+++ b/lib/relay/client/methods.go
@@ -17,7 +17,7 @@ import (
 
 func GetInvitationFromRelay(uri *url.URL, id syncthingprotocol.DeviceID, certs []tls.Certificate) (protocol.SessionInvitation, error) {
 	if uri.Scheme != "relay" {
-		return protocol.SessionInvitation{}, fmt.Errorf("Unsupported relay scheme:", uri.Scheme)
+		return protocol.SessionInvitation{}, fmt.Errorf("Unsupported relay scheme: %v", uri.Scheme)
 	}
 
 	conn, err := tls.Dial("tcp", uri.Host, configForCerts(certs))