diff --git a/CMakeLists.txt b/CMakeLists.txt
index de29f99..3ee82ca 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -50,6 +50,7 @@ FILE (GLOB_RECURSE core_SRCS
     ./include/Common/Numeric.h
     ./include/Common/deprecate.h
     ./include/Common/containers.h
+    ./include/Common/debug.h
     ./include/Plugin/IPlugin.h
     ./include/Data/ArrayDataIterator.h
     ./include/Data/VariableRequest.h
diff --git a/include/Common/debug.h b/include/Common/debug.h
new file mode 100644
index 0000000..059649f
--- /dev/null
+++ b/include/Common/debug.h
@@ -0,0 +1,9 @@
+#ifndef DEBUG_H
+#define DEBUG_H
+
+#ifdef SCIQLOP_CRASH_ON_ERROR
+    #define SCIQLOP_ERROR(x) assert(false)
+#else
+    #define SCIQLOP_ERROR(x)
+#endif
+#endif
diff --git a/include/Data/IDataProvider.h b/include/Data/IDataProvider.h
index 1535e40..ba4e869 100644
--- a/include/Data/IDataProvider.h
+++ b/include/Data/IDataProvider.h
@@ -46,7 +46,12 @@ public:
               = 0;
     )
 
-    virtual QUuid getData(const DataProviderParameters &parameters){return QUuid::createUuid();}
+    // Synchronous call -> asyncGetData may be written for asynchronous get
+    virtual IDataSeries* getData(const DataProviderParameters &parameters)
+    {
+        Q_UNUSED(parameters);
+        return nullptr;
+    }
 
 
     DEPRECATE(
@@ -56,7 +61,7 @@ public:
             virtual void requestDataAborting(QUuid acqIdentifier) = 0;
     )
 
-    virtual void abort(QUuid requestID){}
+    virtual void abort(QUuid requestID){Q_UNUSED(requestID);}
 
 signals:
     DEPRECATE(
diff --git a/include/Variable/Variable.h b/include/Variable/Variable.h
index 30fc2a3..ef0cdf5 100644
--- a/include/Variable/Variable.h
+++ b/include/Variable/Variable.h
@@ -9,7 +9,9 @@
 
 #include <QLoggingCategory>
 #include <QObject>
+#include <QUuid>
 
+#include <Common/deprecate.h>
 #include <Common/MetaTypes.h>
 #include <Common/spimpl.h>
 
@@ -70,7 +72,10 @@ public:
 
     QVector<DateTimeRange> provideNotInCacheRangeList(const DateTimeRange &range) const noexcept;
     QVector<DateTimeRange> provideInCacheRangeList(const DateTimeRange &range) const noexcept;
+DEPRECATE(
     void mergeDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept;
+    )
+    void mergeDataSeries(IDataSeries* dataSeries) noexcept;
 
     static QVector<DateTimeRange> provideNotInCacheRangeList(const DateTimeRange &oldRange,
                                                         const DateTimeRange &nextRange);
@@ -78,6 +83,7 @@ public:
     static QVector<DateTimeRange> provideInCacheRangeList(const DateTimeRange &oldRange,
                                                      const DateTimeRange &nextRange);
 
+    QUuid ID(){return _uuid;}
 signals:
     void updated();
     /// Signal emitted when when the data series of the variable is loaded for the first time
@@ -86,6 +92,7 @@ signals:
 private:
     class VariablePrivate;
     spimpl::unique_impl_ptr<VariablePrivate> impl;
+    QUuid _uuid;
 };
 
 // Required for using shared_ptr in signals/slots
diff --git a/include/Variable/VariableController2.h b/include/Variable/VariableController2.h
index 2352aa3..a11f4ac 100644
--- a/include/Variable/VariableController2.h
+++ b/include/Variable/VariableController2.h
@@ -1,26 +1,36 @@
-#include <Common/spimpl.h>
 #include <memory>
 #include <vector>
 #include <QHash>
+#include <QObject>
+#include <QMutexLocker>
+#include <QUuid>
+#include <QItemSelectionModel>
+#include <Common/spimpl.h>
 #include <Variable/Variable.h>
 #include <Variable/VariableSynchronizationGroup.h>
 #include <Variable/VariableModel.h>
 #include <Data/IDataProvider.h>
 #include "Data/DateTimeRange.h"
-#include <QMutexLocker>
-#include <QUuid>
-#include <QItemSelectionModel>
 
-class VariableController2Private;
-class VariableController2
+class VariableController2: public QObject
 {
+    class VariableController2Private;
+    Q_OBJECT
+
     spimpl::unique_impl_ptr<VariableController2Private> impl;
 
 public:
     explicit VariableController2();
     std::shared_ptr<Variable> createVariable(const QString &name, const QVariantHash &metadata,
                                              std::shared_ptr<IDataProvider> provider, const DateTimeRange &range);
-    void changeRange(QUuid variable, DateTimeRange r);
-    void asyncChangeRange(QUuid variable, DateTimeRange r);
+
+    void deleteVariable(std::shared_ptr<Variable> variable);
+    void changeRange(std::shared_ptr<Variable> variable, DateTimeRange r);
+    void asyncChangeRange(std::shared_ptr<Variable> variable, DateTimeRange r);
+    const std::set<std::shared_ptr<Variable> > &variables();
+
+signals:
+    void variableAdded(std::shared_ptr<Variable>);
+    void variableDeleted(std::shared_ptr<Variable>);
 
 };
