diff --git a/src/backends/julia/juliasession.cpp b/src/backends/julia/juliasession.cpp
index df0b02b3..f3443afe 100644
--- a/src/backends/julia/juliasession.cpp
+++ b/src/backends/julia/juliasession.cpp
@@ -1,248 +1,229 @@
 /*
     This program is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License
     as published by the Free Software Foundation; either version 2
     of the License, or (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA  02110-1301, USA.
 
     ---
     Copyright (C) 2016 Ivan Lakhtanov <ivan.lakhtanov@gmail.com>
  */
 #include "juliasession.h"
 
 #include <KProcess>
 #include <QDBusConnection>
 #include <QDBusInterface>
 #include <QDBusReply>
 #include <QStandardPaths>
 
 #include "defaultvariablemodel.h"
 
 #include "juliaexpression.h"
 #include "settings.h"
 #include "juliahighlighter.h"
 #include "juliakeywords.h"
 #include "juliavariablemodel.h"
 #include "juliaextensions.h"
 #include "juliabackend.h"
 #include "juliacompletionobject.h"
 #include <julia_version.h>
 
 using namespace Cantor;
 
 JuliaSession::JuliaSession(Cantor::Backend *backend)
     : Session(backend)
     , m_process(nullptr)
     , m_interface(nullptr)
-    , m_variableModel(new JuliaVariableModel(this))
-    , m_needUpdate(false)
 {
+    setVariableModel(new JuliaVariableModel(this));
 }
 
 void JuliaSession::login()
 {
     emit loginStarted();
 
     if (m_process) {
         m_process->deleteLater();
     }
 
     m_process = new KProcess(this);
     m_process->setOutputChannelMode(KProcess::SeparateChannels);
 
     (*m_process)
         << QStandardPaths::findExecutable(QLatin1String("cantor_juliaserver"));
 
     m_process->start();
 
     m_process->waitForStarted();
     m_process->waitForReadyRead();
     QTextStream stream(m_process->readAllStandardOutput());
 
     QString readyStatus = QLatin1String("ready");
     while (m_process->state() == QProcess::Running) {
         const QString &rl = stream.readLine();
         if (rl == readyStatus) {
             break;
         }
     }
 
     if (!QDBusConnection::sessionBus().isConnected()) {
         qWarning() << "Can't connect to the D-Bus session bus.\n"
                       "To start it, run: eval `dbus-launch --auto-syntax`";
         return;
     }
 
     const QString &serviceName =
         QString::fromLatin1("org.kde.Cantor.Julia-%1").arg(m_process->pid());
 
     m_interface = new QDBusInterface(
         serviceName,
         QString::fromLatin1("/"),
         QString(),
         QDBusConnection::sessionBus()
     );
 
     if (!m_interface->isValid()) {
         qWarning() << QDBusConnection::sessionBus().lastError().message();
         return;
     }
 
     m_interface->call(
         QString::fromLatin1("login"),
         JuliaSettings::self()->replPath().path()
     );
 
-    m_variableModel->setJuliaServer(m_interface);
-    m_variableModel->update();
+    static_cast<JuliaVariableModel*>(variableModel())->setJuliaServer(m_interface);
 
     // Plots integration
     if (integratePlots()) {
         runJuliaCommand(
             QLatin1String("import GR; ENV[\"GKS_WSTYPE\"] = \"nul\"")
         );
+        updateVariables();
     }
 
     changeStatus(Session::Done);
     emit loginDone();
     qDebug() << "login to julia " << JULIA_VERSION_STRING << "done";
 }
 
 void JuliaSession::logout()
 {
     m_process->terminate();
 
-    m_variableModel->clearVariables();
+    variableModel()->clearVariables();
 
     changeStatus(Status::Disable);
 }
 
 void JuliaSession::interrupt()
 {
     if (expressionQueue().isEmpty())
         return;
 
     if (m_process->pid()) {
         m_process->kill();
     }
 
     qDebug()<<"interrupting " << expressionQueue().first()->command();
     foreach (Cantor::Expression* expression, expressionQueue())
         expression->setStatus(Cantor::Expression::Interrupted);
     expressionQueue().clear();
 
     changeStatus(Cantor::Session::Done);
 }
 
 Cantor::Expression *JuliaSession::evaluateExpression(
     const QString &cmd,
     Cantor::Expression::FinishingBehavior behave,
     bool internal)
 {
     JuliaExpression *expr = new JuliaExpression(this, internal);
 
     expr->setFinishingBehavior(behave);
     expr->setCommand(cmd);
     expr->evaluate();
 
     return expr;
 }
 
 Cantor::CompletionObject *JuliaSession::completionFor(
     const QString &command,
     int index)
 {
     return new JuliaCompletionObject(command, index, this);
 }
 
 QSyntaxHighlighter *JuliaSession::syntaxHighlighter(QObject *parent)
 {
     return new JuliaHighlighter(parent, this);
 }
 
 void JuliaSession::runJuliaCommand(const QString &command) const
 {
     m_interface->call(QLatin1String("runJuliaCommand"), command);
 }
 
 void JuliaSession::runJuliaCommandAsync(const QString &command)
 {
     m_interface->callWithCallback(
         QLatin1String("runJuliaCommand"),
         {command},
         this,
         SLOT(onResultReady())
     );
 }
 
 void JuliaSession::onResultReady()
 {
-    JuliaExpression* expr = static_cast<JuliaExpression*>(expressionQueue().takeFirst());
-    expr->finalize();
-    m_needUpdate |= !expr->isInternal();
-
-    if (expressionQueue().isEmpty())
-    {
-        if(m_needUpdate)
-        {
-            m_variableModel->update();
-            m_needUpdate = false;
-        }
-        changeStatus(Cantor::Session::Done);
-    }
-    else
-        runFirstExpression();
+    static_cast<JuliaExpression*>(expressionQueue().first())->finalize();
+    finishFirstExpression(true);
 }
 
 void JuliaSession::runFirstExpression()
 {
     Cantor::Expression* expr = expressionQueue().first();
     expr->setStatus(Cantor::Expression::Computing);
 
     runJuliaCommandAsync(expr->internalCommand());
 }
 
 QString JuliaSession::getStringFromServer(const QString &method)
 {
     const QDBusReply<QString> &reply = m_interface->call(method);
     return (reply.isValid() ? reply.value() : reply.error().message());
 }
 
 QString JuliaSession::getOutput()
 {
     return getStringFromServer(QLatin1String("getOutput"));
 }
 
 QString JuliaSession::getError()
 {
     return getStringFromServer(QLatin1String("getError"));
 }
 
 bool JuliaSession::getWasException()
 {
     const QDBusReply<bool> &reply =
         m_interface->call(QLatin1String("getWasException"));
     return reply.isValid() && reply.value();
 }
 
