From 39d3f6149739d2d7d39e377aaa97ca10803fc575 Mon Sep 17 00:00:00 2001
From: Michael Carlberg <c@rlberg.se>
Date: Tue, 31 May 2016 05:58:58 +0200
Subject: [PATCH] refactor(core): Clean-up

- use "#pragma once" instead of the regular include guard
- fix errors and warnings reported by cppcheck
---
 CMakeLists.txt                  |  8 +--
 include/bar.hpp                 |  7 +--
 include/config.hpp.cmake        |  5 +-
 include/drawtypes/animation.hpp |  7 +--
 include/drawtypes/bar.hpp       |  9 ++--
 include/drawtypes/icon.hpp      |  5 +-
 include/drawtypes/label.hpp     |  5 +-
 include/drawtypes/ramp.hpp      |  7 +--
 include/eventloop.hpp           |  7 +--
 include/exception.hpp           | 10 ++--
 include/interfaces/alsa.hpp     | 24 ++++-----
 include/interfaces/mpd.hpp      | 29 ++++++-----
 include/interfaces/net.hpp      | 32 +++++-------
 include/lemonbuddy.hpp          |  5 +-
 include/modules/backlight.hpp   | 20 ++++----
 include/modules/base.hpp        | 49 ++++++++++---------
 include/modules/battery.hpp     |  9 ++--
 include/modules/bspwm.hpp       | 13 ++---
 include/modules/counter.hpp     |  9 ++--
 include/modules/cpu.hpp         | 17 +++----
 include/modules/date.hpp        | 15 ++----
 include/modules/i3.hpp          | 18 ++-----
 include/modules/memory.hpp      | 13 ++---
 include/modules/menu.hpp        | 17 +++----
 include/modules/mpd.hpp         | 57 ++++++++++-----------
 include/modules/network.hpp     | 23 ++++-----
 include/modules/script.hpp      |  9 ++--
 include/modules/text.hpp        |  9 ++--
 include/modules/torrent.hpp     | 11 ++---
 include/modules/volume.hpp      | 25 +++++-----
 include/registry.hpp            | 17 ++-----
 include/services/builder.hpp    |  9 ++--
 include/services/command.hpp    | 24 ++++-----
 include/services/inotify.hpp    |  9 ++--
 include/services/logger.hpp     |  8 ++-
 include/services/store.hpp      |  4 ++
 include/utils/cli.hpp           | 10 +---
 include/utils/concurrency.hpp   |  6 ++-
 include/utils/config.hpp        | 52 +++++---------------
 include/utils/io.hpp            | 16 +++---
 include/utils/macros.hpp        | 13 +++++
 include/utils/math.hpp          |  5 +-
 include/utils/memory.hpp        |  5 +-
 include/utils/proc.hpp          | 16 ++----
 include/utils/streams.hpp       |  5 +-
 include/utils/string.hpp        | 12 ++---
 include/utils/timer.hpp         |  9 ++--
 include/utils/xlib.hpp          |  7 +--
 src/bar.cpp                     |  6 +--
 src/drawtypes/animation.cpp     |  2 +-
 src/drawtypes/bar.cpp           |  9 ++--
 src/eventloop.cpp               | 36 +++++++-------
 src/interfaces/alsa.cpp         | 32 ++++++------
 src/interfaces/mpd.cpp          | 87 +++++++++++++++++----------------
 src/interfaces/net.cpp          | 29 +++++------
 src/lemonbuddy.cpp              |  9 ++--
 src/modules/backlight.cpp       | 18 ++++---
 src/modules/battery.cpp         | 11 +++--
 src/modules/bspwm.cpp           | 23 +++++----
 src/modules/cpu.cpp             |  5 +-
 src/modules/date.cpp            |  4 +-
 src/modules/i3.cpp              |  3 +-
 src/modules/memory.cpp          |  3 +-
 src/modules/menu.cpp            |  4 +-
 src/modules/mpd.cpp             | 23 ++++-----
 src/modules/network.cpp         |  7 +--
 src/modules/script.cpp          |  6 +--
 src/modules/text.cpp            |  2 +-
 src/modules/volume.cpp          | 11 ++---
 src/registry.cpp                |  4 +-
 src/services/builder.cpp        |  6 +--
 src/services/command.cpp        | 74 ++++++++++++++--------------
 src/services/inotify.cpp        | 11 +++--
 src/services/logger.cpp         |  8 +--
 src/utils/cli.cpp               |  3 +-
 src/utils/config.cpp            | 19 +++----
 src/utils/io.cpp                | 44 ++++++++---------
 src/utils/proc.cpp              | 13 ++---
 src/utils/string.cpp            | 30 ++++++------
 src/utils/timer.cpp             |  2 +
 src/utils/xlib.cpp              | 73 ++++++++++++++-------------
 81 files changed, 588 insertions(+), 730 deletions(-)
 create mode 100644 include/utils/macros.hpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 77b5c1c9..e716217d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -98,7 +98,7 @@ set(PROJECT_LINK_LIBS
 if(ENABLE_I3)
   find_program(I3_EXECUTABLE "i3")
   if(NOT I3_EXECUTABLE)
-    message(WARNING "${ANSI}[41;30mDisabling \"i3 module\" support (prerequisites failed)${ANSI}[0m")
+    message(WARNING "${ANSI}[41;1mDisabling \"i3 module\" support (prerequisites failed)${ANSI}[0m")
     set(ENABLE_I3 OFF)
   endif()
 endif()
@@ -109,7 +109,7 @@ if(ENABLE_ALSA)
     set(PROJECT_INCL_DIRS ${PROJECT_INCL_DIRS} ${ALSA_INCLUDE_DIR})
     set(PROJECT_LINK_LIBS ${PROJECT_LINK_LIBS} ${ALSA_LIBRARY})
   else(ALSA_FOUND)
-    message(WARNING "${ANSI}[41;30mDisabling \"volume module\" support (prerequisites failed)${ANSI}[0m")
+    message(WARNING "${ANSI}[41;1mDisabling \"volume module\" support (prerequisites failed)${ANSI}[0m")
     set(ENABLE_ALSA OFF)
   endif()
 endif()
@@ -120,7 +120,7 @@ if(ENABLE_MPD)
     set(PROJECT_INCL_DIRS ${PROJECT_INCL_DIRS} ${LIBMPDCLIENT_INCLUDE_DIR})
     set(PROJECT_LINK_LIBS ${PROJECT_LINK_LIBS} ${LIBMPDCLIENT_LIBRARY})
   else(LIBMPDCLIENT_FOUND)
-    message(WARNING "${ANSI}[41;30mDisabling \"mpd module\" support (prerequisites failed)${ANSI}[0m")
+    message(WARNING "${ANSI}[41;1mDisabling \"mpd module\" support (prerequisites failed)${ANSI}[0m")
     set(ENABLE_MPD OFF)
   endif()
 endif()
@@ -131,7 +131,7 @@ if(ENABLE_NETWORK)
     set(PROJECT_INCL_DIRS ${PROJECT_INCL_DIRS} ${LIBIW_INCLUDE_DIR})
     set(PROJECT_LINK_LIBS ${PROJECT_LINK_LIBS} ${LIBIW_LIBRARY})
   else(LIBIW_FOUND)
-    message(WARNING "${ANSI}[41;30mDisabling \"network module\" support (prerequisites failed)${ANSI}[0m")
+    message(WARNING "${ANSI}[41;1mDisabling \"network module\" support (prerequisites failed)${ANSI}[0m")
     set(ENABLE_NETWORK OFF)
   endif()
 endif()
diff --git a/include/bar.hpp b/include/bar.hpp
index 72b667c6..96f92608 100644
--- a/include/bar.hpp
+++ b/include/bar.hpp
@@ -1,5 +1,4 @@
-#ifndef _BAR_HPP_
-#define _BAR_HPP_
+#pragma once
 
 #include <string>
 #include <memory>
@@ -12,7 +11,7 @@ DefineBaseException(ConfigurationError);
 
 struct CompiledWithoutModuleSupport : public ConfigurationError
 {
-  CompiledWithoutModuleSupport(std::string module_name)
+  explicit CompiledWithoutModuleSupport(std::string module_name)
     : ConfigurationError(std::string(APP_NAME) + " was not compiled with support for module \""+ module_name +"\"") {}
 };
 
@@ -96,5 +95,3 @@ class Bar
 std::shared_ptr<Bar> &get_bar();
 
 const Options& bar_opts();
-
-#endif
diff --git a/include/config.hpp.cmake b/include/config.hpp.cmake
index ffdc9caa..412c6064 100644
--- a/include/config.hpp.cmake
+++ b/include/config.hpp.cmake
@@ -1,5 +1,4 @@
-#ifndef _CONFIG_HPP_
-#define _CONFIG_HPP_
+#pragma once
 
 #define APP_NAME "@PROJECT_NAME@"
 
@@ -22,5 +21,3 @@
 #define BSPWM_STATUS_PREFIX "@SETTING_BSPWM_STATUS_PREFIX@"
 #define PATH_CPU_INFO "@SETTING_PATH_CPU_INFO@"
 #define PATH_MEMORY_INFO "@SETTING_PATH_MEMORY_INFO@"
-
-#endif // _CONFIG_HPP_
diff --git a/include/drawtypes/animation.hpp b/include/drawtypes/animation.hpp
index 9346cc6f..1ddffff2 100644
--- a/include/drawtypes/animation.hpp
+++ b/include/drawtypes/animation.hpp
@@ -1,5 +1,4 @@
-#ifndef _DRAWTYPES_ANIMATION_HPP_
-#define _DRAWTYPES_ANIMATION_HPP_
+#pragma once
 
 #include <string>
 #include <vector>
@@ -21,7 +20,7 @@ namespace drawtypes
 
     public:
       Animation(std::vector<std::unique_ptr<Icon>> &&frames, int framerate_ms = 1);
-      Animation(int framerate_ms)
+      explicit Animation(int framerate_ms)
         : framerate_ms(framerate_ms){}
 
       void add(std::unique_ptr<Icon> &&frame);
@@ -37,5 +36,3 @@ namespace drawtypes
 
   std::unique_ptr<Animation> get_config_animation(const std::string& config_path, const std::string& animation_name = "animation", bool required = true);
 }
-
-#endif
diff --git a/include/drawtypes/bar.hpp b/include/drawtypes/bar.hpp
index d39ccd34..1a9379aa 100644
--- a/include/drawtypes/bar.hpp
+++ b/include/drawtypes/bar.hpp
@@ -1,5 +1,4 @@
-#ifndef _DRAWTYPES_BAR_HPP_
-#define _DRAWTYPES_BAR_HPP_
+#pragma once
 
 #include <string>
 #include <memory>
@@ -16,7 +15,7 @@ namespace drawtypes
     protected:
       std::unique_ptr<Builder> builder;
       std::vector<std::string> colors;
-      bool gradient;
+      bool gradient = false;
       unsigned int width;
       std::string format;
 
@@ -25,7 +24,7 @@ namespace drawtypes
       std::unique_ptr<Icon> indicator;
 
     public:
-      Bar(int width, const std::string& format, bool lazy_builder_closing = true);
+      Bar(int width, const std::string& fmt, bool lazy_builder_closing = true);
       Bar(int width, bool lazy_builder_closing = true)
         : Bar(width, "<fill><indicator><empty>", lazy_builder_closing){}
 
@@ -41,5 +40,3 @@ namespace drawtypes
 
   std::unique_ptr<Bar> get_config_bar(const std::string& config_path, const std::string& bar_name = "bar", bool lazy_builder_closing = true);
 }
-
-#endif
diff --git a/include/drawtypes/icon.hpp b/include/drawtypes/icon.hpp
index 8cd8a287..85304cbc 100644
--- a/include/drawtypes/icon.hpp
+++ b/include/drawtypes/icon.hpp
@@ -1,5 +1,4 @@
-#ifndef _DRAWTYPES_ICON_HPP_
-#define _DRAWTYPES_ICON_HPP_
+#pragma once
 
 #include <string>
 #include <vector>
@@ -37,5 +36,3 @@ namespace drawtypes
   std::unique_ptr<Icon> get_config_icon(const std::string& module_name, const std::string& icon_name = "icon", bool required = true, const std::string& def = "");
   std::unique_ptr<Icon> get_optional_config_icon(const std::string& module_name, const std::string& icon_name = "icon", const std::string& def = "");
 }
-
-#endif
diff --git a/include/drawtypes/label.hpp b/include/drawtypes/label.hpp
index 129b3d31..52cd8b7c 100644
--- a/include/drawtypes/label.hpp
+++ b/include/drawtypes/label.hpp
@@ -1,5 +1,4 @@
-#ifndef _DRAWTYPES_LABEL_HPP_
-#define _DRAWTYPES_LABEL_HPP_
+#pragma once
 
 #include <string>
 #include <memory>
@@ -29,5 +28,3 @@ namespace drawtypes
   std::unique_ptr<Label> get_config_label(const std::string& module_name, const std::string& label_name = "label", bool required = true, const std::string& def = "");
   std::unique_ptr<Label> get_optional_config_label(const std::string& module_name, const std::string& label_name = "label", const std::string& def = "");
 }
-
-#endif
diff --git a/include/drawtypes/ramp.hpp b/include/drawtypes/ramp.hpp
index 38c0adbb..c76ba991 100644
--- a/include/drawtypes/ramp.hpp
+++ b/include/drawtypes/ramp.hpp
@@ -1,5 +1,4 @@
-#ifndef _DRAWTYPES_RAMP_HPP_
-#define _DRAWTYPES_RAMP_HPP_
+#pragma once
 
 #include <string>
 #include <vector>
@@ -17,7 +16,7 @@ namespace drawtypes
 
     public:
       Ramp(){}
-      Ramp(std::vector<std::unique_ptr<Icon>> icons);
+      explicit Ramp(std::vector<std::unique_ptr<Icon>> icons);
 
       void add(std::unique_ptr<Icon> &&icon);
       std::unique_ptr<Icon> &get(int idx);
@@ -30,5 +29,3 @@ namespace drawtypes
 
   std::unique_ptr<Ramp> get_config_ramp(const std::string& module_name, const std::string& ramp_name = "ramp", bool required = true);
 }
-
-#endif
diff --git a/include/eventloop.hpp b/include/eventloop.hpp
index 5d0c9a70..61770a81 100644
--- a/include/eventloop.hpp
+++ b/include/eventloop.hpp
@@ -1,5 +1,4 @@
-#ifndef _EVENTLOOP_HPP_
-#define _EVENTLOOP_HPP_
+#pragma once
 
 #include <map>
 
@@ -46,7 +45,7 @@ class EventLoop
     bool running();
 
   public:
-    EventLoop(std::string input_pipe);
+    explicit EventLoop(std::string input_pipe);
 
     void start();
     void stop();
@@ -56,5 +55,3 @@ class EventLoop
 
     void add_stdin_subscriber(const std::string& module_name);
 };
-
-#endif
diff --git a/include/exception.hpp b/include/exception.hpp
index b0880f52..4c57d218 100644
--- a/include/exception.hpp
+++ b/include/exception.hpp
@@ -1,20 +1,16 @@
-#ifndef _EXCEPTION_HPP_
-#define _EXCEPTION_HPP_
+#pragma once
 
 #include <string>
 #include <stdexcept>
 
 struct Exception : public std::runtime_error
 {
-  Exception(std::string const &error_message = "")
+  explicit Exception(const std::string& error_message = "")
     : std::runtime_error(error_message.c_str()) {}
 };
 
 #define DefineChildException(ExName, ParentEx) struct ExName : public ParentEx { \
-  ExName(std::string error_message = "") \
+  explicit ExName(const std::string& error_message = "") \
     : ParentEx("["+ std::string(__FUNCTION__) +"] => "+ error_message) {} \
 }
 #define DefineBaseException(ExName) DefineChildException(ExName, Exception)
-
-#endif
-
diff --git a/include/interfaces/alsa.hpp b/include/interfaces/alsa.hpp
index 8e1a83af..5a678d0e 100644
--- a/include/interfaces/alsa.hpp
+++ b/include/interfaces/alsa.hpp
@@ -1,5 +1,4 @@
-#ifndef _INTERFACES_ALSA_HPP_
-#define _INTERFACES_ALSA_HPP_
+#pragma once
 
 #include <functional>
 #include <string>
@@ -16,11 +15,14 @@ namespace alsa
   class Exception : public ::Exception
   {
     public:
-      Exception(const std::string& msg) : ::Exception("[Alsa] "+ msg){}
+      explicit Exception(const std::string& msg) : ::Exception("[Alsa] "+ msg){}
   };
 
-  class ControlInterfaceError : public Exception {
-    using Exception::Exception;
+  class ControlInterfaceError : public Exception
+  {
+    public:
+      ControlInterfaceError(int code, const std::string& msg)
+        : Exception(msg +" ["+ std::to_string(code) +"]") {}
   };
 
   class ControlInterface
@@ -36,12 +38,12 @@ namespace alsa
     snd_ctl_elem_id_t *id;
 
     public:
-      ControlInterface(int numid) throw(ControlInterfaceError);
+      explicit ControlInterface(int numid);
       ~ControlInterface();
 
-      bool wait(int timeout = -1) throw(ControlInterfaceError);
+      bool wait(int timeout = -1);
 
-      bool test_device_plugged() throw(ControlInterfaceError);
+      bool test_device_plugged();
   };
 
 
