diff --git a/fairmq/FairMQDevice.cxx b/fairmq/FairMQDevice.cxx
index 08f61ade..c4e382e2 100644
--- a/fairmq/FairMQDevice.cxx
+++ b/fairmq/FairMQDevice.cxx
@@ -261,10 +261,7 @@ void FairMQDevice::InitWrapper()
             }
         }
     }
-    if (!fStateChangeCallback.empty())
-    {
-        fStateChangeCallback(INITIALIZING_DEVICE);
-    }
+    CallStateChangeCallbacks(INITIALIZING_DEVICE);
 
     // Bind channels. Here one run is enough, because bind settings should be available locally
     // If necessary this could be handled in the same way as the connecting channels
@@ -452,10 +449,7 @@ bool FairMQDevice::BindEndpoint(FairMQSocket& socket, string& endpoint)
 
 void FairMQDevice::InitTaskWrapper()
 {
-    if (!fStateChangeCallback.empty())
-    {
-        fStateChangeCallback(INITIALIZING_TASK);
-    }
+    CallStateChangeCallbacks(INITIALIZING_TASK);
 
     InitTask();
 
@@ -517,10 +511,7 @@ void FairMQDevice::PrintChannel(const string& name)
 
 void FairMQDevice::RunWrapper()
 {
-    if (!fStateChangeCallback.empty())
-    {
-        fStateChangeCallback(RUNNING);
-    }
+    CallStateChangeCallbacks(RUNNING);
 
     LOG(INFO) << "DEVICE: Running...";
 
@@ -793,10 +784,7 @@ void FairMQDevice::PostRun()
 
 void FairMQDevice::PauseWrapper()
 {
-    if (!fStateChangeCallback.empty())
-    {
-        fStateChangeCallback(PAUSED);
-    }
+    CallStateChangeCallbacks(PAUSED);
 
     Pause();
 }
@@ -1237,10 +1225,7 @@ void FairMQDevice::Unblock()
 
 void FairMQDevice::ResetTaskWrapper()
 {
-    if (!fStateChangeCallback.empty())
-    {
-        fStateChangeCallback(RESETTING_TASK);
-    }
+    CallStateChangeCallbacks(RESETTING_TASK);
 
     ResetTask();
 
@@ -1253,10 +1238,7 @@ void FairMQDevice::ResetTask()
 
 void FairMQDevice::ResetWrapper()
 {
-    if (!fStateChangeCallback.empty())
-    {
-        fStateChangeCallback(RESETTING_DEVICE);
-    }
+    CallStateChangeCallbacks(RESETTING_DEVICE);
 
     Reset();
 
diff --git a/fairmq/FairMQStateMachine.cxx b/fairmq/FairMQStateMachine.cxx
index 3779e317..44f3f6b3 100644
--- a/fairmq/FairMQStateMachine.cxx
+++ b/fairmq/FairMQStateMachine.cxx
@@ -228,11 +228,11 @@ bool FairMQStateMachine::WaitForEndOfStateForMs(std::string event, int durationI
 
 void FairMQStateMachine::SubscribeToStateChange(const std::string& key, std::function<void(const State)> callback)
 {
-    fStateChangeCallbacks.insert({key, fStateChangeCallback.connect(callback)});
+    fStateChangeSignalsMap.insert({key, fStateChangeSignal.connect(callback)});
 }
 
 void FairMQStateMachine::UnsubscribeFromStateChange(const std::string& key)
 {
-    fStateChangeCallbacks.at(key).disconnect();
-    fStateChangeCallbacks.erase(key);
+    fStateChangeSignalsMap.at(key).disconnect();
+    fStateChangeSignalsMap.erase(key);
 }
diff --git a/fairmq/FairMQStateMachine.h b/fairmq/FairMQStateMachine.h
index 22f5eb31..35a20144 100644
--- a/fairmq/FairMQStateMachine.h
+++ b/fairmq/FairMQStateMachine.h
@@ -85,8 +85,8 @@ struct FairMQFSM_ : public msmf::state_machine_def<FairMQFSM_>
         , fWorkAvailable(false)
         , fState()
         , fChangeStateMutex()
-        , fStateChangeCallback()
-        , fStateChangeCallbacks()
+        , fStateChangeSignal()
+        , fStateChangeSignalsMap()
         {}
 
     // Destructor
@@ -134,10 +134,7 @@ struct FairMQFSM_ : public msmf::state_machine_def<FairMQFSM_>
         {
             LOG(STATE) << "Entering IDLE state";
             fsm.fState = IDLE;
-            if (!fsm.fStateChangeCallbacks.empty())
-            {
-                fsm.fStateChangeCallback(IDLE);
-            }
+            fsm.CallStateChangeCallbacks(IDLE);
         }
     };
 
@@ -167,10 +164,7 @@ struct FairMQFSM_ : public msmf::state_machine_def<FairMQFSM_>
         {
             LOG(STATE) << "Entering DEVICE READY state";
             fsm.fState = DEVICE_READY;
-            if (!fsm.fStateChangeCallback.empty())
-            {
-                fsm.fStateChangeCallback(DEVICE_READY);
-            }
+            fsm.CallStateChangeCallbacks(DEVICE_READY);
         }
     };
 
@@ -194,10 +188,7 @@ struct FairMQFSM_ : public msmf::state_machine_def<FairMQFSM_>
         {
             LOG(STATE) << "Entering READY state";
             fsm.fState = READY;
-            if (!fsm.fStateChangeCallback.empty())
-            {
-                fsm.fStateChangeCallback(READY);
-            }
+            fsm.CallStateChangeCallbacks(READY);
         }
     };
 
@@ -266,10 +257,7 @@ struct FairMQFSM_ : public msmf::state_machine_def<FairMQFSM_>
         {
             LOG(STATE) << "Entering READY state";
             fsm.fState = READY;
-            if (!fsm.fStateChangeCallback.empty())
-            {
-                fsm.fStateChangeCallback(READY);
-            }
+            fsm.CallStateChangeCallbacks(READY);
 
             fsm.Unblock();
             std::unique_lock<std::mutex> lock(fsm.fWorkMutex);
@@ -287,10 +275,7 @@ struct FairMQFSM_ : public msmf::state_machine_def<FairMQFSM_>
         {
             LOG(STATE) << "RUNNING state finished without an external event, entering READY state";
             fsm.fState = READY;
-            if (!fsm.fStateChangeCallback.empty())
-            {
-                fsm.fStateChangeCallback(READY);
-            }
+            fsm.CallStateChangeCallbacks(READY);
 
             fsm.Unblock();
         }
@@ -341,10 +326,7 @@ struct FairMQFSM_ : public msmf::state_machine_def<FairMQFSM_>
         {
             LOG(STATE) << "Entering EXITING state";
             fsm.fState = EXITING;
-            if (!fsm.fStateChangeCallback.empty())
-            {
-                fsm.fStateChangeCallback(EXITING);
-            }
+            fsm.CallStateChangeCallbacks(EXITING);
 
             // terminate worker thread
             {
@@ -370,10 +352,7 @@ struct FairMQFSM_ : public msmf::state_machine_def<FairMQFSM_>
         {
             LOG(STATE) << "Entering ERROR state";
             fsm.fState = ERROR;
-            if (!fsm.fStateChangeCallback.empty())
-            {
-                fsm.fStateChangeCallback(ERROR);
-            }
+            fsm.CallStateChangeCallbacks(ERROR);
         }
     };
 
@@ -488,7 +467,7 @@ struct FairMQFSM_ : public msmf::state_machine_def<FairMQFSM_>
         EXITING
     };
 
-    std::string GetStateName(int state) const
+    static std::string GetStateName(const int state)
     {
         switch(state)
         {
@@ -526,6 +505,14 @@ struct FairMQFSM_ : public msmf::state_machine_def<FairMQFSM_>
     bool CheckCurrentState(int state) const { return state == fState; }
     bool CheckCurrentState(std::string state) const { return state == GetCurrentStateName(); }
 
+    void CallStateChangeCallbacks(const State state) const
+    {
+        if (!fStateChangeSignal.empty())
+        {
+            fStateChangeSignal(state);
+        }
+    }
+
     // this is to run certain functions in a separate thread
     std::thread fWorkerThread;
 
@@ -542,8 +529,8 @@ struct FairMQFSM_ : public msmf::state_machine_def<FairMQFSM_>
     std::atomic<State> fState;
     std::mutex fChangeStateMutex;
 
-    boost::signals2::signal<void(const State)> fStateChangeCallback;
-    std::unordered_map<std::string, boost::signals2::connection> fStateChangeCallbacks;
+    boost::signals2::signal<void(const State)> fStateChangeSignal;
+    std::unordered_map<std::string, boost::signals2::connection> fStateChangeSignalsMap;
 };
 
 // reactivate the warning for non-virtual destructor