diff --git a/poincare/include/poincare/absolute_value_layout_node.h b/poincare/include/poincare/absolute_value_layout_node.h
index 719cd0b49..3da2fb13a 100644
--- a/poincare/include/poincare/absolute_value_layout_node.h
+++ b/poincare/include/poincare/absolute_value_layout_node.h
@@ -20,8 +20,10 @@ public:
   static AbsoluteValueLayoutNode * FailedAllocationStaticNode();
   AbsoluteValueLayoutNode * failedAllocationStaticNode() override { return FailedAllocationStaticNode(); }
   size_t size() const override { return sizeof(AbsoluteValueLayoutNode); }
-#if TREE_LOG
-  const char * description() const override { return "AbsoluteValueLayout"; }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "AbsoluteValueLayout";
+  }
 #endif
 
 private:
diff --git a/poincare/include/poincare/addition.h b/poincare/include/poincare/addition.h
index 128d67b55..a6474101f 100644
--- a/poincare/include/poincare/addition.h
+++ b/poincare/include/poincare/addition.h
@@ -23,8 +23,10 @@ public:
   static AdditionNode * FailedAllocationStaticNode();
   AdditionNode * failedAllocationStaticNode() override { return FailedAllocationStaticNode(); }
   size_t size() const override { return sizeof(AdditionNode); }
-#if TREE_LOG
-  const char * description() const override { return "Addition";  }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "Addition";
+  }
 #endif
 
   // ExpressionNode
diff --git a/poincare/include/poincare/allocation_failure_node.h b/poincare/include/poincare/allocation_failure_node.h
index 8b18b65bb..702c66d52 100644
--- a/poincare/include/poincare/allocation_failure_node.h
+++ b/poincare/include/poincare/allocation_failure_node.h
@@ -13,11 +13,15 @@ public:
 
   // TreeNode
   size_t size() const override { return sizeof(AllocationFailureNode<T>); }
-#if TREE_LOG
-  const char * description() const override { return "AllocationFailure";  }
-#endif
   int numberOfChildren() const override { return 0; }
   bool isAllocationFailure() const override { return true; }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "AllocationFailure[";
+    T::logNodeName(stream);
+    stream << "]";
+  }
+#endif
 };
 
 }
diff --git a/poincare/include/poincare/binomial_coefficient_layout_node.h b/poincare/include/poincare/binomial_coefficient_layout_node.h
index 55f225729..ff6d68dd9 100644
--- a/poincare/include/poincare/binomial_coefficient_layout_node.h
+++ b/poincare/include/poincare/binomial_coefficient_layout_node.h
@@ -26,8 +26,10 @@ public:
   BinomialCoefficientLayoutNode * failedAllocationStaticNode() override { return FailedAllocationStaticNode(); }
   size_t size() const override { return sizeof(BinomialCoefficientLayoutNode); }
   int numberOfChildren() const override { return 2; }
-#if TREE_LOG
-  const char * description() const override { return "BinomialCoefficientLayout"; }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "BinomialCoefficientLayout";
+  }
 #endif
 
 protected:
diff --git a/poincare/include/poincare/ceiling_layout_node.h b/poincare/include/poincare/ceiling_layout_node.h
index aebff7cd0..00480a65a 100644
--- a/poincare/include/poincare/ceiling_layout_node.h
+++ b/poincare/include/poincare/ceiling_layout_node.h
@@ -17,8 +17,10 @@ public:
   static CeilingLayoutNode * FailedAllocationStaticNode();
   CeilingLayoutNode * failedAllocationStaticNode() override { return FailedAllocationStaticNode(); }
   size_t size() const override { return sizeof(CeilingLayoutNode); }
-#if TREE_LOG
-  const char * description() const override { return "CeilingLayout"; }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "CeilingLayout";
+  }
 #endif
 
 protected:
diff --git a/poincare/include/poincare/char_layout_node.h b/poincare/include/poincare/char_layout_node.h
index c8135f8b1..5b85b80f9 100644
--- a/poincare/include/poincare/char_layout_node.h
+++ b/poincare/include/poincare/char_layout_node.h
@@ -33,11 +33,12 @@ public:
   // TreeNode
   size_t size() const override { return sizeof(CharLayoutNode); }
   int numberOfChildren() const override { return 0; }
-#if TREE_LOG
-  const char * description() const override {
-    static char Description[] = "Char a";
-    Description[5] = m_char;
-    return Description;
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "CharLayout";
+  }
+  virtual void logAttributes(std::ostream & stream) const {
+    stream << " char=\"" << m_char << "\"";
   }
 #endif
 