@@ -57,10 +59,10 @@ namespace alsa
     snd_mixer_elem_t *mixer_element = nullptr;
 
     public:
-      Mixer(const std::string& mixer_control_name) throw(MixerError);
+      explicit Mixer(const std::string& mixer_control_name);
       ~Mixer();
 
-      bool wait(int timeout = -1) throw(MixerError);
+      bool wait(int timeout = -1);
 
       int get_volume();
       void set_volume(float percentage);
@@ -72,5 +74,3 @@ namespace alsa
       void error_handler(const std::string& message);
   };
 }
-
-#endif
diff --git a/include/interfaces/mpd.hpp b/include/interfaces/mpd.hpp
index d6e45744..8e047040 100644
--- a/include/interfaces/mpd.hpp
+++ b/include/interfaces/mpd.hpp
@@ -1,5 +1,4 @@
-#ifndef _INTERFACES_MPD_HPP_
-#define _INTERFACES_MPD_HPP_
+#pragma once
 
 #include <string>
 #include <stdlib.h>
@@ -24,7 +23,7 @@ namespace mpd
   class ClientError : public Exception
   {
     public:
-      ClientError(const std::string& msg, mpd_error code, bool clearable)
+      explicit ClientError(const std::string& msg, mpd_error code, bool clearable)
         : Exception("[mpd::ClientError::"+ std::to_string(code) +"] "+ msg, clearable){}
   };
 
@@ -46,14 +45,14 @@ namespace mpd
   struct Song
   {
     Song(){}
-    Song(mpd_song *song);
+    explicit Song(mpd_song *song);
 
     std::shared_ptr<mpd_song> song;
 
     std::string get_artist();
     std::string get_album();
     std::string get_title();
-    unsigned get_duration();
+    // unsigned get_duration();
 
     operator bool() {
       return this->song.get() != nullptr;
@@ -69,7 +68,7 @@ namespace mpd
       }
     };
 
-    Status(mpd_status *status);
+    explicit Status(mpd_status *status);
 
     std::unique_ptr<struct mpd_status, StatusDeleter> status;
     std::unique_ptr<Song> song;
@@ -92,8 +91,8 @@ namespace mpd
     void update(int event);
     void update_timer();
 
-    unsigned get_total_time();
-    unsigned get_elapsed_time();
+    // unsigned get_total_time();
+    // unsigned get_elapsed_time();
     unsigned get_elapsed_percentage();
     std::string get_formatted_elapsed();
     std::string get_formatted_total();
@@ -128,12 +127,14 @@ namespace mpd
     void check_errors();
 
     public:
+      Connection() = default;
+
       static std::shared_ptr<Connection> &get();
 
       void connect();
       void disconnect();
       bool connected();
-      bool retry_connection(int interval = 1);
+      // bool retry_connection(int interval = 1);
       void idle();
       int noidle();
 
@@ -147,15 +148,15 @@ namespace mpd
 
       void play();
       void pause(bool state);
-      void toggle();
+      // void toggle();
       void stop();
       void prev();
       void next();
       void seek(int percentage);
 
-      void repeat(bool mode);
-      void random(bool mode);
-      void single(bool mode);
+      void set_repeat(bool mode);
+      void set_random(bool mode);
+      void set_single(bool mode);
   };
 
   struct MpdStatus
@@ -179,5 +180,3 @@ namespace mpd
     }
   };
 }
-
-#endif
diff --git a/include/interfaces/net.hpp b/include/interfaces/net.hpp
index 91ddff98..193aea97 100644
--- a/include/interfaces/net.hpp
+++ b/include/interfaces/net.hpp
@@ -1,5 +1,4 @@
-#ifndef _INTERFACES_NET_HPP_
-#define _INTERFACES_NET_HPP_
+#pragma once
 
 #include <string>
 #include <memory>
@@ -16,13 +15,12 @@ namespace net
 {
   bool is_wireless_interface(const std::string& ifname);
 
-  //
   // Network
-  //
+
   class NetworkException : public Exception
   {
     public:
-      NetworkException(const std::string& msg)
+      explicit NetworkException(const std::string& msg)
         : Exception("[Network] "+ msg){}
   };
 
@@ -34,22 +32,21 @@ namespace net
       struct ifreq data;
       int fd;
 
-      bool test_interface() throw(NetworkException);
-      bool test_connection() throw(NetworkException);
+      bool test_interface();
+      bool test_connection();
 
     public:
-      Network(const std::string& interface) throw(NetworkException);
+      explicit Network(const std::string& interface);
       ~Network();
 
       virtual bool connected();
       virtual bool test();
 
-      std::string get_ip() throw(NetworkException);
+      std::string get_ip();
   };
 
-  //
   // WiredNetwork
-  //
+
   class WiredNetworkException : public NetworkException {
     using NetworkException::NetworkException;
   };
@@ -59,14 +56,13 @@ namespace net
     int linkspeed = 0;
 
     public:
-      WiredNetwork(const std::string& interface);
+      explicit WiredNetwork(const std::string& interface);
 
       std::string get_link_speed();
   };
 
-  //
   // WirelessNetwork
-  //
+
   class WirelessNetworkException : public NetworkException {
     using NetworkException::NetworkException;
   };
@@ -76,14 +72,12 @@ namespace net
     struct iwreq iw;
 
     public:
-      WirelessNetwork(const std::string& interface);
+      explicit WirelessNetwork(const std::string& interface);
 
-      std::string get_essid() throw(WirelessNetworkException);
-      float get_signal_dbm() throw(WirelessNetworkException);
+      std::string get_essid();
+      float get_signal_dbm();
       float get_signal_quality();
   };
 
 
 }
-
-#endif
diff --git a/include/lemonbuddy.hpp b/include/lemonbuddy.hpp
index c8807a83..0536fe5c 100644
--- a/include/lemonbuddy.hpp
+++ b/include/lemonbuddy.hpp
@@ -1,5 +1,4 @@
-#ifndef _LEMONBUDDY_HPP_
-#define _LEMONBUDDY_HPP_
+#pragma once
 
 #include "exception.hpp"
 
@@ -9,5 +8,3 @@ void register_pid(pid_t pid);
 void unregister_pid(pid_t pid);
 
 void register_command_handler(const std::string& module_name);
-
-#endif
diff --git a/include/modules/backlight.hpp b/include/modules/backlight.hpp
index 9f7957b4..e03517fa 100644
--- a/include/modules/backlight.hpp
+++ b/include/modules/backlight.hpp
@@ -1,5 +1,4 @@
-#ifndef _MODULES_BACKLIGHT_HPP_
-#define _MODULES_BACKLIGHT_HPP_
+#pragma once
 
 #include "config.hpp"
 #include "modules/base.hpp"
@@ -10,9 +9,9 @@ namespace modules
 {
   DefineModule(BacklightModule, InotifyModule)
   {
-    const char *TAG_LABEL = "<label>";
-    const char *TAG_BAR = "<bar>";
-    const char *TAG_RAMP = "<ramp>";
+    static constexpr auto TAG_LABEL = "<label>";
+    static constexpr auto TAG_BAR = "<bar>";
+    static constexpr auto TAG_RAMP = "<ramp>";
 
     std::unique_ptr<drawtypes::Bar> bar;
     std::unique_ptr<drawtypes::Ramp> ramp;
@@ -22,14 +21,17 @@ namespace modules
     std::string path_val, path_max;
     float val = 0, max = 0;
 
-    std::atomic<int> percentage;
+    concurrency::Atomic<int> percentage;
 
     public:
-      BacklightModule(const std::string& name);
+      explicit BacklightModule(const std::string& name);
 
       bool on_event(InotifyEvent *event);
       bool build(Builder *builder, const std::string& tag);
+
+      void idle() const
+      {
+        std::this_thread::sleep_for(25ms);
+      }
   };
 }
-
-#endif
diff --git a/include/modules/base.hpp b/include/modules/base.hpp
index 9a81561b..8ff00daa 100644
--- a/include/modules/base.hpp
+++ b/include/modules/base.hpp
@@ -1,5 +1,4 @@
-#ifndef _MODULES_BASE_HPP_
-#define _MODULES_BASE_HPP_
+#pragma once
 
 #include <chrono>
 #include <memory>
@@ -10,24 +9,29 @@
 #include <condition_variable>
 #include <map>
 #include <thread>
-#include <atomic>
 #include <algorithm>
 
 #include "exception.hpp"
 #include "services/builder.hpp"
 #include "services/inotify.hpp"
+#include "services/logger.hpp"
 #include "utils/config.hpp"
 #include "utils/string.hpp"
 #include "utils/concurrency.hpp"
 
 using namespace std::chrono_literals;
 
-#define DEFAULT_FORMAT "format"
+#define Concat(one, two) one ## two
+
+#define _Stringify(expr) #expr
+#define Stringify(expr) _Stringify(expr)
 
 #define DefineModule(ModuleName, ModuleType) struct ModuleName : public ModuleType<ModuleName>
 #define CastModule(ModuleName) static_cast<ModuleName *>(this)
 #define ConstCastModule(ModuleName) static_cast<ModuleName const &>(*this)
 
+#define DEFAULT_FORMAT "format"
+
 DefineBaseException(ModuleError);
 DefineChildException(UndefinedFormat, ModuleError);
 DefineChildException(UndefinedFormatTag, ModuleError);
@@ -75,10 +79,10 @@ class ModuleFormatter
   std::map<std::string, std::unique_ptr<Format>> formats;
 
   public:
-    ModuleFormatter(const std::string& module_name)
+    explicit ModuleFormatter(const std::string& module_name)
       : module_name(module_name) {}
 
-    void add(const std::string& name, const std::string& fallback, std::vector<std::string> &&tags, std::vector<std::string> &&whitelist = {}) throw(UndefinedFormatTag)
+    void add(const std::string& name, const std::string& fallback, std::vector<std::string> &&tags, std::vector<std::string> &&whitelist = {})
     {
       auto format = std::make_unique<Format>();
 
@@ -106,7 +110,7 @@ class ModuleFormatter
       this->formats.insert(std::make_pair(name, std::move(format)));
     }
 
-    std::unique_ptr<Format>& get(const std::string& format_name) throw(UndefinedFormat)
+    std::unique_ptr<Format>& get(const std::string& format_name)
     {
       auto format = this->formats.find(format_name);
       if (format == this->formats.end())
@@ -114,7 +118,7 @@ class ModuleFormatter
       return format->second;
     }
 
-    bool has(const std::string& tag, const std::string& format_name) throw(UndefinedFormat)
+    bool has(const std::string& tag, const std::string& format_name)
     {
       auto format = this->formats.find(format_name);
       if (format == this->formats.end())
@@ -168,13 +172,12 @@ namespace modules
       std::vector<std::thread> threads;
 
     public:
-      Module(const std::string& name)
+      Module(const std::string& name, bool lazy_builder = true)
+        : name_("module/"+ name), builder(std::make_unique<Builder>(lazy_builder))
       {
-        this->name_ = "module/" + name;
         this->enable(false);
         this->cache = "";
         // this->builder = std::make_unique<Builder>(false);
-        this->builder = std::make_unique<Builder>();
         this->formatter = std::make_unique<ModuleFormatter>(ConstCastModule(ModuleImpl).name());
       }
 
@@ -274,15 +277,9 @@ namespace modules
   template<typename ModuleImpl>
   class StaticModule : public Module<ModuleImpl>
   {
-    protected:
-      std::unique_ptr<Builder> builder;
+    using Module<ModuleImpl>::Module;
 
     public:
-      StaticModule(const std::string& name, bool lazybuilder = true) : Module<ModuleImpl>(name)
-      {
-        this->builder = std::make_unique<Builder>(lazybuilder);
-      }
-
       void start()
       {
         this->enable(true);
@@ -385,23 +382,33 @@ namespace modules
         }
       }
 
+      void idle() const
+      {
+        // std::this_thread::sleep_for(1s);
+      }
+
       void poll_events()
       {
         std::lock_guard<concurrency::SpinLock> lck(this->update_lock);
         std::vector<std::unique_ptr<InotifyWatch>> watches;
 
-        for (auto &&w : this->watch_list) {
+        for (auto &&w : this->watch_list)
           watches.emplace_back(std::make_unique<InotifyWatch>(w.first, w.second));
-        }
 
         while (this->enabled()) {
+          ConstCastModule(ModuleImpl).idle();
+
           for (auto &&w : watches) {
             log_trace("Polling inotify event for watch at "+ (*w)());
+
             if (w->has_event(500 / watches.size())) {
               std::unique_ptr<InotifyEvent> event = w->get_event();
+
               watches.clear();
+
               if (CastModule(ModuleImpl)->on_event(event.get()))
                 CastModule(ModuleImpl)->broadcast();
+
               return;
             }
           }
@@ -433,5 +440,3 @@ namespace modules
       }
   };
 }
-
-#endif
diff --git a/include/modules/battery.hpp b/include/modules/battery.hpp
index 5d3fedd7..8130dc65 100644
--- a/include/modules/battery.hpp
+++ b/include/modules/battery.hpp
@@ -1,5 +1,4 @@
-#ifndef _MODULES_BATTERY_HPP_
-#define _MODULES_BATTERY_HPP_
+#pragma once
 
 #include <memory>
 #include <string>
@@ -47,10 +46,10 @@ namespace modules
       concurrency::Atomic<int> percentage;
       int full_at;
 
-      void subthread_runner();
+      void subthread_routine();
 
     public:
-      BatteryModule(const std::string& name);
+      explicit BatteryModule(const std::string& name);
 
       void start();
 
@@ -59,5 +58,3 @@ namespace modules
       bool build(Builder *builder, const std::string& tag);
   };
 }
-
-#endif
diff --git a/include/modules/bspwm.hpp b/include/modules/bspwm.hpp
index 0cab5f9b..ffd7a09b 100644
--- a/include/modules/bspwm.hpp
+++ b/include/modules/bspwm.hpp
@@ -1,5 +1,4 @@
-#ifndef _MODULES_BSPWM_HPP_
-#define _MODULES_BSPWM_HPP_
+#pragma once
 
 #include <memory>
 #include <string>
@@ -49,10 +48,10 @@ namespace modules
 
   DefineModule(BspwmModule, EventModule)
   {
-    const char *TAG_LABEL_STATE = "<label:state>";
-    const char *TAG_LABEL_MODE = "<label:mode>";
+    static constexpr auto TAG_LABEL_STATE = "<label:state>";
+    static constexpr auto TAG_LABEL_MODE = "<label:mode>";
 
-    const char *EVENT_CLICK = "bwm";
+    static constexpr auto EVENT_CLICK = "bwm";
 
     std::map<Bspwm::Flag, std::unique_ptr<drawtypes::Label>> mode_labels;
     std::map<Bspwm::Flag, std::unique_ptr<drawtypes::Label>> state_labels;
@@ -63,7 +62,7 @@ namespace modules
     std::unique_ptr<drawtypes::IconMap> icons;
     std::string monitor;
 
-    int socket_fd;
+    int socket_fd = -1;
     std::string prev_data;
 
     public:
@@ -77,5 +76,3 @@ namespace modules
       bool handle_command(const std::string& cmd);
   };
 }
-
-#endif
diff --git a/include/modules/counter.hpp b/include/modules/counter.hpp
index 7d2abcef..42291f69 100644
--- a/include/modules/counter.hpp
+++ b/include/modules/counter.hpp
@@ -1,5 +1,4 @@
-#ifndef _MODULES_COUNTER_HPP_
-#define _MODULES_COUNTER_HPP_
+#pragma once
 
 #include "modules/base.hpp"
 
@@ -7,16 +6,14 @@ namespace modules
 {
   DefineModule(CounterModule, TimerModule)
   {
-    const char *TAG_COUNTER = "<counter>";
+    static constexpr auto TAG_COUNTER = "<counter>";
 
     concurrency::Atomic<int> counter;
 
     public:
-      CounterModule(const std::string& name);
+      explicit CounterModule(const std::string& name);
 
       bool update();
       bool build(Builder *builder, const std::string& tag);
   };
 }
-
-#endif
diff --git a/include/modules/cpu.hpp b/include/modules/cpu.hpp
index f89e40e2..01541f71 100644
--- a/include/modules/cpu.hpp
+++ b/include/modules/cpu.hpp
@@ -1,5 +1,4 @@
-#ifndef _MODULES_CPU_HPP_
-#define _MODULES_CPU_HPP_
+#pragma once
 
 #include <memory>
 #include <string>
