From fcaa545e1ef4d68ae35dc064693da7df9b832204 Mon Sep 17 00:00:00 2001
From: Tzu-Jung Lee <roylee17@gmail.com>
Date: Mon, 16 Jan 2017 22:48:24 -0800
Subject: [PATCH 1/5] lint: remove dot import (go-common)

Spell out the package explicitly.
This commit is totally textual, and does not change any logic.

The swiss-army knife package may serve a kick-start in early
stage development. But as the codebase growing, we might want
to retire it gradually:

  For simple wrapping functions, just inline it on the call site.
  For larger pice of code, make it an independent package.
---
 client/client.go                        |  4 ++--
 client/grpc_client.go                   | 12 ++++++------
 client/local_client.go                  |  6 +++---
 client/socket_client.go                 | 16 ++++++++--------
 cmd/abci-cli/tmsp-cli.go                | 10 +++++-----
 cmd/counter/main.go                     |  6 +++---
 cmd/dummy/main.go                       |  6 +++---
 example/chain_aware/chain_aware_app.go  |  8 ++++----
 example/chain_aware/chain_aware_test.go |  4 ++--
 example/counter/counter.go              | 18 +++++++++---------
 example/dummy/dummy.go                  |  4 ++--
 example/dummy/dummy_test.go             |  6 +++---
 example/dummy/persistent_dummy.go       | 18 +++++++++---------
 example/example_test.go                 | 13 +++++++------
 server/grpc_server.go                   |  8 ++++----
 server/server.go                        |  6 +++---
 server/socket_server.go                 | 10 +++++-----
 tests/benchmarks/parallel/parallel.go   | 13 ++++++-------
 tests/benchmarks/simple/simple.go       | 11 +++++------
 tests/test_app/app.go                   | 18 +++++++++---------
 20 files changed, 98 insertions(+), 99 deletions(-)