diff --git a/poincare/include/poincare/complex.h b/poincare/include/poincare/complex.h
index efc658095..690e588bf 100644
--- a/poincare/include/poincare/complex.h
+++ b/poincare/include/poincare/complex.h
@@ -18,10 +18,16 @@ public:
 
   // TreeNode
   size_t size() const override { return sizeof(ComplexNode<T>); }
-#if TREE_LOG
-  const char * description() const override { return "Evaluation complex";  }
-#endif
   int numberOfChildren() const override { return 0; }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "Complex";
+  }
+  virtual void logAttributes(std::ostream & stream) const {
+    stream << " real=\"" << this->real() << "\"";
+    stream << " imag=\"" << this->imag() << "\"";
+  }
+#endif
 
   void setComplex(std::complex<T> c);
   typename Poincare::EvaluationNode<T>::Type type() const override { return Poincare::EvaluationNode<T>::Type::Complex; }
diff --git a/poincare/include/poincare/condensed_sum_layout_node.h b/poincare/include/poincare/condensed_sum_layout_node.h
index 58e95688c..680f9505a 100644
--- a/poincare/include/poincare/condensed_sum_layout_node.h
+++ b/poincare/include/poincare/condensed_sum_layout_node.h
@@ -31,9 +31,9 @@ public:
   CondensedSumLayoutNode * failedAllocationStaticNode() override { return FailedAllocationStaticNode(); }
   size_t size() const override { return sizeof(CondensedSumLayoutNode); }
   int numberOfChildren() const override { return 3; }
-#if TREE_LOG
-  const char * description() const override {
-    return "CondensedSumLayout";
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "CondensedSumLayout";
   }
 #endif
 
diff --git a/poincare/include/poincare/conjugate_layout_node.h b/poincare/include/poincare/conjugate_layout_node.h
index 604aeb917..a35a3b849 100644
--- a/poincare/include/poincare/conjugate_layout_node.h
+++ b/poincare/include/poincare/conjugate_layout_node.h
@@ -22,9 +22,9 @@ public:
   ConjugateLayoutNode * failedAllocationStaticNode() override { return FailedAllocationStaticNode(); }
   size_t size() const override { return sizeof(ConjugateLayoutNode); }
   int numberOfChildren() const override { return 1; }
-#if TREE_LOG
-  const char * description() const override {
-    return "ConjugateLayout";
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "ConjugateLayout";
   }
 #endif
 
diff --git a/poincare/include/poincare/decimal.h b/poincare/include/poincare/decimal.h
index 4f7c7a2ca..b8c72bbca 100644
--- a/poincare/include/poincare/decimal.h
+++ b/poincare/include/poincare/decimal.h
@@ -30,8 +30,15 @@ public:
 
   // TreeNode
   size_t size() const override { return sizeof(DecimalNode); }
-#if TREE_LOG
-  const char * description() const override { return "Decimal";  }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "Decimal";
+  }
+  virtual void logAttributes(std::ostream & stream) const {
+    char buffer[256];
+    serialize(buffer, sizeof(buffer));
+    stream << " value=\"" << buffer << "\"";
+  }
 #endif
 
   // Properties
diff --git a/poincare/include/poincare/division.h b/poincare/include/poincare/division.h
index db35fe7b4..62c0ffcb5 100644
--- a/poincare/include/poincare/division.h
+++ b/poincare/include/poincare/division.h
@@ -17,10 +17,12 @@ public:
 
   // TreeNode
   size_t size() const override { return sizeof(DivisionNode); }
-#if TREE_LOG
-  const char * description() const override { return "Division";  }
-#endif
   int numberOfChildren() const override { return 2; }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "Division";
+  }
+#endif
 
   // Properties
   Type type() const override { return Type::Division; }
diff --git a/poincare/include/poincare/empty_layout_node.h b/poincare/include/poincare/empty_layout_node.h
index 87c8c94fe..7d75b4c6a 100644
--- a/poincare/include/poincare/empty_layout_node.h
+++ b/poincare/include/poincare/empty_layout_node.h
@@ -42,8 +42,10 @@ public:
   EmptyLayoutNode * failedAllocationStaticNode() override { return FailedAllocationStaticNode(); }
   size_t size() const override { return sizeof(EmptyLayoutNode); }
   int numberOfChildren() const override { return 0; }
-#if TREE_LOG
-  const char * description() const override { return "Empty"; }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "EmptyLayout";
+  }
 #endif
 
 protected:
diff --git a/poincare/include/poincare/float.h b/poincare/include/poincare/float.h
index a07f7aad6..5650db102 100644
--- a/poincare/include/poincare/float.h
+++ b/poincare/include/poincare/float.h
@@ -30,8 +30,13 @@ public:
 
   // TreeNode
   size_t size() const override { return sizeof(FloatNode<T>); }