@@ -23,10 +22,10 @@ namespace modules
 
   DefineModule(CpuModule, TimerModule)
   {
-    const char *TAG_LABEL = "<label>";
-    const char *TAG_BAR_LOAD = "<bar:load>";
-    const char *TAG_RAMP_LOAD = "<ramp:load>";
-    const char *TAG_RAMP_LOAD_PER_CORE = "<ramp:load_per_core>";
+    static constexpr auto TAG_LABEL = "<label>";
+    static constexpr auto TAG_BAR_LOAD = "<bar:load>";
+    static constexpr auto TAG_RAMP_LOAD = "<ramp:load>";
+    static constexpr auto TAG_RAMP_LOAD_PER_CORE = "<ramp:load_per_core>";
 
     std::vector<std::unique_ptr<CpuTime>> cpu_times;
     std::vector<std::unique_ptr<CpuTime>> prev_cpu_times;
@@ -37,18 +36,16 @@ namespace modules
     std::unique_ptr<drawtypes::Label> label;
     std::unique_ptr<drawtypes::Label> label_tokenized;
 
-    float current_total_load;
+    float current_total_load = 0;
     std::vector<float> current_load;
 
     bool read_values();
     float get_load(int core);
 
     public:
-      CpuModule(const std::string& name);
+      explicit CpuModule(const std::string& name);
 
       bool update();
       bool build(Builder *builder, const std::string& tag);
   };
 }
-
-#endif
diff --git a/include/modules/date.hpp b/include/modules/date.hpp
index d57f9e94..e804f1e6 100644
--- a/include/modules/date.hpp
+++ b/include/modules/date.hpp
@@ -1,7 +1,4 @@
-#ifndef _MODULES_DATE_HPP_
-#define _MODULES_DATE_HPP_
-
-#include <string>
+#pragma once
 
 #include "modules/base.hpp"
 
@@ -9,20 +6,20 @@ namespace modules
 {
   DefineModule(DateModule, TimerModule)
   {
-    const char *TAG_DATE = "<date>";
+    static constexpr auto TAG_DATE = "<date>";
 
-    const char *EVENT_TOGGLE = "datetoggle";
+    static constexpr auto EVENT_TOGGLE = "datetoggle";
 
     std::unique_ptr<Builder> builder;
 
     std::string date;
     std::string date_detailed;
 
-    char date_str[256];
+    char date_str[256] = {};
     bool detailed = false;
 
     public:
-      DateModule(const std::string& name);
+      explicit DateModule(const std::string& name);
 
       bool update();
       bool build(Builder *builder, const std::string& tag);
@@ -31,5 +28,3 @@ namespace modules
       bool handle_command(const std::string& cmd);
   };
 }
-
-#endif
diff --git a/include/modules/i3.hpp b/include/modules/i3.hpp
index 028e9973..be0e96e4 100644
--- a/include/modules/i3.hpp
+++ b/include/modules/i3.hpp
@@ -1,14 +1,10 @@
-#ifndef _MODULES_I3_HPP_
-#define _MODULES_I3_HPP_
-
-#include "config.hpp"
+#pragma once
 
 #include <memory>
-#include <string>
 #include <unistd.h>
-
 #include <i3ipc++/ipc.hpp>
 
+#include "config.hpp"
 #include "modules/base.hpp"
 #include "drawtypes/icon.hpp"
 #include "drawtypes/label.hpp"
@@ -46,11 +42,9 @@ namespace modules
 
   DefineModule(i3Module, EventModule)
   {
-    const char *TAG_LABEL_STATE = "<label:state>";
+    static constexpr auto TAG_LABEL_STATE = "<label:state>";
 
-    const char *EVENT_CLICK = "i3";
-
-    concurrency::SpinLock update_lock;
+    static constexpr auto EVENT_CLICK = "i3";
 
     std::unique_ptr<i3ipc::connection> ipc;
 
@@ -66,7 +60,7 @@ namespace modules
     bool local_workspaces = true;
     std::size_t workspace_name_strip_nchars = 0;
 
-    int ipc_fd;
+    int ipc_fd = -1;
 
     public:
       i3Module(const std::string& name, const std::string& monitor);
@@ -81,5 +75,3 @@ namespace modules
       bool handle_command(const std::string& cmd);
   };
 }
-
-#endif
diff --git a/include/modules/memory.hpp b/include/modules/memory.hpp
index efe21922..d5c82916 100644
--- a/include/modules/memory.hpp
+++ b/include/modules/memory.hpp
@@ -1,5 +1,4 @@
-#ifndef _MODULES_MEMORY_HPP_
-#define _MODULES_MEMORY_HPP_
+#pragma once
 
 #include <atomic>
 
@@ -12,9 +11,9 @@ namespace modules
 {
   DefineModule(MemoryModule, TimerModule)
   {
-    const char *TAG_LABEL = "<label>";
-    const char *TAG_BAR_USED = "<bar:used>";
-    const char *TAG_BAR_FREE = "<bar:free>";
+    static constexpr auto TAG_LABEL = "<label>";
+    static constexpr auto TAG_BAR_USED = "<bar:used>";
+    static constexpr auto TAG_BAR_FREE = "<bar:free>";
 
     std::unique_ptr<drawtypes::Bar> bar_used;
     std::unique_ptr<drawtypes::Bar> bar_free;
@@ -25,11 +24,9 @@ namespace modules
     std::atomic<int> percentage_free;
 
     public:
-      MemoryModule(const std::string& name);
+      explicit MemoryModule(const std::string& name);
 
       bool update();
       bool build(Builder *builder, const std::string& tag);
   };
 }
-
-#endif
diff --git a/include/modules/menu.hpp b/include/modules/menu.hpp
index 610d7f2e..e982b38e 100644
--- a/include/modules/menu.hpp
+++ b/include/modules/menu.hpp
@@ -1,5 +1,4 @@
-#ifndef _MODULES_MENU_HPP_
-#define _MODULES_MENU_HPP_
+#pragma once
 
 #include <mutex>
 
@@ -18,11 +17,11 @@ namespace modules
 
   DefineModule(MenuModule, StaticModule)
   {
-    const char *TAG_LABEL_TOGGLE = "<label:toggle>";
-    const char *TAG_MENU = "<menu>";
+    static constexpr auto TAG_LABEL_TOGGLE = "<label:toggle>";
+    static constexpr auto TAG_MENU = "<menu>";
 
-    const char *EVENT_MENU_OPEN = "menu_open:";
-    const char *EVENT_MENU_CLOSE = "menu_close";
+    static constexpr auto EVENT_MENU_OPEN = "menu_open:";
+    static constexpr auto EVENT_MENU_CLOSE = "menu_close";
 
     std::mutex output_mtx;
     std::mutex cmd_mtx;
@@ -34,14 +33,12 @@ namespace modules
     std::unique_ptr<drawtypes::Label> label_close;
 
     public:
-      MenuModule(const std::string& name);
+      explicit MenuModule(const std::string& name);
 
-      std::string get_output() throw(UndefinedFormat);
+      std::string get_output();
 
       bool build(Builder *builder, const std::string& tag);
 
       bool handle_command(const std::string& cmd);
   };
 }
-
-#endif
diff --git a/include/modules/mpd.hpp b/include/modules/mpd.hpp
index cc7d1190..aeaf7aca 100644
--- a/include/modules/mpd.hpp
+++ b/include/modules/mpd.hpp
@@ -1,5 +1,4 @@
-#ifndef _MODULES_MPD_HPP_
-#define _MODULES_MPD_HPP_
+#pragma once
 
 #include "modules/base.hpp"
 #include "interfaces/mpd.hpp"
@@ -14,32 +13,32 @@ namespace modules
     static const int PROGRESSBAR_THREAD_SYNC_COUNT = 10;
     const std::chrono::duration<double> PROGRESSBAR_THREAD_INTERVAL = 1s;
 
-    const char *FORMAT_ONLINE = "format:online";
-    const char *TAG_BAR_PROGRESS = "<bar:progress>";
-    const char *TAG_TOGGLE = "<toggle>";
-    const char *TAG_LABEL_SONG = "<label:song>";
-    const char *TAG_LABEL_TIME = "<label:time>";
-    const char *TAG_ICON_RANDOM = "<icon:random>";
-    const char *TAG_ICON_REPEAT = "<icon:repeat>";
-    const char *TAG_ICON_REPEAT_ONE = "<icon:repeatone>";
-    const char *TAG_ICON_PREV = "<icon:prev>";
-    const char *TAG_ICON_STOP = "<icon:stop>";
-    const char *TAG_ICON_PLAY = "<icon:play>";
-    const char *TAG_ICON_PAUSE = "<icon:pause>";
-    const char *TAG_ICON_NEXT = "<icon:next>";
+    static constexpr auto FORMAT_ONLINE = "format:online";
+    static constexpr auto TAG_BAR_PROGRESS = "<bar:progress>";
+    static constexpr auto TAG_TOGGLE = "<toggle>";
+    static constexpr auto TAG_LABEL_SONG = "<label:song>";
+    static constexpr auto TAG_LABEL_TIME = "<label:time>";
+    static constexpr auto TAG_ICON_RANDOM = "<icon:random>";
+    static constexpr auto TAG_ICON_REPEAT = "<icon:repeat>";
+    static constexpr auto TAG_ICON_REPEAT_ONE = "<icon:repeatone>";
+    static constexpr auto TAG_ICON_PREV = "<icon:prev>";
+    static constexpr auto TAG_ICON_STOP = "<icon:stop>";
+    static constexpr auto TAG_ICON_PLAY = "<icon:play>";
+    static constexpr auto TAG_ICON_PAUSE = "<icon:pause>";
+    static constexpr auto TAG_ICON_NEXT = "<icon:next>";
 
-    const char *FORMAT_OFFLINE = "format:offline";
-    const char *TAG_LABEL_OFFLINE = "<label:offline>";
+    static constexpr auto FORMAT_OFFLINE = "format:offline";
+    static constexpr auto TAG_LABEL_OFFLINE = "<label:offline>";
 
-    const char *EVENT_PLAY = "mpdplay";
-    const char *EVENT_PAUSE = "mpdpause";
-    const char *EVENT_STOP = "mpdstop";
-    const char *EVENT_PREV = "mpdprev";
-    const char *EVENT_NEXT = "mpdnext";
-    const char *EVENT_REPEAT = "mpdrepeat";
-    const char *EVENT_REPEAT_ONE = "mpdrepeatone";
-    const char *EVENT_RANDOM = "mpdrandom";
-    const char *EVENT_SEEK = "mpdseek";
+    static constexpr auto EVENT_PLAY = "mpdplay";
+    static constexpr auto EVENT_PAUSE = "mpdpause";
+    static constexpr auto EVENT_STOP = "mpdstop";
+    static constexpr auto EVENT_PREV = "mpdprev";
+    static constexpr auto EVENT_NEXT = "mpdnext";
+    static constexpr auto EVENT_REPEAT = "mpdrepeat";
+    static constexpr auto EVENT_REPEAT_ONE = "mpdrepeatone";
+    static constexpr auto EVENT_RANDOM = "mpdrandom";
+    static constexpr auto EVENT_SEEK = "mpdseek";
 
     std::unique_ptr<drawtypes::Bar> bar_progress;
     std::unique_ptr<drawtypes::IconMap> icons;
@@ -56,13 +55,13 @@ namespace modules
 
     std::shared_ptr<mpd::Connection> mpd;
     std::chrono::system_clock::time_point synced_at;
-    float sync_interval;
+    float sync_interval = 0.5f;
 
     bool clickable_progress = false;
     std::string progress_fill, progress_empty, progress_indicator;
 
     public:
-      MpdModule(const std::string& name);
+      explicit MpdModule(const std::string& name);
       ~MpdModule();
 
       void start();
@@ -74,5 +73,3 @@ namespace modules
       bool handle_command(const std::string& cmd);
   };
 }
-
-#endif
diff --git a/include/modules/network.hpp b/include/modules/network.hpp
index 10f217ec..9a6375ab 100644
--- a/include/modules/network.hpp
+++ b/include/modules/network.hpp
@@ -1,5 +1,4 @@
-#ifndef _MODULES_NETWORK_HPP_
-#define _MODULES_NETWORK_HPP_
+#pragma once
 
 #include <atomic>
 #include <chrono>
@@ -18,15 +17,15 @@ namespace modules
 {
   DefineModule(NetworkModule, TimerModule)
   {
-    const char *FORMAT_CONNECTED = "format:connected";
-    const char *FORMAT_PACKETLOSS = "format:packetloss";
-    const char *FORMAT_DISCONNECTED = "format:disconnected";
+    static constexpr auto FORMAT_CONNECTED = "format:connected";
+    static constexpr auto FORMAT_PACKETLOSS = "format:packetloss";
+    static constexpr auto FORMAT_DISCONNECTED = "format:disconnected";
 
-    const char *TAG_RAMP_SIGNAL = "<ramp:signal>";
-    const char *TAG_LABEL_CONNECTED = "<label:connected>";
-    const char *TAG_LABEL_DISCONNECTED = "<label:disconnected>";
-    const char *TAG_LABEL_PACKETLOSS = "<label:packetloss>";
-    const char *TAG_ANIMATION_PACKETLOSS = "<animation:packetloss>";
+    static constexpr auto TAG_RAMP_SIGNAL = "<ramp:signal>";
+    static constexpr auto TAG_LABEL_CONNECTED = "<label:connected>";
+    static constexpr auto TAG_LABEL_DISCONNECTED = "<label:disconnected>";
+    static constexpr auto TAG_LABEL_PACKETLOSS = "<label:packetloss>";
+    static constexpr auto TAG_ANIMATION_PACKETLOSS = "<animation:packetloss>";
 
     std::unique_ptr<net::WiredNetwork> wired_network;
     std::unique_ptr<net::WirelessNetwork> wireless_network;
@@ -51,7 +50,7 @@ namespace modules
     void subthread_routine();
 
     public:
-      NetworkModule(const std::string& name);
+      explicit NetworkModule(const std::string& name);
 
       void start();
       bool update();
@@ -62,5 +61,3 @@ namespace modules
 
   };
 }
-
-#endif
diff --git a/include/modules/script.hpp b/include/modules/script.hpp
index dd728a67..de55ad52 100644
--- a/include/modules/script.hpp
+++ b/include/modules/script.hpp
@@ -1,5 +1,4 @@
-#ifndef _MODULES_SCRIPT_HPP_
-#define _MODULES_SCRIPT_HPP_
+#pragma once
 
 #include "modules/base.hpp"
 #include "services/command.hpp"
@@ -8,7 +7,7 @@ namespace modules
 {
   DefineModule(ScriptModule, TimerModule)
   {
-    const char *TAG_OUTPUT = "<output>";
+    static constexpr auto TAG_OUTPUT = "<output>";
 
     std::unique_ptr<Builder> builder;
 
@@ -25,12 +24,10 @@ namespace modules
     protected:
 
     public:
-      ScriptModule(const std::string& name);
+      explicit ScriptModule(const std::string& name);
 
       bool update();
       bool build(Builder *builder, const std::string& tag);
       std::string get_output();
   };
 }
-
-#endif
diff --git a/include/modules/text.hpp b/include/modules/text.hpp
index 9bb76449..e8116d72 100644
--- a/include/modules/text.hpp
+++ b/include/modules/text.hpp
@@ -1,5 +1,4 @@
-#ifndef _MODULES_TEXT_HPP_
-#define _MODULES_TEXT_HPP_
+#pragma once
 
 #include "modules/base.hpp"
 
@@ -7,14 +6,12 @@ namespace modules
 {
   DefineModule(TextModule, StaticModule)
   {
-    const char *FORMAT = "content";
+    static constexpr auto FORMAT = "content";
 
     public:
-      TextModule(const std::string& name) throw(UndefinedFormat);
+      explicit TextModule(const std::string& name);
 
       std::string get_format();
       std::string get_output();
   };
 }
-
-#endif
diff --git a/include/modules/torrent.hpp b/include/modules/torrent.hpp
index f34d936f..0b70f9af 100644
--- a/include/modules/torrent.hpp
+++ b/include/modules/torrent.hpp
@@ -1,5 +1,4 @@
-#ifndef _MODULES_TORRENT_HPP_
-#define _MODULES_TORRENT_HPP_
+#pragma once
 
 #include "modules/base.hpp"
 #include "drawtypes/bar.hpp"
@@ -19,8 +18,8 @@ namespace modules
 
   DefineModule(TorrentModule, InotifyModule)
   {
-    const char *TAG_LABEL = "<label>";
-    const char *TAG_BAR_PROGRESS = "<bar:progress>";
+    static constexpr auto TAG_LABEL = "<label>";
+    static constexpr auto TAG_BAR_PROGRESS = "<bar:progress>";
 
     std::vector<std::unique_ptr<Torrent>> torrents;
     std::unique_ptr<drawtypes::Label> label;
@@ -31,12 +30,10 @@ namespace modules
     std::vector<std::unique_ptr<Torrent>> &read_data_into(std::vector<std::unique_ptr<Torrent>> &container);
 
     public:
-      TorrentModule(const std::string& name);
+      explicit TorrentModule(const std::string& name);
 
       void start();
       bool on_event(InotifyEvent *event);
       bool build(Builder *builder, const std::string& tag);
   };
 }
-
-#endif
diff --git a/include/modules/volume.hpp b/include/modules/volume.hpp
index 222e1197..6c85a5cc 100644
--- a/include/modules/volume.hpp
+++ b/include/modules/volume.hpp
@@ -1,5 +1,4 @@
-#ifndef _MODULES_VOLUME_HPP_
-#define _MODULES_VOLUME_HPP_
+#pragma once
 
 #include "modules/base.hpp"
 #include "interfaces/alsa.hpp"