-Cantor::DefaultVariableModel* JuliaSession::variableModel() const
-{
-    return m_variableModel;
-}
-
 
 bool JuliaSession::integratePlots()
 {
     return JuliaSettings::integratePlots();
 }
 
 
diff --git a/src/backends/julia/juliasession.h b/src/backends/julia/juliasession.h
index 843c0760..19e9bed4 100644
--- a/src/backends/julia/juliasession.h
+++ b/src/backends/julia/juliasession.h
@@ -1,156 +1,147 @@
 /*
     This program is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License
     as published by the Free Software Foundation; either version 2
     of the License, or (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA  02110-1301, USA.
 
     ---
     Copyright (C) 2016 Ivan Lakhtanov <ivan.lakhtanov@gmail.com>
  */
 #pragma once
 
 #include <QMap>
 #include <QRegularExpression>
 
 #include "session.h"
 
 class JuliaExpression;
 class JuliaCompletionObject;
 class JuliaVariableModel;
 class KProcess;
 class QDBusInterface;
 namespace Cantor {
     class DefaultVariableModel;
 }
 
 /**
  * Implements a Cantor session for the Julia backend
  *
  * It communicates through DBus interface with JuliaServer
  */
 class JuliaSession: public Cantor::Session
 {
     Q_OBJECT
 public:
     /**
      * Constructs session
      *
      * @param backend owning backend
      */
     explicit JuliaSession(Cantor::Backend *backend);
 
     /**
      * @see Cantor::Session::login
      */
     void login() override;
 
     /**
      * @see Cantor::Session::logout
      */
     void logout() override;
 
     /**
      * @see Cantor::Session::interrupt
      */
     void interrupt() override;
 
     /**
      * @see Cantor::Session::evaluateExpression
      */
     Cantor::Expression *evaluateExpression(
         const QString &command,
         Cantor::Expression::FinishingBehavior behave = Cantor::Expression::FinishingBehavior::DoNotDelete,
         bool internal = false) override;
 
     /**
      * @see Cantor::Session::completionFor
      */
     Cantor::CompletionObject *completionFor(
         const QString &cmd,
         int index = -1) override;
 
     /**
      * @see Cantor::Session::syntaxHighlighter
      */
     QSyntaxHighlighter *syntaxHighlighter(QObject *parent) override;
 
-    /**
-     * @see Cantor::Session::variableModel
-     */
-    Cantor::DefaultVariableModel *variableModel() const override;
-
     /**
      * @return indicator if config says to integrate plots into worksheet
      */
     bool integratePlots();
 
 private Q_SLOTS:
     /**
      * Called when async call to JuliaServer is finished
      */
     void onResultReady();
 
 private:
     KProcess *m_process; //< process to run JuliaServer inside
     QDBusInterface *m_interface; //< interface to JuliaServer
 
-    /// Variable management model
-    JuliaVariableModel *m_variableModel;
-    bool m_needUpdate;
-
     /// Cache to speedup modules whos calls
     QMap<QString, QString> m_whos_cache;
 
     friend JuliaExpression;
     friend JuliaCompletionObject;
 
     void runFirstExpression() override;
 
     /**
      * Runs Julia piece of code in synchronous mode
      *
      * @param command command to execute
      */
     void runJuliaCommand(const QString &command) const;
 
     /**
      * Runs Julia piece of code in asynchronous mode. When finished
      * onResultReady is called
      *
      * @param command command to execute
      */
     void runJuliaCommandAsync(const QString &command);
 
     /**
      * Helper method to get QString returning function result
      *
      * @param method DBus method to call
      * @return result of the method
      */
     QString getStringFromServer(const QString &method);
 
     /**
      * @return stdout of the last executed command
      */
     QString getOutput();
 
     /**
      * @return stderr of the last executed command
      */
     QString getError();
 
     /**
      * @return indicator of exception occurred during the last command execution
      */
     bool getWasException();
 };