diff --git a/src/Variable/Variable.cpp b/src/Variable/Variable.cpp
index 036e244..06b5397 100644
--- a/src/Variable/Variable.cpp
+++ b/src/Variable/Variable.cpp
@@ -6,6 +6,7 @@
 #include <QMutex>
 #include <QReadWriteLock>
 #include <QThread>
+#include <Common/debug.h>
 
 Q_LOGGING_CATEGORY(LOG_Variable, "Variable")
 
@@ -106,12 +107,14 @@ struct Variable::VariablePrivate {
 };
 
 Variable::Variable(const QString &name, const QVariantHash &metadata)
-        : impl{spimpl::make_unique_impl<VariablePrivate>(name, metadata)}
+        : impl{spimpl::make_unique_impl<VariablePrivate>(name, metadata)},
+          _uuid{QUuid::createUuid()}
 {
 }
 
 Variable::Variable(const Variable &other)
-        : impl{spimpl::make_unique_impl<VariablePrivate>(*other.impl)}
+        : impl{spimpl::make_unique_impl<VariablePrivate>(*other.impl)},
+          _uuid{QUuid::createUuid()} //is a clone but must have a != uuid
 {
 }
 
@@ -206,6 +209,34 @@ void Variable::mergeDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept
     }
 }
 