-#if TREE_LOG
-  const char * description() const override { return "Float";  }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "Float";
+  }
+  virtual void logAttributes(std::ostream & stream) const {
+    stream << " value=\"" << m_value << "\"";
+  }
 #endif
 
   // Properties
diff --git a/poincare/include/poincare/floor_layout_node.h b/poincare/include/poincare/floor_layout_node.h
index 4fc57dcf6..b392af605 100644
--- a/poincare/include/poincare/floor_layout_node.h
+++ b/poincare/include/poincare/floor_layout_node.h
@@ -18,8 +18,10 @@ public:
   static FloorLayoutNode * FailedAllocationStaticNode();
   FloorLayoutNode * failedAllocationStaticNode() override { return FailedAllocationStaticNode(); }
   size_t size() const override { return sizeof(FloorLayoutNode); }
-#if TREE_LOG
-  const char * description() const override { return "FloorLayout"; }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "FloorLayout";
+  }
 #endif
 
 protected:
diff --git a/poincare/include/poincare/fraction_layout_node.h b/poincare/include/poincare/fraction_layout_node.h
index caf75c1cc..e14b60ceb 100644
--- a/poincare/include/poincare/fraction_layout_node.h
+++ b/poincare/include/poincare/fraction_layout_node.h
@@ -38,8 +38,10 @@ public:
   // TreeNode
   size_t size() const override { return sizeof(FractionLayoutNode); }
   int numberOfChildren() const override { return 2; }
-#if TREE_LOG
-  const char * description() const override { return "FractionLayout"; }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "FractionLayout";
+  }
 #endif
 
 protected:
diff --git a/poincare/include/poincare/ghost_node.h b/poincare/include/poincare/ghost_node.h
index bcf15fc17..1ec1e3b17 100644
--- a/poincare/include/poincare/ghost_node.h
+++ b/poincare/include/poincare/ghost_node.h
@@ -12,9 +12,12 @@ public:
   // TreeNode
   int numberOfChildren() const override { return 0; }
   size_t size() const override { return sizeof(GhostNode); }
-#if TREE_LOG
-  const char * description() const override { return "Ghost";  }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "Ghost";
+  }
 #endif
+
   // Ghost
   bool isGhost() const override { return true; }
   // Allocation Failure
diff --git a/poincare/include/poincare/horizontal_layout_node.h b/poincare/include/poincare/horizontal_layout_node.h
index 7434624bb..fbc7f5eca 100644
--- a/poincare/include/poincare/horizontal_layout_node.h
+++ b/poincare/include/poincare/horizontal_layout_node.h
@@ -43,8 +43,10 @@ public:
     m_numberOfChildren-= decrement;
   }
   void eraseNumberOfChildren() override { m_numberOfChildren = 0; }
-#if TREE_LOG
-  const char * description() const override { return "Horizontal Layout"; }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "HorizontalLayout";
+  }
 #endif
 
 protected:
diff --git a/poincare/include/poincare/infinity.h b/poincare/include/poincare/infinity.h
index 9ed773f12..eaf16e3ca 100644
--- a/poincare/include/poincare/infinity.h
+++ b/poincare/include/poincare/infinity.h
@@ -17,7 +17,7 @@ public:
   // TreeNode
   size_t size() const override { return sizeof(InfinityNode); }
 #if POINCARE_TREE_LOG
-  virtual void logNodeName(std::ostream stream) {
+  virtual void logNodeName(std::ostream & stream) const {
     stream << "Infinity";
   }
 #endif
diff --git a/poincare/include/poincare/integer.h b/poincare/include/poincare/integer.h
index 7657bdd81..bf265b9a6 100644
--- a/poincare/include/poincare/integer.h
+++ b/poincare/include/poincare/integer.h
@@ -133,8 +133,15 @@ public:
 
   // TreeNode
   size_t size() const override;
-#if TREE_LOG
-  const char * description() const override { return "Integer";  }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "Integer";
+  }
+  virtual void logAttributes(std::ostream & stream) const {
+    char buffer[256];
+    serialize(buffer, sizeof(buffer));
+    stream << " value=\"" << buffer << "\"";
+  }
 #endif
 
   // ExpressionNode
diff --git a/poincare/include/poincare/integral_layout_node.h b/poincare/include/poincare/integral_layout_node.h
index 2bc7039a1..23907c013 100644
--- a/poincare/include/poincare/integral_layout_node.h
+++ b/poincare/include/poincare/integral_layout_node.h
@@ -33,8 +33,10 @@ public:
   IntegralLayoutNode * failedAllocationStaticNode() override { return FailedAllocationStaticNode(); }
   size_t size() const override { return sizeof(IntegralLayoutNode); }
   int numberOfChildren() const override { return 3; }
