diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h
index 95d48303..c4024cf9 100644
--- a/datapoollocal/LocalDataPoolManager.h
+++ b/datapoollocal/LocalDataPoolManager.h
@@ -48,7 +48,7 @@ class HousekeepingPacketUpdate;
  * @author 		R. Mueller
  */
 class LocalDataPoolManager {
-	template<typename T> friend class LocalPoolVar;
+	template<typename T> friend class LocalPoolVariable;
 	template<typename T, uint16_t vecSize> friend class LocalPoolVector;
 	friend class LocalPoolDataSetBase;
 	friend void (Factory::setStaticFrameworkObjectIds)();
diff --git a/datapoollocal/LocalPoolVariable.h b/datapoollocal/LocalPoolVariable.h
index c18d5443..7b7e443e 100644
--- a/datapoollocal/LocalPoolVariable.h
+++ b/datapoollocal/LocalPoolVariable.h
@@ -22,10 +22,10 @@
  * @ingroup data_pool
  */
 template<typename T>
-class LocalPoolVar: public LocalPoolObjectBase {
+class LocalPoolVariable: public LocalPoolObjectBase {
 public:
 	//! Default ctor is forbidden.
-	LocalPoolVar() = delete;
+	LocalPoolVariable() = delete;
 
 	/**
 	 * This constructor is used by the data creators to have pool variable
@@ -43,7 +43,7 @@ public:
 	 * If nullptr, the variable is not registered.
 	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
 	 */
-	LocalPoolVar(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
+	LocalPoolVariable(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
 			DataSetIF* dataSet = nullptr,
 			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
@@ -64,7 +64,7 @@ public:
 	 * @param setReadWriteMode Specify the read-write mode of the pool variable.
 	 *
 	 */
-	LocalPoolVar(object_id_t poolOwner, lp_id_t poolId,
+	LocalPoolVariable(object_id_t poolOwner, lp_id_t poolId,
 			DataSetIF* dataSet = nullptr,
 			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 	/**
@@ -73,10 +73,10 @@ public:
 	 * @param dataSet
 	 * @param setReadWriteMode
 	 */
-	LocalPoolVar(gp_id_t globalPoolId, DataSetIF* dataSet = nullptr,
+	LocalPoolVariable(gp_id_t globalPoolId, DataSetIF* dataSet = nullptr,
 			pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
 
-	virtual~ LocalPoolVar() {};
+	virtual~ LocalPoolVariable() {};
 
 	/**
 	 * @brief	This is the local copy of the data pool entry.
@@ -118,23 +118,23 @@ public:
 	ReturnValue_t commit(dur_millis_t lockTimeout = MutexIF::BLOCKING) override;
 
 
-	LocalPoolVar<T> &operator=(const T& newValue);
-	LocalPoolVar<T> &operator=(const LocalPoolVar<T>& newPoolVariable);
+	LocalPoolVariable<T> &operator=(const T& newValue);
+	LocalPoolVariable<T> &operator=(const LocalPoolVariable<T>& newPoolVariable);
 
 	//! Explicit type conversion operator. Allows casting the class to
 	//! its template type to perform operations on value.
 	explicit operator T() const;
 
-	bool operator==(const LocalPoolVar<T>& other) const;
+	bool operator==(const LocalPoolVariable<T>& other) const;
 	bool operator==(const T& other) const;
 
-	bool operator!=(const LocalPoolVar<T>& other) const;
+	bool operator!=(const LocalPoolVariable<T>& other) const;
 	bool operator!=(const T& other) const;
 
-	bool operator<(const LocalPoolVar<T>& other) const;
+	bool operator<(const LocalPoolVariable<T>& other) const;
 	bool operator<(const T& other) const;
 
-	bool operator>(const LocalPoolVar<T>& other) const;
+	bool operator>(const LocalPoolVariable<T>& other) const;
 	bool operator>(const T& other) const;
 
 protected:
@@ -160,7 +160,7 @@ protected:
 	// std::ostream is the type for object std::cout
 	template <typename U>
 	friend std::ostream& operator<< (std::ostream &out,
-			const LocalPoolVar<U> &var);
+			const LocalPoolVariable<U> &var);
 
 private:
 };
@@ -168,18 +168,18 @@ private:
 #include "LocalPoolVariable.tpp"
 
 template<class T>
-using lp_var_t = LocalPoolVar<T>;
+using lp_var_t = LocalPoolVariable<T>;
 
-using lp_bool_t = LocalPoolVar<uint8_t>;
-using lp_uint8_t = LocalPoolVar<uint8_t>;
-using lp_uint16_t = LocalPoolVar<uint16_t>;
-using lp_uint32_t = LocalPoolVar<uint32_t>;
-using lp_uint64_t = LocalPoolVar<uint64_t>;
-using lp_int8_t = LocalPoolVar<int8_t>;
-using lp_int16_t = LocalPoolVar<int16_t>;
-using lp_int32_t = LocalPoolVar<int32_t>;
-using lp_int64_t = LocalPoolVar<int64_t>;
-using lp_float_t = LocalPoolVar<float>;
-using lp_double_t = LocalPoolVar<double>;
+using lp_bool_t = LocalPoolVariable<uint8_t>;
+using lp_uint8_t = LocalPoolVariable<uint8_t>;
+using lp_uint16_t = LocalPoolVariable<uint16_t>;
+using lp_uint32_t = LocalPoolVariable<uint32_t>;
+using lp_uint64_t = LocalPoolVariable<uint64_t>;
+using lp_int8_t = LocalPoolVariable<int8_t>;
+using lp_int16_t = LocalPoolVariable<int16_t>;
+using lp_int32_t = LocalPoolVariable<int32_t>;
+using lp_int64_t = LocalPoolVariable<int64_t>;
+using lp_float_t = LocalPoolVariable<float>;
+using lp_double_t = LocalPoolVariable<double>;
 
 #endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_ */
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index b9f7b906..48649ad5 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -6,32 +6,32 @@
 #endif
 
 template<typename T>
-inline LocalPoolVar<T>::LocalPoolVar(HasLocalDataPoolIF* hkOwner,
+inline LocalPoolVariable<T>::LocalPoolVariable(HasLocalDataPoolIF* hkOwner,
 		lp_id_t poolId, DataSetIF* dataSet, pool_rwm_t setReadWriteMode):
 		LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
 template<typename T>
-inline LocalPoolVar<T>::LocalPoolVar(object_id_t poolOwner, lp_id_t poolId,
+inline LocalPoolVariable<T>::LocalPoolVariable(object_id_t poolOwner, lp_id_t poolId,
         DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
         LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
 
 
 template<typename T>
-inline LocalPoolVar<T>::LocalPoolVar(gp_id_t globalPoolId, DataSetIF *dataSet,
+inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId, DataSetIF *dataSet,
 		pool_rwm_t setReadWriteMode):
 		LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
 				dataSet, setReadWriteMode){}
 
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::read(dur_millis_t lockTimeout) {
+inline ReturnValue_t LocalPoolVariable<T>::read(dur_millis_t lockTimeout) {
 	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
 			lockTimeout);
 	return readWithoutLock();
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::readWithoutLock() {
+inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_WRITE) {
 		sif::debug << "LocalPoolVar: Invalid read write "
 				"mode for read() call." << std::endl;
@@ -53,14 +53,14 @@ inline ReturnValue_t LocalPoolVar<T>::readWithoutLock() {
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::commit(dur_millis_t lockTimeout) {
+inline ReturnValue_t LocalPoolVariable<T>::commit(dur_millis_t lockTimeout) {
 	MutexHelper(hkManager->getMutexHandle(), MutexIF::TimeoutType::WAITING,
 			lockTimeout);
 	return commitWithoutLock();
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::commitWithoutLock() {
+inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
 	if(readWriteMode == pool_rwm_t::VAR_READ) {
 		sif::debug << "LocalPoolVar: Invalid read write "
 				 "mode for commit() call." << std::endl;
@@ -81,88 +81,88 @@ inline ReturnValue_t LocalPoolVar<T>::commitWithoutLock() {
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::serialize(uint8_t** buffer, size_t* size,
+inline ReturnValue_t LocalPoolVariable<T>::serialize(uint8_t** buffer, size_t* size,
 		const size_t max_size, SerializeIF::Endianness streamEndianness) const {
 	return SerializeAdapter::serialize(&value,
 			buffer, size ,max_size, streamEndianness);
 }
 
 template<typename T>
-inline size_t LocalPoolVar<T>::getSerializedSize() const {
+inline size_t LocalPoolVariable<T>::getSerializedSize() const {
 	return SerializeAdapter::getSerializedSize(&value);
 }
 
 template<typename T>
-inline ReturnValue_t LocalPoolVar<T>::deSerialize(const uint8_t** buffer,
+inline ReturnValue_t LocalPoolVariable<T>::deSerialize(const uint8_t** buffer,
 		size_t* size, SerializeIF::Endianness streamEndianness) {
 	return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
 }
 
 template<typename T>
 inline std::ostream& operator<< (std::ostream &out,
-		const LocalPoolVar<T> &var) {
+		const LocalPoolVariable<T> &var) {
     out << var.value;
     return out;
 }
 
 template<typename T>
-inline LocalPoolVar<T>::operator T() const {
+inline LocalPoolVariable<T>::operator T() const {
 	return value;
 }
 
 template<typename T>
-inline LocalPoolVar<T> & LocalPoolVar<T>::operator=(const T& newValue) {
+inline LocalPoolVariable<T> & LocalPoolVariable<T>::operator=(const T& newValue) {
     value = newValue;
     return *this;
 }
 
 template<typename T>
-inline LocalPoolVar<T>& LocalPoolVar<T>::operator =(
-		const LocalPoolVar<T>& newPoolVariable) {
+inline LocalPoolVariable<T>& LocalPoolVariable<T>::operator =(
+		const LocalPoolVariable<T>& newPoolVariable) {
 	value = newPoolVariable.value;
 	return *this;
 }
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator ==(const LocalPoolVar<T> &other) const {
+inline bool LocalPoolVariable<T>::operator ==(const LocalPoolVariable<T> &other) const {
 	return this->value == other.value;
 }
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator ==(const T &other) const {
+inline bool LocalPoolVariable<T>::operator ==(const T &other) const {
 	return this->value == other;
 }
 
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator !=(const LocalPoolVar<T> &other) const {
+inline bool LocalPoolVariable<T>::operator !=(const LocalPoolVariable<T> &other) const {
 	return not (*this == other);
 }
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator !=(const T &other) const {
+inline bool LocalPoolVariable<T>::operator !=(const T &other) const {
 	return not (*this == other);
 }
 
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator <(const LocalPoolVar<T> &other) const {
+inline bool LocalPoolVariable<T>::operator <(const LocalPoolVariable<T> &other) const {
 	return this->value < other.value;
 }
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator <(const T &other) const {
+inline bool LocalPoolVariable<T>::operator <(const T &other) const {
 	return this->value < other;
 }
 
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator >(const LocalPoolVar<T> &other) const {
+inline bool LocalPoolVariable<T>::operator >(const LocalPoolVariable<T> &other) const {
 	return not (*this < other);
 }
 
 template<typename T>
-inline bool LocalPoolVar<T>::operator >(const T &other) const {
+inline bool LocalPoolVariable<T>::operator >(const T &other) const {
 	return not (*this < other);
 }
 
diff --git a/monitoring/MonitorBase.h b/monitoring/MonitorBase.h
index 530a3840..967f0f62 100644
--- a/monitoring/MonitorBase.h
+++ b/monitoring/MonitorBase.h
@@ -72,7 +72,7 @@ protected:
 	    return HasReturnvaluesIF::RETURN_OK;
 	}
 
-	LocalPoolVar<T> poolVariable;
+	LocalPoolVariable<T> poolVariable;
 };
 
 #endif /* FSFW_MONITORING_MONITORBASE_H_ */