@@ -12,17 +11,17 @@ namespace modules
 {
   DefineModule(VolumeModule, EventModule)
   {
-    const char *FORMAT_VOLUME = "format:volume";
-    const char *FORMAT_MUTED = "format:muted";
+    static constexpr auto FORMAT_VOLUME = "format:volume";
+    static constexpr auto FORMAT_MUTED = "format:muted";
 
-    const char *TAG_RAMP_VOLUME = "<ramp:volume>";
-    const char *TAG_BAR_VOLUME = "<bar:volume>";
-    const char *TAG_LABEL_VOLUME = "<label:volume>";
-    const char *TAG_LABEL_MUTED = "<label:muted>";
+    static constexpr auto TAG_RAMP_VOLUME = "<ramp:volume>";
+    static constexpr auto TAG_BAR_VOLUME = "<bar:volume>";
+    static constexpr auto TAG_LABEL_VOLUME = "<label:volume>";
+    static constexpr auto TAG_LABEL_MUTED = "<label:muted>";
 
-    const char *EVENT_VOLUME_UP = "volup";
-    const char *EVENT_VOLUME_DOWN = "voldown";
-    const char *EVENT_TOGGLE_MUTE = "volmute";
+    static constexpr auto EVENT_VOLUME_UP = "volup";
+    static constexpr auto EVENT_VOLUME_DOWN = "voldown";
+    static constexpr auto EVENT_TOGGLE_MUTE = "volmute";
 
     std::unique_ptr<alsa::Mixer> master_mixer;
     std::unique_ptr<alsa::Mixer> speaker_mixer;
@@ -43,7 +42,7 @@ namespace modules
     bool muted = false;
 
     public:
-      VolumeModule(const std::string& name) throw(ModuleError);
+      explicit VolumeModule(const std::string& name);
       ~VolumeModule();
 
       bool has_event();
@@ -56,5 +55,3 @@ namespace modules
       bool handle_command(const std::string& cmd);
   };
 }
-
-#endif
diff --git a/include/registry.hpp b/include/registry.hpp
index 85208eee..81202f50 100644
--- a/include/registry.hpp
+++ b/include/registry.hpp
@@ -1,22 +1,17 @@
-#ifndef _REGISTRY_HPP_
-#define _REGISTRY_HPP_
+#pragma once
 
-#include <condition_variable>
-
-#include "exception.hpp"
 #include "modules/base.hpp"
 
 DefineBaseException(RegistryError);
 DefineChildException(ModuleNotFound, RegistryError);
 
-struct ModuleEntry
+struct RegistryModuleEntry
 {
   concurrency::Atomic<bool> warmedup;
   std::unique_ptr<modules::ModuleInterface> module;
 
-  ModuleEntry(std::unique_ptr<modules::ModuleInterface> &&module)
+  RegistryModuleEntry(std::unique_ptr<modules::ModuleInterface> &&module) : warmedup(false)
   {
-    this->warmedup = false;
     this->module.swap(module);
   }
 };
@@ -34,7 +29,7 @@ class Registry
 
   concurrency::Atomic<int> stage;
 
-  std::vector<std::unique_ptr<ModuleEntry>> modules;
+  std::vector<std::unique_ptr<RegistryModuleEntry>> modules;
 
   std::mutex wait_mtx;
   std::condition_variable wait_cv;
@@ -49,9 +44,7 @@ class Registry
     bool wait();
     void notify(const std::string& module_name);
     std::string get(const std::string& module_name);
-    std::unique_ptr<ModuleEntry>& find(const std::string& module_name) throw(ModuleNotFound);
+    std::unique_ptr<RegistryModuleEntry>& find(const std::string& module_name);
 };
 
 std::shared_ptr<Registry> &get_registry();
-
-#endif
diff --git a/include/services/builder.hpp b/include/services/builder.hpp
index dbef504b..32f9e224 100644
--- a/include/services/builder.hpp
+++ b/include/services/builder.hpp
@@ -1,5 +1,4 @@
-#ifndef _SERVICES_BUILDER_HPP_
-#define _SERVICES_BUILDER_HPP_
+#pragma once
 
 #include <string>
 #include <memory>
@@ -43,7 +42,7 @@ class Builder
     void align_right();
 
   public:
-    Builder(bool lazy_closing = true) : lazy_closing(lazy_closing){}
+    explicit Builder(bool lazy_closing = true) : lazy_closing(lazy_closing){}
 
     void set_lazy_closing(bool mode) { this->lazy_closing = mode; }
 
@@ -93,10 +92,8 @@ class Builder
     void underline(const std::string& color = "");
     void underline_close(bool force = false);
 
-    void invert();
+    // void invert();
 
     void cmd(int button, std::string action, bool condition = true);
     void cmd_close(bool force = false);
 };
-
-#endif
diff --git a/include/services/command.hpp b/include/services/command.hpp
index 22518851..bc48f4cb 100644
--- a/include/services/command.hpp
+++ b/include/services/command.hpp
@@ -1,5 +1,4 @@
-#ifndef _SERVICES_COMMAND_HPP_
-#define _SERVICES_COMMAND_HPP_
+#pragma once
 
 #include <functional>
 #include <memory>
@@ -9,9 +8,7 @@
 #include "exception.hpp"
 #include "utils/proc.hpp"
 
-class CommandException : public Exception {
-  using Exception::Exception;
-};
+DefineBaseException(CommandException);
 
 class Command
 {
@@ -25,21 +22,18 @@ class Command
     int fork_status;
 
   public:
-    Command(const std::string& cmd, int stdout[2] = nullptr, int stdin[2] = nullptr)
-      throw(CommandException);
-    ~Command() throw(CommandException);
+    Command(const std::string& cmd, int stdout[2] = nullptr, int stdin[2] = nullptr);
+    ~Command();
 
-    int exec(bool wait_for_completion = true) throw(CommandException);
-    int wait() throw(CommandException);
+    int exec(bool wait_for_completion = true);
+    int wait();
 
     void tail(std::function<void(std::string)> callback);
     int writeline(const std::string& data);
 
     int get_stdout(int);
-    int get_stdin(int);
+    // int get_stdin(int);
 
-    pid_t get_pid();
-    int get_exit_status();
+    // pid_t get_pid();
+    // int get_exit_status();
 };
-
-#endif
diff --git a/include/services/inotify.hpp b/include/services/inotify.hpp
index a208a330..42223812 100644
--- a/include/services/inotify.hpp
+++ b/include/services/inotify.hpp
@@ -1,5 +1,4 @@
-#ifndef _SERVICES_INOTIFY_HPP_
-#define _SERVICES_INOTIFY_HPP_
+#pragma once
 
 #include <memory>
 #include <sys/inotify.h>
@@ -9,7 +8,7 @@
 class InotifyException : public Exception
 {
   public:
-    InotifyException(const std::string& msg)
+    explicit InotifyException(const std::string& msg)
       : Exception("[Inotify] "+ msg){}
 };
 
@@ -49,7 +48,7 @@ class InotifyWatch
   int fd = -1, wd = -1, mask;
 
   public:
-    InotifyWatch(const std::string& path, int mask = InotifyEvent::ALL) throw (InotifyException);
+    explicit InotifyWatch(const std::string& path, int mask = InotifyEvent::ALL);
     ~InotifyWatch();
 
     std::string operator()() {
@@ -59,5 +58,3 @@ class InotifyWatch
     bool has_event(int timeout_ms = 1000);
     std::unique_ptr<InotifyEvent> get_event();
 };
-
-#endif
diff --git a/include/services/logger.hpp b/include/services/logger.hpp
index 22ff0a62..3e5e6cdb 100644
--- a/include/services/logger.hpp
+++ b/include/services/logger.hpp
@@ -1,9 +1,9 @@
-#ifndef _SERVICES_LOGGER_HPP_
-#define _SERVICES_LOGGER_HPP_
+#pragma once
 
 #include <memory>
 #include <string>
 #include <mutex>
+#include <unistd.h>
 
 #include "exception.hpp"
 #include "utils/streams.hpp"
@@ -44,7 +44,7 @@ class Logger
   public:
     Logger();
 
-    void set_level(int level);
+    // void set_level(int level);
     void add_level(int level);
 
     void fatal(const std::string& msg);
@@ -65,5 +65,3 @@ class Logger
 };
 
 std::shared_ptr<Logger> &get_logger();
-
-#endif
diff --git a/include/services/store.hpp b/include/services/store.hpp
index d8bf334f..90dafe45 100644
--- a/include/services/store.hpp
+++ b/include/services/store.hpp
@@ -1,6 +1,9 @@
 #if 0
 #ifndef _SERVICES_STORE_HPP_
 #define _SERVICES_STORE_HPP_
+=======
+#pragma once
+>>>>>>> task(core): Cleanup
 
 #include <string>
 #include <memory>
@@ -33,6 +36,7 @@ struct Store
   Store(int size);
   ~Store() {}
 };
+<<<<<<< 78384e08923e669c65c68a8cdf81dba37a633d6c
 
 #endif
 #endif
diff --git a/include/utils/cli.hpp b/include/utils/cli.hpp
index c45f2e75..d74ea584 100644
--- a/include/utils/cli.hpp
+++ b/include/utils/cli.hpp
@@ -1,16 +1,12 @@
-#ifndef _UTILS_CLI_HPP_
-#define _UTILS_CLI_HPP_
+#pragma once
 
-#include <string>
 #include <vector>
 
 #include "exception.hpp"
 
 namespace cli
 {
-  class CommandLineError : public Exception {
-    using Exception::Exception;
-  };
+  DefineBaseException(CommandLineError);
 
   struct Option
   {
@@ -40,5 +36,3 @@ namespace cli
 
   void usage(const std::string& usage, bool exit_success = true);
 }
-
-#endif
diff --git a/include/utils/concurrency.hpp b/include/utils/concurrency.hpp
index f7c028fc..8f0970cc 100644
--- a/include/utils/concurrency.hpp
+++ b/include/utils/concurrency.hpp
@@ -1,3 +1,5 @@
+#pragma once
+
 #include <atomic>
 #include <mutex>
 #include <thread>
@@ -59,7 +61,7 @@ namespace concurrency
 
     public:
       Atomic() = default;
-      Atomic(T init) {
+      explicit Atomic(T init) {
         this->operator=(init);
       }
 
@@ -96,7 +98,7 @@ namespace concurrency
 
     public:
       Value() = default;
-      Value(T init) {
+      explicit Value(T init) {
         this->operator=(init);
       }
 
diff --git a/include/utils/config.hpp b/include/utils/config.hpp
index f689c9bf..a0833c11 100644
--- a/include/utils/config.hpp
+++ b/include/utils/config.hpp
@@ -1,62 +1,38 @@
-#ifndef _UTILS_CONFIG_HPP_
-#define _UTILS_CONFIG_HPP_
+#pragma once
 
-#include <string>
-#include <vector>
 #include <mutex>
 
 #include <boost/property_tree/ptree.hpp>
 #include <boost/property_tree/ini_parser.hpp>
 
 #include "exception.hpp"
-#include "services/logger.hpp"
 #include "utils/string.hpp"
 
 namespace config
 {
-  class ConfigException : public Exception {
-    using Exception::Exception;
-  };
-
-  class UnexistingFileError : public ConfigException {
-    using ConfigException::ConfigException;
-  };
-
-  class ParseError : public ConfigException {
-    using ConfigException::ConfigException;
-  };
-
-  class MissingValueException : public ConfigException {
-    using ConfigException::ConfigException;
-  };
-
-  class MissingListValueException : public ConfigException {
-    using ConfigException::ConfigException;
-  };
-
-  class InvalidVariableException : public ConfigException {
-    using ConfigException::ConfigException;
-  };
-
-  class InvalidReferenceException : public ConfigException {
-    using ConfigException::ConfigException;
-  };
+  DefineBaseException(ConfigException);
+  DefineChildException(UnexistingFileError, ConfigException);
+  DefineChildException(ParseError, ConfigException);
+  DefineChildException(MissingValueException, ConfigException);
+  DefineChildException(MissingListValueException, ConfigException);
+  DefineChildException(InvalidVariableException, ConfigException);
+  DefineChildException(InvalidReferenceException, ConfigException);
 
   static std::recursive_mutex mtx;
 
   std::string get_bar_path();
   void set_bar_path(const std::string& path);
 
-  void load(const std::string& path) throw(UnexistingFileError, ParseError);
+  void load(const std::string& path);
   void load(const char *dir, const std::string& path);
-  void reload() throw(ParseError);
+  // void reload();
 
   boost::property_tree::ptree get_tree();
 
   std::string build_path(const std::string& section, const std::string& key);
 
   template<typename T>
-  T dereference_var(const std::string& ref_section, const std::string& ref_key, const std::string& var, const T ref_val) throw (InvalidVariableException, InvalidReferenceException)
+  T dereference_var(const std::string& ref_section, const std::string& ref_key, const std::string& var, const T ref_val)
   {
     std::lock_guard<std::recursive_mutex> lck(config::mtx);
 
@@ -85,7 +61,7 @@ namespace config
   }
 
   template<typename T>
-  T get(const std::string& section, const std::string& key) throw (MissingValueException)
+  T get(const std::string& section, const std::string& key)
   {
     std::lock_guard<std::recursive_mutex> lck(config::mtx);
 
@@ -111,7 +87,7 @@ namespace config
   }
 
   template<typename T>
-  std::vector<T> get_list(const std::string& section, const std::string& key) throw (MissingListValueException)
+  std::vector<T> get_list(const std::string& section, const std::string& key)
   {
     std::lock_guard<std::recursive_mutex> lck(config::mtx);
 
@@ -148,5 +124,3 @@ namespace config
       return vec;
   }
 }
-
-#endif
diff --git a/include/utils/io.hpp b/include/utils/io.hpp
index 672cf345..841ede44 100644
--- a/include/utils/io.hpp
+++ b/include/utils/io.hpp
@@ -1,5 +1,4 @@
-#ifndef _UTILS_IO_HPP_
-#define _UTILS_IO_HPP_
+#pragma once
 
 #include <string>
 #include <functional>
@@ -30,9 +29,8 @@ namespace io
         std::string mode;
 
         FilePtr(const std::string& path, const std::string& mode = "a+")
+          : path(std::string(path)), mode(std::string(mode))
         {
-          this->path = std::string(path);
-          this->mode = std::string(mode);
           this->fptr = fopen(this->path.c_str(), this->mode.c_str());
         }
 
@@ -69,12 +67,10 @@ namespace io
   void tail(int read_fd, int writeback_fd);
 
   bool poll_read(int fd, int timeout_ms = 1);
-  bool poll_write(int fd, int timeout_ms = 1);
+  // bool poll_write(int fd, int timeout_ms = 1);
   bool poll(int fd, short int events, int timeout_ms = 1);
 
-  int get_flags(int fd);
-  int set_blocking(int fd);
-  int set_non_blocking(int fd);
+  // int get_flags(int fd);
+  // int set_blocking(int fd);
+  // int set_non_blocking(int fd);
 }
-
-#endif
diff --git a/include/utils/macros.hpp b/include/utils/macros.hpp
new file mode 100644
index 00000000..28fd4e41
--- /dev/null
+++ b/include/utils/macros.hpp
@@ -0,0 +1,13 @@
+#pragma once
+
+#define writeln(s) std::cout << s << std::endl
+#define writeln_ss(s) { std::stringstream ss; ss << s; writeln(ss.str()); std::stringstream s; }
+
+#define ToStr(s) std::string(s)
+#define IntToStr(s) std::to_string(s)
+
+#define StrErrno() ToStr(std::strerror(errno))
+#define StrErrnoCustom(s) ToStr(std::strerror(s))
+
+#define StrSignal(sig) IntToStr(sig)
+#define StrSignalC(sig) strsignal(sig)
diff --git a/include/utils/math.hpp b/include/utils/math.hpp
index 30b92887..e6dfd5d6 100644
--- a/include/utils/math.hpp
+++ b/include/utils/math.hpp
@@ -1,5 +1,4 @@
-#ifndef _UTILS_MATH_HPP_
-#define _UTILS_MATH_HPP_
+#pragma once
 
 #include <string>
 #include <algorithm>
@@ -14,5 +13,3 @@ namespace math
     return value;
   }
 }
-
-#endif
diff --git a/include/utils/memory.hpp b/include/utils/memory.hpp
index cc83c436..d9f223e5 100644
--- a/include/utils/memory.hpp
+++ b/include/utils/memory.hpp
@@ -1,5 +1,4 @@
-#ifndef _UTILS_MEMORY_HPP
-#define _UTILS_MEMORY_HPP
+#pragma once
 
 // Swap the two ints without the need of creating another tmp variable
 #define int_memswap(one, two) one += two; \
@@ -12,5 +11,3 @@
 #define repeat_with(n, m) for (m = n; m--;)
 #define repeat_i i
 #define repeat_i_rev(n) (n - i - 1)