-#if TREE_LOG
-  const char * description() const override { return "IntegralLayout"; }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "IntegralLayout";
+  }
 #endif
 
 protected:
diff --git a/poincare/include/poincare/left_parenthesis_layout_node.h b/poincare/include/poincare/left_parenthesis_layout_node.h
index f8d53ae3b..0aa0466c2 100644
--- a/poincare/include/poincare/left_parenthesis_layout_node.h
+++ b/poincare/include/poincare/left_parenthesis_layout_node.h
@@ -25,8 +25,10 @@ public:
   // TreeNode
   static LeftParenthesisLayoutNode * FailedAllocationStaticNode();
   LeftParenthesisLayoutNode * failedAllocationStaticNode() override { return FailedAllocationStaticNode(); }
-#if TREE_LOG
-  const char * description() const override { return "Left parenthesis"; }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "LeftParenthesisLayout";
+  }
 #endif
 
 protected:
diff --git a/poincare/include/poincare/left_square_bracket_layout_node.h b/poincare/include/poincare/left_square_bracket_layout_node.h
index a75d66e9c..74e807054 100644
--- a/poincare/include/poincare/left_square_bracket_layout_node.h
+++ b/poincare/include/poincare/left_square_bracket_layout_node.h
@@ -19,9 +19,12 @@ public:
   static LeftSquareBracketLayoutNode * FailedAllocationStaticNode();
   LeftSquareBracketLayoutNode * failedAllocationStaticNode() override { return FailedAllocationStaticNode(); }
   size_t size() const override { return sizeof(LeftSquareBracketLayoutNode); }
-#if TREE_LOG
-  const char * description() const override { return "LeftSquareBracketLayout"; }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "LeftSquareBracketLayout";
+  }
 #endif
+
 protected:
   void render(KDContext * ctx, KDPoint p, KDColor expressionColor, KDColor backgroundColor) override;
 };
diff --git a/poincare/include/poincare/matrix_complex.h b/poincare/include/poincare/matrix_complex.h
index 66d35d3c6..6664a307c 100644
--- a/poincare/include/poincare/matrix_complex.h
+++ b/poincare/include/poincare/matrix_complex.h
@@ -26,10 +26,16 @@ public:
 
   // TreeNode
   size_t size() const override { return sizeof(MatrixComplexNode<T>); }
-#if TREE_LOG
-  const char * description() const override { return "Evaluation matrix complex";  }
-#endif
   int numberOfChildren() const override { return m_numberOfRows*m_numberOfColumns; }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "MatrixComplex";
+  }
+  virtual void logAttributes(std::ostream & stream) const {
+    stream << " rows=\"" << m_numberOfRows << "\"";
+    stream << " columns=\"" << m_numberOfColumns << "\"";
+  }
+#endif
 
   // EvaluationNode
   typename EvaluationNode<T>::Type type() const override { return EvaluationNode<T>::Type::MatrixComplex; }
diff --git a/poincare/include/poincare/matrix_layout_node.h b/poincare/include/poincare/matrix_layout_node.h
index 160153d87..24bfebfd6 100644
--- a/poincare/include/poincare/matrix_layout_node.h
+++ b/poincare/include/poincare/matrix_layout_node.h
@@ -33,8 +33,10 @@ public:
   static MatrixLayoutNode * FailedAllocationStaticNode();
   MatrixLayoutNode * failedAllocationStaticNode() override { return FailedAllocationStaticNode(); }
   size_t size() const override { return sizeof(MatrixLayoutNode); }
-#if TREE_LOG
-  const char * description() const override { return "MatrixLayout"; }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "MatrixLayout";
+  }
 #endif
 
 protected:
diff --git a/poincare/include/poincare/multiplication.h b/poincare/include/poincare/multiplication.h
index 326ae49e3..74b21f221 100644
--- a/poincare/include/poincare/multiplication.h
+++ b/poincare/include/poincare/multiplication.h
@@ -23,8 +23,10 @@ public:
   static MultiplicationNode * FailedAllocationStaticNode();
   MultiplicationNode * failedAllocationStaticNode() override { return FailedAllocationStaticNode(); }
   size_t size() const override { return sizeof(MultiplicationNode); }
-#if TREE_LOG
-  const char * description() const override { return "Multiplication";  }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "Multiplication";
+  }
 #endif
 
   Type type() const override { return Type::Multiplication; }