diff --git a/client/client.go b/client/client.go
index cdeb4db0..dc70645e 100644
--- a/client/client.go
+++ b/client/client.go
@@ -5,11 +5,11 @@ import (
 	"sync"
 
 	"github.com/tendermint/abci/types"
-	. "github.com/tendermint/go-common"
+	common "github.com/tendermint/go-common"
 )
 
 type Client interface {
-	Service
+	common.Service
 
 	SetResponseCallback(Callback)
 	Error() error
diff --git a/client/grpc_client.go b/client/grpc_client.go
index 1a0e11d2..c48ebbcb 100644
--- a/client/grpc_client.go
+++ b/client/grpc_client.go
@@ -9,13 +9,13 @@ import (
 	grpc "google.golang.org/grpc"
 
 	"github.com/tendermint/abci/types"
-	. "github.com/tendermint/go-common"
+	common "github.com/tendermint/go-common"
 )
 
 // A stripped copy of the remoteClient that makes
 // synchronous calls using grpc
 type grpcClient struct {
-	BaseService
+	common.BaseService
 	mustConnect bool
 
 	client types.ABCIApplicationClient
@@ -31,13 +31,13 @@ func NewGRPCClient(addr string, mustConnect bool) (*grpcClient, error) {
 		addr:        addr,
 		mustConnect: mustConnect,
 	}
-	cli.BaseService = *NewBaseService(nil, "grpcClient", cli)
+	cli.BaseService = *common.NewBaseService(nil, "grpcClient", cli)
 	_, err := cli.Start() // Just start it, it's confusing for callers to remember to start.
 	return cli, err
 }
 
 func dialerFunc(addr string, timeout time.Duration) (net.Conn, error) {
-	return Connect(addr)
+	return common.Connect(addr)
 }
 
 func (cli *grpcClient) OnStart() error {
@@ -50,7 +50,7 @@ RETRY_LOOP:
 			if cli.mustConnect {
 				return err
 			} else {
-				log.Warn(Fmt("abci.grpcClient failed to connect to %v.  Retrying...\n", cli.addr))
+				log.Warn(common.Fmt("abci.grpcClient failed to connect to %v.  Retrying...\n", cli.addr))
 				time.Sleep(time.Second * 3)
 				continue RETRY_LOOP
 			}
@@ -93,7 +93,7 @@ func (cli *grpcClient) StopForError(err error) {
 	}
 	cli.mtx.Unlock()
 
-	log.Warn(Fmt("Stopping abci.grpcClient for error: %v", err.Error()))
+	log.Warn(common.Fmt("Stopping abci.grpcClient for error: %v", err.Error()))
 	cli.Stop()
 }
 
diff --git a/client/local_client.go b/client/local_client.go
index 33dd619b..235e3fce 100644
--- a/client/local_client.go
+++ b/client/local_client.go
@@ -4,11 +4,11 @@ import (
 	"sync"
 
 	types "github.com/tendermint/abci/types"
-	. "github.com/tendermint/go-common"
+	common "github.com/tendermint/go-common"
 )
 
 type localClient struct {
-	BaseService
+	common.BaseService
 	mtx *sync.Mutex
 	types.Application
 	Callback
@@ -22,7 +22,7 @@ func NewLocalClient(mtx *sync.Mutex, app types.Application) *localClient {
 		mtx:         mtx,
 		Application: app,
 	}
-	cli.BaseService = *NewBaseService(log, "localClient", cli)
+	cli.BaseService = *common.NewBaseService(log, "localClient", cli)
 	return cli
 }
 
diff --git a/client/socket_client.go b/client/socket_client.go
index 744b6c0c..9309b67a 100644
--- a/client/socket_client.go
+++ b/client/socket_client.go
@@ -11,7 +11,7 @@ import (
 	"time"
 
 	"github.com/tendermint/abci/types"
-	. "github.com/tendermint/go-common"
+	common "github.com/tendermint/go-common"
 )
 
 const (
@@ -27,10 +27,10 @@ const flushThrottleMS = 20      // Don't wait longer than...
 // the application in general is not meant to be interfaced
 // with concurrent callers.
 type socketClient struct {
-	BaseService
+	common.BaseService
 
 	reqQueue    chan *ReqRes
-	flushTimer  *ThrottleTimer
+	flushTimer  *common.ThrottleTimer
 	mustConnect bool
 
 	mtx     sync.Mutex
@@ -45,14 +45,14 @@ type socketClient struct {
 func NewSocketClient(addr string, mustConnect bool) (*socketClient, error) {
 	cli := &socketClient{
 		reqQueue:    make(chan *ReqRes, reqQueueSize),
-		flushTimer:  NewThrottleTimer("socketClient", flushThrottleMS),
+		flushTimer:  common.NewThrottleTimer("socketClient", flushThrottleMS),
 		mustConnect: mustConnect,
 
 		addr:    addr,
 		reqSent: list.New(),
 		resCb:   nil,
 	}
-	cli.BaseService = *NewBaseService(nil, "socketClient", cli)
+	cli.BaseService = *common.NewBaseService(nil, "socketClient", cli)
 
 	_, err := cli.Start() // Just start it, it's confusing for callers to remember to start.
 	return cli, err
@@ -65,12 +65,12 @@ func (cli *socketClient) OnStart() error {
 	var conn net.Conn
 RETRY_LOOP:
 	for {
-		conn, err = Connect(cli.addr)
+		conn, err = common.Connect(cli.addr)
 		if err != nil {
 			if cli.mustConnect {
 				return err
 			} else {
-				log.Warn(Fmt("abci.socketClient failed to connect to %v.  Retrying...", cli.addr))
+				log.Warn(common.Fmt("abci.socketClient failed to connect to %v.  Retrying...", cli.addr))
 				time.Sleep(time.Second * 3)
 				continue RETRY_LOOP
 			}
@@ -109,7 +109,7 @@ func (cli *socketClient) StopForError(err error) {
 	}
 	cli.mtx.Unlock()
 
-	log.Warn(Fmt("Stopping abci.socketClient for error: %v", err.Error()))
+	log.Warn(common.Fmt("Stopping abci.socketClient for error: %v", err.Error()))
 	cli.Stop()
 }
 
diff --git a/cmd/abci-cli/tmsp-cli.go b/cmd/abci-cli/tmsp-cli.go
index 39dace9f..99d22a08 100644
--- a/cmd/abci-cli/tmsp-cli.go
+++ b/cmd/abci-cli/tmsp-cli.go
@@ -11,7 +11,7 @@ import (
 
 	"github.com/tendermint/abci/client"
 	"github.com/tendermint/abci/types"
-	. "github.com/tendermint/go-common"
+	common "github.com/tendermint/go-common"
 	"github.com/urfave/cli"
 )
 
@@ -135,7 +135,7 @@ func main() {
 	app.Before = before
 	err := app.Run(os.Args)
 	if err != nil {
-		Exit(err.Error())
+		common.Exit(err.Error())
 	}
 
 }
@@ -145,7 +145,7 @@ func before(c *cli.Context) error {
 		var err error
 		client, err = abcicli.NewClient(c.GlobalString("address"), c.GlobalString("abci"), false)
 		if err != nil {
-			Exit(err.Error())
+			common.Exit(err.Error())
 		}
 	}
 	return nil
@@ -244,7 +244,7 @@ func cmdSetOption(c *cli.Context) error {
 		return errors.New("Command set_option takes 2 arguments (key, value)")
 	}
 	res := client.SetOptionSync(args[0], args[1])
-	rsp := newResponse(res, Fmt("%s=%s", args[0], args[1]), false)
+	rsp := newResponse(res, common.Fmt("%s=%s", args[0], args[1]), false)
 	printResponse(c, rsp)
 	return nil
 }
@@ -284,7 +284,7 @@ func cmdCheckTx(c *cli.Context) error {
 // Get application Merkle root hash
 func cmdCommit(c *cli.Context) error {
 	res := client.CommitSync()
-	rsp := newResponse(res, Fmt("0x%X", res.Data), false)
+	rsp := newResponse(res, common.Fmt("0x%X", res.Data), false)
 	printResponse(c, rsp)
 	return nil
 }
diff --git a/cmd/counter/main.go b/cmd/counter/main.go
index 0714380b..24abc5de 100644
--- a/cmd/counter/main.go
+++ b/cmd/counter/main.go
@@ -5,7 +5,7 @@ import (
 
 	"github.com/tendermint/abci/example/counter"
 	"github.com/tendermint/abci/server"
-	. "github.com/tendermint/go-common"
+	common "github.com/tendermint/go-common"
 )
 
 func main() {
@@ -19,11 +19,11 @@ func main() {
 	// Start the listener
 	srv, err := server.NewServer(*addrPtr, *abciPtr, app)
 	if err != nil {
-		Exit(err.Error())
+		common.Exit(err.Error())
 	}
 
 	// Wait forever
-	TrapSignal(func() {
+	common.TrapSignal(func() {
 		// Cleanup
 		srv.Stop()
 	})
diff --git a/cmd/dummy/main.go b/cmd/dummy/main.go
index 8167c354..503cf73b 100644
--- a/cmd/dummy/main.go
+++ b/cmd/dummy/main.go
@@ -6,7 +6,7 @@ import (
 	"github.com/tendermint/abci/example/dummy"
 	"github.com/tendermint/abci/server"
 	"github.com/tendermint/abci/types"
-	. "github.com/tendermint/go-common"
+	common "github.com/tendermint/go-common"
 )
 
 func main() {
@@ -27,11 +27,11 @@ func main() {
 	// Start the listener
 	srv, err := server.NewServer(*addrPtr, *abciPtr, app)
 	if err != nil {
-		Exit(err.Error())
+		common.Exit(err.Error())
 	}
 
 	// Wait forever
-	TrapSignal(func() {
+	common.TrapSignal(func() {
 		// Cleanup
 		srv.Stop()
 	})
diff --git a/example/chain_aware/chain_aware_app.go b/example/chain_aware/chain_aware_app.go
index 85ea7129..c0dc0d6e 100644
--- a/example/chain_aware/chain_aware_app.go
+++ b/example/chain_aware/chain_aware_app.go
@@ -5,7 +5,7 @@ import (
 
 	"github.com/tendermint/abci/server"
 	"github.com/tendermint/abci/types"
-	. "github.com/tendermint/go-common"
+	common "github.com/tendermint/go-common"
 )
 
 func main() {
@@ -17,11 +17,11 @@ func main() {
 	// Start the listener
 	srv, err := server.NewServer(*addrPtr, *abciPtr, NewChainAwareApplication())
 	if err != nil {
-		Exit(err.Error())
+		common.Exit(err.Error())
 	}
 
 	// Wait forever
-	TrapSignal(func() {
+	common.TrapSignal(func() {
 		// Cleanup
 		srv.Stop()
 	})
@@ -58,7 +58,7 @@ func (app *ChainAwareApplication) Commit() types.Result {
 }
 
 func (app *ChainAwareApplication) Query(query []byte) types.Result {
-	return types.NewResultOK([]byte(Fmt("%d,%d", app.beginCount, app.endCount)), "")
+	return types.NewResultOK([]byte(common.Fmt("%d,%d", app.beginCount, app.endCount)), "")
 }
 
 func (app *ChainAwareApplication) BeginBlock(hash []byte, header *types.Header) {
diff --git a/example/chain_aware/chain_aware_test.go b/example/chain_aware/chain_aware_test.go
index 942c9ba9..a19dd781 100644
--- a/example/chain_aware/chain_aware_test.go
+++ b/example/chain_aware/chain_aware_test.go
@@ -8,7 +8,7 @@ import (
 	"github.com/tendermint/abci/client"
 	"github.com/tendermint/abci/server"
 	"github.com/tendermint/abci/types"
-	. "github.com/tendermint/go-common"
+	common "github.com/tendermint/go-common"
 )
 
 func TestChainAware(t *testing.T) {
@@ -25,7 +25,7 @@ func TestChainAware(t *testing.T) {
 	// Connect to the socket
 	client, err := abcicli.NewSocketClient("unix://test.sock", false)
 	if err != nil {
-		Exit(Fmt("Error starting socket client: %v", err.Error()))
+		common.Exit(Fmt("Error starting socket client: %v", err.Error()))
 	}
 	client.Start()
 	defer client.Stop()
diff --git a/example/counter/counter.go b/example/counter/counter.go
index 1249f667..02ff00ee 100644
--- a/example/counter/counter.go
+++ b/example/counter/counter.go
@@ -4,7 +4,7 @@ import (
 	"encoding/binary"
 
 	"github.com/tendermint/abci/types"
-	. "github.com/tendermint/go-common"
+	common "github.com/tendermint/go-common"
 )
 
 type CounterApplication struct {
@@ -18,7 +18,7 @@ func NewCounterApplication(serial bool) *CounterApplication {
 }
 
 func (app *CounterApplication) Info() types.ResponseInfo {
-	return types.ResponseInfo{Data: Fmt("{\"hashes\":%v,\"txs\":%v}", app.hashCount, app.txCount)}
+	return types.ResponseInfo{Data: common.Fmt("{\"hashes\":%v,\"txs\":%v}", app.hashCount, app.txCount)}
 }
 
 func (app *CounterApplication) SetOption(key string, value string) (log string) {
@@ -31,13 +31,13 @@ func (app *CounterApplication) SetOption(key string, value string) (log string)
 func (app *CounterApplication) DeliverTx(tx []byte) types.Result {
 	if app.serial {
 		if len(tx) > 8 {
-			return types.ErrEncodingError.SetLog(Fmt("Max tx size is 8 bytes, got %d", len(tx)))
+			return types.ErrEncodingError.SetLog(common.Fmt("Max tx size is 8 bytes, got %d", len(tx)))
 		}
 		tx8 := make([]byte, 8)
 		copy(tx8[len(tx8)-len(tx):], tx)
 		txValue := binary.BigEndian.Uint64(tx8)
 		if txValue != uint64(app.txCount) {
-			return types.ErrBadNonce.SetLog(Fmt("Invalid nonce. Expected %v, got %v", app.txCount, txValue))
+			return types.ErrBadNonce.SetLog(common.Fmt("Invalid nonce. Expected %v, got %v", app.txCount, txValue))
 		}
 	}
 	app.txCount += 1
@@ -47,13 +47,13 @@ func (app *CounterApplication) DeliverTx(tx []byte) types.Result {
 func (app *CounterApplication) CheckTx(tx []byte) types.Result {
 	if app.serial {
 		if len(tx) > 8 {
-			return types.ErrEncodingError.SetLog(Fmt("Max tx size is 8 bytes, got %d", len(tx)))
+			return types.ErrEncodingError.SetLog(common.Fmt("Max tx size is 8 bytes, got %d", len(tx)))
 		}
 		tx8 := make([]byte, 8)
 		copy(tx8[len(tx8)-len(tx):], tx)
 		txValue := binary.BigEndian.Uint64(tx8)
 		if txValue < uint64(app.txCount) {
-			return types.ErrBadNonce.SetLog(Fmt("Invalid nonce. Expected >= %v, got %v", app.txCount, txValue))
+			return types.ErrBadNonce.SetLog(common.Fmt("Invalid nonce. Expected >= %v, got %v", app.txCount, txValue))
 		}
 	}
 	return types.OK
@@ -76,10 +76,10 @@ func (app *CounterApplication) Query(query []byte) types.Result {
 
 	switch queryStr {
 	case "hash":
-		return types.NewResultOK(nil, Fmt("%v", app.hashCount))
+		return types.NewResultOK(nil, common.Fmt("%v", app.hashCount))
 	case "tx":
-		return types.NewResultOK(nil, Fmt("%v", app.txCount))
+		return types.NewResultOK(nil, common.Fmt("%v", app.txCount))
 	}
 
-	return types.ErrUnknownRequest.SetLog(Fmt("Invalid nonce. Expected hash or tx, got %v", queryStr))
+	return types.ErrUnknownRequest.SetLog(common.Fmt("Invalid nonce. Expected hash or tx, got %v", queryStr))
 }
diff --git a/example/dummy/dummy.go b/example/dummy/dummy.go
index 6fdf8785..c49353e1 100644
--- a/example/dummy/dummy.go
+++ b/example/dummy/dummy.go
@@ -5,7 +5,7 @@ import (
 	"strings"
 
 	"github.com/tendermint/abci/types"
-	. "github.com/tendermint/go-common"
+	common "github.com/tendermint/go-common"
 	"github.com/tendermint/go-merkle"
 	"github.com/tendermint/go-wire"
 )
@@ -20,7 +20,7 @@ func NewDummyApplication() *DummyApplication {
 }
 
 func (app *DummyApplication) Info() (resInfo types.ResponseInfo) {
-	return types.ResponseInfo{Data: Fmt("{\"size\":%v}", app.state.Size())}
+	return types.ResponseInfo{Data: common.Fmt("{\"size\":%v}", app.state.Size())}
 }
 
 func (app *DummyApplication) SetOption(key string, value string) (log string) {
diff --git a/example/dummy/dummy_test.go b/example/dummy/dummy_test.go
index f745d2ea..9236068e 100644
--- a/example/dummy/dummy_test.go
+++ b/example/dummy/dummy_test.go
@@ -7,7 +7,7 @@ import (
 	"testing"
 
 	"github.com/tendermint/abci/types"
-	. "github.com/tendermint/go-common"
+	common "github.com/tendermint/go-common"
 	"github.com/tendermint/go-crypto"
 	"github.com/tendermint/go-wire"
 )
@@ -107,8 +107,8 @@ func TestValSetChanges(t *testing.T) {
 	nInit := 5
 	vals := make([]*types.Validator, total)
 	for i := 0; i < total; i++ {
-		pubkey := crypto.GenPrivKeyEd25519FromSecret([]byte(Fmt("test%d", i))).PubKey().Bytes()
-		power := RandInt()
+		pubkey := crypto.GenPrivKeyEd25519FromSecret([]byte(common.Fmt("test%d", i))).PubKey().Bytes()
+		power := common.RandInt()
 		vals[i] = &types.Validator{pubkey, uint64(power)}
 	}
 	// iniitalize with the first nInit
diff --git a/example/dummy/persistent_dummy.go b/example/dummy/persistent_dummy.go
index 550c5969..b7c1eb4b 100644
--- a/example/dummy/persistent_dummy.go
+++ b/example/dummy/persistent_dummy.go
@@ -7,7 +7,7 @@ import (
 	"strings"
 
 	"github.com/tendermint/abci/types"
-	. "github.com/tendermint/go-common"
+	common "github.com/tendermint/go-common"
 	dbm "github.com/tendermint/go-db"
 	"github.com/tendermint/go-merkle"
 	"github.com/tendermint/go-wire"
@@ -135,7 +135,7 @@ func LoadLastBlock(db dbm.DB) (lastBlock LastBlockInfo) {
 		wire.ReadBinaryPtr(&lastBlock, r, 0, n, err)
 		if *err != nil {
 			// DATA HAS BEEN CORRUPTED OR THE SPEC HAS CHANGED
-			Exit(Fmt("Data has been corrupted or its spec has changed: %v\n", *err))
+			common.Exit(common.Fmt("Data has been corrupted or its spec has changed: %v\n", *err))
 		}
 		// TODO: ensure that buf is completely read.
 	}
@@ -149,7 +149,7 @@ func SaveLastBlock(db dbm.DB, lastBlock LastBlockInfo) {
 	wire.WriteBinary(lastBlock, buf, n, err)
 	if *err != nil {
 		// TODO
-		PanicCrisis(*err)
+		common.PanicCrisis(*err)
 	}
 	db.Set(lastBlockKey, buf.Bytes())
 }
@@ -173,7 +173,7 @@ func (app *PersistentDummyApplication) Validators() (validators []*types.Validat
 }
 
 func MakeValSetChangeTx(pubkey []byte, power uint64) []byte {
-	return []byte(Fmt("val:%X/%d", pubkey, power))
+	return []byte(common.Fmt("val:%X/%d", pubkey, power))
 }
 
 func isValidatorTx(tx []byte) bool {
@@ -188,16 +188,16 @@ func (app *PersistentDummyApplication) execValidatorTx(tx []byte) types.Result {
 	tx = tx[len(ValidatorSetChangePrefix):]
 	pubKeyAndPower := strings.Split(string(tx), "/")
 	if len(pubKeyAndPower) != 2 {
-		return types.ErrEncodingError.SetLog(Fmt("Expected 'pubkey/power'. Got %v", pubKeyAndPower))
+		return types.ErrEncodingError.SetLog(common.Fmt("Expected 'pubkey/power'. Got %v", pubKeyAndPower))
 	}
 	pubkeyS, powerS := pubKeyAndPower[0], pubKeyAndPower[1]
 	pubkey, err := hex.DecodeString(pubkeyS)
 	if err != nil {
-		return types.ErrEncodingError.SetLog(Fmt("Pubkey (%s) is invalid hex", pubkeyS))
+		return types.ErrEncodingError.SetLog(common.Fmt("Pubkey (%s) is invalid hex", pubkeyS))
 	}
 	power, err := strconv.Atoi(powerS)
 	if err != nil {
-		return types.ErrEncodingError.SetLog(Fmt("Power (%s) is not an int", powerS))
+		return types.ErrEncodingError.SetLog(common.Fmt("Power (%s) is not an int", powerS))
 	}
 
 	// update
@@ -210,14 +210,14 @@ func (app *PersistentDummyApplication) updateValidator(v *types.Validator) types
 	if v.Power == 0 {
 		// remove validator
 		if !app.app.state.Has(key) {
-			return types.ErrUnauthorized.SetLog(Fmt("Cannot remove non-existent validator %X", key))
+			return types.ErrUnauthorized.SetLog(common.Fmt("Cannot remove non-existent validator %X", key))
 		}
 		app.app.state.Remove(key)
 	} else {
 		// add or update validator
 		value := bytes.NewBuffer(make([]byte, 0))
 		if err := types.WriteMessage(v, value); err != nil {
-			return types.ErrInternalError.SetLog(Fmt("Error encoding validator: %v", err))
+			return types.ErrInternalError.SetLog(common.Fmt("Error encoding validator: %v", err))
 		}
 		app.app.state.Set(key, value.Bytes())
 	}
diff --git a/example/example_test.go b/example/example_test.go
index fb15f503..94549994 100644
--- a/example/example_test.go
+++ b/example/example_test.go
@@ -7,15 +7,16 @@ import (
 	"testing"
 	"time"
 
-	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 
+	"golang.org/x/net/context"
+
 	"github.com/tendermint/abci/client"
 	"github.com/tendermint/abci/example/dummy"
 	nilapp "github.com/tendermint/abci/example/nil"
 	"github.com/tendermint/abci/server"
 	"github.com/tendermint/abci/types"
-	. "github.com/tendermint/go-common"
+	common "github.com/tendermint/go-common"
 )
 
 func TestDummy(t *testing.T) {
@@ -40,14 +41,14 @@ func testStream(t *testing.T, app types.Application) {
 	// Start the listener
 	server, err := server.NewSocketServer("unix://test.sock", app)
 	if err != nil {
-		Exit(Fmt("Error starting socket server: %v", err.Error()))
+		common.Exit(common.Fmt("Error starting socket server: %v", err.Error()))
 	}
 	defer server.Stop()
 
 	// Connect to the socket
 	client, err := abcicli.NewSocketClient("unix://test.sock", false)
 	if err != nil {
-		Exit(Fmt("Error starting socket client: %v", err.Error()))
+		common.Exit(common.Fmt("Error starting socket client: %v", err.Error()))
 	}
 	client.Start()
 	defer client.Stop()
@@ -113,14 +114,14 @@ func testGRPCSync(t *testing.T, app *types.GRPCApplication) {
 	// Start the listener
 	server, err := server.NewGRPCServer("unix://test.sock", app)
 	if err != nil {
-		Exit(Fmt("Error starting GRPC server: %v", err.Error()))
+		common.Exit(common.Fmt("Error starting GRPC server: %v", err.Error()))
 	}
 	defer server.Stop()
 
 	// Connect to the socket
 	conn, err := grpc.Dial("unix://test.sock", grpc.WithInsecure(), grpc.WithDialer(dialerFunc))
 	if err != nil {
-		Exit(Fmt("Error dialing GRPC server: %v", err.Error()))
+		common.Exit(common.Fmt("Error dialing GRPC server: %v", err.Error()))
 	}
 	defer conn.Close()
 
diff --git a/server/grpc_server.go b/server/grpc_server.go
index 07704c32..3893b20b 100644
--- a/server/grpc_server.go
+++ b/server/grpc_server.go
@@ -7,13 +7,13 @@ import (
 	"google.golang.org/grpc"
 
 	"github.com/tendermint/abci/types"
-	. "github.com/tendermint/go-common"
+	common "github.com/tendermint/go-common"
 )
 
 // var maxNumberConnections = 2
 
 type GRPCServer struct {
-	BaseService
+	common.BaseService
 
 	proto    string
 	addr     string
@@ -23,7 +23,7 @@ type GRPCServer struct {
 	app types.ABCIApplicationServer
 }
 
-func NewGRPCServer(protoAddr string, app types.ABCIApplicationServer) (Service, error) {
+func NewGRPCServer(protoAddr string, app types.ABCIApplicationServer) (common.Service, error) {
 	parts := strings.SplitN(protoAddr, "://", 2)
 	proto, addr := parts[0], parts[1]
 	s := &GRPCServer{
@@ -32,7 +32,7 @@ func NewGRPCServer(protoAddr string, app types.ABCIApplicationServer) (Service,
 		listener: nil,
 		app:      app,
 	}
-	s.BaseService = *NewBaseService(nil, "ABCIServer", s)
+	s.BaseService = *common.NewBaseService(nil, "ABCIServer", s)
 	_, err := s.Start() // Just start it
 	return s, err
 }
diff --git a/server/server.go b/server/server.go
index 6de8747b..1d42e7d5 100644
--- a/server/server.go
+++ b/server/server.go
@@ -4,11 +4,11 @@ import (
 	"fmt"
 
 	"github.com/tendermint/abci/types"
-	. "github.com/tendermint/go-common"
+	common "github.com/tendermint/go-common"
 )
 
-func NewServer(protoAddr, transport string, app types.Application) (Service, error) {
-	var s Service
+func NewServer(protoAddr, transport string, app types.Application) (common.Service, error) {
+	var s common.Service
 	var err error
 	switch transport {
 	case "socket":
diff --git a/server/socket_server.go b/server/socket_server.go
index 1ef47859..06bf0398 100644
--- a/server/socket_server.go
+++ b/server/socket_server.go
@@ -9,13 +9,13 @@ import (
 	"sync"
 
 	"github.com/tendermint/abci/types"
-	. "github.com/tendermint/go-common"
+	common "github.com/tendermint/go-common"
 )
 
 // var maxNumberConnections = 2
 
 type SocketServer struct {
-	BaseService
+	common.BaseService
 
 	proto    string
 	addr     string
@@ -29,7 +29,7 @@ type SocketServer struct {
 	app    types.Application
 }
 
-func NewSocketServer(protoAddr string, app types.Application) (Service, error) {
+func NewSocketServer(protoAddr string, app types.Application) (common.Service, error) {
 	parts := strings.SplitN(protoAddr, "://", 2)
 	proto, addr := parts[0], parts[1]
 	s := &SocketServer{
@@ -39,7 +39,7 @@ func NewSocketServer(protoAddr string, app types.Application) (Service, error) {
 		app:      app,
 		conns:    make(map[int]net.Conn),
 	}
-	s.BaseService = *NewBaseService(nil, "ABCIServer", s)
+	s.BaseService = *common.NewBaseService(nil, "ABCIServer", s)
 	_, err := s.Start() // Just start it
 	return s, err
 }
@@ -100,7 +100,7 @@ func (s *SocketServer) acceptConnectionsRoutine() {
 			if !s.IsRunning() {
 				return // Ignore error from listener closing.
 			}
-			Exit("Failed to accept connection: " + err.Error())
+			common.Exit("Failed to accept connection: " + err.Error())
 		} else {
 			log.Notice("Accepted a new connection")
 		}
diff --git a/tests/benchmarks/parallel/parallel.go b/tests/benchmarks/parallel/parallel.go
index 51d9a636..9b7176f3 100644
--- a/tests/benchmarks/parallel/parallel.go
+++ b/tests/benchmarks/parallel/parallel.go
@@ -3,17 +3,16 @@ package main
 import (
 	"bufio"
 	"fmt"
-	//"encoding/hex"
 
 	"github.com/tendermint/abci/types"
-	. "github.com/tendermint/go-common"
+	common "github.com/tendermint/go-common"
 )
 
 func main() {
 
-	conn, err := Connect("unix://test.sock")
+	conn, err := common.Connect("unix://test.sock")
 	if err != nil {
-		Exit(err.Error())
+		common.Exit(err.Error())
 	}
 
 	// Read a bunch of responses
@@ -23,7 +22,7 @@ func main() {
 			var res = &types.Response{}
 			err := types.ReadMessage(conn, res)
 			if err != nil {
-				Exit(err.Error())
+				common.Exit(err.Error())
 			}
 			counter += 1
 			if counter%1000 == 0 {
@@ -40,11 +39,11 @@ func main() {
 
 		err := types.WriteMessage(req, bufWriter)
 		if err != nil {
-			Exit(err.Error())
+			common.Exit(err.Error())
 		}
 		err = bufWriter.Flush()
 		if err != nil {
-			Exit(err.Error())
+			common.Exit(err.Error())
 		}
 
 		counter += 1
diff --git a/tests/benchmarks/simple/simple.go b/tests/benchmarks/simple/simple.go
index b1b71fb7..5076dc7a 100644
--- a/tests/benchmarks/simple/simple.go
+++ b/tests/benchmarks/simple/simple.go
@@ -6,17 +6,16 @@ import (
 	"fmt"
 	"net"
 	"reflect"
-	//"encoding/hex"
 
 	"github.com/tendermint/abci/types"
-	. "github.com/tendermint/go-common"
+	common "github.com/tendermint/go-common"
 )
 
 func main() {
 
-	conn, err := Connect("unix://test.sock")
+	conn, err := common.Connect("unix://test.sock")
 	if err != nil {
-		Exit(err.Error())
+		common.Exit(err.Error())
 	}
 
 	// Make a bunch of requests
@@ -25,7 +24,7 @@ func main() {
 		req := types.ToRequestEcho("foobar")
 		_, err := makeRequest(conn, req)
 		if err != nil {
-			Exit(err.Error())
+			common.Exit(err.Error())
 		}
 		counter += 1
 		if counter%1000 == 0 {
@@ -63,7 +62,7 @@ func makeRequest(conn net.Conn, req *types.Request) (*types.Response, error) {
 		return nil, err
 	}
 	if _, ok := resFlush.Value.(*types.Response_Flush); !ok {
-		return nil, errors.New(Fmt("Expected flush response but got something else: %v", reflect.TypeOf(resFlush)))
+		return nil, errors.New(common.Fmt("Expected flush response but got something else: %v", reflect.TypeOf(resFlush)))
 	}
 
 	return res, nil
diff --git a/tests/test_app/app.go b/tests/test_app/app.go
index b84b9386..ef932278 100644
--- a/tests/test_app/app.go
+++ b/tests/test_app/app.go
@@ -7,7 +7,7 @@ import (
 
 	"github.com/tendermint/abci/client"
 	"github.com/tendermint/abci/types"
-	. "github.com/tendermint/go-common"
+	common "github.com/tendermint/go-common"
 	"github.com/tendermint/go-process"
 )
 
@@ -46,7 +46,7 @@ func SetOption(client abcicli.Client, key, value string) {
 	res := client.SetOptionSync(key, value)
 	_, _, log := res.Code, res.Data, res.Log
 	if res.IsErr() {
-		panic(Fmt("setting %v=%v: \nlog: %v", key, value, log))
+		panic(common.Fmt("setting %v=%v: \nlog: %v", key, value, log))
 	}
 }
 
@@ -54,10 +54,10 @@ func Commit(client abcicli.Client, hashExp []byte) {
 	res := client.CommitSync()
 	_, data, log := res.Code, res.Data, res.Log
 	if res.IsErr() {
-		panic(Fmt("committing %v\nlog: %v", log))
+		panic(common.Fmt("committing %v\nlog: %v", log))
 	}
 	if !bytes.Equal(res.Data, hashExp) {
-		panic(Fmt("Commit hash was unexpected. Got %X expected %X",
+		panic(common.Fmt("Commit hash was unexpected. Got %X expected %X",
 			data, hashExp))
 	}
 }
@@ -66,11 +66,11 @@ func DeliverTx(client abcicli.Client, txBytes []byte, codeExp types.CodeType, da
 	res := client.DeliverTxSync(txBytes)
 	code, data, log := res.Code, res.Data, res.Log
 	if code != codeExp {
-		panic(Fmt("DeliverTx response code was unexpected. Got %v expected %v. Log: %v",
+		panic(common.Fmt("DeliverTx response code was unexpected. Got %v expected %v. Log: %v",
 			code, codeExp, log))
 	}
 	if !bytes.Equal(data, dataExp) {
-		panic(Fmt("DeliverTx response data was unexpected. Got %X expected %X",
+		panic(common.Fmt("DeliverTx response data was unexpected. Got %X expected %X",
 			data, dataExp))
 	}
 }
@@ -79,14 +79,14 @@ func CheckTx(client abcicli.Client, txBytes []byte, codeExp types.CodeType, data
 	res := client.CheckTxSync(txBytes)
 	code, data, log := res.Code, res.Data, res.Log
 	if res.IsErr() {
-		panic(Fmt("checking tx %X: %v\nlog: %v", txBytes, log))
+		panic(common.Fmt("checking tx %X: %v\nlog: %v", txBytes, log))
 	}
 	if code != codeExp {
-		panic(Fmt("CheckTx response code was unexpected. Got %v expected %v. Log: %v",
+		panic(common.Fmt("CheckTx response code was unexpected. Got %v expected %v. Log: %v",
 			code, codeExp, log))
 	}
 	if !bytes.Equal(data, dataExp) {
-		panic(Fmt("CheckTx response data was unexpected. Got %X expected %X",
+		panic(common.Fmt("CheckTx response data was unexpected. Got %X expected %X",
 			data, dataExp))
 	}
 }

From 1150bbfe367cc4596e4fe4d15c8e7d2ff9c61670 Mon Sep 17 00:00:00 2001
From: Tzu-Jung Lee <roylee17@gmail.com>
Date: Mon, 16 Jan 2017 22:59:46 -0800
Subject: [PATCH 2/5] lint: s/common.Fmt/fmt.Sprintf

---
 client/grpc_client.go                  |  5 +++--
 client/socket_client.go                |  4 ++--
 cmd/abci-cli/tmsp-cli.go               |  4 ++--
 example/chain_aware/chain_aware_app.go |  3 ++-
 example/counter/counter.go             | 18 +++++++++---------
 example/dummy/dummy.go                 |  4 ++--
 example/dummy/dummy_test.go            |  3 ++-
 example/dummy/persistent_dummy.go      | 15 ++++++++-------
 example/example_test.go                |  8 ++++----
 tests/benchmarks/simple/simple.go      |  2 +-
 tests/test_app/app.go                  | 16 ++++++++--------
 11 files changed, 43 insertions(+), 39 deletions(-)

diff --git a/client/grpc_client.go b/client/grpc_client.go
index c48ebbcb..3f568ac2 100644
--- a/client/grpc_client.go
+++ b/client/grpc_client.go
@@ -1,6 +1,7 @@
 package abcicli
 
 import (
+	"fmt"
 	"net"
 	"sync"
 	"time"
@@ -50,7 +51,7 @@ RETRY_LOOP:
 			if cli.mustConnect {
 				return err
 			} else {
-				log.Warn(common.Fmt("abci.grpcClient failed to connect to %v.  Retrying...\n", cli.addr))
+				log.Warn(fmt.Sprintf("abci.grpcClient failed to connect to %v.  Retrying...\n", cli.addr))
 				time.Sleep(time.Second * 3)
 				continue RETRY_LOOP
 			}
@@ -93,7 +94,7 @@ func (cli *grpcClient) StopForError(err error) {
 	}
 	cli.mtx.Unlock()
 
-	log.Warn(common.Fmt("Stopping abci.grpcClient for error: %v", err.Error()))
+	log.Warn(fmt.Sprintf("Stopping abci.grpcClient for error: %v", err.Error()))
 	cli.Stop()
 }
 
diff --git a/client/socket_client.go b/client/socket_client.go
index 9309b67a..2ed51ef4 100644
--- a/client/socket_client.go
+++ b/client/socket_client.go
@@ -70,7 +70,7 @@ RETRY_LOOP:
 			if cli.mustConnect {
 				return err
 			} else {
-				log.Warn(common.Fmt("abci.socketClient failed to connect to %v.  Retrying...", cli.addr))
+				log.Warn(fmt.Sprintf("abci.socketClient failed to connect to %v.  Retrying...", cli.addr))
 				time.Sleep(time.Second * 3)
 				continue RETRY_LOOP
 			}
@@ -109,7 +109,7 @@ func (cli *socketClient) StopForError(err error) {
 	}
 	cli.mtx.Unlock()
 
-	log.Warn(common.Fmt("Stopping abci.socketClient for error: %v", err.Error()))
+	log.Warn(fmt.Sprintf("Stopping abci.socketClient for error: %v", err.Error()))
 	cli.Stop()
 }
 
diff --git a/cmd/abci-cli/tmsp-cli.go b/cmd/abci-cli/tmsp-cli.go
index 99d22a08..d2227a68 100644
--- a/cmd/abci-cli/tmsp-cli.go
+++ b/cmd/abci-cli/tmsp-cli.go
@@ -244,7 +244,7 @@ func cmdSetOption(c *cli.Context) error {
 		return errors.New("Command set_option takes 2 arguments (key, value)")
 	}
 	res := client.SetOptionSync(args[0], args[1])
-	rsp := newResponse(res, common.Fmt("%s=%s", args[0], args[1]), false)
+	rsp := newResponse(res, fmt.Sprintf("%s=%s", args[0], args[1]), false)
 	printResponse(c, rsp)
 	return nil
 }
@@ -284,7 +284,7 @@ func cmdCheckTx(c *cli.Context) error {
 // Get application Merkle root hash
 func cmdCommit(c *cli.Context) error {
 	res := client.CommitSync()
-	rsp := newResponse(res, common.Fmt("0x%X", res.Data), false)
+	rsp := newResponse(res, fmt.Sprintf("0x%X", res.Data), false)
 	printResponse(c, rsp)
 	return nil
 }
diff --git a/example/chain_aware/chain_aware_app.go b/example/chain_aware/chain_aware_app.go
index c0dc0d6e..534135d1 100644
--- a/example/chain_aware/chain_aware_app.go
+++ b/example/chain_aware/chain_aware_app.go
@@ -2,6 +2,7 @@ package main
 
 import (
 	"flag"
+	"fmt"
 
 	"github.com/tendermint/abci/server"
 	"github.com/tendermint/abci/types"
@@ -58,7 +59,7 @@ func (app *ChainAwareApplication) Commit() types.Result {
 }
 
 func (app *ChainAwareApplication) Query(query []byte) types.Result {
-	return types.NewResultOK([]byte(common.Fmt("%d,%d", app.beginCount, app.endCount)), "")
+	return types.NewResultOK([]byte(fmt.Sprintf("%d,%d", app.beginCount, app.endCount)), "")
 }
 
 func (app *ChainAwareApplication) BeginBlock(hash []byte, header *types.Header) {
diff --git a/example/counter/counter.go b/example/counter/counter.go
index 02ff00ee..03861d0f 100644
--- a/example/counter/counter.go
+++ b/example/counter/counter.go
@@ -2,9 +2,9 @@ package counter
 
 import (
 	"encoding/binary"
+	"fmt"
 
 	"github.com/tendermint/abci/types"
-	common "github.com/tendermint/go-common"
 )
 
 type CounterApplication struct {
@@ -18,7 +18,7 @@ func NewCounterApplication(serial bool) *CounterApplication {
 }
 
 func (app *CounterApplication) Info() types.ResponseInfo {
-	return types.ResponseInfo{Data: common.Fmt("{\"hashes\":%v,\"txs\":%v}", app.hashCount, app.txCount)}
+	return types.ResponseInfo{Data: fmt.Sprintf("{\"hashes\":%v,\"txs\":%v}", app.hashCount, app.txCount)}
 }
 
 func (app *CounterApplication) SetOption(key string, value string) (log string) {
@@ -31,13 +31,13 @@ func (app *CounterApplication) SetOption(key string, value string) (log string)
 func (app *CounterApplication) DeliverTx(tx []byte) types.Result {
 	if app.serial {
 		if len(tx) > 8 {
-			return types.ErrEncodingError.SetLog(common.Fmt("Max tx size is 8 bytes, got %d", len(tx)))
+			return types.ErrEncodingError.SetLog(fmt.Sprintf("Max tx size is 8 bytes, got %d", len(tx)))
 		}
 		tx8 := make([]byte, 8)
 		copy(tx8[len(tx8)-len(tx):], tx)
 		txValue := binary.BigEndian.Uint64(tx8)
 		if txValue != uint64(app.txCount) {
-			return types.ErrBadNonce.SetLog(common.Fmt("Invalid nonce. Expected %v, got %v", app.txCount, txValue))
+			return types.ErrBadNonce.SetLog(fmt.Sprintf("Invalid nonce. Expected %v, got %v", app.txCount, txValue))
 		}
 	}
 	app.txCount += 1
@@ -47,13 +47,13 @@ func (app *CounterApplication) DeliverTx(tx []byte) types.Result {
 func (app *CounterApplication) CheckTx(tx []byte) types.Result {
 	if app.serial {
 		if len(tx) > 8 {
-			return types.ErrEncodingError.SetLog(common.Fmt("Max tx size is 8 bytes, got %d", len(tx)))
+			return types.ErrEncodingError.SetLog(fmt.Sprintf("Max tx size is 8 bytes, got %d", len(tx)))
 		}
 		tx8 := make([]byte, 8)
 		copy(tx8[len(tx8)-len(tx):], tx)
 		txValue := binary.BigEndian.Uint64(tx8)
 		if txValue < uint64(app.txCount) {
-			return types.ErrBadNonce.SetLog(common.Fmt("Invalid nonce. Expected >= %v, got %v", app.txCount, txValue))
+			return types.ErrBadNonce.SetLog(fmt.Sprintf("Invalid nonce. Expected >= %v, got %v", app.txCount, txValue))
 		}
 	}
 	return types.OK
@@ -76,10 +76,10 @@ func (app *CounterApplication) Query(query []byte) types.Result {
 
 	switch queryStr {
 	case "hash":
-		return types.NewResultOK(nil, common.Fmt("%v", app.hashCount))
+		return types.NewResultOK(nil, fmt.Sprintf("%v", app.hashCount))
 	case "tx":
-		return types.NewResultOK(nil, common.Fmt("%v", app.txCount))
+		return types.NewResultOK(nil, fmt.Sprintf("%v", app.txCount))
 	}
 
-	return types.ErrUnknownRequest.SetLog(common.Fmt("Invalid nonce. Expected hash or tx, got %v", queryStr))
+	return types.ErrUnknownRequest.SetLog(fmt.Sprintf("Invalid nonce. Expected hash or tx, got %v", queryStr))
 }
diff --git a/example/dummy/dummy.go b/example/dummy/dummy.go
index c49353e1..b514e43c 100644
--- a/example/dummy/dummy.go
+++ b/example/dummy/dummy.go
@@ -2,10 +2,10 @@ package dummy
 
 import (
 	"encoding/hex"
+	"fmt"
 	"strings"
 
 	"github.com/tendermint/abci/types"
-	common "github.com/tendermint/go-common"
 	"github.com/tendermint/go-merkle"
 	"github.com/tendermint/go-wire"
 )
@@ -20,7 +20,7 @@ func NewDummyApplication() *DummyApplication {
 }
 
 func (app *DummyApplication) Info() (resInfo types.ResponseInfo) {
-	return types.ResponseInfo{Data: common.Fmt("{\"size\":%v}", app.state.Size())}
+	return types.ResponseInfo{Data: fmt.Sprintf("{\"size\":%v}", app.state.Size())}
 }
 
 func (app *DummyApplication) SetOption(key string, value string) (log string) {
diff --git a/example/dummy/dummy_test.go b/example/dummy/dummy_test.go
index 9236068e..ca1ec7f9 100644
--- a/example/dummy/dummy_test.go
+++ b/example/dummy/dummy_test.go
@@ -2,6 +2,7 @@ package dummy
 
 import (
 	"bytes"
+	"fmt"
 	"io/ioutil"
 	"sort"
 	"testing"
@@ -107,7 +108,7 @@ func TestValSetChanges(t *testing.T) {
 	nInit := 5
 	vals := make([]*types.Validator, total)
 	for i := 0; i < total; i++ {
-		pubkey := crypto.GenPrivKeyEd25519FromSecret([]byte(common.Fmt("test%d", i))).PubKey().Bytes()
+		pubkey := crypto.GenPrivKeyEd25519FromSecret([]byte(fmt.Sprintf("test%d", i))).PubKey().Bytes()
 		power := common.RandInt()
 		vals[i] = &types.Validator{pubkey, uint64(power)}
 	}
diff --git a/example/dummy/persistent_dummy.go b/example/dummy/persistent_dummy.go
index b7c1eb4b..f7302b9d 100644
--- a/example/dummy/persistent_dummy.go
+++ b/example/dummy/persistent_dummy.go
@@ -3,6 +3,7 @@ package dummy
 import (
 	"bytes"
 	"encoding/hex"
+	"fmt"
 	"strconv"
 	"strings"
 
@@ -135,7 +136,7 @@ func LoadLastBlock(db dbm.DB) (lastBlock LastBlockInfo) {
 		wire.ReadBinaryPtr(&lastBlock, r, 0, n, err)
 		if *err != nil {
 			// DATA HAS BEEN CORRUPTED OR THE SPEC HAS CHANGED
-			common.Exit(common.Fmt("Data has been corrupted or its spec has changed: %v\n", *err))
+			common.Exit(fmt.Sprintf("Data has been corrupted or its spec has changed: %v\n", *err))
 		}
 		// TODO: ensure that buf is completely read.
 	}
@@ -173,7 +174,7 @@ func (app *PersistentDummyApplication) Validators() (validators []*types.Validat
 }
 
 func MakeValSetChangeTx(pubkey []byte, power uint64) []byte {
-	return []byte(common.Fmt("val:%X/%d", pubkey, power))
+	return []byte(fmt.Sprintf("val:%X/%d", pubkey, power))
 }
 
 func isValidatorTx(tx []byte) bool {
@@ -188,16 +189,16 @@ func (app *PersistentDummyApplication) execValidatorTx(tx []byte) types.Result {
 	tx = tx[len(ValidatorSetChangePrefix):]
 	pubKeyAndPower := strings.Split(string(tx), "/")
 	if len(pubKeyAndPower) != 2 {
-		return types.ErrEncodingError.SetLog(common.Fmt("Expected 'pubkey/power'. Got %v", pubKeyAndPower))
+		return types.ErrEncodingError.SetLog(fmt.Sprintf("Expected 'pubkey/power'. Got %v", pubKeyAndPower))
 	}
 	pubkeyS, powerS := pubKeyAndPower[0], pubKeyAndPower[1]
 	pubkey, err := hex.DecodeString(pubkeyS)
 	if err != nil {
-		return types.ErrEncodingError.SetLog(common.Fmt("Pubkey (%s) is invalid hex", pubkeyS))
+		return types.ErrEncodingError.SetLog(fmt.Sprintf("Pubkey (%s) is invalid hex", pubkeyS))
 	}
 	power, err := strconv.Atoi(powerS)
 	if err != nil {
-		return types.ErrEncodingError.SetLog(common.Fmt("Power (%s) is not an int", powerS))
+		return types.ErrEncodingError.SetLog(fmt.Sprintf("Power (%s) is not an int", powerS))
 	}
 
 	// update
@@ -210,14 +211,14 @@ func (app *PersistentDummyApplication) updateValidator(v *types.Validator) types
 	if v.Power == 0 {
 		// remove validator
 		if !app.app.state.Has(key) {
-			return types.ErrUnauthorized.SetLog(common.Fmt("Cannot remove non-existent validator %X", key))
+			return types.ErrUnauthorized.SetLog(fmt.Sprintf("Cannot remove non-existent validator %X", key))
 		}
 		app.app.state.Remove(key)
 	} else {
 		// add or update validator
 		value := bytes.NewBuffer(make([]byte, 0))
 		if err := types.WriteMessage(v, value); err != nil {
-			return types.ErrInternalError.SetLog(common.Fmt("Error encoding validator: %v", err))
+			return types.ErrInternalError.SetLog(fmt.Sprintf("Error encoding validator: %v", err))
 		}
 		app.app.state.Set(key, value.Bytes())
 	}
diff --git a/example/example_test.go b/example/example_test.go
index 94549994..f47962fb 100644
--- a/example/example_test.go
+++ b/example/example_test.go
@@ -41,14 +41,14 @@ func testStream(t *testing.T, app types.Application) {
 	// Start the listener
 	server, err := server.NewSocketServer("unix://test.sock", app)
 	if err != nil {
-		common.Exit(common.Fmt("Error starting socket server: %v", err.Error()))
+		common.Exit(fmt.Sprintf("Error starting socket server: %v", err.Error()))
 	}
 	defer server.Stop()
 
 	// Connect to the socket
 	client, err := abcicli.NewSocketClient("unix://test.sock", false)
 	if err != nil {
-		common.Exit(common.Fmt("Error starting socket client: %v", err.Error()))
+		common.Exit(fmt.Sprintf("Error starting socket client: %v", err.Error()))
 	}
 	client.Start()
 	defer client.Stop()
@@ -114,14 +114,14 @@ func testGRPCSync(t *testing.T, app *types.GRPCApplication) {
 	// Start the listener
 	server, err := server.NewGRPCServer("unix://test.sock", app)
 	if err != nil {
-		common.Exit(common.Fmt("Error starting GRPC server: %v", err.Error()))
+		common.Exit(fmt.Sprintf("Error starting GRPC server: %v", err.Error()))
 	}
 	defer server.Stop()
 
 	// Connect to the socket
 	conn, err := grpc.Dial("unix://test.sock", grpc.WithInsecure(), grpc.WithDialer(dialerFunc))
 	if err != nil {
-		common.Exit(common.Fmt("Error dialing GRPC server: %v", err.Error()))
+		common.Exit(fmt.Sprintf("Error dialing GRPC server: %v", err.Error()))
 	}
 	defer conn.Close()
 
diff --git a/tests/benchmarks/simple/simple.go b/tests/benchmarks/simple/simple.go
index 5076dc7a..d99c1b56 100644
--- a/tests/benchmarks/simple/simple.go
+++ b/tests/benchmarks/simple/simple.go
@@ -62,7 +62,7 @@ func makeRequest(conn net.Conn, req *types.Request) (*types.Response, error) {
 		return nil, err
 	}
 	if _, ok := resFlush.Value.(*types.Response_Flush); !ok {
-		return nil, errors.New(common.Fmt("Expected flush response but got something else: %v", reflect.TypeOf(resFlush)))
+		return nil, errors.New(fmt.Sprintf("Expected flush response but got something else: %v", reflect.TypeOf(resFlush)))
 	}
 
 	return res, nil
diff --git a/tests/test_app/app.go b/tests/test_app/app.go
index ef932278..8651cd4b 100644
--- a/tests/test_app/app.go
+++ b/tests/test_app/app.go
@@ -46,7 +46,7 @@ func SetOption(client abcicli.Client, key, value string) {
 	res := client.SetOptionSync(key, value)
 	_, _, log := res.Code, res.Data, res.Log
 	if res.IsErr() {
-		panic(common.Fmt("setting %v=%v: \nlog: %v", key, value, log))
+		panic(fmt.Sprintf("setting %v=%v: \nlog: %v", key, value, log))
 	}
 }
 
@@ -54,10 +54,10 @@ func Commit(client abcicli.Client, hashExp []byte) {
 	res := client.CommitSync()
 	_, data, log := res.Code, res.Data, res.Log
 	if res.IsErr() {
-		panic(common.Fmt("committing %v\nlog: %v", log))
+		panic(fmt.Sprintf("committing %v\nlog: %v", log))
 	}
 	if !bytes.Equal(res.Data, hashExp) {
-		panic(common.Fmt("Commit hash was unexpected. Got %X expected %X",
+		panic(fmt.Sprintf("Commit hash was unexpected. Got %X expected %X",
 			data, hashExp))
 	}
 }
@@ -66,11 +66,11 @@ func DeliverTx(client abcicli.Client, txBytes []byte, codeExp types.CodeType, da
 	res := client.DeliverTxSync(txBytes)
 	code, data, log := res.Code, res.Data, res.Log
 	if code != codeExp {
-		panic(common.Fmt("DeliverTx response code was unexpected. Got %v expected %v. Log: %v",
+		panic(fmt.Sprintf("DeliverTx response code was unexpected. Got %v expected %v. Log: %v",
 			code, codeExp, log))
 	}
 	if !bytes.Equal(data, dataExp) {
-		panic(common.Fmt("DeliverTx response data was unexpected. Got %X expected %X",
+		panic(fmt.Sprintf("DeliverTx response data was unexpected. Got %X expected %X",
 			data, dataExp))
 	}
 }
@@ -79,14 +79,14 @@ func CheckTx(client abcicli.Client, txBytes []byte, codeExp types.CodeType, data
 	res := client.CheckTxSync(txBytes)
 	code, data, log := res.Code, res.Data, res.Log
 	if res.IsErr() {
-		panic(common.Fmt("checking tx %X: %v\nlog: %v", txBytes, log))
+		panic(fmt.Sprintf("checking tx %X: %v\nlog: %v", txBytes, log))
 	}
 	if code != codeExp {
-		panic(common.Fmt("CheckTx response code was unexpected. Got %v expected %v. Log: %v",
+		panic(fmt.Sprintf("CheckTx response code was unexpected. Got %v expected %v. Log: %v",
 			code, codeExp, log))
 	}
 	if !bytes.Equal(data, dataExp) {
-		panic(common.Fmt("CheckTx response data was unexpected. Got %X expected %X",
+		panic(fmt.Sprintf("CheckTx response data was unexpected. Got %X expected %X",
 			data, dataExp))
 	}
 }

From 9134905f42da8fd5829fbcfe33907b9f35d8fd43 Mon Sep 17 00:00:00 2001
From: Tzu-Jung Lee <roylee17@gmail.com>
Date: Mon, 16 Jan 2017 23:09:33 -0800
Subject: [PATCH 3/5] cleanup: replace common.Exit with log.Crit or log.Fatal

Later we can pick another logger that has fatal, like zap?
---
 cmd/abci-cli/tmsp-cli.go                |  6 +++---
 cmd/counter/main.go                     |  3 ++-
 cmd/dummy/main.go                       |  3 ++-
 example/chain_aware/chain_aware_app.go  |  3 ++-
 example/chain_aware/chain_aware_test.go |  5 +++--
 example/dummy/persistent_dummy.go       |  2 +-
 example/example_test.go                 | 11 ++++++-----
 server/socket_server.go                 |  2 +-
 tests/benchmarks/parallel/parallel.go   |  9 +++++----
 tests/benchmarks/simple/simple.go       |  5 +++--
 10 files changed, 28 insertions(+), 21 deletions(-)

diff --git a/cmd/abci-cli/tmsp-cli.go b/cmd/abci-cli/tmsp-cli.go
index d2227a68..a5e32d0e 100644
--- a/cmd/abci-cli/tmsp-cli.go
+++ b/cmd/abci-cli/tmsp-cli.go
@@ -6,12 +6,12 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"log"
 	"os"
 	"strings"
 
 	"github.com/tendermint/abci/client"
 	"github.com/tendermint/abci/types"
-	common "github.com/tendermint/go-common"
 	"github.com/urfave/cli"
 )
 
@@ -135,7 +135,7 @@ func main() {
 	app.Before = before
 	err := app.Run(os.Args)
 	if err != nil {
-		common.Exit(err.Error())
+		log.Fatal(err.Error())
 	}
 
 }
@@ -145,7 +145,7 @@ func before(c *cli.Context) error {
 		var err error
 		client, err = abcicli.NewClient(c.GlobalString("address"), c.GlobalString("abci"), false)
 		if err != nil {
-			common.Exit(err.Error())
+			log.Fatal(err.Error())
 		}
 	}
 	return nil
diff --git a/cmd/counter/main.go b/cmd/counter/main.go
index 24abc5de..c547d372 100644
--- a/cmd/counter/main.go
+++ b/cmd/counter/main.go
@@ -2,6 +2,7 @@ package main
 
 import (
 	"flag"
+	"log"
 
 	"github.com/tendermint/abci/example/counter"
 	"github.com/tendermint/abci/server"
@@ -19,7 +20,7 @@ func main() {
 	// Start the listener
 	srv, err := server.NewServer(*addrPtr, *abciPtr, app)
 	if err != nil {
-		common.Exit(err.Error())
+		log.Fatal(err.Error())
 	}
 
 	// Wait forever
diff --git a/cmd/dummy/main.go b/cmd/dummy/main.go
index 503cf73b..71102e1a 100644
--- a/cmd/dummy/main.go
+++ b/cmd/dummy/main.go
@@ -2,6 +2,7 @@ package main
 
 import (
 	"flag"
+	"log"
 
 	"github.com/tendermint/abci/example/dummy"
 	"github.com/tendermint/abci/server"
@@ -27,7 +28,7 @@ func main() {
 	// Start the listener
 	srv, err := server.NewServer(*addrPtr, *abciPtr, app)
 	if err != nil {
-		common.Exit(err.Error())
+		log.Fatal(err.Error())
 	}
 
 	// Wait forever
diff --git a/example/chain_aware/chain_aware_app.go b/example/chain_aware/chain_aware_app.go
index 534135d1..92fdad3d 100644
--- a/example/chain_aware/chain_aware_app.go
+++ b/example/chain_aware/chain_aware_app.go
@@ -3,6 +3,7 @@ package main
 import (
 	"flag"
 	"fmt"
+	"log"
 
 	"github.com/tendermint/abci/server"
 	"github.com/tendermint/abci/types"
@@ -18,7 +19,7 @@ func main() {
 	// Start the listener
 	srv, err := server.NewServer(*addrPtr, *abciPtr, NewChainAwareApplication())
 	if err != nil {
-		common.Exit(err.Error())
+		log.Fatal(err.Error())
 	}
 
 	// Wait forever
diff --git a/example/chain_aware/chain_aware_test.go b/example/chain_aware/chain_aware_test.go
index a19dd781..d3ece608 100644
--- a/example/chain_aware/chain_aware_test.go
+++ b/example/chain_aware/chain_aware_test.go
@@ -1,6 +1,8 @@
 package main
 
 import (
+	"fmt"
+	"log"
 	"strconv"
 	"strings"
 	"testing"
@@ -8,7 +10,6 @@ import (
 	"github.com/tendermint/abci/client"
 	"github.com/tendermint/abci/server"
 	"github.com/tendermint/abci/types"
-	common "github.com/tendermint/go-common"
 )
 
 func TestChainAware(t *testing.T) {
@@ -25,7 +26,7 @@ func TestChainAware(t *testing.T) {
 	// Connect to the socket
 	client, err := abcicli.NewSocketClient("unix://test.sock", false)
 	if err != nil {
-		common.Exit(Fmt("Error starting socket client: %v", err.Error()))
+		log.Fatal(fmt.Sprintf("Error starting socket client: %v", err.Error()))
 	}
 	client.Start()
 	defer client.Stop()
diff --git a/example/dummy/persistent_dummy.go b/example/dummy/persistent_dummy.go
index f7302b9d..40c85aea 100644
--- a/example/dummy/persistent_dummy.go
+++ b/example/dummy/persistent_dummy.go
@@ -136,7 +136,7 @@ func LoadLastBlock(db dbm.DB) (lastBlock LastBlockInfo) {
 		wire.ReadBinaryPtr(&lastBlock, r, 0, n, err)
 		if *err != nil {
 			// DATA HAS BEEN CORRUPTED OR THE SPEC HAS CHANGED
-			common.Exit(fmt.Sprintf("Data has been corrupted or its spec has changed: %v\n", *err))
+			log.Crit(fmt.Sprintf("Data has been corrupted or its spec has changed: %v\n", *err))
 		}
 		// TODO: ensure that buf is completely read.
 	}
diff --git a/example/example_test.go b/example/example_test.go
index f47962fb..f31b3974 100644
--- a/example/example_test.go
+++ b/example/example_test.go
@@ -2,6 +2,7 @@ package example
 
 import (
 	"fmt"
+	"log"
 	"net"
 	"reflect"
 	"testing"
@@ -41,14 +42,14 @@ func testStream(t *testing.T, app types.Application) {
 	// Start the listener
 	server, err := server.NewSocketServer("unix://test.sock", app)
 	if err != nil {
-		common.Exit(fmt.Sprintf("Error starting socket server: %v", err.Error()))
+		log.Fatal(fmt.Sprintf("Error starting socket server: %v", err.Error()))
 	}
 	defer server.Stop()
 
 	// Connect to the socket
 	client, err := abcicli.NewSocketClient("unix://test.sock", false)
 	if err != nil {
-		common.Exit(fmt.Sprintf("Error starting socket client: %v", err.Error()))
+		log.Fatal(fmt.Sprintf("Error starting socket client: %v", err.Error()))
 	}
 	client.Start()
 	defer client.Stop()
@@ -104,7 +105,7 @@ func testStream(t *testing.T, app types.Application) {
 // test grpc
 
 func dialerFunc(addr string, timeout time.Duration) (net.Conn, error) {
-	return Connect(addr)
+	return common.Connect(addr)
 }
 
 func testGRPCSync(t *testing.T, app *types.GRPCApplication) {
@@ -114,14 +115,14 @@ func testGRPCSync(t *testing.T, app *types.GRPCApplication) {
 	// Start the listener
 	server, err := server.NewGRPCServer("unix://test.sock", app)
 	if err != nil {
-		common.Exit(fmt.Sprintf("Error starting GRPC server: %v", err.Error()))
+		log.Fatal(fmt.Sprintf("Error starting GRPC server: %v", err.Error()))
 	}
 	defer server.Stop()
 
 	// Connect to the socket
 	conn, err := grpc.Dial("unix://test.sock", grpc.WithInsecure(), grpc.WithDialer(dialerFunc))
 	if err != nil {
-		common.Exit(fmt.Sprintf("Error dialing GRPC server: %v", err.Error()))
+		log.Fatal(fmt.Sprintf("Error dialing GRPC server: %v", err.Error()))
 	}
 	defer conn.Close()
 
diff --git a/server/socket_server.go b/server/socket_server.go
index 06bf0398..8fe445cd 100644
--- a/server/socket_server.go
+++ b/server/socket_server.go
@@ -100,7 +100,7 @@ func (s *SocketServer) acceptConnectionsRoutine() {
 			if !s.IsRunning() {
 				return // Ignore error from listener closing.
 			}
-			common.Exit("Failed to accept connection: " + err.Error())
+			log.Crit("Failed to accept connection: " + err.Error())
 		} else {
 			log.Notice("Accepted a new connection")
 		}
diff --git a/tests/benchmarks/parallel/parallel.go b/tests/benchmarks/parallel/parallel.go
index 9b7176f3..88d19f32 100644
--- a/tests/benchmarks/parallel/parallel.go
+++ b/tests/benchmarks/parallel/parallel.go
@@ -3,6 +3,7 @@ package main
 import (
 	"bufio"
 	"fmt"
+	"log"
 
 	"github.com/tendermint/abci/types"
 	common "github.com/tendermint/go-common"
@@ -12,7 +13,7 @@ func main() {
 
 	conn, err := common.Connect("unix://test.sock")
 	if err != nil {
-		common.Exit(err.Error())
+		log.Fatal(err.Error())
 	}
 
 	// Read a bunch of responses
@@ -22,7 +23,7 @@ func main() {
 			var res = &types.Response{}
 			err := types.ReadMessage(conn, res)
 			if err != nil {
-				common.Exit(err.Error())
+				log.Fatal(err.Error())
 			}
 			counter += 1
 			if counter%1000 == 0 {
@@ -39,11 +40,11 @@ func main() {
 
 		err := types.WriteMessage(req, bufWriter)
 		if err != nil {
-			common.Exit(err.Error())
+			log.Fatal(err.Error())
 		}
 		err = bufWriter.Flush()
 		if err != nil {
-			common.Exit(err.Error())
+			log.Fatal(err.Error())
 		}
 
 		counter += 1
diff --git a/tests/benchmarks/simple/simple.go b/tests/benchmarks/simple/simple.go
index d99c1b56..bd97567d 100644
--- a/tests/benchmarks/simple/simple.go
+++ b/tests/benchmarks/simple/simple.go
@@ -4,6 +4,7 @@ import (
 	"bufio"
 	"errors"
 	"fmt"
+	"log"
 	"net"
 	"reflect"
 
@@ -15,7 +16,7 @@ func main() {
 
 	conn, err := common.Connect("unix://test.sock")
 	if err != nil {
-		common.Exit(err.Error())
+		log.Fatal(err.Error())
 	}
 
 	// Make a bunch of requests
@@ -24,7 +25,7 @@ func main() {
 		req := types.ToRequestEcho("foobar")
 		_, err := makeRequest(conn, req)
 		if err != nil {
-			common.Exit(err.Error())
+			log.Fatal(err.Error())
 		}
 		counter += 1
 		if counter%1000 == 0 {

From af2a66b2263425461fc955fe9cb3726a0693caef Mon Sep 17 00:00:00 2001
From: Tzu-Jung Lee <roylee17@gmail.com>
Date: Mon, 16 Jan 2017 23:23:06 -0800
Subject: [PATCH 4/5] test_app: unexport internal function.

This reverts commit 24c9b2761d7da5ab5084310f0cb3e51c7fc9738d.
---
 tests/test_app/app.go  | 16 +++++++---------
 tests/test_app/main.go | 30 +++++++++++++++---------------
 2 files changed, 22 insertions(+), 24 deletions(-)

diff --git a/tests/test_app/app.go b/tests/test_app/app.go
index 8651cd4b..87b74ead 100644
--- a/tests/test_app/app.go
+++ b/tests/test_app/app.go
@@ -2,18 +2,16 @@ package main
 
 import (
 	"bytes"
+	"fmt"
 	"os"
 	"time"
 
 	"github.com/tendermint/abci/client"
 	"github.com/tendermint/abci/types"
-	common "github.com/tendermint/go-common"
 	"github.com/tendermint/go-process"
 )
 
-//----------------------------------------
-
-func StartApp(abciApp string) *process.Process {
+func startApp(abciApp string) *process.Process {
 	// Start the app
 	//outBuf := NewBufferCloser(nil)
 	proc, err := process.StartProcess("abci_app",
@@ -33,7 +31,7 @@ func StartApp(abciApp string) *process.Process {
 	return proc
 }
 
-func StartClient(abciType string) abcicli.Client {
+func startClient(abciType string) abcicli.Client {
 	// Start client
 	client, err := abcicli.NewClient("tcp://127.0.0.1:46658", abciType, true)
 	if err != nil {
@@ -42,7 +40,7 @@ func StartClient(abciType string) abcicli.Client {
 	return client
 }
 
-func SetOption(client abcicli.Client, key, value string) {
+func setOption(client abcicli.Client, key, value string) {
 	res := client.SetOptionSync(key, value)
 	_, _, log := res.Code, res.Data, res.Log
 	if res.IsErr() {
@@ -50,7 +48,7 @@ func SetOption(client abcicli.Client, key, value string) {
 	}
 }
 
-func Commit(client abcicli.Client, hashExp []byte) {
+func commit(client abcicli.Client, hashExp []byte) {
 	res := client.CommitSync()
 	_, data, log := res.Code, res.Data, res.Log
 	if res.IsErr() {
@@ -62,7 +60,7 @@ func Commit(client abcicli.Client, hashExp []byte) {
 	}
 }
 
-func DeliverTx(client abcicli.Client, txBytes []byte, codeExp types.CodeType, dataExp []byte) {
+func deliverTx(client abcicli.Client, txBytes []byte, codeExp types.CodeType, dataExp []byte) {
 	res := client.DeliverTxSync(txBytes)
 	code, data, log := res.Code, res.Data, res.Log
 	if code != codeExp {
@@ -75,7 +73,7 @@ func DeliverTx(client abcicli.Client, txBytes []byte, codeExp types.CodeType, da
 	}
 }
 
-func CheckTx(client abcicli.Client, txBytes []byte, codeExp types.CodeType, dataExp []byte) {
+func checkTx(client abcicli.Client, txBytes []byte, codeExp types.CodeType, dataExp []byte) {
 	res := client.CheckTxSync(txBytes)
 	code, data, log := res.Code, res.Data, res.Log
 	if res.IsErr() {
diff --git a/tests/test_app/main.go b/tests/test_app/main.go
index 05f66b07..376c02fe 100644
--- a/tests/test_app/main.go
+++ b/tests/test_app/main.go
@@ -27,22 +27,22 @@ func testCounter() {
 	}
 
 	fmt.Printf("Running %s test with abci=%s\n", abciApp, abciType)
-	appProc := StartApp(abciApp)
+	appProc := startApp(abciApp)
 	defer appProc.StopProcess(true)
-	client := StartClient(abciType)
+	client := startClient(abciType)
 	defer client.Stop()
 
-	SetOption(client, "serial", "on")
-	Commit(client, nil)
-	DeliverTx(client, []byte("abc"), types.CodeType_BadNonce, nil)
-	Commit(client, nil)
-	DeliverTx(client, []byte{0x00}, types.CodeType_OK, nil)
-	Commit(client, []byte{0, 0, 0, 0, 0, 0, 0, 1})
-	DeliverTx(client, []byte{0x00}, types.CodeType_BadNonce, nil)
-	DeliverTx(client, []byte{0x01}, types.CodeType_OK, nil)
-	DeliverTx(client, []byte{0x00, 0x02}, types.CodeType_OK, nil)
-	DeliverTx(client, []byte{0x00, 0x03}, types.CodeType_OK, nil)
-	DeliverTx(client, []byte{0x00, 0x00, 0x04}, types.CodeType_OK, nil)
-	DeliverTx(client, []byte{0x00, 0x00, 0x06}, types.CodeType_BadNonce, nil)
-	Commit(client, []byte{0, 0, 0, 0, 0, 0, 0, 5})
+	setOption(client, "serial", "on")
+	commit(client, nil)
+	deliverTx(client, []byte("abc"), types.CodeType_BadNonce, nil)
+	commit(client, nil)
+	deliverTx(client, []byte{0x00}, types.CodeType_OK, nil)
+	commit(client, []byte{0, 0, 0, 0, 0, 0, 0, 1})
+	deliverTx(client, []byte{0x00}, types.CodeType_BadNonce, nil)
+	deliverTx(client, []byte{0x01}, types.CodeType_OK, nil)
+	deliverTx(client, []byte{0x00, 0x02}, types.CodeType_OK, nil)
+	deliverTx(client, []byte{0x00, 0x03}, types.CodeType_OK, nil)
+	deliverTx(client, []byte{0x00, 0x00, 0x04}, types.CodeType_OK, nil)
+	deliverTx(client, []byte{0x00, 0x00, 0x06}, types.CodeType_BadNonce, nil)
+	commit(client, []byte{0, 0, 0, 0, 0, 0, 0, 5})
 }

From 55cb08722df2e06ecad6a66ddb0b43f3c791aa71 Mon Sep 17 00:00:00 2001
From: Tzu-Jung Lee <roylee17@gmail.com>
Date: Tue, 17 Jan 2017 00:26:32 -0800
Subject: [PATCH 5/5] lint: s/+=1/++, remove else clauses

---
 client/grpc_client.go                  | 21 +++++++++------------
 client/socket_client.go                | 22 +++++++++-------------
 example/chain_aware/chain_aware_app.go |  4 ++--
 example/counter/counter.go             | 12 +++++-------
 example/example_test.go                |  4 ++--
 server/socket_server.go                |  2 +-
 tests/benchmarks/parallel/parallel.go  |  4 ++--
 tests/benchmarks/simple/simple.go      |  5 ++---
 8 files changed, 32 insertions(+), 42 deletions(-)

diff --git a/client/grpc_client.go b/client/grpc_client.go
index 3f568ac2..ec6dcdb7 100644
--- a/client/grpc_client.go
+++ b/client/grpc_client.go
@@ -50,11 +50,10 @@ RETRY_LOOP:
 		if err != nil {
 			if cli.mustConnect {
 				return err
-			} else {
-				log.Warn(fmt.Sprintf("abci.grpcClient failed to connect to %v.  Retrying...\n", cli.addr))
-				time.Sleep(time.Second * 3)
-				continue RETRY_LOOP
 			}
+			log.Warn(fmt.Sprintf("abci.grpcClient failed to connect to %v.  Retrying...\n", cli.addr))
+			time.Sleep(time.Second * 3)
+			continue RETRY_LOOP
 		}
 
 		client := types.NewABCIApplicationClient(conn)
@@ -268,11 +267,10 @@ func (cli *grpcClient) InfoSync() (resInfo types.ResponseInfo, err error) {
 	if err = cli.Error(); err != nil {
 		return resInfo, err
 	}
-	if resInfo_ := reqres.Response.GetInfo(); resInfo_ != nil {
-		return *resInfo_, nil
-	} else {
-		return resInfo, nil
+	if info := reqres.Response.GetInfo(); info != nil {
+		return *info, nil
 	}
+	return resInfo, nil
 }
 
 func (cli *grpcClient) SetOptionSync(key string, value string) (res types.Result) {
@@ -335,9 +333,8 @@ func (cli *grpcClient) EndBlockSync(height uint64) (resEndBlock types.ResponseEn
 	if err := cli.Error(); err != nil {
 		return resEndBlock, err
 	}
-	if resEndBlock_ := reqres.Response.GetEndBlock(); resEndBlock_ != nil {
-		return *resEndBlock_, nil
-	} else {
-		return resEndBlock, nil
+	if blk := reqres.Response.GetEndBlock(); blk != nil {
+		return *blk, nil
 	}
+	return resEndBlock, nil
 }
diff --git a/client/socket_client.go b/client/socket_client.go
index 2ed51ef4..a0def235 100644
--- a/client/socket_client.go
+++ b/client/socket_client.go
@@ -69,11 +69,10 @@ RETRY_LOOP:
 		if err != nil {
 			if cli.mustConnect {
 				return err
-			} else {
-				log.Warn(fmt.Sprintf("abci.socketClient failed to connect to %v.  Retrying...", cli.addr))
-				time.Sleep(time.Second * 3)
-				continue RETRY_LOOP
 			}
+			log.Warn(fmt.Sprintf("abci.socketClient failed to connect to %v.  Retrying...", cli.addr))
+			time.Sleep(time.Second * 3)
+			continue RETRY_LOOP
 		}
 		cli.conn = conn
 
@@ -82,7 +81,6 @@ RETRY_LOOP:
 
 		return nil
 	}
-	return nil // never happens
 }
 
 func (cli *socketClient) OnStop() {
@@ -298,11 +296,10 @@ func (cli *socketClient) InfoSync() (resInfo types.ResponseInfo, err error) {
 	if err := cli.Error(); err != nil {
 		return resInfo, err
 	}
-	if resInfo_ := reqres.Response.GetInfo(); resInfo_ != nil {
-		return *resInfo_, nil
-	} else {
-		return resInfo, nil
+	if info := reqres.Response.GetInfo(); info != nil {
+		return *info, nil
 	}
+	return resInfo, nil
 }
 
 func (cli *socketClient) SetOptionSync(key string, value string) (res types.Result) {
@@ -379,11 +376,10 @@ func (cli *socketClient) EndBlockSync(height uint64) (resEndBlock types.Response
 	if err := cli.Error(); err != nil {
 		return resEndBlock, err
 	}
-	if resEndBlock_ := reqres.Response.GetEndBlock(); resEndBlock_ != nil {
-		return *resEndBlock_, nil
-	} else {
-		return resEndBlock, nil
+	if blk := reqres.Response.GetEndBlock(); blk != nil {
+		return *blk, nil
 	}
+	return resEndBlock, nil
 }
 
 //----------------------------------------
diff --git a/example/chain_aware/chain_aware_app.go b/example/chain_aware/chain_aware_app.go
index 92fdad3d..a9a23375 100644
--- a/example/chain_aware/chain_aware_app.go
+++ b/example/chain_aware/chain_aware_app.go
@@ -64,12 +64,12 @@ func (app *ChainAwareApplication) Query(query []byte) types.Result {
 }
 
 func (app *ChainAwareApplication) BeginBlock(hash []byte, header *types.Header) {
-	app.beginCount += 1
+	app.beginCount++
 	return
 }
 
 func (app *ChainAwareApplication) EndBlock(height uint64) (resEndBlock types.ResponseEndBlock) {
-	app.endCount += 1
+	app.endCount++
 	return
 }
 
diff --git a/example/counter/counter.go b/example/counter/counter.go
index 03861d0f..00e71f38 100644
--- a/example/counter/counter.go
+++ b/example/counter/counter.go
@@ -40,7 +40,7 @@ func (app *CounterApplication) DeliverTx(tx []byte) types.Result {
 			return types.ErrBadNonce.SetLog(fmt.Sprintf("Invalid nonce. Expected %v, got %v", app.txCount, txValue))
 		}
 	}
-	app.txCount += 1
+	app.txCount++
 	return types.OK
 }
 
@@ -60,15 +60,13 @@ func (app *CounterApplication) CheckTx(tx []byte) types.Result {
 }
 
 func (app *CounterApplication) Commit() types.Result {
-	app.hashCount += 1
-
+	app.hashCount++
 	if app.txCount == 0 {
 		return types.OK
-	} else {
-		hash := make([]byte, 8)
-		binary.BigEndian.PutUint64(hash, uint64(app.txCount))
-		return types.NewResultOK(hash, "")
 	}
+	hash := make([]byte, 8)
+	binary.BigEndian.PutUint64(hash, uint64(app.txCount))
+	return types.NewResultOK(hash, "")
 }
 
 func (app *CounterApplication) Query(query []byte) types.Result {
diff --git a/example/example_test.go b/example/example_test.go
index f31b3974..b60fc276 100644
--- a/example/example_test.go
+++ b/example/example_test.go
@@ -60,7 +60,7 @@ func testStream(t *testing.T, app types.Application) {
 		// Process response
 		switch r := res.Value.(type) {
 		case *types.Response_DeliverTx:
-			counter += 1
+			counter++
 			if r.DeliverTx.Code != types.CodeType_OK {
 				t.Error("DeliverTx failed with ret_code", r.DeliverTx.Code)
 			}
@@ -135,7 +135,7 @@ func testGRPCSync(t *testing.T, app *types.GRPCApplication) {
 		if err != nil {
 			t.Fatalf("Error in GRPC DeliverTx: %v", err.Error())
 		}
-		counter += 1
+		counter++
 		if response.Code != types.CodeType_OK {
 			t.Error("DeliverTx failed with ret_code", response.Code)
 		}
diff --git a/server/socket_server.go b/server/socket_server.go
index 8fe445cd..070fba8c 100644
--- a/server/socket_server.go
+++ b/server/socket_server.go
@@ -72,7 +72,7 @@ func (s *SocketServer) addConn(conn net.Conn) int {
 	defer s.connsMtx.Unlock()
 
 	connID := s.nextConnID
-	s.nextConnID += 1
+	s.nextConnID++
 	s.conns[connID] = conn
 
 	return connID
diff --git a/tests/benchmarks/parallel/parallel.go b/tests/benchmarks/parallel/parallel.go
index 88d19f32..ac8d4e9e 100644
--- a/tests/benchmarks/parallel/parallel.go
+++ b/tests/benchmarks/parallel/parallel.go
@@ -25,7 +25,7 @@ func main() {
 			if err != nil {
 				log.Fatal(err.Error())
 			}
-			counter += 1
+			counter++
 			if counter%1000 == 0 {
 				fmt.Println("Read", counter)
 			}
@@ -47,7 +47,7 @@ func main() {
 			log.Fatal(err.Error())
 		}
 
-		counter += 1
+		counter++
 		if counter%1000 == 0 {
 			fmt.Println("Write", counter)
 		}
diff --git a/tests/benchmarks/simple/simple.go b/tests/benchmarks/simple/simple.go
index bd97567d..75b66923 100644
--- a/tests/benchmarks/simple/simple.go
+++ b/tests/benchmarks/simple/simple.go
@@ -2,7 +2,6 @@ package main
 
 import (
 	"bufio"
-	"errors"
 	"fmt"
 	"log"
 	"net"
@@ -27,7 +26,7 @@ func main() {
 		if err != nil {
 			log.Fatal(err.Error())
 		}
-		counter += 1
+		counter++
 		if counter%1000 == 0 {
 			fmt.Println(counter)
 		}
@@ -63,7 +62,7 @@ func makeRequest(conn net.Conn, req *types.Request) (*types.Response, error) {
 		return nil, err
 	}
 	if _, ok := resFlush.Value.(*types.Response_Flush); !ok {
-		return nil, errors.New(fmt.Sprintf("Expected flush response but got something else: %v", reflect.TypeOf(resFlush)))
+		return nil, fmt.Errorf("Expected flush response but got something else: %v", reflect.TypeOf(resFlush))
 	}
 
 	return res, nil