+void Variable::mergeDataSeries(IDataSeries *dataSeries) noexcept
+{
+    if (dataSeries==nullptr) {
+        SCIQLOP_ERROR("Given IDataSeries is nullptr");
+        return;
+    }
+
+    auto dataInit = false;
+    // @TODO move to impl to Pimpl this is what it stands for...
+    // Add or merge the data
+    impl->lockWrite();
+    if (!impl->m_DataSeries) {
+        //@TODO find a better way
+        impl->m_DataSeries = dataSeries->clone();
+        dataInit = true;
+        delete dataSeries;
+    }
+    else {
+        impl->m_DataSeries->merge(dataSeries);
+    }
+    impl->purgeDataSeries();
+    impl->unlock();
+
+    if (dataInit) {
+        emit dataInitialized();
+    }
+}
+
 
 std::shared_ptr<IDataSeries> Variable::dataSeries() const noexcept
 {
diff --git a/src/Variable/VariableController2.cpp b/src/Variable/VariableController2.cpp
index 5aa7acf..10f5c8a 100644
--- a/src/Variable/VariableController2.cpp
+++ b/src/Variable/VariableController2.cpp
@@ -1,17 +1,56 @@
 #include "Variable/VariableController2.h"
+#include <Common/containers.h>
+#include <Common/debug.h>
+#include <Data/DataProviderParameters.h>
 
-
-class VariableController2Private
+class VariableController2::VariableController2Private
 {
-
+    std::set<std::shared_ptr<Variable>> _variables;
+    QMap<QUuid,std::shared_ptr<IDataProvider>> _providers;
 public:
     VariableController2Private(QObject* parent=Q_NULLPTR)
-    {}
+    {
+        Q_UNUSED(parent);
+    }
+
     ~VariableController2Private() = default;
+
     std::shared_ptr<Variable> createVariable(const QString &name, const QVariantHash &metadata, std::shared_ptr<IDataProvider> provider, const DateTimeRange &range)
     {
-        return std::make_shared<Variable>(name,metadata);
+        auto newVar = std::make_shared<Variable>(name,metadata);
+        this->_variables.insert(newVar);
+        this->_providers[newVar->ID()] = provider;
+        return newVar;
+    }
+
+    void deleteVariable(std::shared_ptr<Variable> variable)
+    {
+        if(this->_providers.contains(variable->ID()))
+            this->_providers.remove(variable->ID());
+        if(SciQLop::containers::contains(this->_variables, variable))
+            this->_variables.erase(variable);
+    }
+
+    void changeRange(std::shared_ptr<Variable> variable, DateTimeRange r)
+    {
+        if(_providers.contains(variable->ID()))
+        {
+            auto provider = _providers[variable->ID()];
+            auto data = provider->getData(DataProviderParameters{{r},variable->metadata()});
+            variable->mergeDataSeries(data);
+        }
+        else
+        {
+            SCIQLOP_ERROR("No provider found for given variable");
+        }
+    }
+
+
+    const std::set<std::shared_ptr<Variable>>& variables()
+    {
+        return  _variables;
     }
+
 };
 
 VariableController2::VariableController2()
@@ -20,6 +59,25 @@ VariableController2::VariableController2()
 
 std::shared_ptr<Variable> VariableController2::createVariable(const QString &name, const QVariantHash &metadata, std::shared_ptr<IDataProvider> provider, const DateTimeRange &range)
 {
-    return impl->createVariable(name, metadata, provider, range);
+    auto var =  impl->createVariable(name, metadata, provider, range);
+    emit variableAdded(var);
+    impl->changeRange(var,range);
+    return var;
+}
+
+void VariableController2::deleteVariable(std::shared_ptr<Variable> variable)
+{
+    impl->deleteVariable(variable);
+    emit variableDeleted(variable);
+}
+
+void VariableController2::changeRange(std::shared_ptr<Variable> variable, DateTimeRange r)
+{
+    impl->changeRange(variable, r);
+}
+
+const std::set<std::shared_ptr<Variable> > &VariableController2::variables()
+{
+    return impl->variables();
 }
 
diff --git a/tests/Variable/TestVariableController2.cpp b/tests/Variable/TestVariableController2.cpp
index f900346..4235d87 100644
--- a/tests/Variable/TestVariableController2.cpp
+++ b/tests/Variable/TestVariableController2.cpp
@@ -1,9 +1,51 @@
+#include <cmath>
 #include <QtTest>
 #include <QObject>
+#include <Variable/VariableController2.h>
+#include <Data/DateTimeRange.h>
+#include <Data/IDataProvider.h>
+#include <Data/ScalarSeries.h>
+#include <Data/DataProviderParameters.h>
+#include <Common/containers.h>
 
+class FakeProvider: public IDataProvider
+{
+public:
+    FakeProvider() = default;
 
-class TestVariableController2 : public QObject
+    std::shared_ptr<IDataProvider> clone() const override{ return std::make_shared<FakeProvider>(); }
+
+    IDataSeries* getData(const DataProviderParameters &parameters) override
+    {
+        auto tstart = parameters.m_Times[0].m_TStart;
+        auto tend = parameters.m_Times[0].m_TEnd;
+        std::vector<double> x;
+        std::vector<double> y;
+        for(auto i = tstart;i<tend;i+=1.) //1 seconde data resolution
+        {
+            x.push_back(i);
+            y.push_back(i);
+        }
+        auto serie = new ScalarSeries(std::move(x),std::move(y),Unit("Secondes",true),Unit("Volts",false));
+        return serie;
+    }
+
+
+
+    void requestDataLoading(QUuid acqIdentifier, const DataProviderParameters &parameters) override
+    {
+        Q_UNUSED(acqIdentifier)
+        Q_UNUSED(parameters)
+    }
+
+    void requestDataAborting(QUuid acqIdentifier) override
+    {
+        Q_UNUSED(acqIdentifier)
+    }
+
+};
 
+class TestVariableController2 : public QObject
 {
     Q_OBJECT
 public:
@@ -14,9 +56,45 @@ private slots:
     void initTestCase(){}
     void cleanupTestCase(){}
 
-    void test1()
+    void testCreateVariable()
+    {
+        VariableController2 vc;
+        bool callbackCalled = false;
+        connect(&vc,&VariableController2::variableAdded, [&callbackCalled](std::shared_ptr<Variable>){callbackCalled=true;});
+        auto provider = std::make_shared<FakeProvider>();
+        QVERIFY(!callbackCalled);
+        auto var1 = vc.createVariable("var1",{},provider,DateTimeRange());
+        QVERIFY(SciQLop::containers::contains(vc.variables(), var1));
+        QVERIFY(callbackCalled);
+    }
+
+    void testDeleteVariable()
+    {
+        VariableController2 vc;
+        bool callbackCalled = false;
+        connect(&vc,&VariableController2::variableDeleted, [&callbackCalled](std::shared_ptr<Variable>){callbackCalled=true;});
+        auto provider = std::make_shared<FakeProvider>();
+        auto var1 = vc.createVariable("var1",{},provider,DateTimeRange());
+        QVERIFY(SciQLop::containers::contains(vc.variables(), var1));
+        QVERIFY(!callbackCalled);
+        vc.deleteVariable(var1);
+        QVERIFY(!SciQLop::containers::contains(vc.variables(), var1));
+        QVERIFY(callbackCalled);
+    }
+
+    void testGetData()
     {
-        QCOMPARE(1+1, 2);
+        VariableController2 vc;
+        auto provider = std::make_shared<FakeProvider>();
+        auto range1 = DateTimeRange::fromDateTime(QDate(2018,8,7),QTime(14,00),
+                                                  QDate(2018,8,7),QTime(16,00));
+        auto range2 = DateTimeRange::fromDateTime(QDate(2018,8,7),QTime(12,00),
+                                                  QDate(2018,8,7),QTime(18,00));
+        auto var1 = vc.createVariable("var1", {}, provider, range1);
+        QCOMPARE(var1->nbPoints(), int(range1.delta()));
+        vc.changeRange(var1, range2);
+        QCOMPARE(var1->nbPoints(), int(range2.delta()));
+
     }
 
 private: