diff --git a/include/core/Capsule.h b/include/core/Capsule.h
index a3b63f3f129401fb5ce16673d99c1dd706ec26ff..815c8542363f614be1c61e4023b7a9d8ffa779af 100644
--- a/include/core/Capsule.h
+++ b/include/core/Capsule.h
@@ -30,12 +30,12 @@ public:
   const std::string m_Type;       ///< buffer type
   const std::string m_AccessMode; ///< 'w': write, 'r': read, 'a': append
 
-  std::size_t m_DataPosition = 0; ///< position in current data buffer (not
-                                  /// included data flushed to transports)
-  std::size_t m_DataAbsolutePosition =
+  size_t m_DataPosition = 0; ///< position in current data buffer (not
+                             /// included data flushed to transports)
+  size_t m_DataAbsolutePosition =
       0; ///< includes the data flushed to transports
 
-  std::size_t m_MetadataPosition = 0; ///< position in metadata buffer
+  size_t m_MetadataPosition = 0; ///< position in metadata buffer
 
   /**
    * Base class constructor providing type from derived class and accessMode
@@ -44,22 +44,21 @@ public:
    * @param rankMPI current MPI rank
    * @param debugMode
    */
-  Capsule(const std::string type, const std::string accessMode,
-          const int rankMPI, const bool debugMode);
+  Capsule(std::string type, std::string accessMode, int rankMPI,
+          bool debugMode);
 
-  virtual ~Capsule();
+  virtual ~Capsule() = default;
 
   virtual char *GetData() = 0; ///< return the pointer to the raw data buffer
   virtual char *
   GetMetadata() = 0; ///< return the pointer to the raw metadata buffer
 
-  virtual std::size_t GetDataSize() const = 0; ///< get current data buffer size
-  virtual std::size_t
+  virtual size_t GetDataSize() const = 0; ///< get current data buffer size
+  virtual size_t
   GetMetadataSize() const = 0; ///< get current metadata buffer size
 
-  virtual void ResizeData(const std::size_t size); ///< resize data buffer
-  virtual void
-  ResizeMetadata(const std::size_t size); ///< resize metadata buffer
+  virtual void ResizeData(size_t size);     ///< resize data buffer
+  virtual void ResizeMetadata(size_t size); ///< resize metadata buffer
 
 protected:
   const int m_RankMPI = 0;        ///< current MPI rank
diff --git a/include/core/Engine.h b/include/core/Engine.h
index 26a5fa03414bae38191549e5d06fd11714e6c190..d648452690d6d2ab3e2bd3aee5ac693931961473 100644
--- a/include/core/Engine.h
+++ b/include/core/Engine.h
@@ -77,12 +77,11 @@ public:
    * @param nthreads
    * @param endMessage
    */
-  Engine(ADIOS &adios, const std::string engineType, const std::string name,
-         const std::string accessMode, MPI_Comm mpiComm, const Method &method,
-         const bool debugMode, const unsigned int nthreads,
-         const std::string endMessage);
+  Engine(ADIOS &adios, std::string engineType, std::string name,
+         std::string accessMode, MPI_Comm mpiComm, const Method &method,
+         bool debugMode, unsigned int nthreads, std::string endMessage);
 
-  virtual ~Engine();
+  virtual ~Engine() = default;
 
   /** @brief Let ADIOS allocate memory for a variable, which can be used by the
    * user.
@@ -137,7 +136,7 @@ public:
    * @param variableName
    * @param values
    */
-  template <class T> void Write(const std::string variableName, const T *values)
+  template <class T> void Write(const std::string &variableName, const T *values)
   {
     Write(variableName, values);
   }
@@ -159,7 +158,7 @@ public:
    * @param variableName
    * @param values
    */
-  template <class T> void Write(const std::string variableName, const T values)
+  template <class T> void Write(const std::string &variableName, const T values)
   {
     const T val = values;
     Write(variableName, &val);
@@ -203,32 +202,32 @@ public:
    * @param variableName
    * @param values coming from user app
    */
-  virtual void Write(const std::string variableName, const char *values);
-  virtual void Write(const std::string variableName,
+  virtual void Write(const std::string &variableName, const char *values);
+  virtual void Write(const std::string &variableName,
                      const unsigned char *values);
-  virtual void Write(const std::string variableName, const short *values);
-  virtual void Write(const std::string variableName,
+  virtual void Write(const std::string &variableName, const short *values);
+  virtual void Write(const std::string &variableName,
                      const unsigned short *values);
-  virtual void Write(const std::string variableName, const int *values);
-  virtual void Write(const std::string variableName,
+  virtual void Write(const std::string &variableName, const int *values);
+  virtual void Write(const std::string &variableName,
                      const unsigned int *values);
-  virtual void Write(const std::string variableName, const long int *values);
-  virtual void Write(const std::string variableName,
+  virtual void Write(const std::string &variableName, const long int *values);
+  virtual void Write(const std::string &variableName,
                      const unsigned long int *values);
-  virtual void Write(const std::string variableName,
+  virtual void Write(const std::string &variableName,
                      const long long int *values);
-  virtual void Write(const std::string variableName,
+  virtual void Write(const std::string &variableName,
                      const unsigned long long int *values);
-  virtual void Write(const std::string variableName, const float *values);
-  virtual void Write(const std::string variableName, const double *values);
-  virtual void Write(const std::string variableName, const long double *values);
-  virtual void Write(const std::string variableName,
+  virtual void Write(const std::string &variableName, const float *values);
+  virtual void Write(const std::string &variableName, const double *values);
+  virtual void Write(const std::string &variableName, const long double *values);
+  virtual void Write(const std::string &variableName,
                      const std::complex<float> *values);
-  virtual void Write(const std::string variableName,
+  virtual void Write(const std::string &variableName,
                      const std::complex<double> *values);
-  virtual void Write(const std::string variableName,
+  virtual void Write(const std::string &variableName,
                      const std::complex<long double> *values);
-  virtual void Write(const std::string variableName, const void *values);
+  virtual void Write(const std::string &variableName, const void *values);
 
   /**
    * Read function that adds static checking on the variable to be passed by
diff --git a/source/core/Capsule.cpp b/source/core/Capsule.cpp
index f80b2025e9c01d2f7657acf10238175a2dfa2d55..0b268a37065238800c19cdad2336774a2c553774 100644
--- a/source/core/Capsule.cpp
+++ b/source/core/Capsule.cpp
@@ -8,22 +8,22 @@
  *      Author: wfg
  */
 
+#include <utility>
+
 #include "core/Capsule.h"
 
 namespace adios
 {
 
-Capsule::Capsule(const std::string type, const std::string accessMode,
-                 const int rankMPI, const bool debugMode)
-    : m_Type{type}, m_AccessMode{accessMode}, m_RankMPI{rankMPI},
-      m_DebugMode{debugMode}
+Capsule::Capsule(std::string type, std::string accessMode, int rankMPI,
+                 bool debugMode)
+: m_Type{std::move(type)}, m_AccessMode{std::move(accessMode)},
+  m_RankMPI{rankMPI}, m_DebugMode{debugMode}
 {
 }
 
-Capsule::~Capsule() {}
-
-void Capsule::ResizeData(const std::size_t size) {}
+void Capsule::ResizeData(size_t /*size*/) {}
 
-void Capsule::ResizeMetadata(const std::size_t size) {}
+void Capsule::ResizeMetadata(size_t /*size*/) {}
 
-} // end namespace
+} // end namespace adios
diff --git a/source/core/Engine.cpp b/source/core/Engine.cpp
index 515d4781cc3cc5c6c9d69a6eb787f42a12e940f5..d59f815734fa5109cc0f29b1617282256093dbf4 100644
--- a/source/core/Engine.cpp
+++ b/source/core/Engine.cpp
@@ -15,226 +15,263 @@
 namespace adios
 {
 
-Engine::Engine(ADIOS &adios, const std::string engineType,
-               const std::string name, const std::string accessMode,
-               MPI_Comm mpiComm, const Method &method, const bool debugMode,
-               const unsigned int nthreads, const std::string endMessage)
-    : m_MPIComm{mpiComm}, m_EngineType{engineType}, m_Name{name},
-      m_AccessMode{accessMode}, m_Method{method}, m_ADIOS(adios),
-      m_DebugMode{debugMode}, m_nThreads{nthreads}, m_EndMessage(endMessage)
+Engine::Engine(ADIOS &adios, std::string engineType, std::string name,
+               std::string accessMode, MPI_Comm mpiComm, const Method &method,
+               bool debugMode, unsigned int nthreads, std::string endMessage)
+: m_MPIComm{mpiComm}, m_EngineType{std::move(engineType)}, m_Name{std::move(
+                                                               name)},
+  m_AccessMode{std::move(accessMode)}, m_Method{method},
+  m_ADIOS(adios), m_DebugMode{debugMode}, m_nThreads{nthreads},
+  m_EndMessage(std::move(endMessage))
 {
   if (m_DebugMode == true)
   {
     if (m_MPIComm == MPI_COMM_NULL)
+    {
       throw std::ios_base::failure(
           "ERROR: engine communicator is MPI_COMM_NULL,"
           " in call to ADIOS Open or Constructor\n");
+    }
   }
 
   MPI_Comm_rank(m_MPIComm, &m_RankMPI);
   MPI_Comm_size(m_MPIComm, &m_SizeMPI);
 }
 
-Engine::~Engine() {}
-
 void Engine::SetCallBack(std::function<void(const void *, std::string,
                                             std::string, std::string, Dims)>
-                             callback)
+                         /*callback*/)
 {
 }
 
 // should these functions throw an exception?
-void Engine::Write(Variable<char> &variable, const char *values) {}
-void Engine::Write(Variable<unsigned char> &variable,
-                   const unsigned char *values)
+void Engine::Write(Variable<char> & /*variable*/, const char * /*values*/) {}
+void Engine::Write(Variable<unsigned char> & /*variable*/,
+                   const unsigned char * /*values*/)
+{
+}
+void Engine::Write(Variable<short> & /*variable*/, const short * /*values*/) {}
+void Engine::Write(Variable<unsigned short> & /*variable*/,
+                   const unsigned short * /*values*/)
+{
+}
+void Engine::Write(Variable<int> & /*variable*/, const int * /*values*/) {}
+void Engine::Write(Variable<unsigned int> & /*variable*/,
+                   const unsigned int * /*values*/)
 {
 }
-void Engine::Write(Variable<short> &variable, const short *values) {}
-void Engine::Write(Variable<unsigned short> &variable,
-                   const unsigned short *values)
+void Engine::Write(Variable<long int> & /*variable*/,
+                   const long int * /*values*/)
 {
 }
-void Engine::Write(Variable<int> &variable, const int *values) {}
-void Engine::Write(Variable<unsigned int> &variable, const unsigned int *values)
+void Engine::Write(Variable<unsigned long int> & /*variable*/,
+                   const unsigned long int * /*values*/)
 {
 }
-void Engine::Write(Variable<long int> &variable, const long int *values) {}
-void Engine::Write(Variable<unsigned long int> &variable,
-                   const unsigned long int *values)
+void Engine::Write(Variable<long long int> & /*variable*/,
+                   const long long int * /*values*/)
 {
 }
-void Engine::Write(Variable<long long int> &variable,
-                   const long long int *values)
+void Engine::Write(Variable<unsigned long long int> & /*variable*/,
+                   const unsigned long long int * /*values*/)
 {
 }
-void Engine::Write(Variable<unsigned long long int> &variable,
-                   const unsigned long long int *values)
+void Engine::Write(Variable<float> & /*variable*/, const float * /*values*/) {}
+void Engine::Write(Variable<double> & /*variable*/, const double * /*values*/)
 {
 }
-void Engine::Write(Variable<float> &variable, const float *values) {}
-void Engine::Write(Variable<double> &variable, const double *values) {}
-void Engine::Write(Variable<long double> &variable, const long double *values)
+void Engine::Write(Variable<long double> & /*variable*/,
+                   const long double * /*values*/)
 {
 }
-void Engine::Write(Variable<std::complex<float>> &variable,
-                   const std::complex<float> *values)
+void Engine::Write(Variable<std::complex<float>> & /*variable*/,
+                   const std::complex<float> * /*values*/)
 {
 }
-void Engine::Write(Variable<std::complex<double>> &variable,
-                   const std::complex<double> *values)
+void Engine::Write(Variable<std::complex<double>> & /*variable*/,
+                   const std::complex<double> * /*values*/)
 {
 }
-void Engine::Write(Variable<std::complex<long double>> &variable,
-                   const std::complex<long double> *values)
+void Engine::Write(Variable<std::complex<long double>> & /*variable*/,
+                   const std::complex<long double> * /*values*/)
 {
 }
-void Engine::Write(VariableCompound &variable, const void *values) {}
+void Engine::Write(VariableCompound & /*variable*/, const void * /*values*/) {}
 
-void Engine::Write(const std::string variableName, const char *values) {}
-void Engine::Write(const std::string variableName, const unsigned char *values)
+void Engine::Write(const std::string & /*variableName*/, const char * /*values*/)
+{
+}
+void Engine::Write(const std::string & /*variableName*/,
+                   const unsigned char * /*values*/)
+{
+}
+void Engine::Write(const std::string & /*variableName*/, const short * /*values*/)
+{
+}
+void Engine::Write(const std::string & /*variableName*/,
+                   const unsigned short * /*values*/)
+{
+}
+void Engine::Write(const std::string & /*variableName*/, const int * /*values*/)
 {
 }
-void Engine::Write(const std::string variableName, const short *values) {}
-void Engine::Write(const std::string variableName, const unsigned short *values)
+void Engine::Write(const std::string & /*variableName*/,
+                   const unsigned int * /*values*/)
 {
 }
-void Engine::Write(const std::string variableName, const int *values) {}
-void Engine::Write(const std::string variableName, const unsigned int *values)
+void Engine::Write(const std::string & /*variableName*/,
+                   const long int * /*values*/)
 {
 }
-void Engine::Write(const std::string variableName, const long int *values) {}
-void Engine::Write(const std::string variableName,
-                   const unsigned long int *values)
+void Engine::Write(const std::string & /*variableName*/,
+                   const unsigned long int * /*values*/)
 {
 }
-void Engine::Write(const std::string variableName, const long long int *values)
+void Engine::Write(const std::string & /*variableName*/,
+                   const long long int * /*values*/)
 {
 }
-void Engine::Write(const std::string variableName,
-                   const unsigned long long int *values)
+void Engine::Write(const std::string & /*variableName*/,
+                   const unsigned long long int * /*values*/)
 {
 }
-void Engine::Write(const std::string variableName, const float *values) {}
-void Engine::Write(const std::string variableName, const double *values) {}
-void Engine::Write(const std::string variableName, const long double *values) {}
-void Engine::Write(const std::string variableName,
-                   const std::complex<float> *values)
+void Engine::Write(const std::string & /*variableName*/, const float * /*values*/)
 {
 }
-void Engine::Write(const std::string variableName,
-                   const std::complex<double> *values)
+void Engine::Write(const std::string & /*variableName*/,
+                   const double * /*values*/)
 {
 }
-void Engine::Write(const std::string variableName,
-                   const std::complex<long double> *values)
+void Engine::Write(const std::string & /*variableName*/,
+                   const long double * /*values*/)
+{
+}
+void Engine::Write(const std::string & /*variableName*/,
+                   const std::complex<float> * /*values*/)
+{
+}
+void Engine::Write(const std::string & /*variableName*/,
+                   const std::complex<double> * /*values*/)
+{
+}
+void Engine::Write(const std::string & /*variableName*/,
+                   const std::complex<long double> * /*values*/)
+{
+}
+void Engine::Write(const std::string & /*variableName*/, const void * /*values*/)
 {
 }
-void Engine::Write(const std::string variableName, const void *values) {}
 
-void Engine::Advance(float timeout_sec) {}
-void Engine::Advance(AdvanceMode mode, float timeout_sec) {}
+void Engine::Advance(float /*timeout_sec*/) {}
+void Engine::Advance(AdvanceMode /*mode*/, float /*timeout_sec*/) {}
 void Engine::AdvanceAsync(
-    AdvanceMode mode,
-    std::function<void(std::shared_ptr<adios::Engine>)> callback)
+    AdvanceMode /*mode*/,
+    std::function<void(std::shared_ptr<adios::Engine>)> /*callback*/)
 {
 }
 
-void Engine::Close(const int transportIndex) {}
+void Engine::Close(const int /*transportIndex*/) {}
 
 // READ
-Variable<void> *Engine::InquireVariable(const std::string name,
-                                        const bool readIn)
+Variable<void> *Engine::InquireVariable(const std::string /*name*/,
+                                        const bool /*readIn*/)
 {
   return nullptr;
 }
-Variable<char> *Engine::InquireVariableChar(const std::string name,
-                                            const bool readIn)
+Variable<char> *Engine::InquireVariableChar(const std::string /*name*/,
+                                            const bool /*readIn*/)
 {
   return nullptr;
 }
-Variable<unsigned char> *Engine::InquireVariableUChar(const std::string name,
-                                                      const bool readIn)
+Variable<unsigned char> *
+Engine::InquireVariableUChar(const std::string /*name*/, const bool /*readIn*/)
 {
   return nullptr;
 }
-Variable<short> *Engine::InquireVariableShort(const std::string name,
-                                              const bool readIn)
+Variable<short> *Engine::InquireVariableShort(const std::string /*name*/,
+                                              const bool /*readIn*/)
 {
   return nullptr;
 }
-Variable<unsigned short> *Engine::InquireVariableUShort(const std::string name,
-                                                        const bool readIn)
+Variable<unsigned short> *
+Engine::InquireVariableUShort(const std::string /*name*/, const bool /*readIn*/)
 {
   return nullptr;
 }
-Variable<int> *Engine::InquireVariableInt(const std::string name,
-                                          const bool readIn)
+Variable<int> *Engine::InquireVariableInt(const std::string /*name*/,
+                                          const bool /*readIn*/)
 {
   return nullptr;
 }
-Variable<unsigned int> *Engine::InquireVariableUInt(const std::string name,
-                                                    const bool readIn)
+Variable<unsigned int> *Engine::InquireVariableUInt(const std::string /*name*/,
+                                                    const bool /*readIn*/)
 {
   return nullptr;
 }
-Variable<long int> *Engine::InquireVariableLInt(const std::string name,
-                                                const bool readIn)
+Variable<long int> *Engine::InquireVariableLInt(const std::string /*name*/,
+                                                const bool /*readIn*/)
 {
   return nullptr;
 }
 Variable<unsigned long int> *
-Engine::InquireVariableULInt(const std::string name, const bool readIn)
+Engine::InquireVariableULInt(const std::string /*name*/, const bool /*readIn*/)
 {
   return nullptr;
 }
-Variable<long long int> *Engine::InquireVariableLLInt(const std::string name,
-                                                      const bool readIn)
+Variable<long long int> *
+Engine::InquireVariableLLInt(const std::string /*name*/, const bool /*readIn*/)
 {
   return nullptr;
 }
 Variable<unsigned long long int> *
-Engine::InquireVariableULLInt(const std::string name, const bool readIn)
+Engine::InquireVariableULLInt(const std::string /*name*/, const bool /*readIn*/)
 {
   return nullptr;
 }
-Variable<float> *Engine::InquireVariableFloat(const std::string name,
-                                              const bool readIn)
+Variable<float> *Engine::InquireVariableFloat(const std::string /*name*/,
+                                              const bool /*readIn*/)
 {
   return nullptr;
 }
-Variable<double> *Engine::InquireVariableDouble(const std::string name,
-                                                const bool readIn)
+Variable<double> *Engine::InquireVariableDouble(const std::string /*name*/,
+                                                const bool /*readIn*/)
 {
   return nullptr;
 }
-Variable<long double> *Engine::InquireVariableLDouble(const std::string name,
-                                                      const bool readIn)
+Variable<long double> *
+Engine::InquireVariableLDouble(const std::string /*name*/,
+                               const bool /*readIn*/)
 {
   return nullptr;
 }
 Variable<std::complex<float>> *
-Engine::InquireVariableCFloat(const std::string name, const bool readIn)
+Engine::InquireVariableCFloat(const std::string /*name*/, const bool /*readIn*/)
 {
   return nullptr;
 }
 Variable<std::complex<double>> *
-Engine::InquireVariableCDouble(const std::string name, const bool readIn)
+Engine::InquireVariableCDouble(const std::string /*name*/,
+                               const bool /*readIn*/)
 {
   return nullptr;
 }
 Variable<std::complex<long double>> *
-Engine::InquireVariableCLDouble(const std::string name, const bool readIn)
+Engine::InquireVariableCLDouble(const std::string /*name*/,
+                                const bool /*readIn*/)
 {
   return nullptr;
 }
-VariableCompound *Engine::InquireVariableCompound(const std::string name,
-                                                  const bool readIn)
+VariableCompound *Engine::InquireVariableCompound(const std::string /*name*/,
+                                                  const bool /*readIn*/)
 {
   return nullptr;
 }
 
-void Engine::Read(Variable<double> &variable, const double *values) {}
-void Engine::ScheduleRead(Variable<double> &variable, const double *values) {}
+void Engine::Read(Variable<double> & /*variable*/, const double * /*values*/) {}
+void Engine::ScheduleRead(Variable<double> & /*variable*/,
+                          const double * /*values*/)
+{
+}
 void Engine::Release() {}
 
 // PROTECTED
@@ -250,8 +287,12 @@ void Engine::CheckParameter(
     const std::string parameterName, const std::string hint) const
 {
   if (itParam == parameters.end())
-    throw std::invalid_argument("ERROR: parameter name " + parameterName +
-                                " not found " + hint);
+  {
+    {
+      throw std::invalid_argument("ERROR: parameter name " + parameterName +
+                                  " not found " + hint);
+    }
+  }
 }
 
 bool Engine::TransportNamesUniqueness() const
@@ -266,9 +307,11 @@ bool Engine::TransportNamesUniqueness() const
       if (m_DebugMode == true)
       {
         if (itTransport == parameters.end())
+        {
           throw std::invalid_argument(
               "ERROR: transport not defined in Method input to Engine " +
               m_Name);
+        }
       }
 
       const std::string type(itTransport->second);
@@ -277,12 +320,18 @@ bool Engine::TransportNamesUniqueness() const
         std::string name(m_Name);
         auto itName = parameters.find("name");
         if (itName != parameters.end())
+        {
           name = itName->second;
+        }
 
         if (transportNames.count(name) == 0)
+        {
           transportNames.insert(name);
+        }
         else
+        {
           return false;
+        }
       }
     }
     return true;
@@ -305,4 +354,4 @@ void Engine::CheckTransportIndex(const int transportIndex)
   }
 }
 
-} // end namespace
+} // end namespace adios