diff --git a/poincare/include/poincare/nth_root_layout_node.h b/poincare/include/poincare/nth_root_layout_node.h
index cb4c6b12f..53e355aa2 100644
--- a/poincare/include/poincare/nth_root_layout_node.h
+++ b/poincare/include/poincare/nth_root_layout_node.h
@@ -35,8 +35,10 @@ public:
   NthRootLayoutNode * failedAllocationStaticNode() override { return FailedAllocationStaticNode(); }
   size_t size() const override { return sizeof(NthRootLayoutNode); }
   int numberOfChildren() const override { return m_hasIndex ? 2 : 1; }
-#if TREE_LOG
-  const char * description() const override { return "NthRootLayout"; }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "NthRootLayout";
+  }
 #endif
 
 protected:
diff --git a/poincare/include/poincare/opposite.h b/poincare/include/poincare/opposite.h
index 3900dab20..3693bd943 100644
--- a/poincare/include/poincare/opposite.h
+++ b/poincare/include/poincare/opposite.h
@@ -18,10 +18,12 @@ public:
 
   // TreeNode
   size_t size() const override { return sizeof(OppositeNode); }
-#if TREE_LOG
-  const char * description() const override { return "Opposite";  }
-#endif
   int numberOfChildren() const override { return 0; }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "Opposite";
+  }
+#endif
 
   // Properties
   Type type() const override { return Type::Opposite; }
diff --git a/poincare/include/poincare/parenthesis.h b/poincare/include/poincare/parenthesis.h
index c6e17edae..4ecfe349a 100644
--- a/poincare/include/poincare/parenthesis.h
+++ b/poincare/include/poincare/parenthesis.h
@@ -13,10 +13,12 @@ public:
 
   // TreeNode
   size_t size() const override { return sizeof(ParenthesisNode); }
-#if TREE_LOG
-  const char * description() const override { return "Parenthesis";  }
-#endif
   int numberOfChildren() const override { return 1; }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "Parenthesis";
+  }
+#endif
 
   // Properties
   Type type() const override { return Type::Parenthesis; }
diff --git a/poincare/include/poincare/power.h b/poincare/include/poincare/power.h
index 5a7ca24dc..fedee40c2 100644
--- a/poincare/include/poincare/power.h
+++ b/poincare/include/poincare/power.h
@@ -18,10 +18,12 @@ public:
 
   // TreeNode
   size_t size() const override { return sizeof(PowerNode); }
-#if TREE_LOG
-  const char * description() const override { return "Power";  }
-#endif
   int numberOfChildren() const override { return 2; }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "Power";
+  }
+#endif
 
   // Properties
   Type type() const override { return Type::Power; }
diff --git a/poincare/include/poincare/product_layout_node.h b/poincare/include/poincare/product_layout_node.h
index f5b4ca7ba..32188cf0b 100644
--- a/poincare/include/poincare/product_layout_node.h
+++ b/poincare/include/poincare/product_layout_node.h
@@ -13,8 +13,10 @@ public:
   static ProductLayoutNode * FailedAllocationStaticNode();
   ProductLayoutNode * failedAllocationStaticNode() override { return FailedAllocationStaticNode(); }
   size_t size() const override { return sizeof(ProductLayoutNode); }
-#if TREE_LOG
-  const char * description() const override { return "ProductLayout"; }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "ProductLayout";
+  }
 #endif
 
 protected:
diff --git a/poincare/include/poincare/rational.h b/poincare/include/poincare/rational.h
index 0c4799d5f..afcbf9065 100644
--- a/poincare/include/poincare/rational.h
+++ b/poincare/include/poincare/rational.h
@@ -23,8 +23,10 @@ public:
 
   // TreeNode
   size_t size() const override;
-#if TREE_LOG
-  const char * description() const override { return "Rational";  }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "Rational";
+  }
 #endif
 
   // SerializationHelperInterface
diff --git a/poincare/include/poincare/right_parenthesis_layout_node.h b/poincare/include/poincare/right_parenthesis_layout_node.h
index ededac7df..d38fd511b 100644
--- a/poincare/include/poincare/right_parenthesis_layout_node.h
+++ b/poincare/include/poincare/right_parenthesis_layout_node.h
@@ -26,8 +26,10 @@ public:
   static RightParenthesisLayoutNode * FailedAllocationStaticNode();
   RightParenthesisLayoutNode * failedAllocationStaticNode() override { return FailedAllocationStaticNode(); }
   size_t size() const override { return sizeof(RightParenthesisLayoutNode); }
-#if TREE_LOG
-  const char * description() const override { return "RightParenthesisLayout"; }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "RightParenthesisLayout";
+  }
 #endif
 
 protected:
