diff --git a/src/app/Application.cpp b/src/app/Application.cpp
index d1f7b26..622b370 100644
--- a/src/app/Application.cpp
+++ b/src/app/Application.cpp
@@ -132,17 +132,9 @@ void Application::initialize() {
     m_midiInputManager->loadFromSettings();
 }
 
-void Application::connectToMixer(const QString& type, const QString& host, int port) {
-    disconnectFromMixer();
-
-    m_mixer = ProtocolFactory::create(type, this);
-    if (!m_mixer) {
-        return;
-    }
-
+void Application::setupMixerConnection(const QString& type, const QString& host, int port) {
     m_playbackEngine->setMixer(m_mixer);
 
-    // setup connection logging
     m_connectionLogBridge->setConnectionContext(type, host, port);
     m_connectionLogBridge->attachToMixer(m_mixer);
     m_appLogger->logConnectionAttempt(type, host, port);
@@ -160,38 +152,29 @@ void Application::connectToMixer(const QString& type, const QString& host, int p
     settings.endGroup();
 }
 
-void Application::connectToDiscoveredConsole(const DiscoveredConsole& console) {
-    if (!console.isValid()) {
-        return;
-    }
-
+void Application::connectToMixer(const QString& type, const QString& host, int port) {
     disconnectFromMixer();
 
-    m_mixer = ProtocolFactory::create(console, this);
-    if (!m_mixer) {
+    m_mixer = ProtocolFactory::create(type, this);
+    if (!m_mixer)
         return;
-    }
 
-    m_playbackEngine->setMixer(m_mixer);
+    setupMixerConnection(type, host, port);
+}
 
-    // setup connection logging
-    QString host = console.address.toString();
-    QString protocol = console.modelName;
-    m_connectionLogBridge->setConnectionContext(protocol, host, console.port);
-    m_connectionLogBridge->attachToMixer(m_mixer);
-    m_appLogger->logConnectionAttempt(protocol, host, console.port);
+void Application::connectToDiscoveredConsole(const DiscoveredConsole& console) {
+    if (!console.isValid())
+        return;
 
-    connect(m_mixer, &MixerProtocol::connected, this, [this]() { emit mixerConnected(); });
-    connect(m_mixer, &MixerProtocol::disconnected, this, [this]() { emit mixerDisconnected(); });
+    disconnectFromMixer();
 
-    m_mixer->connect(host, console.port);
+    m_mixer = ProtocolFactory::create(console, this);
+    if (!m_mixer)
+        return;
 
-    QSettings settings;
-    settings.beginGroup("LastMixer");
-    settings.setValue("host", host);
-    settings.setValue("type", console.toCapabilities().protocolId);
-    settings.setValue("port", console.port);
-    settings.endGroup();
+    setupMixerConnection(console.toCapabilities().protocolId,
+                         console.address.toString(),
+                         console.port);
 }
 
 void Application::disconnectFromMixer() {
diff --git a/src/app/Application.h b/src/app/Application.h
index ec405ef..ad51a21 100644
--- a/src/app/Application.h
+++ b/src/app/Application.h
@@ -83,6 +83,8 @@ class Application : public QObject {
     void mixerDisconnected();
 
   private:
+    void setupMixerConnection(const QString& type, const QString& host, int port);
+
     static Application* s_instance;
 
     Show* m_show;
diff --git a/src/core/CueValidator.cpp b/src/core/CueValidator.cpp
index 0f0b92b..78a6e16 100644
--- a/src/core/CueValidator.cpp
+++ b/src/core/CueValidator.cpp
@@ -7,7 +7,7 @@ namespace OpenMix {
 
 CueValidator::CueValidator(QObject* parent) : QObject(parent) {}
 
-ValidationResult CueValidator::validate(const Cue& cue, const CueList* cueList) const {
+ValidationResult CueValidator::validate(const Cue& cue, const CueList* cueList) {
     ValidationResult result;
     result.valid = true;
 
@@ -21,8 +21,7 @@ ValidationResult CueValidator::validate(const Cue& cue, const CueList* cueList)
         }
 
         if (cue.macroExecutionMode() == MacroExecutionMode::Parallel) {
-            if (!detectConflictingFadeTargets(cue, cueList, result.issues)) {
-            }
+            detectConflictingFadeTargets(cue, cueList, result.issues);
         }
     }
 
@@ -30,11 +29,11 @@ ValidationResult CueValidator::validate(const Cue& cue, const CueList* cueList)
         result.valid = false;
     }
 
-    emit const_cast<CueValidator*>(this)->validationCompleted(result);
+    emit validationCompleted(result);
     return result;
 }
 
-ValidationResult CueValidator::validateAll(const CueList* cueList) const {
+ValidationResult CueValidator::validateAll(const CueList* cueList) {
     ValidationResult result;
     result.valid = true;
 
@@ -61,7 +60,7 @@ ValidationResult CueValidator::validateAll(const CueList* cueList) const {
         }
     }
 
-    emit const_cast<CueValidator*>(this)->validationCompleted(result);
+    emit validationCompleted(result);
     return result;
 }
 
diff --git a/src/core/CueValidator.h b/src/core/CueValidator.h
index 325c701..6c6d859 100644
--- a/src/core/CueValidator.h
+++ b/src/core/CueValidator.h
@@ -2,6 +2,7 @@
 
 #include <QList>
 #include <QObject>
+#include <algorithm>
 #include <QSet>
 #include <QString>
 
@@ -25,37 +26,23 @@ struct ValidationResult {
     QList<ValidationIssue> issues;
 
     bool hasErrors() const {
-        for (const auto& issue : issues) {
-            if (issue.isError())
-                return true;
-        }
-        return false;
+        return std::any_of(issues.begin(), issues.end(),
+                           [](const ValidationIssue& i) { return i.isError(); });
     }
 
     bool hasWarnings() const {
-        for (const auto& issue : issues) {
-            if (issue.isWarning())
-                return true;
-        }
-        return false;
+        return std::any_of(issues.begin(), issues.end(),
+                           [](const ValidationIssue& i) { return i.isWarning(); });
     }
 
     int errorCount() const {
-        int count = 0;
-        for (const auto& issue : issues) {
-            if (issue.isError())
-                count++;
-        }
-        return count;
+        return static_cast<int>(std::count_if(issues.begin(), issues.end(),
+                                              [](const ValidationIssue& i) { return i.isError(); }));
     }
 
     int warningCount() const {
-        int count = 0;
-        for (const auto& issue : issues) {
-            if (issue.isWarning())
-                count++;
-        }
-        return count;
+        return static_cast<int>(std::count_if(issues.begin(), issues.end(),
+                                              [](const ValidationIssue& i) { return i.isWarning(); }));
     }
 };
 
@@ -65,9 +52,13 @@ class CueValidator : public QObject {
   public:
     explicit CueValidator(QObject* parent = nullptr);
 
-    ValidationResult validate(const Cue& cue, const CueList* cueList) const;
-    ValidationResult validateAll(const CueList* cueList) const;
+    ValidationResult validate(const Cue& cue, const CueList* cueList);
+    ValidationResult validateAll(const CueList* cueList);
 
+  signals:
+    void validationCompleted(const ValidationResult& result);
+
+  private:
     bool validateMacroIds(const Cue& cue, const CueList* cueList,
                           QList<ValidationIssue>& issues) const;
     bool validateParameters(const Cue& cue, QList<ValidationIssue>& issues) const;
@@ -75,11 +66,6 @@ class CueValidator : public QObject {
                                        QList<ValidationIssue>& issues) const;
     bool detectConflictingFadeTargets(const Cue& cue, const CueList* cueList,
                                       QList<ValidationIssue>& issues) const;
-
-  signals:
-    void validationCompleted(const ValidationResult& result);
-
-  private:
     bool hasCircularReference(const QString& cueId, const CueList* cueList, QSet<QString>& visited,
                               QSet<QString>& recursionStack) const;
     QSet<QString> collectMacroParameters(const Cue& cue, const CueList* cueList) const;
diff --git a/src/core/OperationMode.cpp b/src/core/OperationMode.cpp
index e9bb952..dfe0408 100644
--- a/src/core/OperationMode.cpp
+++ b/src/core/OperationMode.cpp
@@ -24,61 +24,21 @@ QString OperationModeManager::modeString(AppMode mode) {
     return tr("Unknown");
 }
 
-bool OperationModeManager::canEditCues() const {
+bool OperationModeManager::requiresProgrammerMode(const QString& operation) {
     if (m_mode != AppMode::Programmer) {
-        emit const_cast<OperationModeManager*>(this)->operationBlocked(tr("Edit cues"));
+        emit operationBlocked(operation);
         return false;
     }
     return true;
 }
 
-bool OperationModeManager::canDeleteCues() const {
-    if (m_mode != AppMode::Programmer) {
-        emit const_cast<OperationModeManager*>(this)->operationBlocked(tr("Delete cues"));
-        return false;
-    }
-    return true;
-}
-
-bool OperationModeManager::canModifyShow() const {
-    if (m_mode != AppMode::Programmer) {
-        emit const_cast<OperationModeManager*>(this)->operationBlocked(tr("Modify show"));
-        return false;
-    }
-    return true;
-}
-
-bool OperationModeManager::canAddCues() const {
-    if (m_mode != AppMode::Programmer) {
-        emit const_cast<OperationModeManager*>(this)->operationBlocked(tr("Add cues"));
-        return false;
-    }
-    return true;
-}
-
-bool OperationModeManager::canRenumberCues() const {
-    if (m_mode != AppMode::Programmer) {
-        emit const_cast<OperationModeManager*>(this)->operationBlocked(tr("Renumber cues"));
-        return false;
-    }
-    return true;
-}
-
-bool OperationModeManager::canOpenShow() const {
-    if (m_mode != AppMode::Programmer) {
-        emit const_cast<OperationModeManager*>(this)->operationBlocked(tr("Open show"));
-        return false;
-    }
-    return true;
-}
-
-bool OperationModeManager::canNewShow() const {
-    if (m_mode != AppMode::Programmer) {
-        emit const_cast<OperationModeManager*>(this)->operationBlocked(tr("New show"));
-        return false;
-    }
-    return true;
-}
+bool OperationModeManager::canEditCues()     { return requiresProgrammerMode(tr("Edit cues")); }
+bool OperationModeManager::canDeleteCues()   { return requiresProgrammerMode(tr("Delete cues")); }
+bool OperationModeManager::canModifyShow()   { return requiresProgrammerMode(tr("Modify show")); }
+bool OperationModeManager::canAddCues()      { return requiresProgrammerMode(tr("Add cues")); }
+bool OperationModeManager::canRenumberCues() { return requiresProgrammerMode(tr("Renumber cues")); }
+bool OperationModeManager::canOpenShow()     { return requiresProgrammerMode(tr("Open show")); }
+bool OperationModeManager::canNewShow()      { return requiresProgrammerMode(tr("New show")); }
 
 bool OperationModeManager::canSaveShow() const { return true; }
 
diff --git a/src/core/OperationMode.h b/src/core/OperationMode.h
index 9278bdf..44fd8ba 100644
--- a/src/core/OperationMode.h
+++ b/src/core/OperationMode.h
@@ -23,13 +23,13 @@ class OperationModeManager : public QObject {
     QString modeString() const;
     static QString modeString(AppMode mode);
 
-    bool canEditCues() const;          // programmer only
-    bool canDeleteCues() const;        // programmer only
-    bool canModifyShow() const;        // programmer only
-    bool canAddCues() const;           // programmer only
-    bool canRenumberCues() const;      // programmer only
-    bool canOpenShow() const;          // programmer only
-    bool canNewShow() const;           // programmer only
+    bool canEditCues();          // programmer only
+    bool canDeleteCues();        // programmer only
+    bool canModifyShow();        // programmer only
+    bool canAddCues();           // programmer only
+    bool canRenumberCues();      // programmer only
+    bool canOpenShow();          // programmer only
+    bool canNewShow();           // programmer only
     bool canSaveShow() const;          // always (emergency save)
     bool canGo() const;                // always
     bool canStop() const;              // always
@@ -58,6 +58,7 @@ class OperationModeManager : public QObject {
     void passwordRequired();
 
   private:
+    bool requiresProgrammerMode(const QString& operation);
     QString hashPassword(const QString& password) const;
 
     AppMode m_mode = AppMode::Programmer;
diff --git a/src/midi/MidiInputManager.cpp b/src/midi/MidiInputManager.cpp
index 1325f65..038b025 100644
--- a/src/midi/MidiInputManager.cpp
+++ b/src/midi/MidiInputManager.cpp
@@ -11,7 +11,7 @@ namespace OpenMix {
 
 MidiInputManager::MidiInputManager(QObject* parent) : QObject(parent) {
     try {
-        m_midiIn = new RtMidiIn();
+        m_midiIn = std::make_unique<RtMidiIn>();
     } catch (RtMidiError& error) {
         qWarning() << "RtMidi initialization error:" << QString::fromStdString(error.getMessage());
     }
@@ -24,7 +24,6 @@ MidiInputManager::MidiInputManager(QObject* parent) : QObject(parent) {
 
 MidiInputManager::~MidiInputManager() {
     closeDevice();
-    delete m_midiIn;
 }
 
 QVector<MidiDeviceInfo> MidiInputManager::availableDevices() const {
diff --git a/src/midi/MidiInputManager.h b/src/midi/MidiInputManager.h
index d1ffee0..0f479cb 100644
--- a/src/midi/MidiInputManager.h
+++ b/src/midi/MidiInputManager.h
@@ -4,6 +4,7 @@
 
 #include <QObject>
 #include <QTimer>
+#include <memory>
 
 class RtMidiIn;
 
@@ -80,7 +81,7 @@ class MidiInputManager : public QObject {
 
     static void midiCallback(double timeStamp, std::vector<unsigned char>* message, void* userData);
 
-    RtMidiIn* m_midiIn = nullptr;
+    std::unique_ptr<RtMidiIn> m_midiIn;
     bool m_deviceOpen = false;
     QString m_currentDeviceName;
     QString m_savedDeviceName;
diff --git a/src/protocol/MixerProtocol.h b/src/protocol/MixerProtocol.h
index e58104f..c5d71e3 100644
--- a/src/protocol/MixerProtocol.h
+++ b/src/protocol/MixerProtocol.h
@@ -56,6 +56,4 @@ class MixerProtocol : public QObject {
     void sceneChanged(int sceneNumber);
 };
 
-MixerProtocol* createMixerProtocol(const QString& type, QObject* parent = nullptr);
-
 } // namespace OpenMix
diff --git a/src/protocol/ProtocolFactory.cpp b/src/protocol/ProtocolFactory.cpp
index 593c991..265aef1 100644
--- a/src/protocol/ProtocolFactory.cpp
+++ b/src/protocol/ProtocolFactory.cpp
@@ -117,8 +117,4 @@ MixerCapabilities ProtocolFactory::capabilities(const QString& type) {
     return MixerCapabilities::forProtocolId(type);
 }
 
-MixerProtocol* createMixerProtocol(const QString& type, QObject* parent) {
-    return ProtocolFactory::create(type, parent);
-}
-
 } // namespace OpenMix