diff --git a/include/aidge/operator/Pad.hpp b/include/aidge/operator/Pad.hpp
index 53ce15b98b26b24d8c470927c4bd6f3200914b46..683ca744760dc7edb7d2e9e212fffb3e85490b2d 100644
--- a/include/aidge/operator/Pad.hpp
+++ b/include/aidge/operator/Pad.hpp
@@ -26,7 +26,7 @@
 #include "aidge/utils/Types.h"
 
 namespace Aidge {
-enum class PadAttr { BeginEndTuples, Type, Value };
+enum class PadAttr { BeginEndBorders, BorderType, BorderValue };
 enum class PadBorderType { Constant, Replicate, Reflect, Wrap };
 
 template <DimIdx_t DIM>
@@ -54,12 +54,12 @@ public:
     using attr = typename Attributes_::template attr<e>;
 
     constexpr Pad_Op(const std::array<std::array<DimSize_t, 2>, DIM> &beginEndTuples,
-                     const PadBorderType &type = PadBorderType::Constant,
-                     double value = 0.0)
+                     const PadBorderType &borderType = PadBorderType::Constant,
+                     double borderValue = 0.0)
         : Operator(Type),
-          Attributes_(attr<PadAttr::BeginEndTuples>(beginEndTuples),
-                           attr<PadAttr::Type>(type),
-                           attr<PadAttr::Value>(value)) {
+          Attributes_(attr<PadAttr::BeginEndBorders>(beginEndTuples),
+                           attr<PadAttr::BorderType>(borderType),
+                           attr<PadAttr::BorderValue>(borderValue)) {
         setDatatype(DataType::Float32);
     }
 
@@ -97,9 +97,9 @@ public:
             std::array<DimSize_t, DIM + 2> outputDims = {};
 
             for (std::size_t dim = 0; dim < DIM; ++dim) {
-                outputDims[dim+2] = this->template getAttr<PadAttr::BeginEndTuples>()[dim][0]
+                outputDims[dim+2] = this->template getAttr<PadAttr::BeginEndBorders>()[dim][0]
                                     + mInput->dims()[dim+2]
-                                    + this->template getAttr<PadAttr::BeginEndTuples>()[dim][1];
+                                    + this->template getAttr<PadAttr::BeginEndBorders>()[dim][1];
             }
             outputDims[1] = mInput->dims()[1];
             outputDims[0] = mInput->dims()[0];
@@ -165,26 +165,26 @@ public:
 template <std::array<DimSize_t, 1>::size_type DIM>
 inline std::shared_ptr<Node> Pad(const std::array<std::array<DimSize_t, 2>, DIM> &beginEndTuples,
                                            const std::string& name = "",
-                                           const PadBorderType &type = PadBorderType::Constant,
-                                           double value = 0.0)
+                                           const PadBorderType &borderType = PadBorderType::Constant,
+                                           double borderValue = 0.0)
 {
     static_assert(DIM<=MaxDim,"Too many kernel dimensions required by Pad, not supported");
-    auto pad = std::make_shared<Node>(std::make_shared<Pad_Op<static_cast<DimIdx_t>(DIM)>>(beginEndTuples, type, value), name);
+    auto pad = std::make_shared<Node>(std::make_shared<Pad_Op<static_cast<DimIdx_t>(DIM)>>(beginEndTuples, borderType, borderValue), name);
     return pad;
 }
 
 template <std::array<DimSize_t, 1>::size_type DIM>
 inline std::shared_ptr<Node> Pad(const std::array<DimSize_t, DIM> &dimBeginEnd,
                                            const std::string& name = "",
-                                           const PadBorderType &type = PadBorderType::Constant,
-                                           double value = 0.0)
+                                           const PadBorderType &borderType = PadBorderType::Constant,
+                                           double borderValue = 0.0)
 {
     static_assert(DIM<=MaxDim,"Too many kernel dimensions required by Pad, not supported");
     std::array<std::array<DimSize_t, 2>, DIM> beginEndTuples;
     for (size_t i = 0; i < DIM; ++i) {
         beginEndTuples[i] = {dimBeginEnd[i], dimBeginEnd[i]};
     }
-    auto pad = std::make_shared<Node>(std::make_shared<Pad_Op<static_cast<DimIdx_t>(DIM)>>(beginEndTuples, type, value), name);
+    auto pad = std::make_shared<Node>(std::make_shared<Pad_Op<static_cast<DimIdx_t>(DIM)>>(beginEndTuples, borderType, borderValue), name);
     return pad;
 }
 
@@ -214,17 +214,17 @@ template <DimSize_t DIM>
 inline std::shared_ptr<Node> Pad(
     std::array<DimSize_t, 2> const (&beginEndTuples)[DIM],
     const std::string& name = "",
-    const PadBorderType &type = PadBorderType::Constant,
-    double value = 0.0)
+    const PadBorderType &borderType = PadBorderType::Constant,
+    double borderValue = 0.0)
 {
     static_assert(DIM<=MaxDim,"Too many kernel dimensions required by Pad, not supported");
-    return Pad(to_array(beginEndTuples), name, type, value);
+    return Pad(to_array(beginEndTuples), name, borderType, borderValue);
 }
 }  // namespace Aidge
 
 namespace {
 template <>
-const char *const EnumStrings<Aidge::PadAttr>::data[] = {"BeginEndTuples", "Type", "Value"};
+const char *const EnumStrings<Aidge::PadAttr>::data[] = {"BeginEndBorders", "BorderType", "BorderValue"};
 
 template <>
 const char *const EnumStrings<Aidge::PadBorderType>::data[] = {"Constant", "Replicate", "Reflect", "Wrap"};