diff --git a/poincare/include/poincare/right_square_bracket_layout_node.h b/poincare/include/poincare/right_square_bracket_layout_node.h
index 97abbae01..1ba3897f9 100644
--- a/poincare/include/poincare/right_square_bracket_layout_node.h
+++ b/poincare/include/poincare/right_square_bracket_layout_node.h
@@ -19,8 +19,10 @@ public:
   static RightSquareBracketLayoutNode * FailedAllocationStaticNode();
   RightSquareBracketLayoutNode * failedAllocationStaticNode() override { return FailedAllocationStaticNode(); }
   size_t size() const override { return sizeof(RightSquareBracketLayoutNode); }
-#if TREE_LOG
-  const char * description() const override { return "RightSquareBracketLayout"; }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "RightSquareBracketLayout";
+  }
 #endif
 
 protected:
diff --git a/poincare/include/poincare/sequence_layout_node.h b/poincare/include/poincare/sequence_layout_node.h
index eb4d7ac09..f8c65408f 100644
--- a/poincare/include/poincare/sequence_layout_node.h
+++ b/poincare/include/poincare/sequence_layout_node.h
@@ -27,11 +27,7 @@ public:
   char XNTChar() const override { return 'n'; }
 
   // TreeNode
-  size_t size() const override { return sizeof(SequenceLayoutNode); }
   int numberOfChildren() const override { return 3; }
-#if TREE_LOG
-  const char * description() const override { return "Sequence Layout"; }
-#endif
 
 protected:
   constexpr static KDCoordinate k_boundHeightMargin = 2;
diff --git a/poincare/include/poincare/subtraction.h b/poincare/include/poincare/subtraction.h
index 6bf724efa..89f474fe7 100644
--- a/poincare/include/poincare/subtraction.h
+++ b/poincare/include/poincare/subtraction.h
@@ -14,8 +14,12 @@ public:
 
   // TreeNode
   size_t size() const override { return sizeof(SubtractionNode); }
-  const char * description() const override { return "Subtraction";  }
   int numberOfChildren() const override { return 2; }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "Subtraction";
+  }
+#endif
 
   // ExpressionNode
 
diff --git a/poincare/include/poincare/sum_layout_node.h b/poincare/include/poincare/sum_layout_node.h
index 7c6276902..8207ad03f 100644
--- a/poincare/include/poincare/sum_layout_node.h
+++ b/poincare/include/poincare/sum_layout_node.h
@@ -12,6 +12,13 @@ public:
   int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
   static SumLayoutNode * FailedAllocationStaticNode();
   SumLayoutNode * failedAllocationStaticNode() override { return FailedAllocationStaticNode(); }
+  size_t size() const override { return sizeof(SumLayoutNode); }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "SumLayout";
+  }
+#endif
+
 private:
   void render(KDContext * ctx, KDPoint p, KDColor expressionColor, KDColor backgroundColor) override;
 };
diff --git a/poincare/include/poincare/symbol.h b/poincare/include/poincare/symbol.h
index 8f2d9ff18..ec1261aec 100644
--- a/poincare/include/poincare/symbol.h
+++ b/poincare/include/poincare/symbol.h
@@ -18,10 +18,12 @@ public:
 
   // TreeNode
   size_t size() const override { return sizeof(SymbolNode); }
-#if TREE_LOG
-  const char * description() const override { return "Symbol";  }
-#endif
   int numberOfChildren() const override { return 0; }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "Symbol";
+  }
+#endif
 
   // Expression Properties
   Type type() const override { return Type::Symbol; }
diff --git a/poincare/include/poincare/tree_by_value.h b/poincare/include/poincare/tree_by_value.h
index 75b7e61e8..79e7f96bf 100644
--- a/poincare/include/poincare/tree_by_value.h
+++ b/poincare/include/poincare/tree_by_value.h
@@ -59,6 +59,11 @@ protected:
   void addChildAtIndexInPlace(TreeByValue t, int index, int currentNumberOfChildren) {
     TreeByReference::addChildAtIndexInPlace(t, index, currentNumberOfChildren);
   }
+  /*
+private:
+  // Fix 
+  using TreeByReference::addChildAtIndexInPlace;
+  */
 };
 
 }
diff --git a/poincare/include/poincare/tree_node.h b/poincare/include/poincare/tree_node.h
index f06302670..8e1308055 100644
--- a/poincare/include/poincare/tree_node.h
+++ b/poincare/include/poincare/tree_node.h
@@ -1,18 +1,20 @@
 #ifndef POINCARE_TREE_NODE_H
 #define POINCARE_TREE_NODE_H
 
