diff --git a/apps/sequence/sequence.cpp b/apps/sequence/sequence.cpp
index 9ef1b7cb1..82b1a2d1c 100644
--- a/apps/sequence/sequence.cpp
+++ b/apps/sequence/sequence.cpp
@@ -15,12 +15,12 @@ using namespace Poincare;
 namespace Sequence {
 
 void Sequence::tidy() {
-  m_definitionHandle.tidyName();
+  m_definition.tidyName();
   Function::tidy(); // m_definitionName.tidy()
-  m_firstInitialConditionHandle.tidy();
-  m_firstInitialConditionHandle.tidyName();
-  m_secondInitialConditionHandle.tidy();
-  m_secondInitialConditionHandle.tidyName();
+  m_firstInitialCondition.tidy();
+  m_firstInitialCondition.tidyName();
+  m_secondInitialCondition.tidy();
+  m_secondInitialCondition.tidyName();
   m_nameLayout = Layout();
 }
 
@@ -69,8 +69,8 @@ void Sequence::setType(Type t) {
 
 void Sequence::setInitialRank(int rank) {
   recordData()->setInitialRank(rank);
-  m_firstInitialConditionHandle.tidyName();
-  m_secondInitialConditionHandle.tidyName();
+  m_firstInitialCondition.tidyName();
+  m_secondInitialCondition.tidyName();
 }
 
 Poincare::Layout Sequence::nameLayout() {
@@ -193,14 +193,14 @@ Sequence::SequenceRecordData * Sequence::recordData() const {
 
 /* Sequence Handle */
 
-Poincare::Layout Sequence::SequenceHandle::name(Sequence * sequence) {
+Poincare::Layout Sequence::SequenceModel::name(Sequence * sequence) {
   if (m_name.isUninitialized()) {
     buildName(sequence);
   }
   return m_name;
 }
 
-void Sequence::SequenceHandle::updateNewDataWithExpression(Ion::Storage::Record * record, Expression & expressionToStore, void * expressionAddress, size_t newExpressionSize, size_t previousExpressionSize) {
+void Sequence::SequenceModel::updateNewDataWithExpression(Ion::Storage::Record * record, Expression & expressionToStore, void * expressionAddress, size_t newExpressionSize, size_t previousExpressionSize) {
   Ion::Storage::Record::Data newData = record->value();
   // Translate expressions located downstream
   size_t sizeBeforeExpression = (char *)expressionAddress -(char *)newData.buffer;
@@ -216,17 +216,17 @@ void Sequence::SequenceHandle::updateNewDataWithExpression(Ion::Storage::Record
 
 /* Definition Handle*/
 
-void * Sequence::DefinitionHandle::expressionAddress(const Ion::Storage::Record * record) const {
+void * Sequence::DefinitionModel::expressionAddress(const Ion::Storage::Record * record) const {
   return (char *)record->value().buffer+sizeof(SequenceRecordData);
 }
 
-size_t Sequence::DefinitionHandle::expressionSize(const Ion::Storage::Record * record) const {
+size_t Sequence::DefinitionModel::expressionSize(const Ion::Storage::Record * record) const {
   Ion::Storage::Record::Data data = record->value();
   SequenceRecordData * dataBuffer = static_cast<const Sequence *>(record)->recordData();
   return data.size-sizeof(SequenceRecordData) - dataBuffer->firstInitialConditionSize() - dataBuffer->secondInitialConditionSize();
 }
 
-void Sequence::DefinitionHandle::buildName(Sequence * sequence) {
+void Sequence::DefinitionModel::buildName(Sequence * sequence) {
   char name = sequence->fullName()[0];
   if (sequence->type() == Type::Explicit) {
     m_name = HorizontalLayout::Builder(
@@ -246,22 +246,22 @@ void Sequence::DefinitionHandle::buildName(Sequence * sequence) {
 
 /* First Initial Condition Handle*/
 
-void * Sequence::FirstInitialConditionHandle::expressionAddress(const Ion::Storage::Record * record) const {
+void * Sequence::FirstInitialConditionModel::expressionAddress(const Ion::Storage::Record * record) const {
   Ion::Storage::Record::Data data = record->value();
   SequenceRecordData * dataBuffer = static_cast<const Sequence *>(record)->recordData();
   size_t offset = data.size - dataBuffer->firstInitialConditionSize() - dataBuffer->secondInitialConditionSize();
   return (char *)data.buffer+offset;
 }
 
-size_t Sequence::FirstInitialConditionHandle::expressionSize(const Ion::Storage::Record * record) const {
+size_t Sequence::FirstInitialConditionModel::expressionSize(const Ion::Storage::Record * record) const {
   return static_cast<const Sequence *>(record)->recordData()->firstInitialConditionSize();
 }
 
-void Sequence::FirstInitialConditionHandle::updateMetaData(const Ion::Storage::Record * record, size_t newSize) {
+void Sequence::FirstInitialConditionModel::updateMetaData(const Ion::Storage::Record * record, size_t newSize) {
   static_cast<const Sequence *>(record)->recordData()->setFirstInitialConditionSize(newSize);
 }
 
-void Sequence::FirstInitialConditionHandle::buildName(Sequence * sequence) {
+void Sequence::FirstInitialConditionModel::buildName(Sequence * sequence) {
   assert(sequence->type() == Type::SingleRecurrence || sequence->type() == Type::DoubleRecurrence);
   char buffer[k_initialRankNumberOfDigits+1];
   Integer(sequence->initialRank()).serialize(buffer, k_initialRankNumberOfDigits+1);
@@ -273,22 +273,22 @@ void Sequence::FirstInitialConditionHandle::buildName(Sequence * sequence) {
 
 /* Second Initial Condition Handle*/
 
-void * Sequence::SecondInitialConditionHandle::expressionAddress(const Ion::Storage::Record * record) const {
+void * Sequence::SecondInitialConditionModel::expressionAddress(const Ion::Storage::Record * record) const {
   Ion::Storage::Record::Data data = record->value();
   SequenceRecordData * dataBuffer = static_cast<const Sequence *>(record)->recordData();
   size_t offset = data.size - dataBuffer->secondInitialConditionSize();
   return (char *)data.buffer+offset;
 }
 
-void Sequence::SecondInitialConditionHandle::updateMetaData(const Ion::Storage::Record * record, size_t newSize) {
+void Sequence::SecondInitialConditionModel::updateMetaData(const Ion::Storage::Record * record, size_t newSize) {
   static_cast<const Sequence *>(record)->recordData()->setSecondInitialConditionSize(newSize);
 }
 
-size_t Sequence::SecondInitialConditionHandle::expressionSize(const Ion::Storage::Record * record) const {
+size_t Sequence::SecondInitialConditionModel::expressionSize(const Ion::Storage::Record * record) const {
   return static_cast<const Sequence *>(record)->recordData()->secondInitialConditionSize();
 }
 
-void Sequence::SecondInitialConditionHandle::buildName(Sequence * sequence) {
+void Sequence::SecondInitialConditionModel::buildName(Sequence * sequence) {
   assert(sequence->type() == Type::DoubleRecurrence);
   char buffer[k_initialRankNumberOfDigits+1];
   Integer(sequence->initialRank()+1).serialize(buffer, k_initialRankNumberOfDigits+1);
diff --git a/apps/sequence/sequence.h b/apps/sequence/sequence.h
index 263c7aa41..ec9708427 100644
--- a/apps/sequence/sequence.h
+++ b/apps/sequence/sequence.h
@@ -31,22 +31,22 @@ public:
   void setType(Type type);
   void setInitialRank(int rank);
   // Definition
-  Poincare::Layout definitionName() { return m_definitionHandle.name(this); }
-  Ion::Storage::Record::ErrorStatus setContent(const char * c) override { return editableHandle()->setContent(this, c, Symbol(), Poincare::Symbol::SpecialSymbols::UnknownN); }
+  Poincare::Layout definitionName() { return m_definition.name(this); }
+  Ion::Storage::Record::ErrorStatus setContent(const char * c) override { return editableModel()->setContent(this, c, Symbol(), Poincare::Symbol::SpecialSymbols::UnknownN); }
   // First initial condition
-  Poincare::Layout firstInitialConditionName() { return m_firstInitialConditionHandle.name(this); }
-  void firstInitialConditionText(char * buffer, size_t bufferSize) const { return m_firstInitialConditionHandle.text(this, buffer, bufferSize); }
-  Poincare::Expression firstInitialConditionExpressionReduced(Poincare::Context * context) const { return m_firstInitialConditionHandle.expressionReduced(this, context); }
-  Poincare::Expression firstInitialConditionExpressionClone() const { return m_firstInitialConditionHandle.expressionClone(this); }
-  Poincare::Layout firstInitialConditionLayout() { return m_firstInitialConditionHandle.layout(this); }
-  Ion::Storage::Record::ErrorStatus setFirstInitialConditionContent(const char * c) { return m_firstInitialConditionHandle.setContent(this, c); }
+  Poincare::Layout firstInitialConditionName() { return m_firstInitialCondition.name(this); }
+  void firstInitialConditionText(char * buffer, size_t bufferSize) const { return m_firstInitialCondition.text(this, buffer, bufferSize); }
+  Poincare::Expression firstInitialConditionExpressionReduced(Poincare::Context * context) const { return m_firstInitialCondition.expressionReduced(this, context); }
+  Poincare::Expression firstInitialConditionExpressionClone() const { return m_firstInitialCondition.expressionClone(this); }
+  Poincare::Layout firstInitialConditionLayout() { return m_firstInitialCondition.layout(this); }
+  Ion::Storage::Record::ErrorStatus setFirstInitialConditionContent(const char * c) { return m_firstInitialCondition.setContent(this, c); }
   // Second initial condition
-  Poincare::Layout secondInitialConditionName() { return m_secondInitialConditionHandle.name(this); }
-  void secondInitialConditionText(char * buffer, size_t bufferSize) const { return m_secondInitialConditionHandle.text(this, buffer, bufferSize); }
-  Poincare::Expression secondInitialConditionExpressionReduced(Poincare::Context * context) const { return m_secondInitialConditionHandle.expressionReduced(this, context); }
-  Poincare::Expression secondInitialConditionExpressionClone() const { return m_secondInitialConditionHandle.expressionClone(this); }
-  Poincare::Layout secondInitialConditionLayout() { return m_secondInitialConditionHandle.layout(this); }
-  Ion::Storage::Record::ErrorStatus setSecondInitialConditionContent(const char * c) { return m_secondInitialConditionHandle.setContent(this, c); }
+  Poincare::Layout secondInitialConditionName() { return m_secondInitialCondition.name(this); }
+  void secondInitialConditionText(char * buffer, size_t bufferSize) const { return m_secondInitialCondition.text(this, buffer, bufferSize); }
+  Poincare::Expression secondInitialConditionExpressionReduced(Poincare::Context * context) const { return m_secondInitialCondition.expressionReduced(this, context); }
+  Poincare::Expression secondInitialConditionExpressionClone() const { return m_secondInitialCondition.expressionClone(this); }
+  Poincare::Layout secondInitialConditionLayout() { return m_secondInitialCondition.layout(this); }
+  Ion::Storage::Record::ErrorStatus setSecondInitialConditionContent(const char * c) { return m_secondInitialCondition.setContent(this, c); }
 
   // Sequence properties
   int numberOfElements() { return (int)type() + 1; }
@@ -94,9 +94,9 @@ private:
     uint16_t m_secondInitialConditionSize;
   };
 
-  class SequenceHandle : public Shared::ExpressionModel {
+  class SequenceModel : public Shared::ExpressionModel {
   public:
-    SequenceHandle() : Shared::ExpressionModel(), m_name() {}
+    SequenceModel() : Shared::ExpressionModel(), m_name() {}
     void tidyName() { m_name = Poincare::Layout(); }
     virtual Poincare::Layout name(Sequence * sequence);
   protected:
@@ -107,7 +107,7 @@ private:
     virtual void updateMetaData(const Ion::Storage::Record * record, size_t newSize) {}
   };
 
-  class DefinitionHandle : public SequenceHandle {
+  class DefinitionModel : public SequenceModel {
   public:
     void * expressionAddress(const Ion::Storage::Record * record) const override;
   private:
@@ -115,7 +115,7 @@ private:
     void buildName(Sequence * sequence) override;
   };
 
-  class FirstInitialConditionHandle : public SequenceHandle {
+  class FirstInitialConditionModel : public SequenceModel {
   public:
     void * expressionAddress(const Ion::Storage::Record * record) const override;
   private:
@@ -124,7 +124,7 @@ private:
     void buildName(Sequence * sequence) override;
   };
 
-  class SecondInitialConditionHandle : public SequenceHandle {
+  class SecondInitialConditionModel : public SequenceModel {
   public:
     void * expressionAddress(const Ion::Storage::Record * record) const override;
   private:
@@ -135,11 +135,11 @@ private:
 
   template<typename T> T templatedApproximateAtAbscissa(T x, SequenceContext * sqctx) const;
   size_t metaDataSize() const override { return sizeof(SequenceRecordData); }
-  const Shared::ExpressionModel * handle() const override { return &m_definitionHandle; }
+  const Shared::ExpressionModel * model() const override { return &m_definition; }
   SequenceRecordData * recordData() const;
-  DefinitionHandle m_definitionHandle;
-  FirstInitialConditionHandle m_firstInitialConditionHandle;
-  SecondInitialConditionHandle m_secondInitialConditionHandle;
+  DefinitionModel m_definition;
+  FirstInitialConditionModel m_firstInitialCondition;
+  SecondInitialConditionModel m_secondInitialCondition;
   Poincare::Layout m_nameLayout;
 };
 
diff --git a/apps/shared/cartesian_function.h b/apps/shared/cartesian_function.h
index dae3a19a3..2b56b8aa5 100644
--- a/apps/shared/cartesian_function.h
+++ b/apps/shared/cartesian_function.h
@@ -15,7 +15,7 @@ public:
   CartesianFunction(Ion::Storage::Record record = Record()) :
     Function(record)
   {}
-  Ion::Storage::Record::ErrorStatus setContent(const char * c) override { return editableHandle()->setContent(this, c, Symbol(), Poincare::Symbol::SpecialSymbols::UnknownX); }
+  Ion::Storage::Record::ErrorStatus setContent(const char * c) override { return editableModel()->setContent(this, c, Symbol(), Poincare::Symbol::SpecialSymbols::UnknownX); }
 
   // Derivative
   bool displayDerivative() const;
@@ -52,7 +52,7 @@ private:
     size_t expressionSize(const Ion::Storage::Record * record) const override;
   };
   size_t metaDataSize() const override { return sizeof(CartesianFunctionRecordData); }
-  const ExpressionModel * handle() const override { return &m_model; }
+  const ExpressionModel * model() const override { return &m_model; }
   CartesianFunctionRecordData * recordData() const;
   Model m_model;
 };
diff --git a/apps/shared/expression_model_handle.h b/apps/shared/expression_model_handle.h
index 0dc368cfa..64878a353 100644
--- a/apps/shared/expression_model_handle.h
+++ b/apps/shared/expression_model_handle.h
@@ -12,10 +12,10 @@ public:
   ExpressionModelHandle(Ion::Storage::Record record = Ion::Storage::Record());
 
   // Property
-  void text(char * buffer, size_t bufferSize) const { return handle()->text(this, buffer, bufferSize); }
-  Poincare::Expression expressionReduced(Poincare::Context * context) const { return handle()->expressionReduced(this, context); }
-  Poincare::Expression expressionClone() const { return handle()->expressionClone(this); }
-  Poincare::Layout layout() { return handle()->layout(this); }
+  void text(char * buffer, size_t bufferSize) const { return model()->text(this, buffer, bufferSize); }
+  Poincare::Expression expressionReduced(Poincare::Context * context) const { return model()->expressionReduced(this, context); }
+  Poincare::Expression expressionClone() const { return model()->expressionClone(this); }
+  Poincare::Layout layout() { return model()->layout(this); }
    /* Here, isDefined is the exact contrary of isEmpty. However, for Sequence
    * inheriting from ExpressionModelHandle, isEmpty and isDefined have not exactly
    * opposite meaning. For instance, u(n+1)=u(n) & u(0) = ... is not empty and
@@ -28,13 +28,13 @@ public:
    * ExpressionModel, tidy and tidyExpressionModel trigger the same
    * behaviour but it is not true for its child classes (for example, in
    * Sequence). */
-  virtual void tidy() { handle()->tidy(); }
-  virtual Ion::Storage::Record::ErrorStatus setContent(const char * c) { return editableHandle()->setContent(this, c); }
-  Ion::Storage::Record::ErrorStatus setExpressionContent(Poincare::Expression & e) { return editableHandle()->setExpressionContent(this, e); }
+  virtual void tidy() { model()->tidy(); }
+  virtual Ion::Storage::Record::ErrorStatus setContent(const char * c) { return editableModel()->setContent(this, c); }
+  Ion::Storage::Record::ErrorStatus setExpressionContent(Poincare::Expression & e) { return editableModel()->setExpressionContent(this, e); }
 protected:
-  bool isCircularlyDefined(Poincare::Context * context) const { return handle()->isCircularlyDefined(this, context); }
-  ExpressionModel * editableHandle() { return const_cast<ExpressionModel *>(handle()); }
-  virtual const ExpressionModel * handle() const = 0;
+  bool isCircularlyDefined(Poincare::Context * context) const { return model()->isCircularlyDefined(this, context); }
+  ExpressionModel * editableModel() { return const_cast<ExpressionModel *>(model()); }
+  virtual const ExpressionModel * model() const = 0;
   virtual size_t metaDataSize() const = 0;
 };
 
diff --git a/apps/solver/equation.cpp b/apps/solver/equation.cpp
index 20ed34a41..583deaf7f 100644
--- a/apps/solver/equation.cpp
+++ b/apps/solver/equation.cpp
@@ -21,7 +21,7 @@ bool Equation::containsIComplex(Context * context) const {
   return expressionClone().recursivelyMatches([](const Expression e, Context & context, bool replaceSymbols) { return e.type() == ExpressionNode::Type::Constant && static_cast<const Constant &>(e).isIComplex(); }, *context, true);
 }
 
-Expression Equation::Handle::standardForm(const Storage::Record * record, Context * context) const {
+Expression Equation::Model::standardForm(const Storage::Record * record, Context * context) const {
   if (m_standardForm.isUninitialized()) {
     const Expression e = expressionReduced(record, context);
     if (e.type() == ExpressionNode::Type::Unreal) {
@@ -44,17 +44,17 @@ Expression Equation::Handle::standardForm(const Storage::Record * record, Contex
   return m_standardForm;
 }
 
-void Equation::Handle::tidy() const {
+void Equation::Model::tidy() const {
   ExpressionModel::tidy();
   // Free the pool of the m_standardForm
   m_standardForm = Expression();
 }
 
-void * Equation::Handle::expressionAddress(const Ion::Storage::Record * record) const {
+void * Equation::Model::expressionAddress(const Ion::Storage::Record * record) const {
   return (char *)record->value().buffer;
 }
 
-size_t Equation::Handle::expressionSize(const Ion::Storage::Record * record) const {
+size_t Equation::Model::expressionSize(const Ion::Storage::Record * record) const {
   return record->value().size;
 }
 
diff --git a/apps/solver/equation.h b/apps/solver/equation.h
index d112d2a3d..5cf5df70f 100644
--- a/apps/solver/equation.h
+++ b/apps/solver/equation.h
@@ -11,11 +11,11 @@ public:
   bool shouldBeClearedBeforeRemove() override {
     return false;
   }
-  Poincare::Expression standardForm(Poincare::Context * context) const { return m_handle.standardForm(this, context); }
+  Poincare::Expression standardForm(Poincare::Context * context) const { return m_model.standardForm(this, context); }
   bool containsIComplex(Poincare::Context * context) const;
 
 private:
-  class Handle : public Shared::ExpressionModel {
+  class Model : public Shared::ExpressionModel {
   public:
     Poincare::Expression standardForm(const Ion::Storage::Record * record, Poincare::Context * context) const;
     void tidy() const override;
@@ -25,8 +25,8 @@ private:
     mutable Poincare::Expression m_standardForm;
   };
   size_t metaDataSize() const override { return 0; }
-  const Shared::ExpressionModel * handle() const override { return &m_handle; }
-  Handle m_handle;
+  const Shared::ExpressionModel * model() const override { return &m_model; }
+  Model m_model;
 };
 
 }