diff --git a/client/connection.go b/client/connection.go
index 35e3027..4fda637 100644
--- a/client/connection.go
+++ b/client/connection.go
@@ -24,8 +24,7 @@ type Conn struct {
 	commands *cSet
 
 	// State tracker for nicks and channels
-	ST         state.StateTracker
-	st         bool
+	st         state.Tracker
 	stRemovers []Remover
 
 	// Use the State field to store external state that handlers might need.
@@ -100,32 +99,34 @@ func Client(nick string, args ...string) *Conn {
 }
 
 func (conn *Conn) EnableStateTracking() {
-	if !conn.st {
+	if conn.st == nil {
 		n := conn.Me
-		conn.ST = state.NewTracker(n.Nick)
-		conn.Me = conn.ST.Me()
+		conn.st = state.NewTracker(n.Nick)
+		conn.Me = conn.st.Me()
 		conn.Me.Ident = n.Ident
 		conn.Me.Name = n.Name
 		conn.addSTHandlers()
-		conn.st = true
 	}
 }
 
 func (conn *Conn) DisableStateTracking() {
-	if conn.st {
-		conn.st = false
+	if conn.st != nil {
 		conn.delSTHandlers()
-		conn.ST.Wipe()
-		conn.ST = nil
+		conn.st.Wipe()
+		conn.st = nil
 	}
 }
 
+func (conn *Conn) StateTracker() state.Tracker {
+	return conn.st
+}
+
 // Per-connection state initialisation.
 func (conn *Conn) initialise() {
 	conn.io = nil
 	conn.sock = nil
-	if conn.st {
-		conn.ST.Wipe()
+	if conn.st != nil {
+		conn.st.Wipe()
 	}
 }
 
@@ -328,8 +329,8 @@ func (conn *Conn) String() string {
 		str += "Not currently connected!\n\n"
 	}
 	str += conn.Me.String() + "\n"
-	if conn.st {
-		str += conn.ST.String() + "\n"
+	if conn.st != nil {
+		str += conn.st.String() + "\n"
 	}
 	return str
 }
diff --git a/client/connection_test.go b/client/connection_test.go
index 40ebd7d..f8b5950 100644
--- a/client/connection_test.go
+++ b/client/connection_test.go
@@ -12,20 +12,19 @@ import (
 
 type testState struct {
 	ctrl *gomock.Controller
-	st   *state.MockStateTracker
+	st   *state.MockTracker
 	nc   *mockNetConn
 	c    *Conn
 }
 
 func setUp(t *testing.T, start ...bool) (*Conn, *testState) {
 	ctrl := gomock.NewController(t)
-	st := state.NewMockStateTracker(ctrl)
+	st := state.NewMockTracker(ctrl)
 	nc := MockNetConn(t)
 	c := Client("test", "test", "Testing IRC")
 	logging.SetLogLevel(logging.LogFatal)
 
-	c.ST = st
-	c.st = true
+	c.st = st
 	c.sock = nc
 	c.Flood = true // Tests can take a while otherwise
 	c.Connected = true
@@ -82,7 +81,7 @@ func TestEOF(t *testing.T) {
 
 func TestClientAndStateTracking(t *testing.T) {
 	ctrl := gomock.NewController(t)
-	st := state.NewMockStateTracker(ctrl)
+	st := state.NewMockTracker(ctrl)
 	c := Client("test", "test", "Testing IRC")
 
 	// Assert some basic things about the initial state of the Conn struct
@@ -114,16 +113,16 @@ func TestClientAndStateTracking(t *testing.T) {
 		c.Me.Name != "Testing IRC" || c.Me.Host != "" {
 		t.Errorf("Enabling state tracking did not replace Me correctly.")
 	}
-	if !c.st || c.ST == nil || c.Me != c.ST.Me() {
+	if c.st == nil || c.Me != c.st.Me() {
 		t.Errorf("State tracker not enabled correctly.")
 	}
 
 	// Now, shim in the mock state tracker and test disabling state tracking
 	me := c.Me
-	c.ST = st
+	c.st = st
 	st.EXPECT().Wipe()
 	c.DisableStateTracking()
-	if c.st || c.ST != nil || c.Me != me {
+	if c.st != nil || c.Me != me {
 		t.Errorf("State tracker not disabled correctly.")
 	}
 
diff --git a/client/handlers.go b/client/handlers.go
index d6ab8b2..6b34977 100644
--- a/client/handlers.go
+++ b/client/handlers.go
@@ -60,8 +60,8 @@ func (conn *Conn) h_433(line *Line) {
 	// we sent in the initial NICK command is in use) we will not receive
 	// a NICK message to confirm our change of nick, so ReNick here...
 	if line.Args[1] == conn.Me.Nick {
-		if conn.st {
-			conn.ST.ReNick(conn.Me.Nick, neu)
+		if conn.st != nil {
+			conn.st.ReNick(conn.Me.Nick, neu)
 		} else {
 			conn.Me.Nick = neu
 		}
@@ -79,7 +79,7 @@ func (conn *Conn) h_CTCP(line *Line) {
 
 // Handle updating our own NICK if we're not using the state tracker
 func (conn *Conn) h_NICK(line *Line) {
-	if !conn.st && line.Nick == conn.Me.Nick {
+	if conn.st == nil && line.Nick == conn.Me.Nick {
 		conn.Me.Nick = line.Args[0]
 	}
 }
diff --git a/client/handlers_test.go b/client/handlers_test.go
index 846644c..1231bab 100644
--- a/client/handlers_test.go
+++ b/client/handlers_test.go
@@ -74,14 +74,14 @@ func Test433(t *testing.T) {
 	}
 
 	// Test the code path that *doesn't* involve state tracking.
-	c.st = false
+	c.st = nil
 	c.h_433(parseLine(":irc.server.org 433 test test :Nickname is already in use."))
 	s.nc.Expect("NICK test_")
 
 	if c.Me.Nick != "test_" {
 		t.Errorf("My nick not updated from '%s'.", c.Me.Nick)
 	}
-	c.st = true
+	c.st = s.st
 }
 
 // Test the handler for NICK messages when state tracking is disabled
@@ -90,7 +90,7 @@ func TestNICK(t *testing.T) {
 	defer s.tearDown()
 
 	// State tracking is enabled by default in setUp
-	c.st = false
+	c.st = nil
 
 	// Call handler with a NICK line changing "our" nick to test1.
 	c.h_NICK(parseLine(":test!test@somehost.com NICK :test1"))
@@ -109,7 +109,7 @@ func TestNICK(t *testing.T) {
 	}
 
 	// Re-enable state tracking and send a line that *should* change nick.
-	c.st = true
+	c.st = s.st
 	c.h_NICK(parseLine(":test1!test@somehost.com NICK :test2"))
 
 	// Verify that our Nick hasn't changed (should be handled by h_STNICK).
diff --git a/client/state_handlers.go b/client/state_handlers.go
index ffc9211..44758be 100644
--- a/client/state_handlers.go
+++ b/client/state_handlers.go
@@ -40,13 +40,13 @@ func (conn *Conn) delSTHandlers() {
 // Handle NICK messages that need to update the state tracker
 func (conn *Conn) h_STNICK(line *Line) {
 	// all nicks should be handled the same way, our own included
-	conn.ST.ReNick(line.Nick, line.Args[0])
+	conn.st.ReNick(line.Nick, line.Args[0])
 }
 
 // Handle JOINs to channels to maintain state
 func (conn *Conn) h_JOIN(line *Line) {
-	ch := conn.ST.GetChannel(line.Args[0])
-	nk := conn.ST.GetNick(line.Nick)
+	ch := conn.st.GetChannel(line.Args[0])
+	nk := conn.st.GetNick(line.Nick)
 	if ch == nil {
 		// first we've seen of this channel, so should be us joining it
 		// NOTE this will also take care of nk == nil && ch == nil
@@ -55,7 +55,7 @@ func (conn *Conn) h_JOIN(line *Line) {
 				"from (non-me) nick %s", line.Args[0], line.Nick)
 			return
 		}
-		ch = conn.ST.NewChannel(line.Args[0])
+		ch = conn.st.NewChannel(line.Args[0])
 		// since we don't know much about this channel, ask server for info
 		// we get the channel users automatically in 353 and the channel
 		// topic in 332 on join, so we just need to get the modes
@@ -66,41 +66,41 @@ func (conn *Conn) h_JOIN(line *Line) {
 	}
 	if nk == nil {
 		// this is the first we've seen of this nick
-		nk = conn.ST.NewNick(line.Nick)
+		nk = conn.st.NewNick(line.Nick)
 		nk.Ident = line.Ident
 		nk.Host = line.Host
 		// since we don't know much about this nick, ask server for info
 		conn.Who(nk.Nick)
 	}
 	// this takes care of both nick and channel linking \o/
-	conn.ST.Associate(ch, nk)
+	conn.st.Associate(ch, nk)
 }
 
 // Handle PARTs from channels to maintain state
 func (conn *Conn) h_PART(line *Line) {
-	conn.ST.Dissociate(conn.ST.GetChannel(line.Args[0]),
-		conn.ST.GetNick(line.Nick))
+	conn.st.Dissociate(conn.st.GetChannel(line.Args[0]),
+		conn.st.GetNick(line.Nick))
 }
 
 // Handle KICKs from channels to maintain state
 func (conn *Conn) h_KICK(line *Line) {
 	// XXX: this won't handle autorejoining channels on KICK
 	// it's trivial to do this in a seperate handler...
-	conn.ST.Dissociate(conn.ST.GetChannel(line.Args[0]),
-		conn.ST.GetNick(line.Args[1]))
+	conn.st.Dissociate(conn.st.GetChannel(line.Args[0]),
+		conn.st.GetNick(line.Args[1]))
 }
 
 // Handle other people's QUITs
 func (conn *Conn) h_QUIT(line *Line) {
-	conn.ST.DelNick(line.Nick)
+	conn.st.DelNick(line.Nick)
 }
 
 // Handle MODE changes for channels we know about (and our nick personally)
 func (conn *Conn) h_MODE(line *Line) {
-	if ch := conn.ST.GetChannel(line.Args[0]); ch != nil {
+	if ch := conn.st.GetChannel(line.Args[0]); ch != nil {
 		// channel modes first
 		ch.ParseModes(line.Args[1], line.Args[2:]...)
-	} else if nk := conn.ST.GetNick(line.Args[0]); nk != nil {
+	} else if nk := conn.st.GetNick(line.Args[0]); nk != nil {
 		// nick mode change, should be us
 		if nk != conn.Me {
 			logging.Warn("irc.MODE(): recieved MODE %s for (non-me) nick %s",
@@ -116,7 +116,7 @@ func (conn *Conn) h_MODE(line *Line) {
 
 // Handle TOPIC changes for channels
 func (conn *Conn) h_TOPIC(line *Line) {
-	if ch := conn.ST.GetChannel(line.Args[0]); ch != nil {
+	if ch := conn.st.GetChannel(line.Args[0]); ch != nil {
 		ch.Topic = line.Args[1]
 	} else {
 		logging.Warn("irc.TOPIC(): topic change on unknown channel %s",
@@ -126,7 +126,7 @@ func (conn *Conn) h_TOPIC(line *Line) {
 
 // Handle 311 whois reply
 func (conn *Conn) h_311(line *Line) {
-	if nk := conn.ST.GetNick(line.Args[1]); nk != nil {
+	if nk := conn.st.GetNick(line.Args[1]); nk != nil {
 		nk.Ident = line.Args[2]
 		nk.Host = line.Args[3]
 		nk.Name = line.Args[5]
@@ -138,7 +138,7 @@ func (conn *Conn) h_311(line *Line) {
 
 // Handle 324 mode reply
 func (conn *Conn) h_324(line *Line) {
-	if ch := conn.ST.GetChannel(line.Args[1]); ch != nil {
+	if ch := conn.st.GetChannel(line.Args[1]); ch != nil {
 		ch.ParseModes(line.Args[2], line.Args[3:]...)
 	} else {
 		logging.Warn("irc.324(): received MODE settings for unknown channel %s",
@@ -148,7 +148,7 @@ func (conn *Conn) h_324(line *Line) {
 
 // Handle 332 topic reply on join to channel
 func (conn *Conn) h_332(line *Line) {
-	if ch := conn.ST.GetChannel(line.Args[1]); ch != nil {
+	if ch := conn.st.GetChannel(line.Args[1]); ch != nil {
 		ch.Topic = line.Args[2]
 	} else {
 		logging.Warn("irc.332(): received TOPIC value for unknown channel %s",
@@ -158,7 +158,7 @@ func (conn *Conn) h_332(line *Line) {
 
 // Handle 352 who reply
 func (conn *Conn) h_352(line *Line) {
-	if nk := conn.ST.GetNick(line.Args[5]); nk != nil {
+	if nk := conn.st.GetNick(line.Args[5]); nk != nil {
 		nk.Ident = line.Args[2]
 		nk.Host = line.Args[3]
 		// XXX: do we care about the actual server the nick is on?
@@ -180,7 +180,7 @@ func (conn *Conn) h_352(line *Line) {
 
 // Handle 353 names reply
 func (conn *Conn) h_353(line *Line) {
-	if ch := conn.ST.GetChannel(line.Args[2]); ch != nil {
+	if ch := conn.st.GetChannel(line.Args[2]); ch != nil {
 		nicks := strings.Split(line.Args[len(line.Args)-1], " ")
 		for _, nick := range nicks {
 			// UnrealIRCd's coders are lazy and leave a trailing space
@@ -192,15 +192,15 @@ func (conn *Conn) h_353(line *Line) {
 				nick = nick[1:]
 				fallthrough
 			default:
-				nk := conn.ST.GetNick(nick)
+				nk := conn.st.GetNick(nick)
 				if nk == nil {
 					// we don't know this nick yet!
-					nk = conn.ST.NewNick(nick)
+					nk = conn.st.NewNick(nick)
 				}
-				cp, ok := conn.ST.IsOn(ch.Name, nick)
+				cp, ok := conn.st.IsOn(ch.Name, nick)
 				if !ok {
 					// This nick isn't associated with this channel yet!
-					cp = conn.ST.Associate(ch, nk)
+					cp = conn.st.Associate(ch, nk)
 				}
 				switch c {
 				case '~':
@@ -224,7 +224,7 @@ func (conn *Conn) h_353(line *Line) {
 
 // Handle 671 whois reply (nick connected via SSL)
 func (conn *Conn) h_671(line *Line) {
-	if nk := conn.ST.GetNick(line.Args[1]); nk != nil {
+	if nk := conn.st.GetNick(line.Args[1]); nk != nil {
 		nk.Modes.SSL = true
 	} else {
 		logging.Warn("irc.671(): received WHOIS SSL info for unknown nick %s",
diff --git a/state/mock_tracker.go b/state/mock_tracker.go
index 2be887e..310b5b7 100644
--- a/state/mock_tracker.go
+++ b/state/mock_tracker.go
@@ -7,144 +7,144 @@ import (
 	gomock "code.google.com/p/gomock/gomock"
 )
 
-// Mock of StateTracker interface
-type MockStateTracker struct {
+// Mock of Tracker interface
+type MockTracker struct {
 	ctrl     *gomock.Controller
-	recorder *_MockStateTrackerRecorder
+	recorder *_MockTrackerRecorder
 }
 
-// Recorder for MockStateTracker (not exported)
-type _MockStateTrackerRecorder struct {
-	mock *MockStateTracker
+// Recorder for MockTracker (not exported)
+type _MockTrackerRecorder struct {
+	mock *MockTracker
 }
 
-func NewMockStateTracker(ctrl *gomock.Controller) *MockStateTracker {
-	mock := &MockStateTracker{ctrl: ctrl}
-	mock.recorder = &_MockStateTrackerRecorder{mock}
+func NewMockTracker(ctrl *gomock.Controller) *MockTracker {
+	mock := &MockTracker{ctrl: ctrl}
+	mock.recorder = &_MockTrackerRecorder{mock}
 	return mock
 }
 
-func (_m *MockStateTracker) EXPECT() *_MockStateTrackerRecorder {
+func (_m *MockTracker) EXPECT() *_MockTrackerRecorder {
 	return _m.recorder
 }
 
-func (_m *MockStateTracker) NewNick(nick string) *Nick {
+func (_m *MockTracker) NewNick(nick string) *Nick {
 	ret := _m.ctrl.Call(_m, "NewNick", nick)
 	ret0, _ := ret[0].(*Nick)
 	return ret0
 }
 
-func (_mr *_MockStateTrackerRecorder) NewNick(arg0 interface{}) *gomock.Call {
+func (_mr *_MockTrackerRecorder) NewNick(arg0 interface{}) *gomock.Call {
 	return _mr.mock.ctrl.RecordCall(_mr.mock, "NewNick", arg0)
 }
 
-func (_m *MockStateTracker) GetNick(nick string) *Nick {
+func (_m *MockTracker) GetNick(nick string) *Nick {
 	ret := _m.ctrl.Call(_m, "GetNick", nick)
 	ret0, _ := ret[0].(*Nick)
 	return ret0
 }
 
-func (_mr *_MockStateTrackerRecorder) GetNick(arg0 interface{}) *gomock.Call {
+func (_mr *_MockTrackerRecorder) GetNick(arg0 interface{}) *gomock.Call {
 	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetNick", arg0)
 }
 
-func (_m *MockStateTracker) ReNick(old string, neu string) {
+func (_m *MockTracker) ReNick(old string, neu string) {
 	_m.ctrl.Call(_m, "ReNick", old, neu)
 }
 
-func (_mr *_MockStateTrackerRecorder) ReNick(arg0, arg1 interface{}) *gomock.Call {
+func (_mr *_MockTrackerRecorder) ReNick(arg0, arg1 interface{}) *gomock.Call {
 	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReNick", arg0, arg1)
 }
 
-func (_m *MockStateTracker) DelNick(nick string) {
+func (_m *MockTracker) DelNick(nick string) {
 	_m.ctrl.Call(_m, "DelNick", nick)
 }
 
-func (_mr *_MockStateTrackerRecorder) DelNick(arg0 interface{}) *gomock.Call {
+func (_mr *_MockTrackerRecorder) DelNick(arg0 interface{}) *gomock.Call {
 	return _mr.mock.ctrl.RecordCall(_mr.mock, "DelNick", arg0)
 }
 
-func (_m *MockStateTracker) NewChannel(channel string) *Channel {
+func (_m *MockTracker) NewChannel(channel string) *Channel {
 	ret := _m.ctrl.Call(_m, "NewChannel", channel)
 	ret0, _ := ret[0].(*Channel)
 	return ret0
 }
 
-func (_mr *_MockStateTrackerRecorder) NewChannel(arg0 interface{}) *gomock.Call {
+func (_mr *_MockTrackerRecorder) NewChannel(arg0 interface{}) *gomock.Call {
 	return _mr.mock.ctrl.RecordCall(_mr.mock, "NewChannel", arg0)
 }
 
-func (_m *MockStateTracker) GetChannel(channel string) *Channel {
+func (_m *MockTracker) GetChannel(channel string) *Channel {
 	ret := _m.ctrl.Call(_m, "GetChannel", channel)
 	ret0, _ := ret[0].(*Channel)
 	return ret0
 }
 
-func (_mr *_MockStateTrackerRecorder) GetChannel(arg0 interface{}) *gomock.Call {
+func (_mr *_MockTrackerRecorder) GetChannel(arg0 interface{}) *gomock.Call {
 	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetChannel", arg0)
 }
 
-func (_m *MockStateTracker) DelChannel(channel string) {
+func (_m *MockTracker) DelChannel(channel string) {
 	_m.ctrl.Call(_m, "DelChannel", channel)
 }
 
-func (_mr *_MockStateTrackerRecorder) DelChannel(arg0 interface{}) *gomock.Call {
+func (_mr *_MockTrackerRecorder) DelChannel(arg0 interface{}) *gomock.Call {
 	return _mr.mock.ctrl.RecordCall(_mr.mock, "DelChannel", arg0)
 }
 
-func (_m *MockStateTracker) Me() *Nick {
+func (_m *MockTracker) Me() *Nick {
 	ret := _m.ctrl.Call(_m, "Me")
 	ret0, _ := ret[0].(*Nick)
 	return ret0
 }
 
-func (_mr *_MockStateTrackerRecorder) Me() *gomock.Call {
+func (_mr *_MockTrackerRecorder) Me() *gomock.Call {
 	return _mr.mock.ctrl.RecordCall(_mr.mock, "Me")
 }
 
-func (_m *MockStateTracker) IsOn(channel string, nick string) (*ChanPrivs, bool) {
+func (_m *MockTracker) IsOn(channel string, nick string) (*ChanPrivs, bool) {
 	ret := _m.ctrl.Call(_m, "IsOn", channel, nick)
 	ret0, _ := ret[0].(*ChanPrivs)
 	ret1, _ := ret[1].(bool)
 	return ret0, ret1
 }
 
-func (_mr *_MockStateTrackerRecorder) IsOn(arg0, arg1 interface{}) *gomock.Call {
+func (_mr *_MockTrackerRecorder) IsOn(arg0, arg1 interface{}) *gomock.Call {
 	return _mr.mock.ctrl.RecordCall(_mr.mock, "IsOn", arg0, arg1)
 }
 
-func (_m *MockStateTracker) Associate(channel *Channel, nick *Nick) *ChanPrivs {
+func (_m *MockTracker) Associate(channel *Channel, nick *Nick) *ChanPrivs {
 	ret := _m.ctrl.Call(_m, "Associate", channel, nick)
 	ret0, _ := ret[0].(*ChanPrivs)
 	return ret0
 }
 
-func (_mr *_MockStateTrackerRecorder) Associate(arg0, arg1 interface{}) *gomock.Call {
+func (_mr *_MockTrackerRecorder) Associate(arg0, arg1 interface{}) *gomock.Call {
 	return _mr.mock.ctrl.RecordCall(_mr.mock, "Associate", arg0, arg1)
 }
 
-func (_m *MockStateTracker) Dissociate(channel *Channel, nick *Nick) {
+func (_m *MockTracker) Dissociate(channel *Channel, nick *Nick) {
 	_m.ctrl.Call(_m, "Dissociate", channel, nick)
 }
 
-func (_mr *_MockStateTrackerRecorder) Dissociate(arg0, arg1 interface{}) *gomock.Call {
+func (_mr *_MockTrackerRecorder) Dissociate(arg0, arg1 interface{}) *gomock.Call {
 	return _mr.mock.ctrl.RecordCall(_mr.mock, "Dissociate", arg0, arg1)
 }
 
-func (_m *MockStateTracker) Wipe() {
+func (_m *MockTracker) Wipe() {
 	_m.ctrl.Call(_m, "Wipe")
 }
 
-func (_mr *_MockStateTrackerRecorder) Wipe() *gomock.Call {
+func (_mr *_MockTrackerRecorder) Wipe() *gomock.Call {
 	return _mr.mock.ctrl.RecordCall(_mr.mock, "Wipe")
 }
 
-func (_m *MockStateTracker) String() string {
+func (_m *MockTracker) String() string {
 	ret := _m.ctrl.Call(_m, "String")
 	ret0, _ := ret[0].(string)
 	return ret0
 }
 
-func (_mr *_MockStateTrackerRecorder) String() *gomock.Call {
+func (_mr *_MockTrackerRecorder) String() *gomock.Call {
 	return _mr.mock.ctrl.RecordCall(_mr.mock, "String")
 }
diff --git a/state/tracker.go b/state/tracker.go
index fb29cd2..893b68d 100644
--- a/state/tracker.go
+++ b/state/tracker.go
@@ -5,7 +5,7 @@ import (
 )
 
 // The state manager interface
-type StateTracker interface {
+type Tracker interface {
 	// Nick methods
 	NewNick(nick string) *Nick
 	GetNick(nick string) *Nick
@@ -63,7 +63,7 @@ func (st *stateTracker) Wipe() {
 // can be properly tracked for state management purposes.
 func (st *stateTracker) NewNick(n string) *Nick {
 	if _, ok := st.nicks[n]; ok {
-		logging.Warn("StateTracker.NewNick(): %s already tracked.", n)
+		logging.Warn("Tracker.NewNick(): %s already tracked.", n)
 		return nil
 	}
 	st.nicks[n] = NewNick(n)
@@ -93,10 +93,10 @@ func (st *stateTracker) ReNick(old, neu string) {
 				ch.lookup[neu] = nk
 			}
 		} else {
-			logging.Warn("StateTracker.ReNick(): %s already exists.", neu)
+			logging.Warn("Tracker.ReNick(): %s already exists.", neu)
 		}
 	} else {
-		logging.Warn("StateTracker.ReNick(): %s not tracked.", old)
+		logging.Warn("Tracker.ReNick(): %s not tracked.", old)
 	}
 }
 
@@ -106,17 +106,17 @@ func (st *stateTracker) DelNick(n string) {
 		if nk != st.me {
 			st.delNick(nk)
 		} else {
-			logging.Warn("StateTracker.DelNick(): won't delete myself.")
+			logging.Warn("Tracker.DelNick(): won't delete myself.")
 		}
 	} else {
-		logging.Warn("StateTracker.DelNick(): %s not tracked.", n)
+		logging.Warn("Tracker.DelNick(): %s not tracked.", n)
 	}
 }
 
 func (st *stateTracker) delNick(nk *Nick) {
 	if nk == st.me {
 		// Shouldn't get here => internal state tracking code is fubar.
-		logging.Error("StateTracker.DelNick(): TRYING TO DELETE ME :-(")
+		logging.Error("Tracker.DelNick(): TRYING TO DELETE ME :-(")
 		return
 	}
 	delete(st.nicks, nk.Nick)
@@ -126,7 +126,7 @@ func (st *stateTracker) delNick(nk *Nick) {
 		if len(ch.nicks) == 0 {
 			// Deleting a nick from tracking shouldn't empty any channels as
 			// *we* should be on the channel with them to be tracking them.
-			logging.Error("StateTracker.delNick(): deleting nick %s emptied "+
+			logging.Error("Tracker.delNick(): deleting nick %s emptied "+
 				"channel %s, this shouldn't happen!", nk.Nick, ch.Name)
 		}
 	}
@@ -136,7 +136,7 @@ func (st *stateTracker) delNick(nk *Nick) {
 // can be properly tracked for state management purposes.
 func (st *stateTracker) NewChannel(c string) *Channel {
 	if _, ok := st.chans[c]; ok {
-		logging.Warn("StateTracker.NewChannel(): %s already tracked.", c)
+		logging.Warn("Tracker.NewChannel(): %s already tracked.", c)
 		return nil
 	}
 	st.chans[c] = NewChannel(c)
@@ -156,7 +156,7 @@ func (st *stateTracker) DelChannel(c string) {
 	if ch, ok := st.chans[c]; ok {
 		st.delChannel(ch)
 	} else {
-		logging.Warn("StateTracker.DelChannel(): %s not tracked.", c)
+		logging.Warn("Tracker.DelChannel(): %s not tracked.", c)
 	}
 }
 
@@ -191,21 +191,21 @@ func (st *stateTracker) IsOn(c, n string) (*ChanPrivs, bool) {
 // Associates an already known nick with an already known channel.
 func (st *stateTracker) Associate(ch *Channel, nk *Nick) *ChanPrivs {
 	if ch == nil || nk == nil {
-		logging.Error("StateTracker.Associate(): passed nil values :-(")
+		logging.Error("Tracker.Associate(): passed nil values :-(")
 		return nil
 	} else if _ch, ok := st.chans[ch.Name]; !ok || ch != _ch {
 		// As we can implicitly delete both nicks and channels from being
 		// tracked by dissociating one from the other, we should verify that
 		// we're not being passed an old Nick or Channel.
-		logging.Error("StateTracker.Associate(): channel %s not found in "+
+		logging.Error("Tracker.Associate(): channel %s not found in "+
 			"(or differs from) internal state.", ch.Name)
 		return nil
 	} else if _nk, ok := st.nicks[nk.Nick]; !ok || nk != _nk {
-		logging.Error("StateTracker.Associate(): nick %s not found in "+
+		logging.Error("Tracker.Associate(): nick %s not found in "+
 			"(or differs from) internal state.", nk.Nick)
 		return nil
 	} else if _, ok := nk.IsOn(ch); ok {
-		logging.Warn("StateTracker.Associate(): %s already on %s.",
+		logging.Warn("Tracker.Associate(): %s already on %s.",
 			nk.Nick, ch.Name)
 		return nil
 	}
@@ -220,18 +220,18 @@ func (st *stateTracker) Associate(ch *Channel, nk *Nick) *ChanPrivs {
 // any common channels with, and channels we're no longer on.
 func (st *stateTracker) Dissociate(ch *Channel, nk *Nick) {
 	if ch == nil || nk == nil {
-		logging.Error("StateTracker.Dissociate(): passed nil values :-(")
+		logging.Error("Tracker.Dissociate(): passed nil values :-(")
 	} else if _ch, ok := st.chans[ch.Name]; !ok || ch != _ch {
 		// As we can implicitly delete both nicks and channels from being
 		// tracked by dissociating one from the other, we should verify that
 		// we're not being passed an old Nick or Channel.
-		logging.Error("StateTracker.Dissociate(): channel %s not found in "+
+		logging.Error("Tracker.Dissociate(): channel %s not found in "+
 			"(or differs from) internal state.", ch.Name)
 	} else if _nk, ok := st.nicks[nk.Nick]; !ok || nk != _nk {
-		logging.Error("StateTracker.Dissociate(): nick %s not found in "+
+		logging.Error("Tracker.Dissociate(): nick %s not found in "+
 			"(or differs from) internal state.", nk.Nick)
 	} else if _, ok := nk.IsOn(ch); !ok {
-		logging.Warn("StateTracker.Dissociate(): %s not on %s.",
+		logging.Warn("Tracker.Dissociate(): %s not on %s.",
 			nk.Nick, ch.Name)
 	} else if nk == st.me {
 		// I'm leaving the channel for some reason, so it won't be tracked.