+#define POINCARE_TREE_LOG 1
+
 #include <assert.h>
 #include <stddef.h>
 #include <strings.h>
-
-#include <stdio.h>
+#if POINCARE_TREE_LOG
+#include <ostream>
+#endif
 
 /* What's in a TreeNode, really?
  *  - a vtable pointer
  *  - an identifier
  *  - a reference counter
  */
-#define TREE_LOG 0
 
 namespace Poincare {
 
@@ -41,8 +43,6 @@ public:
     }
   }
 
-  virtual const char * description() const { return "UNKNOWN";}
-
   // Ghost
   virtual bool isGhost() const { return false; }
 
@@ -153,11 +153,11 @@ public:
   }
 
 #if POINCARE_TREE_LOG
-  virtual void logNodeName(std::ostream stream) = 0;
-  virtual void logAttributes(std::ostream stream) {
+  virtual void logNodeName(std::ostream & stream) const = 0;
+  virtual void logAttributes(std::ostream & stream) const {
   }
 
-  void log(std::ostream stream, bool recursive = true) {
+  void log(std::ostream & stream, bool recursive = true) {
     stream << "<";
     logNodeName(stream);
     stream << " id=\"" << m_identifier << "\"";
@@ -166,13 +166,13 @@ public:
     logAttributes(stream);
     stream << ">";
     if (recursive) {
-      for (TreeNode * child : node->depthFirstChildren()) {
-        t->log(stream, recursive);
+      for (TreeNode * child : depthFirstChildren()) {
+        child->log(stream, recursive);
       }
     }
     stream << "</";
     logNodeName(stream);
-    stream << ">"
+    stream << ">";
   }
 #endif
 
diff --git a/poincare/include/poincare/tree_pool.h b/poincare/include/poincare/tree_pool.h
index 071829ead..30ffed028 100644
--- a/poincare/include/poincare/tree_pool.h
+++ b/poincare/include/poincare/tree_pool.h
@@ -98,8 +98,8 @@ void TreeByReference::buildGhostChildren() {
   }
 
 #if POINCARE_TREE_LOG
-  void flatLog(std::ostream stream);
-  void treeLog(std::ostream stream);
+  void flatLog(std::ostream & stream);
+  void treeLog(std::ostream & stream);
 #endif
 
   int numberOfNodes() const {
diff --git a/poincare/include/poincare/undefined.h b/poincare/include/poincare/undefined.h
index 1427b6ae6..e5e4c0470 100644
--- a/poincare/include/poincare/undefined.h
+++ b/poincare/include/poincare/undefined.h
@@ -13,8 +13,10 @@ public:
 
   // TreeNode
   size_t size() const override { return sizeof(UndefinedNode); }
-#if TREE_LOG
-  const char * description() const override { return "Undefined";  }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "Undefined";
+  }
 #endif
 
   // Properties
diff --git a/poincare/include/poincare/vertical_offset_layout_node.h b/poincare/include/poincare/vertical_offset_layout_node.h
index b9c67c068..7bf8634f1 100644
--- a/poincare/include/poincare/vertical_offset_layout_node.h
+++ b/poincare/include/poincare/vertical_offset_layout_node.h
@@ -40,9 +40,9 @@ public:
   // TreeNode
   size_t size() const override { return sizeof(VerticalOffsetLayoutNode); }
   int numberOfChildren() const override { return 1; }
-#if TREE_LOG
-  const char * description() const override {
-    return m_type == Type::Subscript ? "Subscript" : "Superscript";
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << (m_type == Type::Subscript ? "Subscript" : "Superscript");
   }
 #endif
 
diff --git a/poincare/src/tree_pool.cpp b/poincare/src/tree_pool.cpp
index 7cca0e7a4..038e8a178 100644
--- a/poincare/src/tree_pool.cpp
+++ b/poincare/src/tree_pool.cpp
@@ -2,10 +2,6 @@
 #include <string.h>
 #include <stdint.h>
 
-#if POINCARE_TREE_LOG
-#include <iostream>
-#endif
-
 namespace Poincare {
 
 TreePool * TreePool::sharedPool() {
@@ -99,8 +95,8 @@ void TreePool::moveNodes(TreeNode * destination, TreeNode * source, size_t moveS
 }
 
 #if POINCARE_TREE_LOG
-void TreePool::flatLog(std::ostream stream) {
-  size_t size static_cast<char *>(m_cursor) - static_cast<char *>(m_buffer);
+void TreePool::flatLog(std::ostream & stream) {
+  size_t size = static_cast<char *>(m_cursor) - static_cast<char *>(m_buffer);
   stream << "<TreePool format=\"flat\" size=\"" << size << "\">";
   for (TreeNode * node : allNodes()) {
     node->log(stream, false);
@@ -108,7 +104,7 @@ void TreePool::flatLog(std::ostream stream) {
   stream << "</TreePool>";
 }
 
-void TreePool::treeLog() {
+void TreePool::treeLog(std::ostream & stream) {
   stream << "<TreePool format=\"tree\" size=\"" << (int)(m_cursor-m_buffer) << "\">";
   for (TreeNode * node : roots()) {
     node->log(stream, true);
diff --git a/poincare/test/tree/blob_node.h b/poincare/test/tree/blob_node.h
index 63acadc7c..0b14b7be6 100644
--- a/poincare/test/tree/blob_node.h
+++ b/poincare/test/tree/blob_node.h
@@ -22,6 +22,11 @@ public:
   int data() { return m_data; }
   void setData(int data) { m_data = data; }
   virtual int numberOfChildren() const override { return 0; }
+  #if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "Blob";
+  }
+#endif
 private:
   int m_data;
 };
diff --git a/poincare/test/tree/pair_node.h b/poincare/test/tree/pair_node.h
new file mode 100644
index 000000000..fff8d08c4
--- /dev/null
+++ b/poincare/test/tree/pair_node.h
@@ -0,0 +1,51 @@
+#ifndef POINCARE_TEST_PAIR_NODE_H
+#define POINCARE_TEST_PAIR_NODE_H
+
+#include <poincare/tree_node.h>
+#include <poincare/allocation_failure_node.h>
+#include <poincare/tree_by_reference.h>
+#include <poincare/tree_by_value.h>
+
+namespace Poincare {
+
+
+class PairNode : public TreeNode {
+public:
+  static PairNode * FailedAllocationStaticNode() {
+    static AllocationFailureNode<PairNode> failureNode;
+    return &failureNode;
+  }
+  virtual PairNode * failedAllocationStaticNode() override {
+    return PairNode::FailedAllocationStaticNode();
+  }
+  virtual size_t size() const override { return sizeof(PairNode); }
+  virtual int numberOfChildren() const override { return 2; }
+#if POINCARE_TREE_LOG
+  virtual void logNodeName(std::ostream & stream) const {
+    stream << "Pair";
+  }
+#endif
+};
+
+
+class PairByReference : public TreeByReference {
+public:
+  PairByReference(TreeByReference t1, TreeByReference t2) : TreeByReference(TreePool::sharedPool()->createTreeNode<PairNode>()) {
+    replaceChildAtIndexInPlace(0, t1); // TODO: Is that the correct way to do this?
+    replaceChildAtIndexInPlace(1, t2); // TODO: Is that the correct way to do this?
+  }
+};
+
+
+class PairByValue : public TreeByValue {
+public:
+  PairByValue(TreeByValue t1, TreeByValue t2) : TreeByValue(TreePool::sharedPool()->createTreeNode<PairNode>()) {
+    replaceChildAtIndexInPlace(0, t1);
+    replaceChildAtIndexInPlace(1, t2);
+  }
+};
+
+
+}
+
+#endif
diff --git a/poincare/test/tree/tree_by_value.cpp b/poincare/test/tree/tree_by_value.cpp
index aa2a82b00..6d206065c 100644
--- a/poincare/test/tree/tree_by_value.cpp
+++ b/poincare/test/tree/tree_by_value.cpp
@@ -3,6 +3,7 @@
 #include <assert.h>
 
 #include "blob_node.h"
+#include "pair_node.h"
 
 using namespace Poincare;
 
@@ -23,6 +24,15 @@ QUIZ_CASE(tree_by_values_are_stored_in_pool) {
   assert_pool_size(0);
 }
 
+TreeByValue blob_with_data_3() {
+  return BlobByValue(3);
+}
+QUIZ_CASE(tree_by_values_can_be_returned) {
+  assert_pool_size(0);
+  TreeByValue b = blob_with_data_3();
+  assert_pool_size(1);
+}
+
 QUIZ_CASE(tree_by_values_allocation_failures) {
   assert_pool_size(0);
   BlobByValue b(1);
@@ -34,3 +44,13 @@ QUIZ_CASE(tree_by_values_allocation_failures) {
   }
   assert_pool_size(1);
 }
+
+QUIZ_CASE(tree_by_value_deep_copies) {
+  assert_pool_size(0);
+  BlobByValue b1(1);
+  BlobByValue b2(2);
+  PairByValue p(b1, b2);
+  assert_pool_size(3);
+  PairByValue p2 = p;
+  assert_pool_size(6);
+}