-
-#endif
diff --git a/include/utils/proc.hpp b/include/utils/proc.hpp
index bc37c253..c9ffd575 100644
--- a/include/utils/proc.hpp
+++ b/include/utils/proc.hpp
@@ -1,5 +1,4 @@
-#ifndef _UTILS_PROC_HPP_
-#define _UTILS_PROC_HPP_
+#pragma once
 
 #include <string>
 #include <errno.h>
@@ -11,13 +10,6 @@
 #define PIPE_READ  0
 #define PIPE_WRITE 1
 
-#define STRERRNO std::string(std::strerror(errno))
-#define STRERRNO_VAL(s) std::string(std::strerror(s))
-
-#define SIGCSTR(sig) strsignal(sig)
-#define SIGNSTR(sig) std::to_string(sig)
-#define SIGSTR(sig) std::string(SIGCSTR(sig))
-
 namespace proc
 {
   class ExecFailure : public Exception {
@@ -25,14 +17,14 @@ namespace proc
   };
 
   pid_t get_process_id();
-  pid_t get_parent_process_id();
+  // pid_t get_parent_process_id();
 
   bool in_parent_process(pid_t pid);
   bool in_forked_process(pid_t pid);
 
   pid_t fork();
   bool pipe(int fds[2]);
-  void exec(const std::string& cmd) throw(ExecFailure);
+  void exec(const std::string& cmd);
 
   bool kill(pid_t pid, int sig = SIGTERM);
 
@@ -43,5 +35,3 @@ namespace proc
   pid_t wait_for_completion_nohang(int *status);
   pid_t wait_for_completion_nohang();
 }
-
-#endif
diff --git a/include/utils/streams.hpp b/include/utils/streams.hpp
index 5cde2dc0..f9f3a8cd 100644
--- a/include/utils/streams.hpp
+++ b/include/utils/streams.hpp
@@ -1,5 +1,5 @@
-#ifndef _UTILS_STREAMS_HPP_
-#define _UTILS_STREAMS_HPP_
+#if 0
+#pragma once
 
 #include <iostream>
 #include <streambuf>
@@ -43,5 +43,4 @@ namespace streams
       }
   };
 }
-
 #endif
diff --git a/include/utils/string.hpp b/include/utils/string.hpp
index b864c985..495329b7 100644
--- a/include/utils/string.hpp
+++ b/include/utils/string.hpp
@@ -1,17 +1,13 @@
-#ifndef _UTILS_STRING_HPP_
-#define _UTILS_STRING_HPP_
+#pragma once
 
 #include <string>
 #include <vector>
 
-#define STR(s) std::string(s)
-#define STRI(s) std::to_string(s)
-
 namespace string
 {
   bool compare(const std::string& s1, const std::string& s2);
 
-  std::string upper(const std::string& s);
+  // std::string upper(const std::string& s);
   std::string lower(const std::string& s);
 
   std::string replace(const std::string& haystack, const std::string& needle, const std::string& replacement);
@@ -19,7 +15,7 @@ namespace string
 
   std::string squeeze(const std::string& haystack, const char &needle);
 
-  std::string strip(const std::string& haystack, const char &needle);
+  // std::string strip(const std::string& haystack, const char &needle);
   std::string strip_trailing_newline(const std::string& s);
 
   std::string trim(const std::string& haystack, const char &needle);
@@ -33,5 +29,3 @@ namespace string
 
   std::size_t find_nth(const std::string& haystack, std::size_t pos, const std::string& needle, std::size_t nth);
 }
-
-#endif
diff --git a/include/utils/timer.hpp b/include/utils/timer.hpp
index 0828c74d..35b2b9f4 100644
--- a/include/utils/timer.hpp
+++ b/include/utils/timer.hpp
@@ -1,10 +1,9 @@
-#ifndef _UTILS_TIMER_HPP_
-#define _UTILS_TIMER_HPP_
+#if 0
+#pragma once
 
 namespace timer
 {
-  unsigned int seconds_to_microseconds(float seconds);
-  void sleep(float seconds);
+  // unsigned int seconds_to_microseconds(float seconds);
+  // void sleep(float seconds);
 }
-
 #endif
diff --git a/include/utils/xlib.hpp b/include/utils/xlib.hpp
index 660fee36..be69916b 100644
--- a/include/utils/xlib.hpp
+++ b/include/utils/xlib.hpp
@@ -1,5 +1,4 @@
-#ifndef _UTILS_XLIB_HPP_
-#define _UTILS_XLIB_HPP_
+#pragma once
 
 #include <sstream>
 #include <memory>
@@ -26,9 +25,7 @@ namespace xlib
     }
   };
 
-  std::unique_ptr<Monitor> get_monitor(const std::string& monitor_name);
+  // std::unique_ptr<Monitor> get_monitor(const std::string& monitor_name);
 
   std::vector<std::unique_ptr<Monitor>> get_sorted_monitorlist();
 }
-
-#endif
diff --git a/src/bar.cpp b/src/bar.cpp
index d772e3c1..554429bc 100644
--- a/src/bar.cpp
+++ b/src/bar.cpp
@@ -44,14 +44,10 @@ const Options& bar_opts() {
 /**
  * Bar constructor
  */
-Bar::Bar()
+Bar::Bar() : config_path(config::get_bar_path()), opts(std::make_unique<Options>())
 {
-  this->config_path = config::get_bar_path();
-
   struct Options defaults;
 
-  this->opts = std::make_unique<Options>();
-
   try {
     this->opts->locale = config::get<std::string>(this->config_path, "locale");
     std::locale::global(std::locale(this->opts->locale.c_str()));
diff --git a/src/drawtypes/animation.cpp b/src/drawtypes/animation.cpp
index 3bb27243..c640285c 100644
--- a/src/drawtypes/animation.cpp
+++ b/src/drawtypes/animation.cpp
@@ -31,9 +31,9 @@ namespace drawtypes
   }
 
   Animation::Animation(std::vector<std::unique_ptr<Icon>> &&frames, int framerate_ms)
+    : frames(std::move(frames))
   {
     this->framerate_ms = framerate_ms;
-    this->frames = std::move(frames);
     this->num_frames = this->frames.size();
     this->updated_at = std::chrono::system_clock::now();
   }
diff --git a/src/drawtypes/bar.cpp b/src/drawtypes/bar.cpp
index 8c4d229e..2a267ad1 100644
--- a/src/drawtypes/bar.cpp
+++ b/src/drawtypes/bar.cpp
@@ -28,11 +28,10 @@ namespace drawtypes
     return bar;
   }
 
-  Bar::Bar(int width, const std::string& format, bool lazy_builder_closing)
+  Bar::Bar(int width, const std::string& fmt, bool lazy_builder_closing)
+    : builder(std::make_unique<Builder>(lazy_builder_closing)), format(fmt)
   {
     this->width = width;
-    this->format = format;
-    this->builder = std::make_unique<Builder>(lazy_builder_closing);
   }
 
   void Bar::set_fill(std::unique_ptr<Icon> &&fill) {
@@ -63,7 +62,6 @@ namespace drawtypes
     int fill_width = (int) this->width * percentage / 100 + add;
     int empty_width = this->width - fill_width;
     int color_step = this->width / this->colors.size() + 0.5f;
-    int i = 0, j = 0;
 
     auto output = std::string(this->format);
 
@@ -83,9 +81,10 @@ namespace drawtypes
       this->fill->fg = this->colors[color-1];
       while (fill_width--) this->builder->node(this->fill);
     } else {
+      int i = 0;
       for (auto color : this->colors) {
         i += 1;
-        j = 0;
+        int j = 0;
 
         if ((i-1) * color_step >= fill_width) break;
 
diff --git a/src/eventloop.cpp b/src/eventloop.cpp
index 291a569e..7acf4a0a 100644
--- a/src/eventloop.cpp
+++ b/src/eventloop.cpp
@@ -8,25 +8,23 @@
 #include "eventloop.hpp"
 #include "services/command.hpp"
 #include "utils/io.hpp"
+#include "utils/macros.hpp"
 
 EventLoop::EventLoop(std::string input_pipe)
+  : bar(get_bar()),
+    registry(get_registry()),
+    logger(get_logger()),
+    state(STATE_STOPPED),
+    pipe_filename(input_pipe)
 {
-  this->bar = get_bar();
-  this->registry = get_registry();
-  this->logger = get_logger();
-
-  this->state = STATE_STOPPED;
-
-  this->pipe_filename = input_pipe;
-
-  if (!this->pipe_filename.empty()) {
-    if (!io::file::is_fifo(this->pipe_filename)) {
-      if (io::file::exists(this->pipe_filename))
-        unlink(this->pipe_filename.c_str());
-      if (mkfifo(this->pipe_filename.c_str(), 0600) == -1)
-        throw Exception(STRERRNO);
-    }
-  }
+  if (this->pipe_filename.empty())
+    return;
+  if (io::file::is_fifo(this->pipe_filename))
+    return;
+  if (io::file::exists(this->pipe_filename))
+    unlink(this->pipe_filename.c_str());
+  if (mkfifo(this->pipe_filename.c_str(), 0600) == -1)
+    throw EventLoopTerminate(StrErrno());
 }
 
 bool EventLoop::running()
@@ -83,7 +81,7 @@ void EventLoop::wait()
   sigaddset(&this->wait_mask, SIGTERM);
 
   if (pthread_sigmask(SIG_BLOCK, &this->wait_mask, nullptr) == -1)
-    logger->fatal(STRERRNO);
+    logger->fatal(StrErrno());
 
   // Wait for termination signal
   sigwait(&this->wait_mask, &sig);
@@ -145,8 +143,8 @@ void EventLoop::loop_read()
 {
   while (!this->pipe_filename.empty() && this->running()) {
     try {
-      if ((this->fd_stdin = open(this->pipe_filename.c_str(), O_RDONLY)) == -1)
-        throw Exception(STRERRNO);
+      if ((this->fd_stdin = ::open(this->pipe_filename.c_str(), O_RDONLY)) == -1)
+        throw EventLoopTerminate(StrErrno());
 
       this->read_stdin();
     } catch (Exception &e) {
diff --git a/src/interfaces/alsa.cpp b/src/interfaces/alsa.cpp
index 5f89deb9..551b0ed1 100644
--- a/src/interfaces/alsa.cpp
+++ b/src/interfaces/alsa.cpp
@@ -4,10 +4,11 @@
 #include "utils/config.hpp"
 #include "utils/memory.hpp"
 #include "utils/proc.hpp"
+#include "utils/macros.hpp"
 
 namespace alsa
 {
-  ControlInterface::ControlInterface(int numid) throw(ControlInterfaceError)
+  ControlInterface::ControlInterface(int numid)
   {
     int err;
 
@@ -19,22 +20,22 @@ namespace alsa
     snd_ctl_elem_info_set_id(this->info, this->id);
 
     if ((err = snd_ctl_open(&this->ctl, ALSA_SOUNDCARD, SND_CTL_NONBLOCK | SND_CTL_READONLY)) < 0)
-      throw ControlInterfaceError("Could not open control \""+ STR(ALSA_SOUNDCARD) +"\": "+ STRSNDERR(err));
+      throw ControlInterfaceError(err, "Could not open control \""+ ToStr(ALSA_SOUNDCARD) +"\": "+ STRSNDERR(err));
 
     if ((err = snd_ctl_elem_info(this->ctl, this->info)) < 0)
-      throw ControlInterfaceError("Could not get control data: "+ STRSNDERR(err));
+      throw ControlInterfaceError(err, "Could not get control data: "+ STRSNDERR(err));
 
     snd_ctl_elem_info_get_id(this->info, this->id);
 
     if ((err = snd_hctl_open(&this->hctl, ALSA_SOUNDCARD, 0)) < 0)
-      throw ControlInterfaceError(STRSNDERR(err));
+      throw ControlInterfaceError(err, STRSNDERR(err));
     if ((err = snd_hctl_load(this->hctl)) < 0)
-      throw ControlInterfaceError(STRSNDERR(err));
+      throw ControlInterfaceError(err, STRSNDERR(err));
     if ((elem = snd_hctl_find_elem(this->hctl, this->id)) == nullptr)
-      throw ControlInterfaceError("Could not find control with id "+ STRI(snd_ctl_elem_id_get_numid(this->id)));
+      throw ControlInterfaceError(err, "Could not find control with id "+ IntToStr(snd_ctl_elem_id_get_numid(this->id)));
 
     if ((err = snd_ctl_subscribe_events(this->ctl, 1)) < 0)
-      throw ControlInterfaceError("Could not subscribe to events: "+ STRI(snd_ctl_elem_id_get_numid(this->id)));
+      throw ControlInterfaceError(err, "Could not subscribe to events: "+ IntToStr(snd_ctl_elem_id_get_numid(this->id)));
 
     log_trace("Successfully initialized control interface");
   }
@@ -45,20 +46,23 @@ namespace alsa
     snd_hctl_close(this->hctl);
   }
 
-  bool ControlInterface::wait(int timeout) throw(ControlInterfaceError)
+  bool ControlInterface::wait(int timeout)
   {
     std::lock_guard<std::mutex> lck(this->mtx);
 
     int err;
 
     if ((err = snd_ctl_wait(this->ctl, timeout)) < 0)
-      throw ControlInterfaceError("Failed to wait for events: "+ STRSNDERR(err));
+      throw ControlInterfaceError(err, "Failed to wait for events: "+ STRSNDERR(err));
 
     snd_ctl_event_t *event;
     snd_ctl_event_alloca(&event);
 
-    if ((err = snd_ctl_read(this->ctl, event)) < 0)
+    if ((err = snd_ctl_read(this->ctl, event)) < 0) {
+      log_trace(err);
       return false;
+    }
+
     if (snd_ctl_event_get_type(event) != SND_CTL_EVENT_ELEM)
       return false;
 
@@ -67,7 +71,7 @@ namespace alsa
     return mask & SND_CTL_EVENT_MASK_VALUE;
   }
 
-  bool ControlInterface::test_device_plugged() throw(ControlInterfaceError)
+  bool ControlInterface::test_device_plugged()
   {
     int err;
 
@@ -75,13 +79,13 @@ namespace alsa
       return false;
 
     if ((err = snd_hctl_elem_read(this->elem, this->value)) < 0)
-      throw ControlInterfaceError("Could not read control value: "+ STRSNDERR(err));
+      throw ControlInterfaceError(err, "Could not read control value: "+ STRSNDERR(err));
 
     return snd_ctl_elem_value_get_boolean(this->value, 0);
   }
 
 
-  Mixer::Mixer(const std::string& mixer_control_name) throw(MixerError)
+  Mixer::Mixer(const std::string& mixer_control_name)
   {
     snd_mixer_selem_id_t *mixer_id;
 
@@ -112,7 +116,7 @@ namespace alsa
     snd_mixer_close(this->hardware_mixer);
   }
 
-  bool Mixer::wait(int timeout) throw(MixerError)
+  bool Mixer::wait(int timeout)
   {
     std::lock_guard<std::mutex> lck(this->mtx);
 
diff --git a/src/interfaces/mpd.cpp b/src/interfaces/mpd.cpp
index e1530594..6da6b864 100644
--- a/src/interfaces/mpd.cpp
+++ b/src/interfaces/mpd.cpp
@@ -56,23 +56,23 @@ namespace mpd
     return this->connection.get() != nullptr;
   }
 
-  bool Connection::retry_connection(int interval)
-  {
-    if (this->connected())
-      return true;
-
-    while (true) {
-      try {
-        this->connect();
-        return true;
-      } catch (Exception &e) {
-        get_logger()->debug(e.what());
-      }
-
-      std::this_thread::sleep_for(
-        std::chrono::duration<double>(interval));
-    }
-  }
+  // bool Connection::retry_connection(int interval)
+  // {
+  //   if (this->connected())
+  //     return true;
+  //
+  //   while (true) {
+  //     try {
+  //       this->connect();
+  //       return true;
+  //     } catch (Exception &e) {
+  //       get_logger()->debug(e.what());
+  //     }
+  //
+  //     std::this_thread::sleep_for(
+  //       std::chrono::duration<double>(interval));
+  //   }
+  // }
 
   void Connection::idle()
   {
@@ -159,16 +159,16 @@ namespace mpd
     }
   }
 
-  void Connection::toggle()
-  {
-    try {
-      this->check_prerequisites_commands_list();
-      mpd_run_toggle_pause(this->connection.get());
-      this->check_errors();
-    } catch (Exception &e) {
-      log_error(e.what());
-    }
-  }
+  // void Connection::toggle()
+  // {
+  //   try {
+  //     this->check_prerequisites_commands_list();
+  //     mpd_run_toggle_pause(this->connection.get());
+  //     this->check_errors();
+  //   } catch (Exception &e) {
+  //     log_error(e.what());
+  //   }
+  // }
 
   void Connection::stop()
   {
@@ -222,7 +222,7 @@ namespace mpd
     }
   }
 
-  void Connection::repeat(bool mode)
+  void Connection::set_repeat(bool mode)
   {
     try {
       this->check_prerequisites_commands_list();
@@ -233,7 +233,7 @@ namespace mpd
     }
   }
 
-  void Connection::random(bool mode)
+  void Connection::set_random(bool mode)
   {
     try {
       this->check_prerequisites_commands_list();
@@ -244,7 +244,7 @@ namespace mpd
     }
   }
 
-  void Connection::single(bool mode)
+  void Connection::set_single(bool mode)
   {
     try {
       this->check_prerequisites_commands_list();
@@ -315,13 +315,13 @@ namespace mpd
     this->updated_at = std::chrono::system_clock::now();
   }
 
-  unsigned Status::get_total_time() {
-    return this->total_time;
-  }
+  // unsigned Status::get_total_time() {
+  //   return this->total_time;
+  // }
 
-  unsigned Status::get_elapsed_time() {
-    return this->elapsed_time;
-  }
+  // unsigned Status::get_elapsed_time() {
+  //   return this->elapsed_time;
+  // }
 
   unsigned Status::get_elapsed_percentage()
   {
@@ -360,8 +360,9 @@ namespace mpd
       return std::make_unique<Song>(song);
   }
 
-  Song::Song(struct mpd_song *song) {
-    this->song = std::shared_ptr<struct mpd_song>(song, mpd_song_free);
+  Song::Song(struct mpd_song *song)
+    : song(std::shared_ptr<struct mpd_song>(song, mpd_song_free))
+  {
   }
 
   std::string Song::get_artist()
@@ -391,9 +392,9 @@ namespace mpd
     return std::string(tag);
   }
 
-  unsigned Song::get_duration()
-  {
-    assert(this->song);
-    return mpd_song_get_duration(this->song.get());
-  }
+  // unsigned Song::get_duration()
+  // {
+  //   assert(this->song);
+  //   return mpd_song_get_duration(this->song.get());
+  // }
 }
diff --git a/src/interfaces/net.cpp b/src/interfaces/net.cpp
index 15535df5..85602fb6 100644
--- a/src/interfaces/net.cpp
+++ b/src/interfaces/net.cpp
@@ -15,6 +15,7 @@
 #include "services/logger.hpp"
 #include "interfaces/net.hpp"
 #include "utils/io.hpp"
+#include "utils/macros.hpp"
 #include "utils/string.hpp"
 
 using namespace net;
@@ -26,15 +27,14 @@ bool net::is_wireless_interface(const std::string& ifname) {
 
 // Network
 
-Network::Network(const std::string& interface) throw(NetworkException)
+Network::Network(const std::string& interface)
+  : interface(interface)
 {
-  this->interface = interface;
-
   if (if_nametoindex(this->interface.c_str()) == 0)
     throw NetworkException("Invalid network interface \""+ this->interface +"\"");
 
   if ((this->fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
-    throw NetworkException("Failed to open socket: "+ STRERRNO);
+    throw NetworkException("Failed to open socket: "+ StrErrno());
 
   std::memset(&this->data, 0, sizeof(this->data));
   std::strncpy(this->data.ifr_name, this->interface.data(), IFNAMSIZ-1);
@@ -43,17 +43,18 @@ Network::Network(const std::string& interface) throw(NetworkException)
 Network::~Network()
 {
   if (close(this->fd) == -1)
-    log_error("Failed to close Network socket FD: "+ STRERRNO);
+    log_error("Failed to close Network socket FD: "+ StrErrno());
 }
 
-bool Network::test_interface() throw(NetworkException)
+bool Network::test_interface()
 {
   if ((ioctl(this->fd, SIOCGIFFLAGS, &this->data)) == -1)
-    throw NetworkException(STRERRNO);
+    throw NetworkException(StrErrno());
   return this->data.ifr_flags & IFF_UP;
 }
 
-bool Network::test_connection() throw(NetworkException) {
+bool Network::test_connection()
+{
   int status = EXIT_FAILURE;
 
   try {
@@ -91,7 +92,7 @@ bool Network::connected()
   }
 }
 
-std::string Network::get_ip() throw(NetworkException)
+std::string Network::get_ip()
 {
   if (!this->test_interface())
     throw NetworkException("Interface is not up");
@@ -99,7 +100,7 @@ std::string Network::get_ip() throw(NetworkException)
   this->data.ifr_addr.sa_family = AF_INET;
 
   if (ioctl(this->fd, SIOCGIFADDR, &this->data) == -1)
-    throw NetworkException(STRERRNO);
+    throw NetworkException(StrErrno());
 
   return inet_ntoa(((struct sockaddr_in *) &this->data.ifr_addr)->sin_addr);
 }
@@ -130,7 +131,7 @@ WirelessNetwork::WirelessNetwork(const std::string& interface) : Network(interfa
   std::strcpy((char *) &this->iw.ifr_ifrn.ifrn_name, this->interface.c_str());
 }
 
-std::string WirelessNetwork::get_essid() throw(WirelessNetworkException)
+std::string WirelessNetwork::get_essid()
 {
   char essid[IW_ESSID_MAX_SIZE+1];
 
@@ -140,7 +141,7 @@ std::string WirelessNetwork::get_essid() throw(WirelessNetworkException)
   this->iw.u.essid.length = sizeof(essid);
 
   if (ioctl(this->fd, SIOCGIWESSID, &this->iw) == -1)
-    throw WirelessNetworkException(STRERRNO);
+    throw WirelessNetworkException(StrErrno());
 
   return string::trim(essid, ' ');
 }
@@ -151,13 +152,13 @@ float WirelessNetwork::get_signal_quality()
   return 2 * (dbm + 100);
 }
 
-float WirelessNetwork::get_signal_dbm() throw(WirelessNetworkException)
+float WirelessNetwork::get_signal_dbm()
 {
   this->iw.u.data.pointer = (iw_statistics *) std::malloc(sizeof(iw_statistics));
   this->iw.u.data.length = sizeof(iw_statistics);
 
   if (ioctl(this->fd, SIOCGIWSTATS, &this->iw) == -1)
-    throw WirelessNetworkException(STRERRNO);
+    throw WirelessNetworkException(StrErrno());
 
   auto signal = ((iw_statistics *) this->iw.u.data.pointer)->qual.level - 256;
 
diff --git a/src/lemonbuddy.cpp b/src/lemonbuddy.cpp
index 62b209c8..ee58496e 100644
--- a/src/lemonbuddy.cpp
+++ b/src/lemonbuddy.cpp
@@ -14,6 +14,7 @@
 #include "utils/cli.hpp"
 #include "utils/config.hpp"
 #include "utils/io.hpp"
+#include "utils/macros.hpp"
 #include "utils/proc.hpp"
 #include "utils/string.hpp"
 #include "utils/timer.hpp"
@@ -25,8 +26,6 @@
  * TODO: Simplify overall flow
  */
 
-#define writeln(s) std::cout << s << std::endl;
-
 std::unique_ptr<EventLoop> eventloop;
 
 std::mutex pid_mtx;
@@ -56,7 +55,7 @@ int main(int argc, char **argv)
   sigemptyset(&pipe_mask);
   sigaddset(&pipe_mask, SIGPIPE);
   if (pthread_sigmask(SIG_BLOCK, &pipe_mask, nullptr) == -1)
-    logger->fatal(STRERRNO);
+    logger->fatal(StrErrno());
 
   try {
     auto usage = "Usage: "+ std::string(argv[0]) + " bar_name [OPTION...]";
@@ -169,7 +168,7 @@ int main(int argc, char **argv)
           + std::to_string(proc::get_process_id());
         auto fptr = std::make_unique<io::file::FilePtr>(pipe_file, "a+");
         if (!*fptr)
-          throw Exception(STRERRNO);
+          throw ApplicationError(StrErrno());
       }
     }
 
@@ -192,7 +191,7 @@ int main(int argc, char **argv)
    * Terminate forked sub processes
    */
   if (!pids.empty()) {
-    logger->info("Terminating "+ STRI(pids.size()) +" spawned process"+ (pids.size() > 1 ? "es" : ""));
+    logger->info("Terminating "+ IntToStr(pids.size()) +" spawned process"+ (pids.size() > 1 ? "es" : ""));
 
     for (auto &&pid : pids)
       proc::kill(pid, SIGKILL);
diff --git a/src/modules/backlight.cpp b/src/modules/backlight.cpp
index 560ee744..3548e2ef 100644
--- a/src/modules/backlight.cpp
+++ b/src/modules/backlight.cpp
@@ -6,6 +6,10 @@ using namespace modules;
 
 BacklightModule::BacklightModule(const std::string& name_) : InotifyModule(name_)
 {
+  // Load configuration values
+  auto card = config::get<std::string>(name(), "card");
+
+  // Add formats and elements
   this->formatter->add(DEFAULT_FORMAT, TAG_LABEL, { TAG_LABEL, TAG_BAR, TAG_RAMP });
 
   if (this->formatter->has(TAG_LABEL))
@@ -18,8 +22,7 @@ BacklightModule::BacklightModule(const std::string& name_) : InotifyModule(name_
   if (this->label)
     this->label_tokenized = this->label->clone();
 
-  auto card = config::get<std::string>(name(), "card");
-
+  // Build path to the file where the current/maximum brightness value is located
   this->path_val = string::replace(PATH_BACKLIGHT_VAL, "%card%", card);
   this->path_max = string::replace(PATH_BACKLIGHT_MAX, "%card%", card);
 
@@ -28,7 +31,8 @@ BacklightModule::BacklightModule(const std::string& name_) : InotifyModule(name_
   if (!io::file::exists(this->path_max))
     throw ModuleError("[BacklightModule] The file \""+ this->path_max +"\" does not exist");
 
-  this->watch(this->path_val);
+  // Add inotify watch
+  this->watch(string::replace(PATH_BACKLIGHT_VAL, "%card%", card));
 }
 
 bool BacklightModule::on_event(InotifyEvent *event)
@@ -42,13 +46,13 @@ bool BacklightModule::on_event(InotifyEvent *event)
   auto max = io::file::get_contents(this->path_max);
   this->max = std::stoull(max.c_str(), 0, 10);
 
-  this->percentage = (int) float(this->val) / float(this->max) * 100.f + 0.5f;
+  this->percentage = (int) float(this->val) / float(this->max) * 100.0f + 0.5f;
 
   if (!this->label)
     return true;
 
   this->label_tokenized->text = this->label->text;
-  this->label_tokenized->replace_token("%percentage%", std::to_string(this->percentage)+"%");
+  this->label_tokenized->replace_token("%percentage%", std::to_string(this->percentage())+"%");
 
   return true;
 }
@@ -56,9 +60,9 @@ bool BacklightModule::on_event(InotifyEvent *event)
 bool BacklightModule::build(Builder *builder, const std::string& tag)
 {
   if (tag == TAG_BAR)
-    builder->node(this->bar, this->percentage);
+    builder->node(this->bar, this->percentage());
   else if (tag == TAG_RAMP)
-    builder->node(this->ramp, this->percentage);
+    builder->node(this->ramp, this->percentage());
   else if (tag == TAG_LABEL)
     builder->node(this->label_tokenized);
   else
diff --git a/src/modules/battery.cpp b/src/modules/battery.cpp
index 088faaf2..b0f7525b 100644
--- a/src/modules/battery.cpp
+++ b/src/modules/battery.cpp
@@ -7,6 +7,7 @@
 #include "utils/config.hpp"
 #include "utils/io.hpp"
 #include "utils/math.hpp"
+#include "utils/macros.hpp"
 #include "utils/string.hpp"
 
 using namespace modules;
@@ -68,10 +69,10 @@ BatteryModule::BatteryModule(const std::string& name_) : InotifyModule(name_)
 void BatteryModule::start()
 {
   this->InotifyModule::start();
-  this->threads.emplace_back(std::thread(&BatteryModule::subthread_runner, this));
+  this->threads.emplace_back(std::thread(&BatteryModule::subthread_routine, this));
 }
 
-void BatteryModule::subthread_runner()
+void BatteryModule::subthread_routine()
 {
   std::this_thread::yield();
 
@@ -149,13 +150,13 @@ bool BatteryModule::on_event(InotifyEvent *event)
     this->label_full_tokenized = this->label_full->clone();
 
   this->label_charging_tokenized->text = this->label_charging->text;
-  this->label_charging_tokenized->replace_token("%percentage%", std::to_string(percentage) + "%");
+  this->label_charging_tokenized->replace_token("%percentage%", IntToStr(percentage) + "%");
 
   this->label_discharging_tokenized->text = this->label_discharging->text;
-  this->label_discharging_tokenized->replace_token("%percentage%", std::to_string(percentage) + "%");
+  this->label_discharging_tokenized->replace_token("%percentage%", IntToStr(percentage) + "%");
 
   this->label_full_tokenized->text = this->label_full->text;
-  this->label_full_tokenized->replace_token("%percentage%", std::to_string(percentage) + "%");
+  this->label_full_tokenized->replace_token("%percentage%", IntToStr(percentage) + "%");
 
   this->state = state;
   this->percentage = percentage;
diff --git a/src/modules/bspwm.cpp b/src/modules/bspwm.cpp
index 7a76a94e..48c850e9 100644
--- a/src/modules/bspwm.cpp
+++ b/src/modules/bspwm.cpp
@@ -17,10 +17,9 @@ using namespace Bspwm;
 #define DEFAULT_WS_ICON "workspace_icon:default"
 #define DEFAULT_WS_LABEL "%icon%  %name%"
 
-BspwmModule::BspwmModule(const std::string& name_, const std::string& monitor) : EventModule(name_)
+BspwmModule::BspwmModule(const std::string& name_, const std::string& monitor)
+  : EventModule(name_), monitor(monitor)
 {
-  this->monitor = monitor;
-
   this->formatter->add(DEFAULT_FORMAT, TAG_LABEL_STATE, { TAG_LABEL_STATE }, { TAG_LABEL_MODE });
 
   if (this->formatter->has(TAG_LABEL_STATE)) {
@@ -86,25 +85,29 @@ bool BspwmModule::update()
   if (data.empty())
     return false;
 
-  auto prefix = std::string(BSPWM_STATUS_PREFIX);
+  const auto prefix = std::string(BSPWM_STATUS_PREFIX);
 
-  if (data.find(prefix) != 0) {
+  if (data.compare(0, prefix.length(), prefix) != 0) {
     log_error("Received unknown status -> "+ data);
     return false;
   }
 
+  const auto needle_active = "M"+ this->monitor +":";
+  const auto needle_inactive = "m"+ this->monitor +":";
+
   // Cut out the relevant section for the current monitor
-  if ((n = data.find(prefix +"M"+ this->monitor +":")) != std::string::npos) {
+  if ((n = data.find(prefix + needle_active)) != std::string::npos) {
     if ((m = data.find(":m")) != std::string::npos) data = data.substr(n, m);
-  } else if ((n = data.find(prefix +"m"+ this->monitor +":")) != std::string::npos) {
+  } else if ((n = data.find(prefix + needle_inactive)) != std::string::npos) {
     if ((m = data.find(":M")) != std::string::npos) data = data.substr(n, m);
-  } else if ((n = data.find("M"+ this->monitor +":")) != std::string::npos) {
+  } else if ((n = data.find(needle_active)) != std::string::npos) {
     data.erase(0, n);
-  } else if ((n = data.find("m"+ this->monitor +":")) != std::string::npos) {
+  } else if ((n = data.find(needle_inactive)) != std::string::npos) {
     data.erase(0, n);
   }
 
-  if (data.find(prefix) == 0) data.erase(0, 1);
+  if (data.compare(0, prefix.length(), prefix) == 0)
+    data.erase(0, 1);
 
   log_trace(data);
 
diff --git a/src/modules/cpu.cpp b/src/modules/cpu.cpp
index 36e06c7b..e318d0ac 100644
--- a/src/modules/cpu.cpp
+++ b/src/modules/cpu.cpp
@@ -89,9 +89,10 @@ bool CpuModule::read_values()
     std::ifstream in(PATH_CPU_INFO);
     std::string str;
 
-    while (std::getline(in, str) && str.find("cpu") == 0) {
+    while (std::getline(in, str) && str.compare(0, 3, "cpu") == 0) {
       // skip the accumulated line
-      if (str.find("cpu ") == 0) continue;
+      if (str.compare(0, 4, "cpu ") == 0)
+        continue;
 
       auto values = string::split(str, ' ');
       auto cpu = std::make_unique<CpuTime>();
diff --git a/src/modules/date.cpp b/src/modules/date.cpp
index 1dca332b..24e32db4 100644
--- a/src/modules/date.cpp
+++ b/src/modules/date.cpp
@@ -6,9 +6,9 @@
 
 using namespace modules;
 
-DateModule::DateModule(const std::string& name_) : TimerModule(name_, 1s)
+DateModule::DateModule(const std::string& name_)
+  : TimerModule(name_, 1s), builder(std::make_unique<Builder>())
 {
-  this->builder = std::make_unique<Builder>();
   this->interval = std::chrono::duration<double>(
     config::get<float>(name(), "interval", 1));
 
diff --git a/src/modules/i3.cpp b/src/modules/i3.cpp
index 39df6c77..aeb83b5b 100644
--- a/src/modules/i3.cpp
+++ b/src/modules/i3.cpp
@@ -11,6 +11,7 @@
 #include "modules/i3.hpp"
 #include "utils/config.hpp"
 #include "utils/io.hpp"
+#include "utils/macros.hpp"
 #include "utils/string.hpp"
 
 using namespace modules;
@@ -128,7 +129,7 @@ bool i3Module::update()
       // if (!monitor_focused)
       //   flag = i3::WORKSPACE_DIMMED;
 
-      auto workspace_name = STR(ws->name);
+      auto workspace_name = ToStr(ws->name);
       if (this->workspace_name_strip_nchars > 0 && workspace_name.length() > this->workspace_name_strip_nchars)
         workspace_name.erase(0, this->workspace_name_strip_nchars);
 
diff --git a/src/modules/memory.cpp b/src/modules/memory.cpp
index d8139de9..c6069301 100644
--- a/src/modules/memory.cpp
+++ b/src/modules/memory.cpp
@@ -1,6 +1,7 @@
 #include "config.hpp"
 #include "modules/memory.hpp"
 #include "utils/config.hpp"
+#include "utils/macros.hpp"
 
 using namespace modules;
 
@@ -48,7 +49,7 @@ bool MemoryModule::update()
     kbytes_total = 0;
     // kbytes_free = 0;
     kbytes_available = 0;
-    log_error("Failed to read memory values: "+ STR(e.what()));
+    log_error("Failed to read memory values: "+ ToStr(e.what()));
   }
 
   if (kbytes_total > 0)
diff --git a/src/modules/menu.cpp b/src/modules/menu.cpp
index c9056e29..0063340c 100644
--- a/src/modules/menu.cpp
+++ b/src/modules/menu.cpp
@@ -52,7 +52,7 @@ MenuModule::MenuModule(const std::string& name_) : StaticModule(name_)
   register_command_handler(name());
 }
 
-std::string MenuModule::get_output() throw(UndefinedFormat)
+std::string MenuModule::get_output()
 {
   this->builder->node(this->Module::get_output());
 
@@ -98,7 +98,7 @@ bool MenuModule::handle_command(const std::string& cmd)
 {
   std::lock_guard<std::mutex> lck(this->cmd_mtx);
 
-  if (cmd.find(EVENT_MENU_OPEN) == 0) {
+  if (cmd.compare(0, std::strlen(EVENT_MENU_OPEN), EVENT_MENU_OPEN) == 0) {
     auto level = cmd.substr(std::strlen(EVENT_MENU_OPEN));
 
     if (level.empty())
diff --git a/src/modules/mpd.cpp b/src/modules/mpd.cpp
index 774834b7..369f1065 100644
--- a/src/modules/mpd.cpp
+++ b/src/modules/mpd.cpp
@@ -10,10 +10,9 @@
 using namespace modules;
 using namespace mpd;
 
-MpdModule::MpdModule(const std::string& name_) : EventModule(name_)
+MpdModule::MpdModule(const std::string& name_)
+  : EventModule(name_), icons(std::make_unique<drawtypes::IconMap>())
 {
-  this->icons = std::make_unique<drawtypes::IconMap>();
-
   this->formatter->add(FORMAT_ONLINE, TAG_LABEL_SONG, {
     TAG_BAR_PROGRESS, TAG_TOGGLE,      TAG_LABEL_SONG,      TAG_LABEL_TIME,
     TAG_ICON_RANDOM,  TAG_ICON_REPEAT, TAG_ICON_REPEAT_ONE, TAG_ICON_PREV,
@@ -69,7 +68,7 @@ void MpdModule::start()
   this->mpd = mpd::Connection::get();
 
   this->synced_at = std::chrono::system_clock::now();
-  this->sync_interval = config::get<float>(name(), "interval", 0.5) * 1000;
+  this->sync_interval = config::get<float>(name(), "interval", this->sync_interval) * 1000;
 
   try {
     mpd->connect();
@@ -273,22 +272,20 @@ bool MpdModule::handle_command(const std::string& cmd)
       mpd->next();
     else if (cmd == EVENT_REPEAT_ONE)
       if (this->status)
-        mpd->single(!this->status->single);
+        mpd->set_single(!this->status->single);
       else
-        mpd->single(true);
+        mpd->set_single(true);
     else if (cmd == EVENT_REPEAT)
       if (this->status)
-#undef repeat
-        mpd->repeat(!this->status->repeat);
+        mpd->set_repeat(!this->status->repeat);
       else
-        mpd->repeat(true);
-#define repeat _repeat(n)
+        mpd->set_repeat(true);
     else if (cmd == EVENT_RANDOM)
       if (this->status)
-        mpd->random(!this->status->random);
+        mpd->set_random(!this->status->random);
       else
-        mpd->random(true);
-    else if (cmd.find(EVENT_SEEK) == 0) {
+        mpd->set_random(true);
+    else if (cmd.compare(0, std::strlen(EVENT_SEEK), EVENT_SEEK) == 0) {
       auto s = cmd.substr(std::strlen(EVENT_SEEK));
       int perc = 0;
       if (s.empty())
diff --git a/src/modules/network.cpp b/src/modules/network.cpp
index 06b30782..ab173353 100644
--- a/src/modules/network.cpp
+++ b/src/modules/network.cpp
@@ -12,7 +12,8 @@ using namespace modules;
 
 // TODO: Add up-/download speed (check how ifconfig read the bytes)
 
-NetworkModule::NetworkModule(const std::string& name_) : TimerModule(name_, 1s)
+NetworkModule::NetworkModule(const std::string& name_)
+  : TimerModule(name_, 1s), connected(false), conseq_packetloss(false)
 {
   static const auto DEFAULT_FORMAT_CONNECTED = TAG_LABEL_CONNECTED;
   static const auto DEFAULT_FORMAT_DISCONNECTED = TAG_LABEL_DISCONNECTED;
@@ -22,9 +23,6 @@ NetworkModule::NetworkModule(const std::string& name_) : TimerModule(name_, 1s)
   static const auto DEFAULT_LABEL_DISCONNECTED = "";
   static const auto DEFAULT_LABEL_PACKETLOSS = "";
 
-  this->connected = false;
-  this->conseq_packetloss = false;
-
   // Load configuration values
   this->interface = config::get<std::string>(name(), "interface");
   this->interval = std::chrono::duration<double>(config::get<float>(name(), "interval", 1));
@@ -147,7 +145,6 @@ bool NetworkModule::update()
       if (this->wired_network) {
         label->replace_token("%linkspeed%", linkspeed);
       } else if (this->wireless_network) {
-        // label->replace_token("%essid%", essid);
         label->replace_token("%essid%", !essid.empty() ? essid : "No network");
         label->replace_token("%signal%", std::to_string(signal_quality)+"%");
       }
diff --git a/src/modules/script.cpp b/src/modules/script.cpp
index c695c7d0..78e9be39 100644
--- a/src/modules/script.cpp
+++ b/src/modules/script.cpp
@@ -6,11 +6,9 @@
 
 using namespace modules;
 
-ScriptModule::ScriptModule(const std::string& name_) : TimerModule(name_, 1s)
+ScriptModule::ScriptModule(const std::string& name_)
+  : TimerModule(name_, 1s), builder(std::make_unique<Builder>(true)), counter(0)
 {
-  this->counter = 0;
-  this->builder = std::make_unique<Builder>(true);
-
   this->exec = config::get<std::string>(name(), "exec");
 
   this->interval = std::chrono::duration<double>(
diff --git a/src/modules/text.cpp b/src/modules/text.cpp
index f4abb5bd..49536acb 100644
--- a/src/modules/text.cpp
+++ b/src/modules/text.cpp
@@ -5,7 +5,7 @@
 
 using namespace modules;
 
-TextModule::TextModule(const std::string& name_) throw(UndefinedFormat) : StaticModule(name_) {
+TextModule::TextModule(const std::string& name_) : StaticModule(name_) {
   this->formatter->add(FORMAT, "", {});
   if (this->formatter->get(FORMAT)->value.empty())
     throw UndefinedFormat(FORMAT);
diff --git a/src/modules/volume.cpp b/src/modules/volume.cpp
index b5922676..4d7761bb 100644
--- a/src/modules/volume.cpp
+++ b/src/modules/volume.cpp
@@ -1,15 +1,12 @@
-#include <thread>
-
 #include "lemonbuddy.hpp"
 #include "bar.hpp"
-#include "services/builder.hpp"
-#include "utils/config.hpp"
 #include "utils/math.hpp"
+#include "utils/macros.hpp"
 #include "modules/volume.hpp"
 
 using namespace modules;
 
-VolumeModule::VolumeModule(const std::string& name_) throw(ModuleError) : EventModule(name_)
+VolumeModule::VolumeModule(const std::string& name_) : EventModule(name_)
 {
   auto speaker_mixer = config::get<std::string>(name(), "speaker_mixer", "");
   auto headphone_mixer = config::get<std::string>(name(), "headphone_mixer", "");
@@ -33,7 +30,7 @@ VolumeModule::VolumeModule(const std::string& name_) throw(ModuleError) : EventM
     try {
       mixer = std::make_unique<alsa::Mixer>(mixer_name);
     } catch (alsa::MixerError &e) {
-      log_error("Failed to open \""+ mixer_name +"\" mixer => "+ STR(e.what()));
+      log_error("Failed to open \""+ mixer_name +"\" mixer => "+ ToStr(e.what()));
       mixer.reset();
     }
 
@@ -56,7 +53,7 @@ VolumeModule::VolumeModule(const std::string& name_) throw(ModuleError) : EventM
     try {
       this->headphone_ctrl = std::make_unique<alsa::ControlInterface>(this->headphone_ctrl_numid);
     } catch (alsa::ControlInterfaceError &e) {
-      log_error("Failed to open headphone control interface => "+ STR(e.what()));
+      log_error("Failed to open headphone control interface => "+ ToStr(e.what()));
       this->headphone_ctrl.reset();
     }
   }
diff --git a/src/registry.cpp b/src/registry.cpp
index bec969f5..a35b5e33 100644
--- a/src/registry.cpp
+++ b/src/registry.cpp
@@ -30,7 +30,7 @@ bool Registry::ready()
 void Registry::insert(std::unique_ptr<modules::ModuleInterface> &&module)
 {
   log_trace("Inserting module: "+ module->name());
-  this->modules.emplace_back(std::make_unique<ModuleEntry>(std::move(module)));
+  this->modules.emplace_back(std::make_unique<RegistryModuleEntry>(std::move(module)));
 }
 
 void Registry::load()
@@ -149,7 +149,7 @@ std::string Registry::get(const std::string& module_name)
   return (*this->find(module_name)->module)();
 }
 
-std::unique_ptr<ModuleEntry>& Registry::find(const std::string& module_name) throw(ModuleNotFound)
+std::unique_ptr<RegistryModuleEntry>& Registry::find(const std::string& module_name)
 {
   for (auto &&entry : this->modules)
     if (entry->module->name() == module_name)
diff --git a/src/services/builder.cpp b/src/services/builder.cpp
index 36c42415..d91a51ae 100644
--- a/src/services/builder.cpp
+++ b/src/services/builder.cpp
@@ -287,9 +287,9 @@ void Builder::remove_trailing_space(int width)
     this->output = this->output.substr(0, this->output.length()-spacing);
 }
 
-void Builder::invert() {
-  this->tag_open('R', "");
-}
+// void Builder::invert() {
+//   this->tag_open('R', "");
+// }
 
 
 // Fonts
diff --git a/src/services/command.cpp b/src/services/command.cpp
index a018804d..c3d93fa8 100644
--- a/src/services/command.cpp
+++ b/src/services/command.cpp
@@ -8,8 +8,9 @@
 #include "lemonbuddy.hpp"
 #include "services/command.hpp"
 #include "services/logger.hpp"
-#include "utils/string.hpp"
 #include "utils/io.hpp"
+#include "utils/macros.hpp"
+#include "utils/string.hpp"
 
 /**
  * auto cmd = std::make_unique<Command>("cat /etc/rc.local");
@@ -25,10 +26,9 @@
  * std::cout << cmd->readline(); //---> 1
  * std::cout << cmd->readline() << cmd->readline(); //---> 23
  */
-Command::Command(const std::string& cmd, int stdout[2], int stdin[2]) throw(CommandException)
+Command::Command(const std::string& cmd, int stdout[2], int stdin[2])
+  : cmd(cmd)
 {
-  this->cmd = cmd;
-
   if (stdin != nullptr) {
     this->stdin[PIPE_READ] = stdin[PIPE_READ];
     this->stdin[PIPE_WRITE] = stdin[PIPE_WRITE];
@@ -40,29 +40,29 @@ Command::Command(const std::string& cmd, int stdout[2], int stdin[2]) throw(Comm
     this->stdout[PIPE_WRITE] = stdout[PIPE_WRITE];
   } else if (false == proc::pipe(this->stdout)) {
     if ((this->stdin[PIPE_READ] = close(this->stdin[PIPE_READ])) == -1)
-      throw CommandException("Failed to close fd: "+ STRERRNO);
+      throw CommandException("Failed to close fd: "+ StrErrno());
     if ((this->stdin[PIPE_WRITE] = close(this->stdin[PIPE_WRITE])) == -1)
-      throw CommandException("Failed to close fd: "+ STRERRNO);
+      throw CommandException("Failed to close fd: "+ StrErrno());
     throw CommandException("Failed to allocate pipe");
   }
 }
 
-Command::~Command() throw(CommandException)
+Command::~Command()
 {
   if (this->stdin[PIPE_READ] > 0 && (close(this->stdin[PIPE_READ]) == -1))
-    throw CommandException("Failed to close fd: "+ STRERRNO);
+    log_error("Failed to close fd: "+ StrErrno());
   if (this->stdin[PIPE_WRITE] > 0 && (close(this->stdin[PIPE_WRITE]) == -1))
-    throw CommandException("Failed to close fd: "+ STRERRNO);
+    log_error("Failed to close fd: "+ StrErrno());
   if (this->stdout[PIPE_READ] > 0 && (close(this->stdout[PIPE_READ]) == -1))
-    throw CommandException("Failed to close fd: "+ STRERRNO);
+    log_error("Failed to close fd: "+ StrErrno());
   if (this->stdout[PIPE_WRITE] > 0 && (close(this->stdout[PIPE_WRITE]) == -1))
-    throw CommandException("Failed to close fd: "+ STRERRNO);
+    log_error("Failed to close fd: "+ StrErrno());
 }
 
-int Command::exec(bool wait_for_completion) throw(CommandException)
+int Command::exec(bool wait_for_completion)
 {
   if ((this->fork_pid = proc::fork()) == -1)
-    throw CommandException("Failed to fork process: "+ STRERRNO);
+    throw CommandException("Failed to fork process: "+ StrErrno());
 
   if (proc::in_forked_process(this->fork_pid)) {
     if (dup2(this->stdin[PIPE_READ], STDIN_FILENO) == -1)
@@ -74,13 +74,13 @@ int Command::exec(bool wait_for_completion) throw(CommandException)
 
     // Close file descriptors that won't be used by forked process
     if ((this->stdin[PIPE_READ] = close(this->stdin[PIPE_READ])) == -1)
-      throw CommandException("Failed to close fd: "+ STRERRNO);
+      throw CommandException("Failed to close fd: "+ StrErrno());
     if ((this->stdin[PIPE_WRITE] = close(this->stdin[PIPE_WRITE])) == -1)
-      throw CommandException("Failed to close fd: "+ STRERRNO);
+      throw CommandException("Failed to close fd: "+ StrErrno());
     if ((this->stdout[PIPE_READ] = close(this->stdout[PIPE_READ])) == -1)
-      throw CommandException("Failed to close fd: "+ STRERRNO);
+      throw CommandException("Failed to close fd: "+ StrErrno());
     if ((this->stdout[PIPE_WRITE] = close(this->stdout[PIPE_WRITE])) == -1)
-      throw CommandException("Failed to close fd: "+ STRERRNO);
+      throw CommandException("Failed to close fd: "+ StrErrno());
 
     // Replace the forked process with the given command
     proc::exec(cmd);
@@ -90,9 +90,9 @@ int Command::exec(bool wait_for_completion) throw(CommandException)
 
     // Close file descriptors that won't be used by parent process
     if ((this->stdin[PIPE_READ] = close(this->stdin[PIPE_READ])) == -1)
-      throw CommandException("Failed to close fd: "+ STRERRNO);
+      throw CommandException("Failed to close fd: "+ StrErrno());
     if ((this->stdout[PIPE_WRITE] = close(this->stdout[PIPE_WRITE])) == -1)
-      throw CommandException("Failed to close fd: "+ STRERRNO);
+      throw CommandException("Failed to close fd: "+ StrErrno());
 
     if (wait_for_completion)
       return this->wait();
@@ -101,7 +101,7 @@ int Command::exec(bool wait_for_completion) throw(CommandException)
   return EXIT_SUCCESS;
 }
 
-int Command::wait() throw(CommandException)
+int Command::wait()
 {
   // Wait for the child processs to finish
   do {
@@ -110,19 +110,19 @@ int Command::wait() throw(CommandException)
 
     if ((pid = proc::wait_for_completion(this->fork_pid, &this->fork_status, WCONTINUED | WUNTRACED)) == -1) {
       unregister_pid(this->fork_pid);
-      throw CommandException("Process did not finish successfully ("+ STRI(this->fork_status) +")");
+      throw CommandException("Process did not finish successfully ("+ IntToStr(this->fork_status) +")");
     }
 
-    if WIFEXITED(this->fork_status)
+    if (WIFEXITED(this->fork_status))
       sprintf(msg, "exited with status %d", WEXITSTATUS(this->fork_status));
-    else if WIFSIGNALED(this->fork_status)
-      sprintf(msg, "got killed by signal %d (%s)", WTERMSIG(this->fork_status), SIGCSTR(WTERMSIG(this->fork_status)));
-    else if WIFSTOPPED(this->fork_status)
-      sprintf(msg, "stopped by signal %d (%s)", WSTOPSIG(this->fork_status), SIGCSTR(WSTOPSIG(this->fork_status)));
-    else if WIFCONTINUED(this->fork_status)
+    else if (WIFSIGNALED(this->fork_status))
+      sprintf(msg, "got killed by signal %d (%s)", WTERMSIG(this->fork_status), StrSignalC(WTERMSIG(this->fork_status)));
+    else if (WIFSTOPPED(this->fork_status))
+      sprintf(msg, "stopped by signal %d (%s)", WSTOPSIG(this->fork_status), StrSignalC(WSTOPSIG(this->fork_status)));
+    else if (WIFCONTINUED(this->fork_status))
       sprintf(msg, "continued");
 
-    get_logger()->debug("Command "+ STR(msg));
+    get_logger()->debug("Command "+ ToStr(msg));
   } while (!WIFEXITED(this->fork_status) && !WIFSIGNALED(this->fork_status));
 
   unregister_pid(this->fork_pid);
@@ -142,14 +142,14 @@ int Command::get_stdout(int c) {
   return this->stdout[c];
 }
 
-int Command::get_stdin(int c) {
-  return this->stdin[c];
-}
+// int Command::get_stdin(int c) {
+//   return this->stdin[c];
+// }
 
-pid_t Command::get_pid() {
-  return this->fork_pid;
-}
+// pid_t Command::get_pid() {
+//   return this->fork_pid;
+// }
 
-int Command::get_exit_status() {
-  return this->fork_status;
-}
+// int Command::get_exit_status() {
+//   return this->fork_status;
+// }
diff --git a/src/services/inotify.cpp b/src/services/inotify.cpp
index 6a20aa08..92aadf6b 100644
--- a/src/services/inotify.cpp
+++ b/src/services/inotify.cpp
@@ -5,16 +5,17 @@
 #include "services/inotify.hpp"
 #include "services/logger.hpp"
 #include "utils/io.hpp"
+#include "utils/macros.hpp"
 #include "utils/proc.hpp"
 
-InotifyWatch::InotifyWatch(const std::string& path, int mask) throw (InotifyException)
+InotifyWatch::InotifyWatch(const std::string& path, int mask)
 {
   log_trace("Installing watch at: "+ path);
 
   if ((this->fd = inotify_init()) < 0)
-    throw InotifyException(STRERRNO);
+    throw InotifyException(StrErrno());
   if ((this->wd = inotify_add_watch(this->fd, path.c_str(), mask)) < 0)
-    throw InotifyException(STRERRNO);
+    throw InotifyException(StrErrno());
 
   this->path = path;
   this->mask = mask;
@@ -25,10 +26,10 @@ InotifyWatch::~InotifyWatch()
   log_trace("Uninstalling watch at: "+ this->path);
 
   if ((this->fd > 0 || this->wd > 0) && inotify_rm_watch(this->fd, this->wd) == -1)
-    log_error("Failed to remove inotify watch: "+ STRERRNO);
+    log_error("Failed to remove inotify watch: "+ StrErrno());
 
   if (this->fd > 0 && close(this->fd) == -1)
-    log_error("Failed to close inotify watch fd: "+ STRERRNO);
+    log_error("Failed to close inotify watch fd: "+ StrErrno());
 }
 
 bool InotifyWatch::has_event(int timeout_ms) {
diff --git a/src/services/logger.cpp b/src/services/logger.cpp
index 93e9725c..27605507 100644
--- a/src/services/logger.cpp
+++ b/src/services/logger.cpp
@@ -21,10 +21,10 @@ Logger::Logger()
   }
 }
 
-void Logger::set_level(int mask)
-{
-  this->level = mask;
-}
+// void Logger::set_level(int mask)
+// {
+//   this->level = mask;
+// }
 
 void Logger::add_level(int mask)
 {
diff --git a/src/utils/cli.cpp b/src/utils/cli.cpp
index 7420b3ff..324debf2 100644
--- a/src/utils/cli.cpp
+++ b/src/utils/cli.cpp
@@ -88,9 +88,10 @@ namespace cli
 
   void usage(const std::string& usage, bool exit_success)
   {
-    int longest_n = 0, n;
+    int longest_n = 0;
 
     for (auto &o : options) {
+      int n;
       if ((n = o.flag_long.length() + o.placeholder.length() + 1) > longest_n)
         longest_n = n;
     }
diff --git a/src/utils/config.cpp b/src/utils/config.cpp
index 832c9d51..672cd43f 100644
--- a/src/utils/config.cpp
+++ b/src/utils/config.cpp
@@ -1,3 +1,4 @@
+#include "services/logger.hpp"
 #include "utils/config.hpp"
 #include "utils/io.hpp"
 
@@ -17,7 +18,7 @@ namespace config
     return bar_path;
   }
 
-  void load(const std::string& path) throw(UnexistingFileError, ParseError)
+  void load(const std::string& path)
   {
     if (!io::file::exists(path)) {
       throw UnexistingFileError("Could not find configuration file \""+ path + "\"");
@@ -38,14 +39,14 @@ namespace config
     load(std::string(dir != nullptr ? dir : "") +"/"+ path);
   }
 
-  void reload() throw(ParseError)
-  {
-    try {
-      boost::property_tree::read_ini(file_path, pt);
-    } catch (std::exception &e) {
-      throw ParseError(e.what());
-    }
-  }
+  // void reload()
+  // {
+  //   try {
+  //     boost::property_tree::read_ini(file_path, pt);
+  //   } catch (std::exception &e) {
+  //     throw ParseError(e.what());
+  //   }
+  // }
 
   boost::property_tree::ptree get_tree() {
     return pt;
diff --git a/src/utils/io.cpp b/src/utils/io.cpp
index 0c01228a..2757adcd 100644
--- a/src/utils/io.cpp
+++ b/src/utils/io.cpp
@@ -12,6 +12,7 @@
 #include "utils/io.hpp"
 #include "utils/proc.hpp"
 #include "utils/string.hpp"
+#include "utils/macros.hpp"
 
 namespace io
 {
@@ -23,7 +24,7 @@ namespace io
       struct sockaddr_un sock_addr;
 
       if ((fd = ::socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
-        log_error("[io::socket::open] Error opening socket: "+ STRERRNO);
+        log_error("[io::socket::open] Error opening socket: "+ StrErrno());
         return -1;
       }
 
@@ -31,7 +32,7 @@ namespace io
       std::snprintf(sock_addr.sun_path, sizeof(sock_addr.sun_path), "%s", path.c_str());
 
       if (connect(fd, (struct sockaddr *) &sock_addr, sizeof(sock_addr)) == -1) {
-        log_error("[io::socket::open] Error connecting to socket: "+ STRERRNO);
+        log_error("[io::socket::open] Error connecting to socket: "+ StrErrno());
         return -1;
       }
 
@@ -42,7 +43,7 @@ namespace io
     {
       int bytes = ::send(fd, data.c_str(), data.size()+1, flags);
       if (bytes == -1)
-        log_error("[io::socket::send] Error sending data: "+ STRERRNO);
+        log_error("[io::socket::send] Error sending data: "+ StrErrno());
       return bytes;
     }
 
@@ -52,7 +53,7 @@ namespace io
       if (bytes > 0)
         buffer[bytes] = 0;
       else if (bytes == -1)
-        log_error("[io::socket::recv] Error receiving data: "+ STRERRNO);
+        log_error("[io::socket::recv] Error receiving data: "+ StrErrno());
       return bytes;
     }
   }
@@ -93,7 +94,6 @@ namespace io
     std::size_t write(io::file::FilePtr *fptr, const std::string& data) {
       auto buf = data.c_str();
       return fwrite(buf, sizeof(char), sizeof(buf), (*fptr)());
-      return 0;
     }
 
     std::size_t write(const std::string& fpath, const std::string& data) {
@@ -111,7 +111,7 @@ namespace io
     status_loc = 0;
 
     if ((bytes_read_loc = ::read(read_fd, &buffer, bytes_to_read)) > 0) {
-      buffer[bytes_read_loc] = 0;
+      // buffer[bytes_read_loc] = 0;
     } else if (bytes_read_loc == 0) {
       get_logger()->debug("Reached EOF");
       status_loc = -1;
@@ -184,9 +184,9 @@ namespace io
     return poll(fd, POLLIN, timeout_ms);
   }
 
-  bool poll_write(int fd, int timeout_ms) {
-    return poll(fd, POLLOUT, timeout_ms);
-  }
+  // bool poll_write(int fd, int timeout_ms) {
+  //   return poll(fd, POLLOUT, timeout_ms);
+  // }
 
   bool poll(int fd, short int events, int timeout_ms)
   {
@@ -202,19 +202,19 @@ namespace io
     return fds[0].revents & events;
   }
 
-  int get_flags(int fd)
-  {
-    int flags;
-    if ((flags = fcntl(fd, F_GETFL, 0)) == -1)
-      return 0;
-    return flags;
-  }
+  // int get_flags(int fd)
+  // {
+  //   int flags;
+  //   if ((flags = fcntl(fd, F_GETFL, 0)) == -1)
+  //     return 0;
+  //   return flags;
+  // }
 
-  int set_blocking(int fd) {
-    return fcntl(fd, F_SETFL, io::get_flags(fd) & ~O_NONBLOCK);
-  }
+  // int set_blocking(int fd) {
+  //   return fcntl(fd, F_SETFL, io::get_flags(fd) & ~O_NONBLOCK);
+  // }
 
-  int set_non_blocking(int fd) {
-    return fcntl(fd, F_SETFL, io::get_flags(fd) | O_NONBLOCK);
-  }
+  // int set_non_blocking(int fd) {
+  //   return fcntl(fd, F_SETFL, io::get_flags(fd) | O_NONBLOCK);
+  // }
 }
diff --git a/src/utils/proc.cpp b/src/utils/proc.cpp
index 23d45da0..f64c22fa 100644
--- a/src/utils/proc.cpp
+++ b/src/utils/proc.cpp
@@ -3,6 +3,7 @@
 #include <sys/wait.h>
 
 #include "services/logger.hpp"
+#include "utils/macros.hpp"
 #include "utils/proc.hpp"
 #include "utils/string.hpp"
 
@@ -12,9 +13,9 @@ namespace proc
     return getpid();
   }
 
-  pid_t get_parent_process_id() {
-    return getppid();
-  }
+  // pid_t get_parent_process_id() {
+  //   return getppid();
+  // }
 
   bool in_parent_process(pid_t pid) {
     return pid != -1 && pid != 0;
@@ -29,7 +30,7 @@ namespace proc
     pid_t pid = ::fork();
 
     if (pid < 0) {
-      log_error("Failed to fork process: "+ STRERRNO +" ("+ std::to_string(errno) +")");
+      log_error("Failed to fork process: "+ StrErrno() +" ("+ std::to_string(errno) +")");
       return -1;
     }
 
@@ -50,7 +51,7 @@ namespace proc
     return true;
   }
 
-  void exec(const std::string& cmd) throw(ExecFailure)
+  void exec(const std::string& cmd)
   {
     // log_trace(string::replace_all(cmd, "\n", " "));
 
@@ -71,7 +72,7 @@ namespace proc
 
     ::execvp(c_args[0], c_args.data());
 
-    throw ExecFailure("Failed to execute command:\n-> "+ STRERRNO+ " ("+ std::to_string(errno) + ")");
+    throw ExecFailure("Failed to execute command:\n-> "+ StrErrno()+ " ("+ std::to_string(errno) + ")");
   }
 
   bool kill(pid_t pid, int sig) {
diff --git a/src/utils/string.cpp b/src/utils/string.cpp
index bfc3fd75..3f0e35bf 100644
--- a/src/utils/string.cpp
+++ b/src/utils/string.cpp
@@ -8,13 +8,13 @@ namespace string
     return lower(s1) == lower(s2);
   }
 
-  std::string upper(const std::string& s)
-  {
-    std::string str(s);
-    for (auto &c : str)
-      c = std::toupper(c);
-    return str;
-  }
+  // std::string upper(const std::string& s)
+  // {
+  //   std::string str(s);
+  //   for (auto &c : str)
+  //     c = std::toupper(c);
+  //   return str;
+  // }
 
   std::string lower(const std::string& s)
   {
@@ -41,14 +41,14 @@ namespace string
     return replace_all(haystack, {needle, needle}, {needle});
   }
 
-  std::string strip(const std::string& haystack, const char &needle)
-  {
-    std::string str(haystack);
-    std::string::size_type pos;
-    while ((pos = str.find(needle)) != std::string::npos)
-      str.erase(pos, 1);
-    return str;
-  }
+  // std::string strip(const std::string& haystack, const char &needle)
+  // {
+  //   std::string str(haystack);
+  //   std::string::size_type pos;
+  //   while ((pos = str.find(needle)) != std::string::npos)
+  //     str.erase(pos, 1);
+  //   return str;
+  // }
 
   std::string strip_trailing_newline(const std::string& haystack)
   {
diff --git a/src/utils/timer.cpp b/src/utils/timer.cpp
index 1d312c13..f60cd981 100644
--- a/src/utils/timer.cpp
+++ b/src/utils/timer.cpp
@@ -1,3 +1,4 @@
+#if 0
 #include <unistd.h>
 
 #include "utils/timer.hpp"
@@ -12,3 +13,4 @@ namespace timer
     usleep(seconds_to_microseconds(seconds));
   }
 }
+#endif
diff --git a/src/utils/xlib.cpp b/src/utils/xlib.cpp
index 040eef7d..eccbda92 100644
--- a/src/utils/xlib.cpp
+++ b/src/utils/xlib.cpp
@@ -1,8 +1,7 @@
-#include <string>
 #include <algorithm>
-#include <cstring>
-#include <X11/Xos.h>
-#include <X11/Xutil.h>
+// #include <cstring>
+// #include <X11/Xos.h>
+// #include <X11/Xutil.h>
 #include <X11/extensions/Xrandr.h>
 
 #include "utils/memory.hpp"
@@ -63,37 +62,37 @@ namespace xlib
     return monitors;
   }
 
-  std::unique_ptr<Monitor> get_monitor(const std::string& n_monitorsame)
-  {
-    auto monitor = std::make_unique<Monitor>();
-    int n_monitors;
-
-    Display *display = XOpenDisplay(nullptr);
-    int screen = XDefaultScreen(display);
-    Window root = XRootWindow(display, screen);
-    XRRMonitorInfo *info = XRRGetMonitors(display, root, 1, &n_monitors);
-
-    repeat(n_monitors)
-    {
-      char *name = XGetAtomName(display, info[repeat_i_rev(n_monitors)].name);
-
-      if (std::strcmp(name, n_monitorsame.c_str()) != 0) {
-        continue;
-      }
-
-      monitor->name = std::string(name);
-      monitor->width = info[repeat_i_rev(n_monitors)].width;
-      monitor->height = info[repeat_i_rev(n_monitors)].height;
-      monitor->x = info[repeat_i_rev(n_monitors)].x;
-      monitor->y = info[repeat_i_rev(n_monitors)].y;
-
-      std::free(name);
-    }
-
-    std::free(info);
-
-    XCloseDisplay(display);
-
-    return monitor;
-  }
+  // std::unique_ptr<Monitor> get_monitor(const std::string& n_monitorsame)
+  // {
+  //   auto monitor = std::make_unique<Monitor>();
+  //   int n_monitors;
+  //
+  //   Display *display = XOpenDisplay(nullptr);
+  //   int screen = XDefaultScreen(display);
+  //   Window root = XRootWindow(display, screen);
+  //   XRRMonitorInfo *info = XRRGetMonitors(display, root, 1, &n_monitors);
+  //
+  //   repeat(n_monitors)
+  //   {
+  //     char *name = XGetAtomName(display, info[repeat_i_rev(n_monitors)].name);
+  //
+  //     if (std::strcmp(name, n_monitorsame.c_str()) != 0) {
+  //       continue;
+  //     }
+  //
+  //     monitor->name = std::string(name);
+  //     monitor->width = info[repeat_i_rev(n_monitors)].width;
+  //     monitor->height = info[repeat_i_rev(n_monitors)].height;
+  //     monitor->x = info[repeat_i_rev(n_monitors)].x;
+  //     monitor->y = info[repeat_i_rev(n_monitors)].y;
+  //
+  //     std::free(name);
+  //   }
+  //
+  //   std::free(info);
+  //
+  //   XCloseDisplay(display);
+  //
+  //   return monitor;
+  // }
 }