Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Administrator/3.3/Views/Common/UpdateControl.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Administrator/3.3/Views/Common/UpdateControl.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Administrator/3.3/Views/Common/UpdateControl.cs	(revision 6743)
@@ -40,6 +40,8 @@
       if (imgBoxProgress.InvokeRequired) {
         imgBoxProgress.Invoke(new MethodInvoker(() => imgBoxProgress.Visible = false));
+        btnRefresh.Invoke(new MethodInvoker(() => btnRefresh.Enabled = true));
       } else {
         imgBoxProgress.Visible = false;
+        btnRefresh.Enabled = true;
       }
     }
@@ -49,6 +51,8 @@
         if (imgBoxProgress.InvokeRequired) {
           imgBoxProgress.Invoke(new MethodInvoker(() => imgBoxProgress.Visible = true));
+          btnRefresh.Invoke(new MethodInvoker(() => btnRefresh.Enabled = false));
         } else {
           imgBoxProgress.Visible = true;
+          btnRefresh.Enabled = false;
         }
 
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.ExperimentManager/3.3/Views/RefreshableHiveExperimentView.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.ExperimentManager/3.3/Views/RefreshableHiveExperimentView.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.ExperimentManager/3.3/Views/RefreshableHiveExperimentView.cs	(revision 6743)
@@ -93,12 +93,12 @@
 
     private void RegisterHiveJobEvents() {
-      Content.HiveJobs.ItemsAdded += new CollectionItemsChangedEventHandler<HiveTask>(HiveJobs_ItemsAdded_Removed_Reset);
-      Content.HiveJobs.ItemsRemoved += new CollectionItemsChangedEventHandler<HiveTask>(HiveJobs_ItemsAdded_Removed_Reset);
-      Content.HiveJobs.CollectionReset += new CollectionItemsChangedEventHandler<HiveTask>(HiveJobs_ItemsAdded_Removed_Reset);
+      Content.HiveTasks.ItemsAdded += new CollectionItemsChangedEventHandler<HiveTask>(HiveJobs_ItemsAdded_Removed_Reset);
+      Content.HiveTasks.ItemsRemoved += new CollectionItemsChangedEventHandler<HiveTask>(HiveJobs_ItemsAdded_Removed_Reset);
+      Content.HiveTasks.CollectionReset += new CollectionItemsChangedEventHandler<HiveTask>(HiveJobs_ItemsAdded_Removed_Reset);
     }
     private void DeregisterHiveJobEvents() {
-      Content.HiveJobs.ItemsAdded -= new CollectionItemsChangedEventHandler<HiveTask>(HiveJobs_ItemsAdded_Removed_Reset);
-      Content.HiveJobs.ItemsRemoved -= new CollectionItemsChangedEventHandler<HiveTask>(HiveJobs_ItemsAdded_Removed_Reset);
-      Content.HiveJobs.CollectionReset -= new CollectionItemsChangedEventHandler<HiveTask>(HiveJobs_ItemsAdded_Removed_Reset);
+      Content.HiveTasks.ItemsAdded -= new CollectionItemsChangedEventHandler<HiveTask>(HiveJobs_ItemsAdded_Removed_Reset);
+      Content.HiveTasks.ItemsRemoved -= new CollectionItemsChangedEventHandler<HiveTask>(HiveJobs_ItemsAdded_Removed_Reset);
+      Content.HiveTasks.CollectionReset -= new CollectionItemsChangedEventHandler<HiveTask>(HiveJobs_ItemsAdded_Removed_Reset);
     }
 
@@ -140,5 +140,5 @@
       if (Content != null) {
         bool alreadyUploaded = Content.Id != Guid.Empty;
-        bool jobsLoaded = Content.HiveJobs != null && Content.HiveJobs.All(x => x.Task.Id != Guid.Empty);
+        bool jobsLoaded = Content.HiveTasks != null && Content.HiveTasks.All(x => x.Task.Id != Guid.Empty);
 
         this.nameTextBox.ReadOnly = !Content.IsControllable || Content.ExecutionState != ExecutionState.Prepared || alreadyUploaded;
@@ -229,6 +229,6 @@
         Invoke(new EventHandler(Content_HiveJobChanged), sender, e);
       else {
-        if (Content != null && Content.HiveJobs != null) {
-          jobsTreeView.Content = Content.HiveJobs;
+        if (Content != null && Content.HiveTasks != null) {
+          jobsTreeView.Content = Content.HiveTasks;
           RegisterHiveJobEvents();
         } else {
@@ -297,11 +297,11 @@
     #region Control events
     private void startButton_Click(object sender, EventArgs e) {
-      HiveClient.StartExperiment((Exception ex) => ErrorHandling.ShowErrorDialog(this, "Start failed.", ex), Content, new CancellationToken());
+      HiveClient.StartJob((Exception ex) => ErrorHandling.ShowErrorDialog(this, "Start failed.", ex), Content, new CancellationToken());
     }
     private void pauseButton_Click(object sender, EventArgs e) {
-      HiveClient.PauseExperiment(Content);
+      HiveClient.PauseJob(Content);
     }
     private void stopButton_Click(object sender, EventArgs e) {
-      HiveClient.StopExperiment(Content);
+      HiveClient.StopJob(Content);
     }
     private void resetButton_Click(object sender, EventArgs e) { }
@@ -326,5 +326,5 @@
 
     private void refreshButton_Click(object sender, EventArgs e) {
-      var invoker = new Action<RefreshableJob>(HiveClient.LoadExperiment);
+      var invoker = new Action<RefreshableJob>(HiveClient.LoadJob);
       invoker.BeginInvoke(Content, (ar) => {
         try {
@@ -338,5 +338,5 @@
 
     private void refreshPermissionsButton_Click(object sender, EventArgs e) {
-      hiveExperimentPermissionListView.Content = HiveClient.GetHiveExperimentPermissions(this.Content.Job.Id);
+      hiveExperimentPermissionListView.Content = HiveClient.GetJobPermissions(this.Content.Job.Id);
     }
 
@@ -349,5 +349,5 @@
         startButton.Enabled = pauseButton.Enabled = stopButton.Enabled = resetButton.Enabled = false;
       } else {
-        startButton.Enabled = Content.IsControllable && Content.HiveJobs != null && Content.HiveJobs.Count > 0 && Content.ExecutionState == ExecutionState.Prepared;
+        startButton.Enabled = Content.IsControllable && Content.HiveTasks != null && Content.HiveTasks.Count > 0 && Content.ExecutionState == ExecutionState.Prepared;
         pauseButton.Enabled = Content.IsControllable && Content.ExecutionState == ExecutionState.Started;
         stopButton.Enabled = Content.IsControllable && Content.ExecutionState == ExecutionState.Started;
@@ -406,5 +406,5 @@
         var optimizer = obj as IOptimizer;
         if (optimizer != null) {
-          Content.HiveJobs.Add(new OptimizerHiveTask(e.Effect.HasFlag(DragDropEffects.Copy) ? (IOptimizer)optimizer.Clone() : optimizer));
+          Content.HiveTasks.Add(new OptimizerHiveTask(e.Effect.HasFlag(DragDropEffects.Copy) ? (IOptimizer)optimizer.Clone() : optimizer));
         }
       }
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave.App/3.3/HiveSlaveApplication.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave.App/3.3/HiveSlaveApplication.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave.App/3.3/HiveSlaveApplication.cs	(revision 6743)
@@ -34,7 +34,6 @@
       coreThread.Start();
 
-      SlaveItem item = new SlaveItem();
       MainWindow window = new MainWindow();
-      window.SetContent(item);
+      window.Content = new SlaveItem();
       Application.Run(window);
 
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave.App/3.3/MainWindow.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave.App/3.3/MainWindow.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave.App/3.3/MainWindow.cs	(revision 6743)
@@ -40,6 +40,9 @@
     }
 
-    public void SetContent(SlaveItem item) {
-      slaveMainView.Content = item;
+    public SlaveItem Content {
+      get { return slaveMainView.Content; }
+      set {
+        slaveMainView.Content = value;
+      }
     }
 
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave.Views/3.3/JobsView.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave.Views/3.3/JobsView.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave.Views/3.3/JobsView.cs	(revision 6743)
@@ -59,12 +59,17 @@
     #region Event Handlers
     void Content_SlaveStatusChanged(object sender, Common.EventArgs<StatusCommons> e) {
-      lstJobs.Items.Clear();
-      foreach (TaskStatus job in e.Value.Jobs) {
-        ListViewItem item = new ListViewItem();
-        item.Text = job.TaskId.ToString();
-        item.SubItems.Add(job.ExecutionTime.ToString());
-        lstJobs.Items.Add(item);
+      if (InvokeRequired) {
+        Action<object, Common.EventArgs<StatusCommons>> action = new Action<object, Common.EventArgs<StatusCommons>>(Content_SlaveStatusChanged);
+        Invoke(action, sender, e);
+      } else {
+        lstJobs.Items.Clear();
+        foreach (TaskStatus job in e.Value.Jobs) {
+          ListViewItem item = new ListViewItem();
+          item.Text = job.TaskId.ToString();
+          item.SubItems.Add(job.ExecutionTime.ToString());
+          lstJobs.Items.Add(item);
+        }
+        lstJobs.AutoResizeColumns(ColumnHeaderAutoResizeStyle.ColumnContent);
       }
-      lstJobs.AutoResizeColumns(ColumnHeaderAutoResizeStyle.ColumnContent);
     }
     #endregion
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave.Views/3.3/LogView.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave.Views/3.3/LogView.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave.Views/3.3/LogView.cs	(revision 6743)
@@ -69,5 +69,9 @@
     #region Event Handlers
     void Content_SlaveMessageLogged(object sender, EventArgs<string> e) {
-      txtLog.AppendText(e.Value + Environment.NewLine);
+      if (txtLog.InvokeRequired) {
+        txtLog.Invoke(new Action<string>(txtLog.AppendText), e.Value + Environment.NewLine);
+      } else {
+        txtLog.AppendText(e.Value + Environment.NewLine);
+      }
     }
 
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave.Views/3.3/SlaveCmdsWithKill.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave.Views/3.3/SlaveCmdsWithKill.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave.Views/3.3/SlaveCmdsWithKill.cs	(revision 6743)
@@ -65,6 +65,4 @@
     #region Register Content Events
     protected override void DeregisterContentEvents() {
-
-
       base.DeregisterContentEvents();
     }
@@ -173,5 +171,4 @@
     protected override void SetEnabledStateOfControls() {
       base.SetEnabledStateOfControls();
-      //do nothing at the moment, we have nothing editable
     }
 
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave.Views/3.3/SlaveItem.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave.Views/3.3/SlaveItem.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave.Views/3.3/SlaveItem.cs	(revision 6743)
@@ -65,5 +65,5 @@
 
     void pipeFactory_Opened(object sender, EventArgs e) {
-      OnMessageLogged("Connection to Slave core established");
+      OnMessageLogged("Connection to Slave core opened");
       OnCoreConnectionChanged(CoreConnection.Connected);
     }
@@ -188,5 +188,4 @@
       var handler = SlaveDisplayStateChanged;
       if (handler != null) handler(this, new EventArgs<SlaveDisplayStat>(stat));
-
     }
 
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave.Views/3.3/SlaveMainViewBase.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave.Views/3.3/SlaveMainViewBase.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave.Views/3.3/SlaveMainViewBase.cs	(revision 6743)
@@ -76,5 +76,4 @@
       if (Content != null) {
         Content.UserVisibleMessageFired += new System.EventHandler<Common.EventArgs<string>>(Content_UserVisibleMessageFired);
-        ((SlaveItem)base.Content).Open();
         Task.Factory.StartNew(Connector);
       }
@@ -106,7 +105,8 @@
 
     private void Connector() {
+      ((SlaveItem)base.Content).Open();
       bool connected = false;
       while (!connected) {
-        this.Invoke(new Func<bool>(() => connected = ((SlaveItem)base.Content).ReconnectToSlaveCore()));
+        connected = ((SlaveItem)base.Content).ReconnectToSlaveCore();
 
         if (!connected) {
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave.Views/3.3/SlaveMainViewTray.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave.Views/3.3/SlaveMainViewTray.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave.Views/3.3/SlaveMainViewTray.cs	(revision 6743)
@@ -22,5 +22,4 @@
 using System.Windows.Forms;
 using HeuristicLab.MainForm;
-
 
 namespace HeuristicLab.Clients.Hive.SlaveCore.Views {
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave.Views/3.3/SlaveStats.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave.Views/3.3/SlaveStats.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave.Views/3.3/SlaveStats.cs	(revision 6743)
@@ -35,5 +35,4 @@
     private SlaveDisplayStat lastSlaveDisplayStat;
 
-
     public new SlaveItem Content {
       get { return (SlaveItem)base.Content; }
@@ -56,5 +55,4 @@
       Content.SlaveStatusChanged -= new System.EventHandler<EventArgs<StatusCommons>>(Content_SlaveStatusChanged);
       Content.SlaveDisplayStateChanged -= new EventHandler<EventArgs<SlaveDisplayStat>>(Content_SlaveDisplayStateChanged);
-      Content.CoreConnectionChanged -= new EventHandler<EventArgs<CoreConnection>>(Content_CoreConnectionChanged);
 
       base.DeregisterContentEvents();
@@ -66,5 +64,4 @@
       Content.SlaveStatusChanged += new System.EventHandler<EventArgs<StatusCommons>>(Content_SlaveStatusChanged);
       Content.SlaveDisplayStateChanged += new EventHandler<EventArgs<SlaveDisplayStat>>(Content_SlaveDisplayStateChanged);
-      Content.CoreConnectionChanged += new EventHandler<EventArgs<CoreConnection>>(Content_CoreConnectionChanged);
     }
     #endregion
@@ -80,82 +77,96 @@
     #region Event Handlers
     void Content_SlaveStatusChanged(object sender, EventArgs<StatusCommons> e) {
-      RenderJobChart(e.Value);
-      RenderCoreChart(e.Value);
+      if (InvokeRequired) {
+        Action<object, EventArgs<StatusCommons>> action = new Action<object, EventArgs<StatusCommons>>(Content_SlaveStatusChanged);
+        Invoke(action, sender, e);
+      } else {
+        RenderJobChart(e.Value);
+        RenderCoreChart(e.Value);
+      }
     }
 
     void Content_SlaveDisplayStateChanged(object sender, EventArgs<SlaveDisplayStat> e) {
-      lblSlaveState.Text = e.Value.ToString();
-      lastSlaveDisplayStat = e.Value;
-    }
-
-    void Content_CoreConnectionChanged(object sender, EventArgs<CoreConnection> e) {
-
+      if (InvokeRequired) {
+        Action<object, EventArgs<SlaveDisplayStat>> action = new Action<object, EventArgs<SlaveDisplayStat>>(Content_SlaveDisplayStateChanged);
+        Invoke(action, sender, e);
+      } else {
+        lblSlaveState.Text = e.Value.ToString();
+        lastSlaveDisplayStat = e.Value;
+      }
     }
     #endregion
 
     private void RenderJobChart(StatusCommons status) {
-      jobChart.Series[0].Points.Clear();
-      jobChart.Series[1].Points.Clear();
-      jobChart.Series[2].Points.Clear();
-      jobChart.Series[3].Points.Clear();
-      jobChart.Series[4].Points.Clear();
+      if (InvokeRequired) {
+        Invoke(new Action<StatusCommons>(RenderJobChart), status);
+      } else {
+        jobChart.Series[0].Points.Clear();
+        jobChart.Series[1].Points.Clear();
+        jobChart.Series[2].Points.Clear();
+        jobChart.Series[3].Points.Clear();
+        jobChart.Series[4].Points.Clear();
 
 
-      DataPoint pJobs = new DataPoint(1, status.Jobs.Count);
-      DataPoint pJobsAborted = new DataPoint(2, status.JobsAborted);
-      DataPoint pJobsDone = new DataPoint(3, status.JobsFinished);
-      DataPoint pJobsFetched = new DataPoint(4, status.JobsFetched);
-      DataPoint pJobsFailed = new DataPoint(5, status.JobsFailed);
+        DataPoint pJobs = new DataPoint(1, status.Jobs.Count);
+        DataPoint pJobsAborted = new DataPoint(2, status.JobsAborted);
+        DataPoint pJobsDone = new DataPoint(3, status.JobsFinished);
+        DataPoint pJobsFetched = new DataPoint(4, status.JobsFetched);
+        DataPoint pJobsFailed = new DataPoint(5, status.JobsFailed);
 
-      pJobs.LegendText = "Current jobs: " + status.Jobs.Count;
-      pJobs.Color = System.Drawing.Color.Yellow;
-      pJobs.ToolTip = pJobs.LegendText;
-      jobChart.Series[0].Color = System.Drawing.Color.Yellow;
-      jobChart.Series[0].LegendText = pJobs.LegendText;
-      jobChart.Series[0].Points.Add(pJobs);
+        pJobs.LegendText = "Current jobs: " + status.Jobs.Count;
+        pJobs.Color = System.Drawing.Color.Yellow;
+        pJobs.ToolTip = pJobs.LegendText;
+        jobChart.Series[0].Color = System.Drawing.Color.Yellow;
+        jobChart.Series[0].LegendText = pJobs.LegendText;
+        jobChart.Series[0].Points.Add(pJobs);
 
-      pJobsAborted.LegendText = "Aborted jobs: " + status.JobsAborted;
-      pJobsAborted.Color = System.Drawing.Color.Orange;
-      pJobsAborted.ToolTip = pJobsAborted.LegendText;
-      jobChart.Series[1].Color = System.Drawing.Color.Orange;
-      jobChart.Series[1].LegendText = pJobsAborted.LegendText;
-      jobChart.Series[1].Points.Add(pJobsAborted);
+        pJobsAborted.LegendText = "Aborted jobs: " + status.JobsAborted;
+        pJobsAborted.Color = System.Drawing.Color.Orange;
+        pJobsAborted.ToolTip = pJobsAborted.LegendText;
+        jobChart.Series[1].Color = System.Drawing.Color.Orange;
+        jobChart.Series[1].LegendText = pJobsAborted.LegendText;
+        jobChart.Series[1].Points.Add(pJobsAborted);
 
-      pJobsDone.LegendText = "Finished jobs: " + status.JobsFinished;
-      pJobsDone.Color = System.Drawing.Color.Green;
-      pJobsDone.ToolTip = pJobsDone.LegendText;
-      jobChart.Series[2].Color = System.Drawing.Color.Green;
-      jobChart.Series[2].LegendText = pJobsDone.LegendText;
-      jobChart.Series[2].Points.Add(pJobsDone);
+        pJobsDone.LegendText = "Finished jobs: " + status.JobsFinished;
+        pJobsDone.Color = System.Drawing.Color.Green;
+        pJobsDone.ToolTip = pJobsDone.LegendText;
+        jobChart.Series[2].Color = System.Drawing.Color.Green;
+        jobChart.Series[2].LegendText = pJobsDone.LegendText;
+        jobChart.Series[2].Points.Add(pJobsDone);
 
-      pJobsFetched.LegendText = "Fetched jobs: " + status.JobsFetched;
-      pJobsFetched.ToolTip = pJobsFetched.LegendText;
-      pJobsFetched.Color = System.Drawing.Color.Blue;
-      jobChart.Series[3].Color = System.Drawing.Color.Blue;
-      jobChart.Series[3].LegendText = pJobsFetched.LegendText;
-      jobChart.Series[3].Points.Add(pJobsFetched);
+        pJobsFetched.LegendText = "Fetched jobs: " + status.JobsFetched;
+        pJobsFetched.ToolTip = pJobsFetched.LegendText;
+        pJobsFetched.Color = System.Drawing.Color.Blue;
+        jobChart.Series[3].Color = System.Drawing.Color.Blue;
+        jobChart.Series[3].LegendText = pJobsFetched.LegendText;
+        jobChart.Series[3].Points.Add(pJobsFetched);
 
-      pJobsFailed.LegendText = "Failed jobs: " + status.JobsFailed;
-      pJobsFailed.ToolTip = pJobsFailed.LegendText;
-      pJobsFailed.Color = System.Drawing.Color.Red;
-      jobChart.Series[4].Color = System.Drawing.Color.Red;
-      jobChart.Series[4].LegendText = pJobsFailed.LegendText;
-      jobChart.Series[4].Points.Add(pJobsFailed);
+        pJobsFailed.LegendText = "Failed jobs: " + status.JobsFailed;
+        pJobsFailed.ToolTip = pJobsFailed.LegendText;
+        pJobsFailed.Color = System.Drawing.Color.Red;
+        jobChart.Series[4].Color = System.Drawing.Color.Red;
+        jobChart.Series[4].LegendText = pJobsFailed.LegendText;
+        jobChart.Series[4].Points.Add(pJobsFailed);
+      }
     }
 
     private void RenderCoreChart(StatusCommons statusCommons) {
-      int usedCores = statusCommons.TotalCores - statusCommons.FreeCores;
-      DataPoint pFreeCores = new DataPoint(statusCommons.FreeCores, statusCommons.FreeCores);
-      DataPoint pUsedCores = new DataPoint(usedCores, usedCores);
+      if (InvokeRequired) {
+        Invoke(new Action<StatusCommons>(RenderCoreChart), statusCommons);
+      } else {
+        int usedCores = statusCommons.TotalCores - statusCommons.FreeCores;
+        DataPoint pFreeCores = new DataPoint(statusCommons.FreeCores, statusCommons.FreeCores);
+        DataPoint pUsedCores = new DataPoint(usedCores, usedCores);
 
-      coresChart.Series[0].Points.Clear();
+        coresChart.Series[0].Points.Clear();
 
-      pFreeCores.LegendText = "Free cores: " + statusCommons.FreeCores;
-      pFreeCores.Color = System.Drawing.Color.Green;
-      pUsedCores.LegendText = "Used cores: " + usedCores;
-      pUsedCores.Color = System.Drawing.Color.Red;
+        pFreeCores.LegendText = "Free cores: " + statusCommons.FreeCores;
+        pFreeCores.Color = System.Drawing.Color.Green;
+        pUsedCores.LegendText = "Used cores: " + usedCores;
+        pUsedCores.Color = System.Drawing.Color.Red;
 
-      coresChart.Series[0].Points.Add(pFreeCores);
-      coresChart.Series[0].Points.Add(pUsedCores);
+        coresChart.Series[0].Points.Add(pFreeCores);
+        coresChart.Series[0].Points.Add(pUsedCores);
+      }
     }
   }
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave.Views/3.3/SlaveViewTray.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave.Views/3.3/SlaveViewTray.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave.Views/3.3/SlaveViewTray.cs	(revision 6743)
@@ -37,5 +37,4 @@
     #region Register Content Events
     protected override void DeregisterContentEvents() {
-
       base.DeregisterContentEvents();
     }
@@ -43,6 +42,4 @@
     protected override void RegisterContentEvents() {
       base.RegisterContentEvents();
-
-
     }
     #endregion
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave/3.3/Core.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave/3.3/Core.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave/3.3/Core.cs	(revision 6743)
@@ -232,10 +232,10 @@
       int usedCores = 0;
       try {
-        task = wcfService.GetJob(taskId);
+        task = wcfService.GetTask(taskId);
         if (task == null) throw new TaskNotFoundException(taskId);
         if (ConfigManager.Instance.GetFreeCores() < task.CoresNeeded) throw new OutOfCoresException();
         if (ConfigManager.GetFreeMemory() < task.MemoryNeeded) throw new OutOfMemoryException();
         SlaveStatusInfo.IncrementUsedCores(task.CoresNeeded); usedCores = task.CoresNeeded;
-        TaskData taskData = wcfService.GetJobData(taskId);
+        TaskData taskData = wcfService.GetTaskData(taskId);
         if (taskData == null) throw new TaskDataNotFoundException(taskId);
         task = wcfService.UpdateJobState(taskId, TaskState.Calculating, null);
@@ -273,5 +273,5 @@
       Guid taskId = (Guid)taskIdObj;
       try {
-        Task task = wcfService.GetJob(taskId);
+        Task task = wcfService.GetTask(taskId);
         if (task == null) throw new TaskNotFoundException(taskId);
         taskManager.StopTaskAsync(taskId);
@@ -291,5 +291,5 @@
       Guid taskId = (Guid)taskIdObj;
       try {
-        Task task = wcfService.GetJob(taskId);
+        Task task = wcfService.GetTask(taskId);
         if (task == null) throw new TaskNotFoundException(taskId);
         taskManager.PauseTaskAsync(taskId);
@@ -334,9 +334,9 @@
         SlaveStatusInfo.DecrementUsedCores(e.Value.CoresNeeded);
         heartbeatManager.AwakeHeartBeatThread();
-        Task task = wcfService.GetJob(e.Value.TaskId);
+        Task task = wcfService.GetTask(e.Value.TaskId);
         if (task == null) throw new TaskNotFoundException(e.Value.TaskId);
         task.ExecutionTime = e.Value.ExecutionTime;
         TaskData taskData = e.Value.GetTaskData();
-        wcfService.UpdateJobData(task, taskData, configManager.GetClientInfo().Id, TaskState.Paused);
+        wcfService.UpdateTaskData(task, taskData, configManager.GetClientInfo().Id, TaskState.Paused);
       }
       catch (TaskNotFoundException ex) {
@@ -352,9 +352,9 @@
         SlaveStatusInfo.DecrementUsedCores(e.Value.CoresNeeded);
         heartbeatManager.AwakeHeartBeatThread();
-        Task task = wcfService.GetJob(e.Value.TaskId);
+        Task task = wcfService.GetTask(e.Value.TaskId);
         if (task == null) throw new TaskNotFoundException(e.Value.TaskId);
         task.ExecutionTime = e.Value.ExecutionTime;
         TaskData taskData = e.Value.GetTaskData();
-        wcfService.UpdateJobData(task, taskData, configManager.GetClientInfo().Id, TaskState.Finished);
+        wcfService.UpdateTaskData(task, taskData, configManager.GetClientInfo().Id, TaskState.Finished);
       }
       catch (TaskNotFoundException ex) {
@@ -374,9 +374,9 @@
         Exception exception = e.Value.Item3;
 
-        Task task = wcfService.GetJob(slaveTask.TaskId);
+        Task task = wcfService.GetTask(slaveTask.TaskId);
         if (task == null) throw new TaskNotFoundException(slaveTask.TaskId);
         task.ExecutionTime = slaveTask.ExecutionTime;
         if (taskData != null) {
-          wcfService.UpdateJobData(task, taskData, configManager.GetClientInfo().Id, TaskState.Failed, exception.ToString());
+          wcfService.UpdateTaskData(task, taskData, configManager.GetClientInfo().Id, TaskState.Failed, exception.ToString());
         } else {
           wcfService.UpdateJobState(task.Id, TaskState.Failed, exception.ToString());
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave/3.3/WcfService.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave/3.3/WcfService.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave/3.3/WcfService.cs	(revision 6743)
@@ -55,34 +55,34 @@
 
     #region Task Methods
-    public Task GetJob(Guid jobId) {
-      return CallHiveService(s => s.GetJob(jobId));
+    public Task GetTask(Guid taskId) {
+      return CallHiveService(s => s.GetTask(taskId));
     }
 
-    public void UpdateJob(Task job) {
-      CallHiveService(s => s.UpdateJob(job));
+    public void UpdateTask(Task task) {
+      CallHiveService(s => s.UpdateTask(task));
     }
     #endregion
 
     #region TaskData Methods
-    public TaskData GetJobData(Guid jobId) {
-      return CallHiveService(s => s.GetJobData(jobId));
+    public TaskData GetTaskData(Guid taskId) {
+      return CallHiveService(s => s.GetTaskData(taskId));
     }
 
     /// <summary>
-    /// Uploads the taskData and sets a new jobState (while correctly setting Transferring state)
+    /// Uploads the taskData and sets a new taskState (while correctly setting Transferring state)
     /// </summary>
-    public void UpdateJobData(Task job, TaskData jobData, Guid slaveId, TaskState state, string exception = "") {
+    public void UpdateTaskData(Task task, TaskData taskData, Guid slaveId, TaskState state, string exception = "") {
       CallHiveService(service => {
-        service.UpdateJob(job);
-        job = service.UpdateJobState(job.Id, TaskState.Transferring, slaveId, null, null);
+        service.UpdateTask(task);
+        task = service.UpdateTaskState(task.Id, TaskState.Transferring, slaveId, null, null);
         HiveClient.TryAndRepeat(() => {
-          service.UpdateJobData(job, jobData);
+          service.UpdateTaskData(task, taskData);
         }, Settings.Default.PluginDeletionRetries, "Could not upload jobdata.");
-        service.UpdateJobState(job.Id, state, slaveId, null, exception);
+        service.UpdateTaskState(task.Id, state, slaveId, null, exception);
       });
     }
 
-    public Task UpdateJobState(Guid jobId, TaskState jobState, string exception) {
-      return CallHiveService(s => s.UpdateJobState(jobId, jobState, ConfigManager.Instance.GetClientInfo().Id, null, exception));
+    public Task UpdateJobState(Guid taskId, TaskState taskState, string exception) {
+      return CallHiveService(s => s.UpdateTaskState(taskId, taskState, ConfigManager.Instance.GetClientInfo().Id, null, exception));
     }
     #endregion
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Tests/ExperimentManagerTests.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Tests/ExperimentManagerTests.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Tests/ExperimentManagerTests.cs	(revision 6743)
@@ -45,7 +45,7 @@
       var rhc = new RefreshableJob();
       var optimizer = CreateOptimizer();
-      rhc.HiveJobs.Add(new OptimizerHiveTask(optimizer));
+      rhc.HiveTasks.Add(new OptimizerHiveTask(optimizer));
       
-      HiveClient.StartExperiment((Exception ex) => TestContext.WriteLine(ex.ToString()), rhc, new CancellationToken());
+      HiveClient.StartJob((Exception ex) => TestContext.WriteLine(ex.ToString()), rhc, new CancellationToken());
 
       while (rhc.ExecutionState != Core.ExecutionState.Stopped) {
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Views/3.3/HiveTasks/HiveTaskView.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Views/3.3/HiveTasks/HiveTaskView.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Views/3.3/HiveTasks/HiveTaskView.cs	(revision 6743)
@@ -129,5 +129,5 @@
           this.dateFinishedTextBox.Text = Content.Task.DateFinished.ToString();
           this.exceptionTextBox.Text = Content.Task.CurrentStateLog != null ? Content.Task.CurrentStateLog.Exception : string.Empty;
-          this.lastUpdatedTextBox.Text = Content.Task.LastJobDataUpdate.ToString();
+          this.lastUpdatedTextBox.Text = Content.Task.LastTaskDataUpdate.ToString();
         } else {
           this.stateTextBox.Text = string.Empty;
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.3/ConcurrentTaskDownloader.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.3/ConcurrentTaskDownloader.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.3/ConcurrentTaskDownloader.cs	(revision 6743)
@@ -42,15 +42,15 @@
     }
 
-    public void DownloadJob(Task job, Action<Task, T> onFinishedAction) {
-      Task<T> task = Task<TaskData>.Factory.StartNew((x) => DownloadJob(x), job.Id)
-                                     .ContinueWith((x) => DeserializeJob(x.Result));
-      task.ContinueWith((x) => OnJobFinished(job, x, onFinishedAction), TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.OnlyOnRanToCompletion);
-      task.ContinueWith((x) => OnJobFailed(job, x, onFinishedAction), TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.OnlyOnFaulted);
+    public void DownloadTask(Task job, Action<Task, T> onFinishedAction) {
+      Task<T> task = Task<TaskData>.Factory.StartNew((x) => DownloadTask(x), job.Id)
+                                     .ContinueWith((x) => DeserializeTask(x.Result));
+      task.ContinueWith((x) => OnTaskFinished(job, x, onFinishedAction), TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.OnlyOnRanToCompletion);
+      task.ContinueWith((x) => OnTaskFailed(job, x, onFinishedAction), TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.OnlyOnFaulted);
     }
 
-    private void OnJobFinished(Task job, Task<T> task, Action<Task, T> onFinishedAction) {
+    private void OnTaskFinished(Task job, Task<T> task, Action<Task, T> onFinishedAction) {
       onFinishedAction(job, task.Result);
     }
-    private void OnJobFailed(Task job, Task<T> task, Action<Task, T> onFinishedAction) {
+    private void OnTaskFailed(Task job, Task<T> task, Action<Task, T> onFinishedAction) {
       task.Exception.Flatten().Handle((e) => { return true; });
       OnExceptionOccured(task.Exception.Flatten());
@@ -58,5 +58,5 @@
     }
 
-    protected TaskData DownloadJob(object jobId) {
+    protected TaskData DownloadTask(object taskId) {
       downloadSemaphore.WaitOne();
       deserializeSemaphore.WaitOne();
@@ -64,5 +64,5 @@
       try {
         if (abort) return null;
-        result = ServiceLocator.Instance.CallHiveService(s => s.GetJobData((Guid)jobId));
+        result = ServiceLocator.Instance.CallHiveService(s => s.GetTaskData((Guid)taskId));
       }
       finally {
@@ -72,11 +72,11 @@
     }
 
-    protected T DeserializeJob(TaskData jobData) {
+    protected T DeserializeTask(TaskData taskData) {
       try {
-        if (abort || jobData == null) return null;
-        Task job = ServiceLocator.Instance.CallHiveService(s => s.GetJob(jobData.TaskId));
-        if (job == null) return null;
-        var deserializedJob = PersistenceUtil.Deserialize<T>(jobData.Data);
-        jobData.Data = null; // reduce memory consumption.
+        if (abort || taskData == null) return null;
+        Task task = ServiceLocator.Instance.CallHiveService(s => s.GetTask(taskData.TaskId));
+        if (task == null) return null;
+        var deserializedJob = PersistenceUtil.Deserialize<T>(taskData.Data);
+        taskData.Data = null; // reduce memory consumption.
         return deserializedJob;
       }
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.3/HiveClient.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.3/HiveClient.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.3/HiveClient.cs	(revision 6743)
@@ -86,16 +86,16 @@
         var oldExperiments = jobs ?? new ItemCollection<RefreshableJob>();
         jobs = new HiveItemCollection<RefreshableJob>();
-        var experimentsLoaded = ServiceLocator.Instance.CallHiveService<IEnumerable<Job>>(s => s.GetHiveExperiments());
+        var experimentsLoaded = ServiceLocator.Instance.CallHiveService<IEnumerable<Job>>(s => s.GetJobs());
 
         foreach (var he in experimentsLoaded) {
-          var hiveExperiment = oldExperiments.SingleOrDefault(x => x.Id == he.Id);
-          if (hiveExperiment == null) {
+          var job = oldExperiments.SingleOrDefault(x => x.Id == he.Id);
+          if (job == null) {
             // new
             jobs.Add(new RefreshableJob(he) { IsAllowedPrivileged = this.isAllowedPrivileged });
           } else {
             // update
-            hiveExperiment.Job = he;
-            hiveExperiment.IsAllowedPrivileged = this.isAllowedPrivileged;
-            jobs.Add(hiveExperiment);
+            job.Job = he;
+            job.IsAllowedPrivileged = this.isAllowedPrivileged;
+            jobs.Add(job);
           }
         }
@@ -139,5 +139,5 @@
       if (item.Id == Guid.Empty) {
         if (item is RefreshableJob) {
-          HiveClient.Instance.UploadExperiment((RefreshableJob)item, cancellationToken);
+          HiveClient.Instance.UploadJob((RefreshableJob)item, cancellationToken);
         }
         if (item is JobPermission) {
@@ -151,5 +151,5 @@
       } else {
         if (item is Job)
-          ServiceLocator.Instance.CallHiveService(s => s.UpdateHiveExperiment((Job)item));
+          ServiceLocator.Instance.CallHiveService(s => s.UpdateJob((Job)item));
       }
     }
@@ -177,7 +177,7 @@
 
       if (item is Job)
-        ServiceLocator.Instance.CallHiveService(s => s.DeleteHiveExperiment(item.Id));
+        ServiceLocator.Instance.CallHiveService(s => s.DeleteJob(item.Id));
       if (item is RefreshableJob)
-        ServiceLocator.Instance.CallHiveService(s => s.DeleteHiveExperiment(item.Id));
+        ServiceLocator.Instance.CallHiveService(s => s.DeleteJob(item.Id));
       if (item is JobPermission) {
         var hep = (JobPermission)item;
@@ -206,5 +206,5 @@
     #endregion
 
-    public static void StartExperiment(Action<Exception> exceptionCallback, RefreshableJob refreshableJob, CancellationToken cancellationToken) {
+    public static void StartJob(Action<Exception> exceptionCallback, RefreshableJob refreshableJob, CancellationToken cancellationToken) {
       HiveClient.StoreAsync(
         new Action<Exception>((Exception ex) => {
@@ -215,19 +215,19 @@
     }
 
-    public static void PauseExperiment(RefreshableJob refreshableHiveExperiment) {
+    public static void PauseJob(RefreshableJob refreshableJob) {
       ServiceLocator.Instance.CallHiveService(service => {
-        foreach (HiveTask job in refreshableHiveExperiment.GetAllHiveJobs()) {
-          if (job.Task.State != TaskState.Finished && job.Task.State != TaskState.Aborted && job.Task.State != TaskState.Failed)
-            service.PauseJob(job.Task.Id);
+        foreach (HiveTask task in refreshableJob.GetAllHiveTasks()) {
+          if (task.Task.State != TaskState.Finished && task.Task.State != TaskState.Aborted && task.Task.State != TaskState.Failed)
+            service.PauseTask(task.Task.Id);
         }
       });
-      refreshableHiveExperiment.ExecutionState = ExecutionState.Paused;
-    }
-
-    public static void StopExperiment(RefreshableJob refreshableJob) {
+      refreshableJob.ExecutionState = ExecutionState.Paused;
+    }
+
+    public static void StopJob(RefreshableJob refreshableJob) {
       ServiceLocator.Instance.CallHiveService(service => {
-        foreach (HiveTask job in refreshableJob.GetAllHiveJobs()) {
-          if (job.Task.State != TaskState.Finished && job.Task.State != TaskState.Aborted && job.Task.State != TaskState.Failed)
-            service.StopJob(job.Task.Id);
+        foreach (HiveTask task in refreshableJob.GetAllHiveTasks()) {
+          if (task.Task.State != TaskState.Finished && task.Task.State != TaskState.Aborted && task.Task.State != TaskState.Failed)
+            service.StopTask(task.Task.Id);
         }
       });
@@ -235,9 +235,9 @@
     }
 
-    #region Upload Experiment
+    #region Upload Job
     private Semaphore jobUploadSemaphore = new Semaphore(4, 4); // todo: take magic number into config
     private static object jobCountLocker = new object();
     private static object pluginLocker = new object();
-    private void UploadExperiment(RefreshableJob refreshableJob, CancellationToken cancellationToken) {
+    private void UploadJob(RefreshableJob refreshableJob, CancellationToken cancellationToken) {
       try {
         refreshableJob.Progress = new Progress("Connecting to server...");
@@ -254,5 +254,5 @@
         }
 
-        foreach (OptimizerHiveTask hiveJob in refreshableJob.HiveJobs.OfType<OptimizerHiveTask>()) {
+        foreach (OptimizerHiveTask hiveJob in refreshableJob.HiveTasks.OfType<OptimizerHiveTask>()) {
           hiveJob.SetIndexInParentOptimizerList(null);
         }
@@ -260,11 +260,11 @@
         // upload Task
         refreshableJob.Progress.Status = "Uploading Task...";
-        refreshableJob.Job.Id = ServiceLocator.Instance.CallHiveService((s) => s.AddHiveExperiment(refreshableJob.Job));
+        refreshableJob.Job.Id = ServiceLocator.Instance.CallHiveService((s) => s.AddJob(refreshableJob.Job));
         bool isPrivileged = refreshableJob.Job.IsPrivileged;
-        refreshableJob.Job = ServiceLocator.Instance.CallHiveService((s) => s.GetHiveExperiment(refreshableJob.Job.Id)); // update owner and permissions
+        refreshableJob.Job = ServiceLocator.Instance.CallHiveService((s) => s.GetJob(refreshableJob.Job.Id)); // update owner and permissions
         refreshableJob.Job.IsPrivileged = isPrivileged;
         cancellationToken.ThrowIfCancellationRequested();
 
-        int totalJobCount = refreshableJob.GetAllHiveJobs().Count();
+        int totalJobCount = refreshableJob.GetAllHiveTasks().Count();
         int[] jobCount = new int[1]; // use a reference type (int-array) instead of value type (int) in order to pass the value via a delegate to task-parallel-library
         cancellationToken.ThrowIfCancellationRequested();
@@ -284,7 +284,7 @@
 
         var tasks = new List<TS.Task>();
-        foreach (HiveTask hiveJob in refreshableJob.HiveJobs) {
+        foreach (HiveTask hiveJob in refreshableJob.HiveTasks) {
           tasks.Add(TS.Task.Factory.StartNew((hj) => {
-            UploadJobWithChildren(refreshableJob.Progress, (HiveTask)hj, null, resourceIds, jobCount, totalJobCount, configFilePlugin.Id, refreshableJob.Job.Id, refreshableJob.Log, refreshableJob.Job.IsPrivileged, cancellationToken);
+            UploadTaskWithChildren(refreshableJob.Progress, (HiveTask)hj, null, resourceIds, jobCount, totalJobCount, configFilePlugin.Id, refreshableJob.Job.Id, refreshableJob.Log, refreshableJob.Job.IsPrivileged, cancellationToken);
           }, hiveJob)
           .ContinueWith((x) => refreshableJob.Log.LogException(x.Exception), TaskContinuationOptions.OnlyOnFaulted));
@@ -334,5 +334,5 @@
     /// </summary>
     /// <param name="parentHiveTask">shall be null if its the root task</param>
-    private void UploadJobWithChildren(IProgress progress, HiveTask hiveJob, HiveTask parentHiveJob, IEnumerable<Guid> groups, int[] jobCount, int totalJobCount, Guid configPluginId, Guid hiveExperimentId, ILog log, bool isPrivileged, CancellationToken cancellationToken) {
+    private void UploadTaskWithChildren(IProgress progress, HiveTask hiveTask, HiveTask parentHiveJob, IEnumerable<Guid> groups, int[] taskCount, int totalJobCount, Guid configPluginId, Guid jobId, ILog log, bool isPrivileged, CancellationToken cancellationToken) {
       jobUploadSemaphore.WaitOne();
       bool semaphoreReleased = false;
@@ -340,17 +340,17 @@
         cancellationToken.ThrowIfCancellationRequested();
         lock (jobCountLocker) {
-          jobCount[0]++;
+          taskCount[0]++;
         }
         TaskData jobData;
         List<IPluginDescription> plugins;
 
-        if (hiveJob.ItemTask.ComputeInParallel && (hiveJob.ItemTask.Item is Optimization.Experiment || hiveJob.ItemTask.Item is Optimization.BatchRun)) {
-          hiveJob.Task.IsParentTask = true;
-          hiveJob.Task.FinishWhenChildJobsFinished = true;
-          jobData = hiveJob.GetAsTaskData(true, out plugins);
+        if (hiveTask.ItemTask.ComputeInParallel && (hiveTask.ItemTask.Item is Optimization.Experiment || hiveTask.ItemTask.Item is Optimization.BatchRun)) {
+          hiveTask.Task.IsParentTask = true;
+          hiveTask.Task.FinishWhenChildJobsFinished = true;
+          jobData = hiveTask.GetAsTaskData(true, out plugins);
         } else {
-          hiveJob.Task.IsParentTask = false;
-          hiveJob.Task.FinishWhenChildJobsFinished = false;
-          jobData = hiveJob.GetAsTaskData(false, out plugins);
+          hiveTask.Task.IsParentTask = false;
+          hiveTask.Task.FinishWhenChildJobsFinished = false;
+          jobData = hiveTask.GetAsTaskData(false, out plugins);
         }
         cancellationToken.ThrowIfCancellationRequested();
@@ -359,20 +359,20 @@
           if (!cancellationToken.IsCancellationRequested) {
             lock (pluginLocker) {
-              ServiceLocator.Instance.CallHiveService((s) => hiveJob.Task.PluginsNeededIds = PluginUtil.GetPluginDependencies(s, this.onlinePlugins, this.alreadyUploadedPlugins, plugins));
+              ServiceLocator.Instance.CallHiveService((s) => hiveTask.Task.PluginsNeededIds = PluginUtil.GetPluginDependencies(s, this.onlinePlugins, this.alreadyUploadedPlugins, plugins));
             }
           }
         }, -1, "Failed to upload plugins");
         cancellationToken.ThrowIfCancellationRequested();
-        hiveJob.Task.PluginsNeededIds.Add(configPluginId);
-        hiveJob.Task.JobId = hiveExperimentId;
-        hiveJob.Task.IsPrivileged = isPrivileged;
-
-        log.LogMessage(string.Format("Uploading task ({0} kb, {1} objects)", jobData.Data.Count() / 1024, hiveJob.ItemTask.GetObjectGraphObjects().Count()));
+        hiveTask.Task.PluginsNeededIds.Add(configPluginId);
+        hiveTask.Task.JobId = jobId;
+        hiveTask.Task.IsPrivileged = isPrivileged;
+
+        log.LogMessage(string.Format("Uploading task ({0} kb, {1} objects)", jobData.Data.Count() / 1024, hiveTask.ItemTask.GetObjectGraphObjects().Count()));
         TryAndRepeat(() => {
           if (!cancellationToken.IsCancellationRequested) {
             if (parentHiveJob != null) {
-              hiveJob.Task.Id = ServiceLocator.Instance.CallHiveService((s) => s.AddChildJob(parentHiveJob.Task.Id, hiveJob.Task, jobData));
+              hiveTask.Task.Id = ServiceLocator.Instance.CallHiveService((s) => s.AddChildTask(parentHiveJob.Task.Id, hiveTask.Task, jobData));
             } else {
-              hiveJob.Task.Id = ServiceLocator.Instance.CallHiveService((s) => s.AddJob(hiveJob.Task, jobData, groups.ToList()));
+              hiveTask.Task.Id = ServiceLocator.Instance.CallHiveService((s) => s.AddTask(hiveTask.Task, jobData, groups.ToList()));
             }
           }
@@ -381,14 +381,14 @@
 
         lock (jobCountLocker) {
-          progress.ProgressValue = (double)jobCount[0] / totalJobCount;
-          progress.Status = string.Format("Uploaded task ({0} of {1})", jobCount[0], totalJobCount);
+          progress.ProgressValue = (double)taskCount[0] / totalJobCount;
+          progress.Status = string.Format("Uploaded task ({0} of {1})", taskCount[0], totalJobCount);
         }
 
         var tasks = new List<TS.Task>();
-        foreach (HiveTask child in hiveJob.ChildHiveTasks) {
+        foreach (HiveTask child in hiveTask.ChildHiveTasks) {
           tasks.Add(TS.Task.Factory.StartNew((tuple) => {
             var arguments = (Tuple<HiveTask, HiveTask>)tuple;
-            UploadJobWithChildren(progress, arguments.Item1, arguments.Item2, groups, jobCount, totalJobCount, configPluginId, hiveExperimentId, log, isPrivileged, cancellationToken);
-          }, new Tuple<HiveTask, HiveTask>(child, hiveJob))
+            UploadTaskWithChildren(progress, arguments.Item1, arguments.Item2, groups, taskCount, totalJobCount, configPluginId, jobId, log, isPrivileged, cancellationToken);
+          }, new Tuple<HiveTask, HiveTask>(child, hiveTask))
           .ContinueWith((x) => log.LogException(x.Exception), TaskContinuationOptions.OnlyOnFaulted));
         }
@@ -408,5 +408,5 @@
 
     #region Download Experiment
-    public static void LoadExperiment(RefreshableJob refreshableJob) {
+    public static void LoadJob(RefreshableJob refreshableJob) {
       var hiveExperiment = refreshableJob.Job;
       refreshableJob.Progress = new Progress();
@@ -415,13 +415,13 @@
         refreshableJob.IsProgressing = true;
         int totalJobCount = 0;
-        IEnumerable<LightweightTask> allJobs;
+        IEnumerable<LightweightTask> allTasks;
 
         refreshableJob.Progress.Status = "Connecting to Server...";
         // fetch all Task objects to create the full tree of tree of HiveTask objects
         refreshableJob.Progress.Status = "Downloading list of jobs...";
-        allJobs = ServiceLocator.Instance.CallHiveService(s => s.GetLightweightExperimentJobs(hiveExperiment.Id));
-        totalJobCount = allJobs.Count();
-
-        TaskDownloader downloader = new TaskDownloader(allJobs.Select(x => x.Id));
+        allTasks = ServiceLocator.Instance.CallHiveService(s => s.GetLightweightJobTasks(hiveExperiment.Id));
+        totalJobCount = allTasks.Count();
+
+        TaskDownloader downloader = new TaskDownloader(allTasks.Select(x => x.Id));
         downloader.StartAsync();
 
@@ -435,7 +435,7 @@
           }
         }
-        IDictionary<Guid, HiveTask> allHiveJobs = downloader.Results;
-
-        refreshableJob.HiveJobs = new ItemCollection<HiveTask>(allHiveJobs.Values.Where(x => !x.Task.ParentTaskId.HasValue));
+        IDictionary<Guid, HiveTask> allHiveTasks = downloader.Results;
+
+        refreshableJob.HiveTasks = new ItemCollection<HiveTask>(allHiveTasks.Values.Where(x => !x.Task.ParentTaskId.HasValue));
 
         if (refreshableJob.IsFinished()) {
@@ -446,6 +446,6 @@
 
         // build child-task tree
-        foreach (HiveTask hiveJob in refreshableJob.HiveJobs) {
-          BuildHiveJobTree(hiveJob, allJobs, allHiveJobs);
+        foreach (HiveTask hiveTask in refreshableJob.HiveTasks) {
+          BuildHiveJobTree(hiveTask, allTasks, allHiveTasks);
         }
 
@@ -482,5 +482,5 @@
 
     public static ItemTask LoadItemJob(Guid jobId) {
-      TaskData jobData = ServiceLocator.Instance.CallHiveService(s => s.GetJobData(jobId));
+      TaskData jobData = ServiceLocator.Instance.CallHiveService(s => s.GetTaskData(jobId));
       try {
         return PersistenceUtil.Deserialize<ItemTask>(jobData.Data);
@@ -506,11 +506,11 @@
     }
 
-    public static HiveItemCollection<JobPermission> GetHiveExperimentPermissions(Guid hiveExperimentId) {
+    public static HiveItemCollection<JobPermission> GetJobPermissions(Guid jobId) {
       return ServiceLocator.Instance.CallHiveService((service) => {
-        IEnumerable<JobPermission> heps = service.GetHiveExperimentPermissions(hiveExperimentId);
-        foreach (var hep in heps) {
+        IEnumerable<JobPermission> jps = service.GetJobPermissions(jobId);
+        foreach (var hep in jps) {
           hep.GrantedUserName = service.GetUsernameByUserId(hep.GrantedUserId);
         }
-        return new HiveItemCollection<JobPermission>(heps);
+        return new HiveItemCollection<JobPermission>(jps);
       });
     }
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.3/HiveJobs/HiveTask.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.3/HiveJobs/HiveTask.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.3/HiveJobs/HiveTask.cs	(revision 6743)
@@ -341,5 +341,5 @@
 
     /// <summary>
-    /// Returns a list of HiveJobs including this and all its child-jobs recursively
+    /// Returns a list of HiveTasks including this and all its child-jobs recursively
     /// </summary>
     public IEnumerable<HiveTask> GetAllHiveTasks() {
@@ -453,10 +453,10 @@
         try {
           foreach (var child in childHiveTasks) {
-            ServiceLocator.Instance.CallHiveService(s => s.PauseJob(child.task.Id));
+            ServiceLocator.Instance.CallHiveService(s => s.PauseTask(child.task.Id));
           }
         }
         finally { childHiveTasksLock.ExitReadLock(); }
       } else {
-        ServiceLocator.Instance.CallHiveService(s => s.PauseJob(this.task.Id));
+        ServiceLocator.Instance.CallHiveService(s => s.PauseTask(this.task.Id));
       }
     }
@@ -467,10 +467,10 @@
         try {
           foreach (var child in childHiveTasks) {
-            ServiceLocator.Instance.CallHiveService(s => s.StopJob(child.task.Id));
+            ServiceLocator.Instance.CallHiveService(s => s.StopTask(child.task.Id));
           }
         }
         finally { childHiveTasksLock.ExitReadLock(); }
       } else {
-        ServiceLocator.Instance.CallHiveService(s => s.StopJob(this.task.Id));
+        ServiceLocator.Instance.CallHiveService(s => s.StopTask(this.task.Id));
       }
     }
@@ -481,8 +481,8 @@
         taskData.TaskId = this.task.Id;
         taskData.Data = PersistenceUtil.Serialize(this.itemTask);
-        service.UpdateJobData(this.Task, taskData);
-        service.RestartJob(this.task.Id);
-        Task job = service.GetJob(this.task.Id);
-        this.task.LastJobDataUpdate = job.LastJobDataUpdate;
+        service.UpdateTaskData(this.Task, taskData);
+        service.RestartTask(this.task.Id);
+        Task task = service.GetTask(this.task.Id);
+        this.task.LastTaskDataUpdate = task.LastTaskDataUpdate;
       });
     }
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.3/JobResultPoller.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.3/JobResultPoller.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.3/JobResultPoller.cs	(revision 6743)
@@ -108,5 +108,5 @@
       return ServiceLocator.Instance.CallHiveService(service => {
         var responses = new List<LightweightTask>();
-        responses.AddRange(service.GetLightweightExperimentJobs(jobId));
+        responses.AddRange(service.GetLightweightJobTasks(jobId));
         OnJobResultsReceived(responses);
         return responses;
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.3/RefreshableJob.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.3/RefreshableJob.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.3/RefreshableJob.cs	(revision 6743)
@@ -55,12 +55,12 @@
     }
 
-    private ItemCollection<HiveTask> hiveJobs;
-    public ItemCollection<HiveTask> HiveJobs {
-      get { return hiveJobs; }
+    private ItemCollection<HiveTask> hiveTasks;
+    public ItemCollection<HiveTask> HiveTasks {
+      get { return hiveTasks; }
       set {
-        if (hiveJobs != value) {
-          if (hiveJobs != null) DeregisterHiveJobsEvents();
-          hiveJobs = value;
-          if (hiveJobs != null) RegisterHiveJobsEvents();
+        if (hiveTasks != value) {
+          if (hiveTasks != null) DeregisterHiveJobsEvents();
+          hiveTasks = value;
+          if (hiveTasks != null) RegisterHiveJobsEvents();
           OnHiveJobsChanged();
         }
@@ -100,5 +100,5 @@
           }
           if (RefreshAutomatically) {
-            if (this.HiveJobs != null && this.HiveJobs.Count > 0 && (jobResultPoller == null || !jobResultPoller.IsPolling)) {
+            if (this.HiveTasks != null && this.HiveTasks.Count > 0 && (jobResultPoller == null || !jobResultPoller.IsPolling)) {
               StartResultPolling();
             }
@@ -130,6 +130,6 @@
           isControllable = value;
           OnIsControllableChanged();
-          if (this.hiveJobs != null) {
-            foreach (var hiveJob in this.hiveJobs) {
+          if (this.hiveTasks != null) {
+            foreach (var hiveJob in this.hiveTasks) {
               hiveJob.IsControllable = value;
             }
@@ -186,5 +186,5 @@
 
     public StateLogListList StateLogList {
-      get { return new StateLogListList(this.GetAllHiveJobs().Select(x => x.StateLog)); }
+      get { return new StateLogListList(this.GetAllHiveTasks().Select(x => x.StateLog)); }
     }
 
@@ -196,5 +196,5 @@
       this.jobDownloader = new ConcurrentTaskDownloader<ItemTask>(2, 2);
       this.jobDownloader.ExceptionOccured += new EventHandler<EventArgs<Exception>>(jobDownloader_ExceptionOccured);
-      this.HiveJobs = new ItemCollection<HiveTask>();
+      this.HiveTasks = new ItemCollection<HiveTask>();
     }
     public RefreshableJob(Job hiveExperiment) {
@@ -204,5 +204,5 @@
       this.jobDownloader = new ConcurrentTaskDownloader<ItemTask>(2, 2);
       this.jobDownloader.ExceptionOccured += new EventHandler<EventArgs<Exception>>(jobDownloader_ExceptionOccured);
-      this.HiveJobs = new ItemCollection<HiveTask>();
+      this.HiveTasks = new ItemCollection<HiveTask>();
     }
     protected RefreshableJob(RefreshableJob original, Cloner cloner) {
@@ -214,5 +214,5 @@
       this.jobDownloader = new ConcurrentTaskDownloader<ItemTask>(2, 2);
       this.jobDownloader.ExceptionOccured += new EventHandler<EventArgs<Exception>>(jobDownloader_ExceptionOccured);
-      this.HiveJobs = cloner.Clone(original.HiveJobs);
+      this.HiveTasks = cloner.Clone(original.HiveTasks);
       this.ExecutionTime = original.ExecutionTime;
       this.ExecutionState = original.ExecutionState;
@@ -263,23 +263,23 @@
     }
     private void jobResultPoller_JobResultReceived(object sender, EventArgs<IEnumerable<LightweightTask>> e) {
-      foreach (LightweightTask lightweightJob in e.Value) {
-        HiveTask hiveJob = GetHiveJobById(lightweightJob.Id);
-        if (hiveJob != null) {
+      foreach (LightweightTask lightweightTask in e.Value) {
+        HiveTask hiveTask = GetHiveJobById(lightweightTask.Id);
+        if (hiveTask != null) {
           // lastJobDataUpdate equals DateTime.MinValue right after it was uploaded. When the first results are polled, this value is updated
-          if (hiveJob.Task.State == TaskState.Offline && lightweightJob.State != TaskState.Finished && lightweightJob.State != TaskState.Failed && lightweightJob.State != TaskState.Aborted) {
-            hiveJob.Task.LastJobDataUpdate = lightweightJob.LastJobDataUpdate;
+          if (hiveTask.Task.State == TaskState.Offline && lightweightTask.State != TaskState.Finished && lightweightTask.State != TaskState.Failed && lightweightTask.State != TaskState.Aborted) {
+            hiveTask.Task.LastTaskDataUpdate = lightweightTask.LastTaskDataUpdate;
           }
 
-          hiveJob.UpdateFromLightweightJob(lightweightJob);
-
-          if (!hiveJob.IsFinishedTaskDownloaded && !hiveJob.IsDownloading && hiveJob.Task.LastJobDataUpdate < lightweightJob.LastJobDataUpdate) {
-            log.LogMessage(string.Format("Downloading task {0}", lightweightJob.Id));
-            hiveJob.IsDownloading = true;
-            jobDownloader.DownloadJob(hiveJob.Task, (localJob, itemJob) => {
+          hiveTask.UpdateFromLightweightJob(lightweightTask);
+
+          if (!hiveTask.IsFinishedTaskDownloaded && !hiveTask.IsDownloading && hiveTask.Task.LastTaskDataUpdate < lightweightTask.LastTaskDataUpdate) {
+            log.LogMessage(string.Format("Downloading task {0}", lightweightTask.Id));
+            hiveTask.IsDownloading = true;
+            jobDownloader.DownloadTask(hiveTask.Task, (localJob, itemJob) => {
               log.LogMessage(string.Format("Finished downloading task {0}", localJob.Id));
-              HiveTask localHiveJob = GetHiveJobById(localJob.Id);
+              HiveTask localHiveTask = GetHiveJobById(localJob.Id);
 
               if (itemJob == null) {
-                localHiveJob.IsDownloading = false;
+                localHiveTask.IsDownloading = false;
               }
 
@@ -290,15 +290,15 @@
 
                 if (localJob.State == TaskState.Paused) {
-                  localHiveJob.ItemTask = itemJob;
+                  localHiveTask.ItemTask = itemJob;
                 } else {
                   if (localJob.ParentTaskId.HasValue) {
-                    HiveTask parentHiveJob = GetHiveJobById(localJob.ParentTaskId.Value);
-                    parentHiveJob.IntegrateChild(itemJob, localJob.Id);
+                    HiveTask parentHiveTask = GetHiveJobById(localJob.ParentTaskId.Value);
+                    parentHiveTask.IntegrateChild(itemJob, localJob.Id);
                   } else {
-                    localHiveJob.ItemTask = itemJob;
+                    localHiveTask.ItemTask = itemJob;
                   }
                 }
-                localHiveJob.IsDownloading = false;
-                localHiveJob.Task.LastJobDataUpdate = localJob.LastJobDataUpdate;
+                localHiveTask.IsDownloading = false;
+                localHiveTask.Task.LastTaskDataUpdate = localJob.LastTaskDataUpdate;
               }
             });
@@ -317,5 +317,5 @@
 
     public HiveTask GetHiveJobById(Guid jobId) {
-      foreach (HiveTask job in this.HiveJobs) {
+      foreach (HiveTask job in this.HiveTasks) {
         var hj = job.GetHiveTaskByTaskId(jobId);
         if (hj != null)
@@ -325,5 +325,5 @@
     }
     private void UpdateStatistics() {
-      var jobs = this.GetAllHiveJobs();
+      var jobs = this.GetAllHiveTasks();
       job.JobCount = jobs.Count();
       job.CalculatingCount = jobs.Count(j => j.Task.State == TaskState.Calculating);
@@ -333,5 +333,5 @@
 
     public bool AllJobsFinished() {
-      return this.GetAllHiveJobs().All(j => (j.Task.State == TaskState.Finished
+      return this.GetAllHiveTasks().All(j => (j.Task.State == TaskState.Finished
                                                    || j.Task.State == TaskState.Aborted
                                                    || j.Task.State == TaskState.Failed)
@@ -346,5 +346,5 @@
     }
     public void UpdateTotalExecutionTime() {
-      this.ExecutionTime = TimeSpan.FromMilliseconds(this.GetAllHiveJobs().Sum(x => x.Task.ExecutionTime.TotalMilliseconds));
+      this.ExecutionTime = TimeSpan.FromMilliseconds(this.GetAllHiveTasks().Sum(x => x.Task.ExecutionTime.TotalMilliseconds));
     }
     #endregion
@@ -468,15 +468,15 @@
     #endregion
 
-    #region HiveJobs Events
+    #region HiveTasks Events
     private void RegisterHiveJobsEvents() {
-      this.hiveJobs.ItemsAdded += new CollectionItemsChangedEventHandler<HiveTask>(hiveJobs_ItemsAdded);
-      this.hiveJobs.ItemsRemoved += new CollectionItemsChangedEventHandler<HiveTask>(hiveJobs_ItemsRemoved);
-      this.hiveJobs.CollectionReset += new CollectionItemsChangedEventHandler<HiveTask>(hiveJobs_CollectionReset);
+      this.hiveTasks.ItemsAdded += new CollectionItemsChangedEventHandler<HiveTask>(hiveJobs_ItemsAdded);
+      this.hiveTasks.ItemsRemoved += new CollectionItemsChangedEventHandler<HiveTask>(hiveJobs_ItemsRemoved);
+      this.hiveTasks.CollectionReset += new CollectionItemsChangedEventHandler<HiveTask>(hiveJobs_CollectionReset);
     }
 
     private void DeregisterHiveJobsEvents() {
-      this.hiveJobs.ItemsAdded -= new CollectionItemsChangedEventHandler<HiveTask>(hiveJobs_ItemsAdded);
-      this.hiveJobs.ItemsRemoved -= new CollectionItemsChangedEventHandler<HiveTask>(hiveJobs_ItemsRemoved);
-      this.hiveJobs.CollectionReset -= new CollectionItemsChangedEventHandler<HiveTask>(hiveJobs_CollectionReset);
+      this.hiveTasks.ItemsAdded -= new CollectionItemsChangedEventHandler<HiveTask>(hiveJobs_ItemsAdded);
+      this.hiveTasks.ItemsRemoved -= new CollectionItemsChangedEventHandler<HiveTask>(hiveJobs_ItemsRemoved);
+      this.hiveTasks.CollectionReset -= new CollectionItemsChangedEventHandler<HiveTask>(hiveJobs_CollectionReset);
     }
 
@@ -514,5 +514,5 @@
         DeregisterResultPollingEvents();
       }
-      if (this.HiveJobs != null && this.HiveJobs.Count > 0 && this.GetAllHiveJobs().All(x => x.Task.Id != Guid.Empty)) {
+      if (this.HiveTasks != null && this.HiveTasks.Count > 0 && this.GetAllHiveTasks().All(x => x.Task.Id != Guid.Empty)) {
         if (this.RefreshAutomatically)
           StartResultPolling();
@@ -581,16 +581,16 @@
 
     public bool IsFinished() {
-      return HiveJobs != null
-        && HiveJobs.All(x => x.Task.DateFinished.HasValue && x.Task.DateCreated.HasValue);
-    }
-
-    public IEnumerable<HiveTask> GetAllHiveJobs() {
-      if (hiveJobs == null) return Enumerable.Empty<HiveTask>();
-
-      var jobs = new List<HiveTask>();
-      foreach (HiveTask job in HiveJobs) {
-        jobs.AddRange(job.GetAllHiveTasks());
-      }
-      return jobs;
+      return HiveTasks != null
+        && HiveTasks.All(x => x.Task.DateFinished.HasValue && x.Task.DateCreated.HasValue);
+    }
+
+    public IEnumerable<HiveTask> GetAllHiveTasks() {
+      if (hiveTasks == null) return Enumerable.Empty<HiveTask>();
+
+      var tasks = new List<HiveTask>();
+      foreach (HiveTask task in HiveTasks) {
+        tasks.AddRange(task.GetAllHiveTasks());
+      }
+      return tasks;
     }
 
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.3/ServiceClients/HiveServiceClient.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.3/ServiceClients/HiveServiceClient.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.3/ServiceClients/HiveServiceClient.cs	(revision 6743)
@@ -59,6 +59,4 @@
 
     public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
-
-
   }
 
@@ -77,5 +75,5 @@
 
     [System.Runtime.Serialization.OptionalFieldAttribute()]
-    private System.DateTime LastJobDataUpdateField;
+    private System.DateTime LastTaskDataUpdateField;
 
     [System.Runtime.Serialization.OptionalFieldAttribute()]
@@ -115,12 +113,12 @@
 
     [System.Runtime.Serialization.DataMemberAttribute()]
-    public System.DateTime LastJobDataUpdate {
-      get {
-        return this.LastJobDataUpdateField;
-      }
-      set {
-        if ((this.LastJobDataUpdateField.Equals(value) != true)) {
-          this.LastJobDataUpdateField = value;
-          this.RaisePropertyChanged("LastJobDataUpdate");
+    public System.DateTime LastTaskDataUpdate {
+      get {
+        return this.LastTaskDataUpdateField;
+      }
+      set {
+        if ((this.LastTaskDataUpdateField.Equals(value) != true)) {
+          this.LastTaskDataUpdateField = value;
+          this.RaisePropertyChanged("LastTaskDataUpdate");
         }
       }
@@ -1577,6 +1575,6 @@
     System.Guid GetResourceId(string resourceName);
 
-    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/GetJobsByResourceId", ReplyAction = "http://tempuri.org/IHiveService/GetJobsByResourceIdResponse")]
-    System.Collections.Generic.List<HeuristicLab.Clients.Hive.Task> GetJobsByResourceId(System.Guid resourceId);
+    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/GetTasksByResourceId", ReplyAction = "http://tempuri.org/IHiveService/GetTasksByResourceIdResponse")]
+    System.Collections.Generic.List<HeuristicLab.Clients.Hive.Task> GetTasksByResourceId(System.Guid resourceId);
 
     [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/TriggerEventManager", ReplyAction = "http://tempuri.org/IHiveService/TriggerEventManagerResponse")]
@@ -1601,78 +1599,78 @@
     System.Guid GetUserIdByUsername(string username);
 
+    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/AddTask", ReplyAction = "http://tempuri.org/IHiveService/AddTaskResponse")]
+    System.Guid AddTask(HeuristicLab.Clients.Hive.Task task, HeuristicLab.Clients.Hive.TaskData taskData, System.Collections.Generic.List<System.Guid> resourceIds);
+
+    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/AddChildTask", ReplyAction = "http://tempuri.org/IHiveService/AddChildTaskResponse")]
+    System.Guid AddChildTask(System.Guid parentTaskId, HeuristicLab.Clients.Hive.Task task, HeuristicLab.Clients.Hive.TaskData taskData);
+
+    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/GetTask", ReplyAction = "http://tempuri.org/IHiveService/GetTaskResponse")]
+    HeuristicLab.Clients.Hive.Task GetTask(System.Guid taskId);
+
+    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/GetTasks", ReplyAction = "http://tempuri.org/IHiveService/GetTasksResponse")]
+    System.Collections.Generic.List<HeuristicLab.Clients.Hive.Task> GetTasks();
+
+    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/GetLightweightTasks", ReplyAction = "http://tempuri.org/IHiveService/GetLightweightTasksResponse")]
+    System.Collections.Generic.List<HeuristicLab.Clients.Hive.LightweightTask> GetLightweightTasks(System.Collections.Generic.List<System.Guid> taskIds);
+
+    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/GetLightweightChildTasks", ReplyAction = "http://tempuri.org/IHiveService/GetLightweightChildTasksResponse")]
+    System.Collections.Generic.List<HeuristicLab.Clients.Hive.LightweightTask> GetLightweightChildTasks(System.Nullable<System.Guid> parentTaskId, bool recursive, bool includeParent);
+
+    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/GetLightweightJobTasks", ReplyAction = "http://tempuri.org/IHiveService/GetLightweightJobTasksResponse")]
+    System.Collections.Generic.List<HeuristicLab.Clients.Hive.LightweightTask> GetLightweightJobTasks(System.Guid jobId);
+
+    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/GetTaskData", ReplyAction = "http://tempuri.org/IHiveService/GetTaskDataResponse")]
+    HeuristicLab.Clients.Hive.TaskData GetTaskData(System.Guid taskId);
+
+    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/UpdateTask", ReplyAction = "http://tempuri.org/IHiveService/UpdateTaskResponse")]
+    void UpdateTask(HeuristicLab.Clients.Hive.Task taskDto);
+
+    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/UpdateTaskData", ReplyAction = "http://tempuri.org/IHiveService/UpdateTaskDataResponse")]
+    void UpdateTaskData(HeuristicLab.Clients.Hive.Task taskDto, HeuristicLab.Clients.Hive.TaskData taskDataDto);
+
+    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/DeleteTask", ReplyAction = "http://tempuri.org/IHiveService/DeleteTaskResponse")]
+    void DeleteTask(System.Guid taskId);
+
+    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/DeleteChildTasks", ReplyAction = "http://tempuri.org/IHiveService/DeleteChildTasksResponse")]
+    void DeleteChildTasks(System.Guid parentTaskId);
+
+    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/UpdateTaskState", ReplyAction = "http://tempuri.org/IHiveService/UpdateTaskStateResponse")]
+    HeuristicLab.Clients.Hive.Task UpdateTaskState(System.Guid taskId, HeuristicLab.Clients.Hive.TaskState taskState, System.Nullable<System.Guid> slaveId, System.Nullable<System.Guid> userId, string exception);
+
+    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/StopTask", ReplyAction = "http://tempuri.org/IHiveService/StopTaskResponse")]
+    void StopTask(System.Guid taskId);
+
+    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/PauseTask", ReplyAction = "http://tempuri.org/IHiveService/PauseTaskResponse")]
+    void PauseTask(System.Guid taskId);
+
+    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/RestartTask", ReplyAction = "http://tempuri.org/IHiveService/RestartTaskResponse")]
+    void RestartTask(System.Guid taskId);
+
+    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/GetJob", ReplyAction = "http://tempuri.org/IHiveService/GetJobResponse")]
+    HeuristicLab.Clients.Hive.Job GetJob(System.Guid id);
+
+    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/GetJobs", ReplyAction = "http://tempuri.org/IHiveService/GetJobsResponse")]
+    System.Collections.Generic.List<HeuristicLab.Clients.Hive.Job> GetJobs();
+
+    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/GetAllJobs", ReplyAction = "http://tempuri.org/IHiveService/GetAllJobsResponse")]
+    System.Collections.Generic.List<HeuristicLab.Clients.Hive.Job> GetAllJobs();
+
     [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/AddJob", ReplyAction = "http://tempuri.org/IHiveService/AddJobResponse")]
-    System.Guid AddJob(HeuristicLab.Clients.Hive.Task job, HeuristicLab.Clients.Hive.TaskData jobData, System.Collections.Generic.List<System.Guid> resourceIds);
-
-    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/AddChildJob", ReplyAction = "http://tempuri.org/IHiveService/AddChildJobResponse")]
-    System.Guid AddChildJob(System.Guid parentJobId, HeuristicLab.Clients.Hive.Task job, HeuristicLab.Clients.Hive.TaskData jobData);
-
-    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/GetJob", ReplyAction = "http://tempuri.org/IHiveService/GetJobResponse")]
-    HeuristicLab.Clients.Hive.Task GetJob(System.Guid jobId);
-
-    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/GetJobs", ReplyAction = "http://tempuri.org/IHiveService/GetJobsResponse")]
-    System.Collections.Generic.List<HeuristicLab.Clients.Hive.Task> GetJobs();
-
-    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/GetLightweightJobs", ReplyAction = "http://tempuri.org/IHiveService/GetLightweightJobsResponse")]
-    System.Collections.Generic.List<HeuristicLab.Clients.Hive.LightweightTask> GetLightweightJobs(System.Collections.Generic.List<System.Guid> jobIds);
-
-    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/GetLightweightChildJobs", ReplyAction = "http://tempuri.org/IHiveService/GetLightweightChildJobsResponse")]
-    System.Collections.Generic.List<HeuristicLab.Clients.Hive.LightweightTask> GetLightweightChildJobs(System.Nullable<System.Guid> parentJobId, bool recursive, bool includeParent);
-
-    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/GetLightweightExperimentJobs", ReplyAction = "http://tempuri.org/IHiveService/GetLightweightExperimentJobsResponse")]
-    System.Collections.Generic.List<HeuristicLab.Clients.Hive.LightweightTask> GetLightweightExperimentJobs(System.Guid experimentId);
-
-    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/GetJobData", ReplyAction = "http://tempuri.org/IHiveService/GetJobDataResponse")]
-    HeuristicLab.Clients.Hive.TaskData GetJobData(System.Guid jobId);
+    System.Guid AddJob(HeuristicLab.Clients.Hive.Job jobDto);
 
     [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/UpdateJob", ReplyAction = "http://tempuri.org/IHiveService/UpdateJobResponse")]
-    void UpdateJob(HeuristicLab.Clients.Hive.Task jobDto);
-
-    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/UpdateJobData", ReplyAction = "http://tempuri.org/IHiveService/UpdateJobDataResponse")]
-    void UpdateJobData(HeuristicLab.Clients.Hive.Task jobDto, HeuristicLab.Clients.Hive.TaskData jobDataDto);
+    void UpdateJob(HeuristicLab.Clients.Hive.Job jobDto);
 
     [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/DeleteJob", ReplyAction = "http://tempuri.org/IHiveService/DeleteJobResponse")]
-    void DeleteJob(System.Guid jobId);
-
-    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/DeleteChildJobs", ReplyAction = "http://tempuri.org/IHiveService/DeleteChildJobsResponse")]
-    void DeleteChildJobs(System.Guid parentJobId);
-
-    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/UpdateJobState", ReplyAction = "http://tempuri.org/IHiveService/UpdateJobStateResponse")]
-    HeuristicLab.Clients.Hive.Task UpdateJobState(System.Guid jobId, HeuristicLab.Clients.Hive.TaskState jobState, System.Nullable<System.Guid> slaveId, System.Nullable<System.Guid> userId, string exception);
-
-    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/StopJob", ReplyAction = "http://tempuri.org/IHiveService/StopJobResponse")]
-    void StopJob(System.Guid jobId);
-
-    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/PauseJob", ReplyAction = "http://tempuri.org/IHiveService/PauseJobResponse")]
-    void PauseJob(System.Guid jobId);
-
-    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/RestartJob", ReplyAction = "http://tempuri.org/IHiveService/RestartJobResponse")]
-    void RestartJob(System.Guid jobId);
-
-    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/GetHiveExperiment", ReplyAction = "http://tempuri.org/IHiveService/GetHiveExperimentResponse")]
-    HeuristicLab.Clients.Hive.Job GetHiveExperiment(System.Guid id);
-
-    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/GetHiveExperiments", ReplyAction = "http://tempuri.org/IHiveService/GetHiveExperimentsResponse")]
-    System.Collections.Generic.List<HeuristicLab.Clients.Hive.Job> GetHiveExperiments();
-
-    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/GetAllHiveExperiments", ReplyAction = "http://tempuri.org/IHiveService/GetAllHiveExperimentsResponse")]
-    System.Collections.Generic.List<HeuristicLab.Clients.Hive.Job> GetAllHiveExperiments();
-
-    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/AddHiveExperiment", ReplyAction = "http://tempuri.org/IHiveService/AddHiveExperimentResponse")]
-    System.Guid AddHiveExperiment(HeuristicLab.Clients.Hive.Job hiveExperimentDto);
-
-    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/UpdateHiveExperiment", ReplyAction = "http://tempuri.org/IHiveService/UpdateHiveExperimentResponse")]
-    void UpdateHiveExperiment(HeuristicLab.Clients.Hive.Job hiveExperimentDto);
-
-    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/DeleteHiveExperiment", ReplyAction = "http://tempuri.org/IHiveService/DeleteHiveExperimentResponse")]
-    void DeleteHiveExperiment(System.Guid hiveExperimentId);
+    void DeleteJob(System.Guid JobId);
 
     [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/GrantPermission", ReplyAction = "http://tempuri.org/IHiveService/GrantPermissionResponse")]
-    void GrantPermission(System.Guid hiveExperimentId, System.Guid grantedUserId, HeuristicLab.Clients.Hive.Permission permission);
+    void GrantPermission(System.Guid jobId, System.Guid grantedUserId, HeuristicLab.Clients.Hive.Permission permission);
 
     [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/RevokePermission", ReplyAction = "http://tempuri.org/IHiveService/RevokePermissionResponse")]
     void RevokePermission(System.Guid hiveExperimentId, System.Guid grantedUserId);
 
-    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/GetHiveExperimentPermissions", ReplyAction = "http://tempuri.org/IHiveService/GetHiveExperimentPermissionsResponse")]
-    System.Collections.Generic.List<HeuristicLab.Clients.Hive.JobPermission> GetHiveExperimentPermissions(System.Guid hiveExperimentId);
+    [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/GetJobPermissions", ReplyAction = "http://tempuri.org/IHiveService/GetJobPermissionsResponse")]
+    System.Collections.Generic.List<HeuristicLab.Clients.Hive.JobPermission> GetJobPermissions(System.Guid jobId);
 
     [System.ServiceModel.OperationContractAttribute(Action = "http://tempuri.org/IHiveService/IsAllowedPrivileged", ReplyAction = "http://tempuri.org/IHiveService/IsAllowedPrivilegedResponse")]
@@ -1780,6 +1778,6 @@
     }
 
-    public System.Collections.Generic.List<HeuristicLab.Clients.Hive.Task> GetJobsByResourceId(System.Guid resourceId) {
-      return base.Channel.GetJobsByResourceId(resourceId);
+    public System.Collections.Generic.List<HeuristicLab.Clients.Hive.Task> GetTasksByResourceId(System.Guid resourceId) {
+      return base.Channel.GetTasksByResourceId(resourceId);
     }
 
@@ -1812,94 +1810,94 @@
     }
 
-    public System.Guid AddJob(HeuristicLab.Clients.Hive.Task job, HeuristicLab.Clients.Hive.TaskData jobData, System.Collections.Generic.List<System.Guid> resourceIds) {
-      return base.Channel.AddJob(job, jobData, resourceIds);
-    }
-
-    public System.Guid AddChildJob(System.Guid parentJobId, HeuristicLab.Clients.Hive.Task job, HeuristicLab.Clients.Hive.TaskData jobData) {
-      return base.Channel.AddChildJob(parentJobId, job, jobData);
-    }
-
-    public HeuristicLab.Clients.Hive.Task GetJob(System.Guid jobId) {
-      return base.Channel.GetJob(jobId);
-    }
-
-    public System.Collections.Generic.List<HeuristicLab.Clients.Hive.Task> GetJobs() {
+    public System.Guid AddTask(HeuristicLab.Clients.Hive.Task task, HeuristicLab.Clients.Hive.TaskData taskData, System.Collections.Generic.List<System.Guid> resourceIds) {
+      return base.Channel.AddTask(task, taskData, resourceIds);
+    }
+
+    public System.Guid AddChildTask(System.Guid parentTaskId, HeuristicLab.Clients.Hive.Task task, HeuristicLab.Clients.Hive.TaskData taskData) {
+      return base.Channel.AddChildTask(parentTaskId, task, taskData);
+    }
+
+    public HeuristicLab.Clients.Hive.Task GetTask(System.Guid taskId) {
+      return base.Channel.GetTask(taskId);
+    }
+
+    public System.Collections.Generic.List<HeuristicLab.Clients.Hive.Task> GetTasks() {
+      return base.Channel.GetTasks();
+    }
+
+    public System.Collections.Generic.List<HeuristicLab.Clients.Hive.LightweightTask> GetLightweightTasks(System.Collections.Generic.List<System.Guid> taskIds) {
+      return base.Channel.GetLightweightTasks(taskIds);
+    }
+
+    public System.Collections.Generic.List<HeuristicLab.Clients.Hive.LightweightTask> GetLightweightChildTasks(System.Nullable<System.Guid> parentTaskId, bool recursive, bool includeParent) {
+      return base.Channel.GetLightweightChildTasks(parentTaskId, recursive, includeParent);
+    }
+
+    public System.Collections.Generic.List<HeuristicLab.Clients.Hive.LightweightTask> GetLightweightJobTasks(System.Guid jobId) {
+      return base.Channel.GetLightweightJobTasks(jobId);
+    }
+
+    public HeuristicLab.Clients.Hive.TaskData GetTaskData(System.Guid taskId) {
+      return base.Channel.GetTaskData(taskId);
+    }
+
+    public void UpdateTask(HeuristicLab.Clients.Hive.Task taskDto) {
+      base.Channel.UpdateTask(taskDto);
+    }
+
+    public void UpdateTaskData(HeuristicLab.Clients.Hive.Task taskDto, HeuristicLab.Clients.Hive.TaskData taskDataDto) {
+      base.Channel.UpdateTaskData(taskDto, taskDataDto);
+    }
+
+    public void DeleteTask(System.Guid taskId) {
+      base.Channel.DeleteTask(taskId);
+    }
+
+    public void DeleteChildTasks(System.Guid parentTaskId) {
+      base.Channel.DeleteChildTasks(parentTaskId);
+    }
+
+    public HeuristicLab.Clients.Hive.Task UpdateTaskState(System.Guid taskId, HeuristicLab.Clients.Hive.TaskState taskState, System.Nullable<System.Guid> slaveId, System.Nullable<System.Guid> userId, string exception) {
+      return base.Channel.UpdateTaskState(taskId, taskState, slaveId, userId, exception);
+    }
+
+    public void StopTask(System.Guid taskId) {
+      base.Channel.StopTask(taskId);
+    }
+
+    public void PauseTask(System.Guid taskId) {
+      base.Channel.PauseTask(taskId);
+    }
+
+    public void RestartTask(System.Guid taskId) {
+      base.Channel.RestartTask(taskId);
+    }
+
+    public HeuristicLab.Clients.Hive.Job GetJob(System.Guid id) {
+      return base.Channel.GetJob(id);
+    }
+
+    public System.Collections.Generic.List<HeuristicLab.Clients.Hive.Job> GetJobs() {
       return base.Channel.GetJobs();
     }
 
-    public System.Collections.Generic.List<HeuristicLab.Clients.Hive.LightweightTask> GetLightweightJobs(System.Collections.Generic.List<System.Guid> jobIds) {
-      return base.Channel.GetLightweightJobs(jobIds);
-    }
-
-    public System.Collections.Generic.List<HeuristicLab.Clients.Hive.LightweightTask> GetLightweightChildJobs(System.Nullable<System.Guid> parentJobId, bool recursive, bool includeParent) {
-      return base.Channel.GetLightweightChildJobs(parentJobId, recursive, includeParent);
-    }
-
-    public System.Collections.Generic.List<HeuristicLab.Clients.Hive.LightweightTask> GetLightweightExperimentJobs(System.Guid experimentId) {
-      return base.Channel.GetLightweightExperimentJobs(experimentId);
-    }
-
-    public HeuristicLab.Clients.Hive.TaskData GetJobData(System.Guid jobId) {
-      return base.Channel.GetJobData(jobId);
-    }
-
-    public void UpdateJob(HeuristicLab.Clients.Hive.Task jobDto) {
+    public System.Collections.Generic.List<HeuristicLab.Clients.Hive.Job> GetAllJobs() {
+      return base.Channel.GetAllJobs();
+    }
+
+    public System.Guid AddJob(HeuristicLab.Clients.Hive.Job jobDto) {
+      return base.Channel.AddJob(jobDto);
+    }
+
+    public void UpdateJob(HeuristicLab.Clients.Hive.Job jobDto) {
       base.Channel.UpdateJob(jobDto);
     }
 
-    public void UpdateJobData(HeuristicLab.Clients.Hive.Task jobDto, HeuristicLab.Clients.Hive.TaskData jobDataDto) {
-      base.Channel.UpdateJobData(jobDto, jobDataDto);
-    }
-
-    public void DeleteJob(System.Guid jobId) {
-      base.Channel.DeleteJob(jobId);
-    }
-
-    public void DeleteChildJobs(System.Guid parentJobId) {
-      base.Channel.DeleteChildJobs(parentJobId);
-    }
-
-    public HeuristicLab.Clients.Hive.Task UpdateJobState(System.Guid jobId, HeuristicLab.Clients.Hive.TaskState jobState, System.Nullable<System.Guid> slaveId, System.Nullable<System.Guid> userId, string exception) {
-      return base.Channel.UpdateJobState(jobId, jobState, slaveId, userId, exception);
-    }
-
-    public void StopJob(System.Guid jobId) {
-      base.Channel.StopJob(jobId);
-    }
-
-    public void PauseJob(System.Guid jobId) {
-      base.Channel.PauseJob(jobId);
-    }
-
-    public void RestartJob(System.Guid jobId) {
-      base.Channel.RestartJob(jobId);
-    }
-
-    public HeuristicLab.Clients.Hive.Job GetHiveExperiment(System.Guid id) {
-      return base.Channel.GetHiveExperiment(id);
-    }
-
-    public System.Collections.Generic.List<HeuristicLab.Clients.Hive.Job> GetHiveExperiments() {
-      return base.Channel.GetHiveExperiments();
-    }
-
-    public System.Collections.Generic.List<HeuristicLab.Clients.Hive.Job> GetAllHiveExperiments() {
-      return base.Channel.GetAllHiveExperiments();
-    }
-
-    public System.Guid AddHiveExperiment(HeuristicLab.Clients.Hive.Job hiveExperimentDto) {
-      return base.Channel.AddHiveExperiment(hiveExperimentDto);
-    }
-
-    public void UpdateHiveExperiment(HeuristicLab.Clients.Hive.Job hiveExperimentDto) {
-      base.Channel.UpdateHiveExperiment(hiveExperimentDto);
-    }
-
-    public void DeleteHiveExperiment(System.Guid hiveExperimentId) {
-      base.Channel.DeleteHiveExperiment(hiveExperimentId);
-    }
-
-    public void GrantPermission(System.Guid hiveExperimentId, System.Guid grantedUserId, HeuristicLab.Clients.Hive.Permission permission) {
-      base.Channel.GrantPermission(hiveExperimentId, grantedUserId, permission);
+    public void DeleteJob(System.Guid JobId) {
+      base.Channel.DeleteJob(JobId);
+    }
+
+    public void GrantPermission(System.Guid jobId, System.Guid grantedUserId, HeuristicLab.Clients.Hive.Permission permission) {
+      base.Channel.GrantPermission(jobId, grantedUserId, permission);
     }
 
@@ -1908,6 +1906,6 @@
     }
 
-    public System.Collections.Generic.List<HeuristicLab.Clients.Hive.JobPermission> GetHiveExperimentPermissions(System.Guid hiveExperimentId) {
-      return base.Channel.GetHiveExperimentPermissions(hiveExperimentId);
+    public System.Collections.Generic.List<HeuristicLab.Clients.Hive.JobPermission> GetJobPermissions(System.Guid jobId) {
+      return base.Channel.GetJobPermissions(jobId);
     }
 
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.3/ServiceClients/LightweightTask.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.3/ServiceClients/LightweightTask.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.3/ServiceClients/LightweightTask.cs	(revision 6743)
@@ -42,5 +42,5 @@
       this.State = job.State;
       this.Command = job.Command;
-      this.LastJobDataUpdate = job.LastJobDataUpdate;
+      this.LastTaskDataUpdate = job.LastTaskDataUpdate;
     }
 
@@ -52,5 +52,5 @@
       this.State = original.State;
       this.Command = original.Command;
-      this.LastJobDataUpdate = original.LastJobDataUpdate;
+      this.LastTaskDataUpdate = original.LastTaskDataUpdate;
     }
     public override IDeepCloneable Clone(Cloner cloner) {
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.3/TaskDownloader.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.3/TaskDownloader.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.3/TaskDownloader.cs	(revision 6743)
@@ -72,18 +72,18 @@
     
     public void StartAsync() {
-      foreach (Guid jobId in taskIds) {
-        Task job = ServiceLocator.Instance.CallHiveService(s => s.GetJob(jobId));
+      foreach (Guid taskId in taskIds) {
+        Task task = ServiceLocator.Instance.CallHiveService(s => s.GetTask(taskId));
 
-        taskDownloader.DownloadJob(job,
+        taskDownloader.DownloadTask(task,
           (localJob, itemJob) => {
             if (localJob != null && itemJob != null) {
-              HiveTask hiveJob;
+              HiveTask hiveTask;
               if (itemJob is OptimizerTask) {
-                hiveJob = new OptimizerHiveTask((OptimizerTask)itemJob);
+                hiveTask = new OptimizerHiveTask((OptimizerTask)itemJob);
               } else {
-                hiveJob = new HiveTask(itemJob, true);
+                hiveTask = new HiveTask(itemJob, true);
               }
-              hiveJob.Task = localJob;
-              this.results.Add(localJob.Id, hiveJob);
+              hiveTask.Task = localJob;
+              this.results.Add(localJob.Id, hiveTask);
             }
           });
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Hive/3.3/HeuristicLab.Hive-3.3.csproj
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Hive/3.3/HeuristicLab.Hive-3.3.csproj	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Hive/3.3/HeuristicLab.Hive-3.3.csproj	(revision 6743)
@@ -77,7 +77,4 @@
       <HintPath>C:\Program Files\HeuristicLab 3.3\HeuristicLab.Core-3.3.dll</HintPath>
     </Reference>
-    <Reference Include="HeuristicLab.Persistence-3.3">
-      <HintPath>C:\Program Files\HeuristicLab 3.3\HeuristicLab.Persistence-3.3.dll</HintPath>
-    </Reference>
     <Reference Include="HeuristicLab.PluginInfrastructure-3.3">
       <HintPath>C:\Program Files\HeuristicLab 3.3\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Hive/3.3/HeuristicLabHivePlugin.cs.frame
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Hive/3.3/HeuristicLabHivePlugin.cs.frame	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Hive/3.3/HeuristicLabHivePlugin.cs.frame	(revision 6743)
@@ -9,6 +9,5 @@
   [PluginFile("HeuristicLab.Hive-3.3.dll", PluginFileType.Assembly)]
   [PluginDependency("HeuristicLab.Common", "3.3")]
-  [PluginDependency("HeuristicLab.Core", "3.3")]
-  [PluginDependency("HeuristicLab.Persistence", "3.3")]
+  [PluginDependency("HeuristicLab.Core", "3.3")]  
   public class HeuristicLabHivePlugin : PluginBase {
   }
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.HiveEngine/3.3/HiveEngine.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.HiveEngine/3.3/HiveEngine.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.HiveEngine/3.3/HiveEngine.cs	(revision 6743)
@@ -252,5 +252,5 @@
           var engineHiveJob = new EngineHiveTask(jobs[i], parentScopeClone);
           engineHiveJob.Task.Priority = this.Priority;
-          refreshableJob.HiveJobs.Add(engineHiveJob);
+          refreshableJob.HiveTasks.Add(engineHiveJob);
 
           // shuffle random variable to avoid the same random sequence in each operation; todo: does not yet work (it cannot find the random variable)
@@ -259,5 +259,5 @@
             random.Reset(random.Next());
         }
-        HiveClient.StartExperiment((e) => { log.LogException(e); }, refreshableJob, cancellationToken);
+        HiveClient.StartJob((e) => { log.LogException(e); }, refreshableJob, cancellationToken);
 
         // do polling until experiment is finished and all jobs are downloaded
@@ -269,5 +269,5 @@
         log.LogMessage(string.Format("{0} finished (TotalExecutionTime: {1}).", refreshableJob.ToString(), refreshableJob.ExecutionTime));
 
-        var failedJobs = refreshableJob.HiveJobs.Where(x => x.Task.State == TaskState.Failed);
+        var failedJobs = refreshableJob.HiveTasks.Where(x => x.Task.State == TaskState.Failed);
         if (failedJobs.Count() > 0) {
           throw new HiveEngineException("Task failed: " + failedJobs.First().Task.StateLog.Last().Exception);
@@ -276,5 +276,5 @@
         // get scopes
         int j = 0;
-        foreach (var hiveJob in refreshableJob.HiveJobs) {
+        foreach (var hiveJob in refreshableJob.HiveTasks) {
           var scope = ((IAtomicOperation)((EngineTask)hiveJob.ItemTask).InitialOperation).Scope;
           scopes[j++] = scope;
@@ -315,5 +315,5 @@
 
     private void ClearData(RefreshableJob refreshableJob) {
-      var jobs = refreshableJob.GetAllHiveJobs();
+      var jobs = refreshableJob.GetAllHiveTasks();
       foreach (var job in jobs) {
         job.ClearData();
@@ -321,7 +321,7 @@
     }
 
-    private void DeleteHiveExperiment(Guid hiveExperimentId) {
+    private void DeleteHiveExperiment(Guid jobId) {
       HiveClient.TryAndRepeat(() => {
-        ServiceLocator.Instance.CallHiveService(s => s.DeleteHiveExperiment(hiveExperimentId));
+        ServiceLocator.Instance.CallHiveService(s => s.DeleteJob(jobId));
       }, 5, string.Format("Could not delete jobs"));
     }
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.DataAccess/3.3/HeuristicLab.Services.Hive.DataAccess-3.3.csproj
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.DataAccess/3.3/HeuristicLab.Services.Hive.DataAccess-3.3.csproj	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.DataAccess/3.3/HeuristicLab.Services.Hive.DataAccess-3.3.csproj	(revision 6743)
@@ -71,13 +71,4 @@
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="HeuristicLab.Common-3.3">
-      <HintPath>C:\Program Files\HeuristicLab 3.3\HeuristicLab.Common-3.3.dll</HintPath>
-    </Reference>
-    <Reference Include="HeuristicLab.Core-3.3">
-      <HintPath>C:\Program Files\HeuristicLab 3.3\HeuristicLab.Core-3.3.dll</HintPath>
-    </Reference>
-    <Reference Include="HeuristicLab.Persistence-3.3">
-      <HintPath>C:\Program Files\HeuristicLab 3.3\HeuristicLab.Persistence-3.3.dll</HintPath>
-    </Reference>
     <Reference Include="HeuristicLab.PluginInfrastructure-3.3">
       <HintPath>C:\Program Files\HeuristicLab 3.3\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.DataAccess/3.3/HeuristicLabServicesHiveDataAccessPlugin.cs.frame
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.DataAccess/3.3/HeuristicLabServicesHiveDataAccessPlugin.cs.frame	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.DataAccess/3.3/HeuristicLabServicesHiveDataAccessPlugin.cs.frame	(revision 6743)
@@ -28,8 +28,5 @@
 namespace HeuristicLab.Services.Hive.DataAccess {
   [Plugin("HeuristicLab.Services.Hive.DataAccess", "3.3.5.$WCREV$")]
-  [PluginFile("HeuristicLab.Services.Hive.DataAccess-3.3.dll", PluginFileType.Assembly)]
-  [PluginDependency("HeuristicLab.Common", "3.3")]
-  [PluginDependency("HeuristicLab.Core", "3.3")]
-  [PluginDependency("HeuristicLab.Persistence", "3.3")]  
+  [PluginFile("HeuristicLab.Services.Hive.DataAccess-3.3.dll", PluginFileType.Assembly)]  
   public class HeuristicLabServicesHiveDataAccessPlugin : PluginBase {
   }
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.DataAccess/3.3/Logger.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.DataAccess/3.3/Logger.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.DataAccess/3.3/Logger.cs	(revision 6743)
@@ -28,5 +28,5 @@
   public class LogFactory {
     public static ILogger GetLogger(string source) {
-      return new Logger("HL.Hive", source);
+      return new Logger(Settings.Default.EventLogName, source);
     }
   }
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.DataAccess/3.3/Settings.Designer.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.DataAccess/3.3/Settings.Designer.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.DataAccess/3.3/Settings.Designer.cs	(revision 6743)
@@ -43,4 +43,13 @@
             }
         }
+        
+        [global::System.Configuration.ApplicationScopedSettingAttribute()]
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+        [global::System.Configuration.DefaultSettingValueAttribute("HL.Hive")]
+        public string EventLogName {
+            get {
+                return ((string)(this["EventLogName"]));
+            }
+        }
     }
 }
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.DataAccess/3.3/Settings.settings
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.DataAccess/3.3/Settings.settings	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.DataAccess/3.3/Settings.settings	(revision 6743)
@@ -14,4 +14,7 @@
       <Value Profile="(Default)">00:05:00</Value>
     </Setting>
+    <Setting Name="EventLogName" Type="System.String" Scope="Application">
+      <Value Profile="(Default)">HL.Hive</Value>
+    </Setting>
   </Settings>
 </SettingsFile>
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.DataAccess/3.3/app.config
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.DataAccess/3.3/app.config	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.DataAccess/3.3/app.config	(revision 6743)
@@ -6,5 +6,5 @@
     </sectionGroup>
   </configSections>
-  <connectionStrings>    
+  <connectionStrings>
     <add name="HeuristicLab.Services.Hive.DataAccess.Settings.HeuristicLab_Hive_LinqConnectionString"
       connectionString="Data Source=localhost;Initial Catalog=HeuristicLab.Hive-3.3;Integrated Security=True;"
@@ -16,4 +16,7 @@
         <value>00:05:00</value>
       </setting>
+      <setting name="EventLogName" serializeAs="String">
+        <value>HL.Hive</value>
+      </setting>
     </HeuristicLab.Services.Hive.DataAccess.Settings>
   </applicationSettings>
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.Tests/DaoTests.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.Tests/DaoTests.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.Tests/DaoTests.cs	(revision 6743)
@@ -49,5 +49,5 @@
       he.OwnerUserId = Guid.NewGuid();
       he.ResourceNames = "HEAL";
-      he.Id = dao.AddHiveExperiment(he);
+      he.Id = dao.AddJob(he);
 
       DT.Task job1 = new DT.Task();
@@ -80,9 +80,9 @@
       job1.PluginsNeededIds.Add(plugin1.Id);
 
-      job1.Id = dao.AddJob(job1);
+      job1.Id = dao.AddTask(job1);
       jobData1.TaskId = job1.Id;
-      dao.AddJobData(jobData1);
-
-      DT.Task job1loaded = dao.GetJob(job1.Id);
+      dao.AddTaskData(jobData1);
+
+      DT.Task job1loaded = dao.GetTask(job1.Id);
       Assert.AreEqual(job1.Id, job1loaded.Id);
       Assert.AreEqual(job1.CoresNeeded, job1loaded.CoresNeeded);
@@ -94,5 +94,5 @@
       Assert.AreEqual(job1.JobId, job1loaded.JobId);
       Assert.AreEqual(job1.IsPrivileged, job1loaded.IsPrivileged);
-      Assert.IsTrue(Math.Abs((job1loaded.LastJobDataUpdate - jobData1.LastUpdate).TotalSeconds) < 1);
+      Assert.IsTrue(Math.Abs((job1loaded.LastTaskDataUpdate - jobData1.LastUpdate).TotalSeconds) < 1);
       for (int i = 0; i < job1.StateLog.Count; i++) {
         Assert.AreEqual(job1.Id, job1loaded.StateLog[i].TaskId);
@@ -111,7 +111,7 @@
       job1.StateLog.Add(new DT.StateLog { State = DT.TaskState.Transferring, DateTime = DateTime.Now }); Thread.Sleep(10);
       job1.StateLog.Add(new DT.StateLog { State = DT.TaskState.Finished, DateTime = DateTime.Now }); Thread.Sleep(10);
-      dao.UpdateJob(job1);
-
-      job1loaded = dao.GetJob(job1.Id);
+      dao.UpdateTask(job1);
+
+      job1loaded = dao.GetTask(job1.Id);
       for (int i = 0; i < job1.StateLog.Count; i++) {
         Assert.AreEqual(job1.Id, job1loaded.StateLog[i].TaskId);
@@ -123,14 +123,14 @@
       }
 
-      DT.TaskData jobData1Loaded = dao.GetJobData(job1.Id);
+      DT.TaskData jobData1Loaded = dao.GetTaskData(job1.Id);
       Assert.AreEqual(jobData1.TaskId, jobData1Loaded.TaskId);
       Assert.IsTrue(Math.Abs((jobData1.LastUpdate - jobData1Loaded.LastUpdate).TotalSeconds) < 1);
       Assert.IsTrue(jobData1.Data.SequenceEqual(jobData1Loaded.Data));
 
-      dao.DeleteHiveExperiment(he.Id);
-
-      Assert.AreEqual(null, dao.GetJob(job1.Id));
-      Assert.AreEqual(null, dao.GetJobData(job1.Id));
-      Assert.AreEqual(null, dao.GetHiveExperiment(he.Id));
+      dao.DeleteJob(he.Id);
+
+      Assert.AreEqual(null, dao.GetTask(job1.Id));
+      Assert.AreEqual(null, dao.GetTaskData(job1.Id));
+      Assert.AreEqual(null, dao.GetJob(he.Id));
 
       dao.DeletePlugin(plugin1.Id);
@@ -220,5 +220,5 @@
       he.OwnerUserId = Guid.NewGuid();
       he.ResourceNames = "HEAL";
-      he.Id = dao.AddHiveExperiment(he);
+      he.Id = dao.AddJob(he);
 
       DT.Task job = new DT.Task();
@@ -226,5 +226,5 @@
       job.StateLog.Add(new DT.StateLog { State = DT.TaskState.Offline, DateTime = DateTime.Now });
       job.JobId = he.Id;
-      job.Id = dao.AddJob(job);
+      job.Id = dao.AddTask(job);
 
       DT.JobPermission perm = new DT.JobPermission();
@@ -233,19 +233,19 @@
       perm.GrantedUserId = Guid.NewGuid();
       perm.Permission = DT.Permission.Full;
-      dao.AddHiveExperimentPermission(perm);
-
-      DT.Job heLoaded = dao.GetHiveExperiment(he.Id);
+      dao.AddJobPermission(perm);
+
+      DT.Job heLoaded = dao.GetJob(he.Id);
       Assert.AreEqual(he.Id, heLoaded.Id);
       Assert.AreEqual(he.Name, heLoaded.Name);
       Assert.AreEqual(he.ResourceNames, heLoaded.ResourceNames);
-      //Assert.AreEqual(he.LastAccessed, heLoaded.LastAccessed);
-      //Assert.AreEqual(he.DateCreated, heLoaded.DateCreated);
-
-      DT.Task jobLoaded = dao.GetJob(job.Id);
+      //Assert.AreEqual(job.LastAccessed, heLoaded.LastAccessed);
+      //Assert.AreEqual(job.DateCreated, heLoaded.DateCreated);
+
+      DT.Task jobLoaded = dao.GetTask(job.Id);
       Assert.AreEqual(job.Id, jobLoaded.Id);
       Assert.AreEqual(job.State, jobLoaded.State);
       Assert.AreEqual(job.JobId, jobLoaded.JobId);
 
-      DT.JobPermission permLoaded = dao.GetHiveExperimentPermission(he.Id, perm.GrantedUserId);
+      DT.JobPermission permLoaded = dao.GetJobPermission(he.Id, perm.GrantedUserId);
       Assert.AreEqual(perm.JobId, permLoaded.JobId);
       Assert.AreEqual(perm.GrantedUserId, permLoaded.GrantedUserId);
@@ -253,8 +253,8 @@
       Assert.AreEqual(perm.Permission, permLoaded.Permission);
 
-      dao.DeleteHiveExperiment(he.Id);
-      Assert.AreEqual(null, dao.GetHiveExperiment(he.Id));
-      Assert.AreEqual(null, dao.GetJob(job.Id));
-      Assert.AreEqual(null, dao.GetHiveExperimentPermission(perm.JobId, perm.GrantedUserId));
+      dao.DeleteJob(he.Id);
+      Assert.AreEqual(null, dao.GetJob(he.Id));
+      Assert.AreEqual(null, dao.GetTask(job.Id));
+      Assert.AreEqual(null, dao.GetJobPermission(perm.JobId, perm.GrantedUserId));
 
     }
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.Tests/HeuristicLab.Services.Hive.Tests-3.3.csproj
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.Tests/HeuristicLab.Services.Hive.Tests-3.3.csproj	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.Tests/HeuristicLab.Services.Hive.Tests-3.3.csproj	(revision 6743)
@@ -85,5 +85,5 @@
       <SubType>Designer</SubType>
     </None>
-    <Shadow Include="Test References\HeuristicLab.Services.Hive-3.4.accessor" />
+    <Shadow Include="Test References\HeuristicLab.Services.Hive-3.3.accessor" />
   </ItemGroup>
   <ItemGroup />
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.Tests/Mocks/MockAuthorizationManager.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.Tests/Mocks/MockAuthorizationManager.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.Tests/Mocks/MockAuthorizationManager.cs	(revision 6743)
@@ -28,9 +28,9 @@
     }
 
-    public void AuthorizeForJob(Guid jobId, DataTransfer.Permission requiredPermission) {
+    public void AuthorizeForTask(Guid jobId, DataTransfer.Permission requiredPermission) {
       // ok.
     }
 
-    public void AuthorizeForExperiment(Guid experimentId, DataTransfer.Permission requiredPermission) {
+    public void AuthorizeForJob(Guid experimentId, DataTransfer.Permission requiredPermission) {
       // ok.
     }
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.Tests/ServiceTests.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.Tests/ServiceTests.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.Tests/ServiceTests.cs	(revision 6743)
@@ -98,12 +98,12 @@
 
       // add hive experiment
-      experiment.Id = service.AddHiveExperiment(experiment);
+      experiment.Id = service.AddJob(experiment);
 
       // add task
       job.JobId = experiment.Id;
-      job.Id = service.AddJob(job, jobData, new List<Guid> { slave.Id });
+      job.Id = service.AddTask(job, jobData, new List<Guid> { slave.Id });
 
       // test task
-      DT.Task jobLoaded = service.GetJob(job.Id);
+      DT.Task jobLoaded = service.GetTask(job.Id);
       Assert.AreEqual(job.Id, jobLoaded.Id);
       Assert.AreEqual(job.CoresNeeded, jobLoaded.CoresNeeded);
@@ -114,10 +114,10 @@
       Assert.AreEqual(job.JobId, jobLoaded.JobId);
 
-      DT.TaskData jobDataLoaded = service.GetJobData(job.Id);
+      DT.TaskData jobDataLoaded = service.GetTaskData(job.Id);
       Assert.AreEqual(job.Id, jobDataLoaded.TaskId);
       Assert.IsTrue(jobData.Data.SequenceEqual(jobDataLoaded.Data));
 
       // test hive experiment
-      DT.Job experimentLoaded = service.GetHiveExperiment(experiment.Id);
+      DT.Job experimentLoaded = service.GetJob(experiment.Id);
       Assert.AreEqual(experiment.Id, experimentLoaded.Id);
       Assert.AreEqual(experiment.Name, experimentLoaded.Name);
@@ -130,9 +130,9 @@
       Assert.AreEqual(job.Id, actions[0].TaskId);
 
-      jobLoaded = service.GetJob(job.Id);
+      jobLoaded = service.GetTask(job.Id);
       Assert.AreEqual(TaskState.Transferring, jobLoaded.State);
 
       // slave is responsible for updating state to 'Calculating'
-      service.UpdateJobState(jobLoaded.Id, DT.TaskState.Calculating, slave.Id, null, null);
+      service.UpdateTaskState(jobLoaded.Id, DT.TaskState.Calculating, slave.Id, null, null);
 
       // send progress
@@ -143,22 +143,22 @@
 
       // the task should be in state 'Calculating' now
-      jobLoaded = service.GetJob(job.Id);
+      jobLoaded = service.GetTask(job.Id);
       Assert.AreEqual(TaskState.Calculating, jobLoaded.State);
       Assert.AreEqual(new TimeSpan(1, 5, 10, 20, 30), jobLoaded.ExecutionTime);
 
       // test if the task is returned for the resource
-      var jobsBySlave = service.GetJobsByResourceId(slave.Id);
+      var jobsBySlave = service.GetTasksByResourceId(slave.Id);
       Assert.AreEqual(1, jobsBySlave.Count());
       Assert.AreEqual(job.Id, jobsBySlave.Single().Id);
 
       // set it to finished
-      service.UpdateJobState(jobLoaded.Id, DT.TaskState.Finished, slave.Id, null, null);
+      service.UpdateTaskState(jobLoaded.Id, DT.TaskState.Finished, slave.Id, null, null);
 
       // test if the task is returned for the resource (it should not be)
-      var jobsBySlave2 = service.GetJobsByResourceId(slave.Id);
+      var jobsBySlave2 = service.GetTasksByResourceId(slave.Id);
       Assert.AreEqual(0, jobsBySlave2.Count());
 
       // set task waiting again
-      service.UpdateJobState(job.Id, DT.TaskState.Waiting, null, null, string.Empty);
+      service.UpdateTaskState(job.Id, DT.TaskState.Waiting, null, null, string.Empty);
 
       // get task again
@@ -181,8 +181,8 @@
 
       // delete
-      service.DeleteHiveExperiment(experiment.Id);
-      Assert.AreEqual(null, service.GetHiveExperiment(experiment.Id));
-      Assert.AreEqual(null, service.GetJob(job.Id));
-      Assert.AreEqual(null, service.GetJobData(job.Id));
+      service.DeleteJob(experiment.Id);
+      Assert.AreEqual(null, service.GetJob(experiment.Id));
+      Assert.AreEqual(null, service.GetTask(job.Id));
+      Assert.AreEqual(null, service.GetTaskData(job.Id));
 
       // send another heartbeat with the deleted task; the server should command the abortion of the task
@@ -241,17 +241,17 @@
 
       // add hive experiment
-      experiment.Id = service.AddHiveExperiment(experiment);
+      experiment.Id = service.AddJob(experiment);
 
       // add parent task
       parentJob.JobId = experiment.Id;
-      parentJob.Id = service.AddJob(parentJob, parentJobData, new List<Guid> { slave.Id });
+      parentJob.Id = service.AddTask(parentJob, parentJobData, new List<Guid> { slave.Id });
 
       // add child task
       childJob.JobId = experiment.Id;
-      childJob.Id = service.AddChildJob(parentJob.Id, childJob, childJobData);
+      childJob.Id = service.AddChildTask(parentJob.Id, childJob, childJobData);
       childJob.ParentTaskId = parentJob.Id;
 
       // test child task
-      var childJobLoaded = service.GetJob(childJob.Id);
+      var childJobLoaded = service.GetTask(childJob.Id);
       Assert.AreEqual(childJob.ParentTaskId, childJobLoaded.ParentTaskId);
       Assert.AreEqual(childJob.JobId, childJobLoaded.JobId);
@@ -261,5 +261,5 @@
 
       // test parent task
-      var parentJobLoaded = service.GetJob(parentJob.Id);
+      var parentJobLoaded = service.GetTask(parentJob.Id);
       Assert.AreEqual(parentJob.JobId, parentJobLoaded.JobId);
       Assert.AreEqual(TaskState.Waiting, parentJobLoaded.State);
@@ -276,9 +276,9 @@
       service.TriggerEventManager(true);
 
-      parentJobLoaded = service.GetJob(parentJob.Id);
+      parentJobLoaded = service.GetTask(parentJob.Id);
       Assert.AreEqual(TaskState.Waiting, parentJobLoaded.State);
 
       // set child task to finished
-      childJobLoaded = service.UpdateJobState(childJobLoaded.Id, DT.TaskState.Finished, slave.Id, null, null);
+      childJobLoaded = service.UpdateTaskState(childJobLoaded.Id, DT.TaskState.Finished, slave.Id, null, null);
 
       // lifecycle - let it process one server-heartbeat; this should set the parent task to finished
@@ -286,11 +286,11 @@
 
       // test if parent task is finished
-      parentJobLoaded = service.GetJob(parentJob.Id);
+      parentJobLoaded = service.GetTask(parentJob.Id);
       Assert.AreEqual(TaskState.Finished, parentJobLoaded.State);
 
       // delete experiment
-      service.DeleteHiveExperiment(experiment.Id);
-      Assert.AreEqual(null, service.GetJob(parentJob.Id));
-      Assert.AreEqual(null, service.GetJob(childJob.Id));
+      service.DeleteJob(experiment.Id);
+      Assert.AreEqual(null, service.GetTask(parentJob.Id));
+      Assert.AreEqual(null, service.GetTask(childJob.Id));
 
       service.DeleteSlave(slave.Id);
@@ -305,9 +305,9 @@
       // create hive experiment
       DT.Job e1 = new DT.Job() { Name = "TestExperiment", Description = "" };
-      e1.Id = service.AddHiveExperiment(e1);
-
-      var e1loaded = service.GetHiveExperiment(e1.Id);
+      e1.Id = service.AddJob(e1);
+
+      var e1loaded = service.GetJob(e1.Id);
       Assert.AreEqual(Permission.Full, e1loaded.Permission);
-      var allExp = service.GetHiveExperiments();
+      var allExp = service.GetJobs();
       Assert.AreEqual(1, allExp.Count(x => x.Id == e1.Id));
 
@@ -315,9 +315,9 @@
       mockServiceLocator.SetCurrentUserId(MockUserManager.MockUserId2);
       try {
-        e1loaded = service.GetHiveExperiment(e1.Id);
+        e1loaded = service.GetJob(e1.Id);
         Assert.Fail("Access should not be possible");
       }
       catch { /* ok, cool */ }
-      allExp = service.GetHiveExperiments();
+      allExp = service.GetJobs();
       Assert.AreEqual(0, allExp.Count(x => x.Id == e1.Id));
 
@@ -335,7 +335,7 @@
       // back to user2
       mockServiceLocator.SetCurrentUserId(MockUserManager.MockUserId2);
-      e1loaded = service.GetHiveExperiment(e1.Id);
+      e1loaded = service.GetJob(e1.Id);
       Assert.AreEqual(Permission.Read, e1loaded.Permission);
-      allExp = service.GetHiveExperiments();
+      allExp = service.GetJobs();
       Assert.AreEqual(1, allExp.Count(x => x.Id == e1.Id));
 
@@ -353,7 +353,7 @@
       // back to user2
       mockServiceLocator.SetCurrentUserId(MockUserManager.MockUserId2);
-      e1loaded = service.GetHiveExperiment(e1.Id);
+      e1loaded = service.GetJob(e1.Id);
       Assert.AreEqual(Permission.Full, e1loaded.Permission);
-      allExp = service.GetHiveExperiments();
+      allExp = service.GetJobs();
       Assert.AreEqual(1, allExp.Count(x => x.Id == e1.Id));
 
@@ -368,14 +368,14 @@
       mockServiceLocator.SetCurrentUserId(MockUserManager.MockUserId2);
       try {
-        e1loaded = service.GetHiveExperiment(e1.Id);
+        e1loaded = service.GetJob(e1.Id);
         Assert.Fail("Access should not be possible");
       }
       catch { /* ok, cool */ }
-      allExp = service.GetHiveExperiments();
+      allExp = service.GetJobs();
       Assert.AreEqual(0, allExp.Count(x => x.Id == e1.Id));
 
       // back to user1
       mockServiceLocator.SetCurrentUserId(MockUserManager.MockUserId1);
-      service.DeleteHiveExperiment(e1.Id);
+      service.DeleteJob(e1.Id);
     }
   }
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.Tests/Test References/HeuristicLab.Services.Hive-3.3.accessor
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.Tests/Test References/HeuristicLab.Services.Hive-3.3.accessor	(revision 6743)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.Tests/Test References/HeuristicLab.Services.Hive-3.3.accessor	(revision 6743)
@@ -0,0 +1,2 @@
+HeuristicLab.Services.Hive-3.3.dll
+Desktop
Index: anches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.Tests/Test References/HeuristicLab.Services.Hive-3.4.accessor
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.Tests/Test References/HeuristicLab.Services.Hive-3.4.accessor	(revision 6742)
+++ 	(revision )
@@ -1,2 +1,0 @@
-HeuristicLab.Services.Hive-3.3.dll
-Desktop
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.Web/Hive-3.4/Status.aspx.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.Web/Hive-3.4/Status.aspx.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.Web/Hive-3.4/Status.aspx.cs	(revision 6743)
@@ -1,3 +1,24 @@
-﻿using System;
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab 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 HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -32,5 +53,5 @@
     int currentlyAvailableCores = onlineSlaves.Sum(s => s.Cores.Value);
     int currentlyUsedCores = currentlyAvailableCores - onlineSlaves.Sum(s => s.FreeCores.Value);
-    int currentlyJobsWaiting = ServiceLocator.Instance.HiveDao.GetJobs(x => x.State == DA.TaskState.Waiting).Count();
+    int currentlyJobsWaiting = ServiceLocator.Instance.HiveDao.GetTasks(x => x.State == DA.TaskState.Waiting).Count();
 
     this.availableCoresLabel.Text = currentlyAvailableCores.ToString();
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/Convert.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/Convert.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/Convert.cs	(revision 6743)
@@ -27,8 +27,7 @@
 using DT = HeuristicLab.Services.Hive.DataTransfer;
 
-
 namespace HeuristicLab.Services.Hive.DataTransfer {
   public static class Convert {
-    #region Job
+    #region Task
     public static DT.Task ToDto(DB.Task source) {
       if (source == null) return null;
@@ -47,5 +46,5 @@
         FinishWhenChildJobsFinished = source.FinishWhenChildJobsFinished,
         Command = Convert.ToDto(source.Command),
-        LastJobDataUpdate = (source.JobData == null ? DateTime.MinValue : source.JobData.LastUpdate),
+        LastTaskDataUpdate = (source.JobData == null ? DateTime.MinValue : source.JobData.LastUpdate),
         JobId = source.JobId,
         IsPrivileged = source.IsPrivileged
@@ -150,5 +149,5 @@
     #endregion
 
-    #region HiveExperimentPermission
+    #region JobPermission
     public static DT.JobPermission ToDto(DB.JobPermission source) {
       if (source == null) return null;
@@ -363,5 +362,4 @@
     }
     #endregion
-
 
     #region TaskData
@@ -433,5 +431,4 @@
     #endregion
 
-
     #region Command
     public static DT.Command? ToDto(DB.Command? source) {
@@ -462,5 +459,4 @@
         return null;
     }
-
     #endregion
 
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/DataTransfer/Heartbeat.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/DataTransfer/Heartbeat.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/DataTransfer/Heartbeat.cs	(revision 6743)
@@ -35,7 +35,7 @@
     public int FreeCores { get; set; }
     [DataMember]
-    public Dictionary<Guid, TimeSpan> JobProgress { get; set; } // TODO: define Type
+    public Dictionary<Guid, TimeSpan> JobProgress { get; set; }
     [DataMember]
-    public bool AssignJob { get; set; } // if false, the server will not assign a new job
+    public bool AssignJob { get; set; } // if false, the server will not assign a new task
     [DataMember]
     public float CpuUtilization { get; set; }
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/DataTransfer/LightweightTask.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/DataTransfer/LightweightTask.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/DataTransfer/LightweightTask.cs	(revision 6743)
@@ -40,5 +40,5 @@
     public Command? Command { get; set; }
     [DataMember]
-    public DateTime LastJobDataUpdate { get; set; }
+    public DateTime LastTaskDataUpdate { get; set; }
 
     public StateLog CurrentStateLog { get { return StateLog.LastOrDefault(); } }
@@ -50,12 +50,12 @@
     }
 
-    public LightweightTask(Task job) {
-      this.Id = job.Id;
-      this.ExecutionTime = job.ExecutionTime;
-      this.ParentTaskId = job.ParentTaskId;
-      this.StateLog = new List<StateLog>(job.StateLog);
-      this.State = job.State;
-      this.Command = job.Command;
-      this.LastJobDataUpdate = job.LastJobDataUpdate;
+    public LightweightTask(Task task) {
+      this.Id = task.Id;
+      this.ExecutionTime = task.ExecutionTime;
+      this.ParentTaskId = task.ParentTaskId;
+      this.StateLog = new List<StateLog>(task.StateLog);
+      this.State = task.State;
+      this.Command = task.Command;
+      this.LastTaskDataUpdate = task.LastTaskDataUpdate;
     }
   }
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/DataTransfer/Permission.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/DataTransfer/Permission.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/DataTransfer/Permission.cs	(revision 6743)
@@ -28,10 +28,10 @@
 
     /// <summary>
-    /// User can only download and view experiments
+    /// User can only download and view jobs
     /// </summary>
     Read,
 
     /// <summary>
-    /// User can pause, stop, restart, delete experiment. can also grant other 
+    /// User can pause, stop, restart, delete job. can also grant other 
     /// </summary>
     Full
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/DataTransfer/TaskState.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/DataTransfer/TaskState.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/DataTransfer/TaskState.cs	(revision 6743)
@@ -26,5 +26,5 @@
   public enum TaskState {
     /// <summary>
-    /// A task is offline as long as he is not yet submitted to the hive
+    /// A task is offline as long as job is not yet submitted to the hive
     /// </summary>
     Offline,
@@ -68,5 +68,5 @@
   public static class TaskStateExtensions {
     /// <summary>
-    /// This job is not yet done
+    /// This task is not yet done
     /// </summary>
     public static bool IsActive(this TaskState taskState) {
@@ -75,5 +75,5 @@
 
     /// <summary>
-    /// This job is Waiting
+    /// This task is Waiting
     /// </summary>
     public static bool IsWaiting(this TaskState taskState) {
@@ -82,5 +82,5 @@
 
     /// <summary>
-    /// This job is Finished || Failed || Aborted
+    /// This task is Finished || Failed || Aborted
     /// </summary>
     public static bool IsDone(this TaskState taskState) {
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/HeuristicLab.Services.Hive-3.3.csproj
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/HeuristicLab.Services.Hive-3.3.csproj	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/HeuristicLab.Services.Hive-3.3.csproj	(revision 6743)
@@ -74,8 +74,4 @@
     <Reference Include="HeuristicLab.Common-3.3">
       <HintPath>C:\Program Files\HeuristicLab 3.3\HeuristicLab.Common-3.3.dll</HintPath>
-    </Reference>
-    <Reference Include="HeuristicLab.Common.Resources-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>C:\Program Files\HeuristicLab 3.3\HeuristicLab.Common.Resources-3.3.dll</HintPath>
     </Reference>
     <Reference Include="HeuristicLab.Core-3.3">
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/HeuristicLabServicesHivePlugin.cs.frame
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/HeuristicLabServicesHivePlugin.cs.frame	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/HeuristicLabServicesHivePlugin.cs.frame	(revision 6743)
@@ -29,6 +29,5 @@
   [Plugin("HeuristicLab.Services.Hive", "3.3.5.$WCREV$")]
   [PluginFile("HeuristicLab.Services.Hive-3.3.dll", PluginFileType.Assembly)]
-  [PluginDependency("HeuristicLab.Common", "3.3")]
-  [PluginDependency("HeuristicLab.Common.Resources", "3.3")]
+  [PluginDependency("HeuristicLab.Common", "3.3")]  
   [PluginDependency("HeuristicLab.Core", "3.3")]
   [PluginDependency("HeuristicLab.Persistence", "3.3")]  
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/HiveDao.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/HiveDao.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/HiveDao.cs	(revision 6743)
@@ -36,6 +36,6 @@
     public HiveDao() { }
 
-    #region Job Methods
-    public DT.Task GetJob(Guid id) {
+    #region Task Methods
+    public DT.Task GetTask(Guid id) {
       using (var db = CreateContext()) {
         return DT.Convert.ToDto(db.Tasks.SingleOrDefault(x => x.TaskId == id));
@@ -43,5 +43,5 @@
     }
 
-    public IEnumerable<DT.Task> GetJobs(Expression<Func<Task, bool>> predicate) {
+    public IEnumerable<DT.Task> GetTasks(Expression<Func<Task, bool>> predicate) {
       using (var db = CreateContext()) {
         return db.Tasks.Where(predicate).Select(x => DT.Convert.ToDto(x)).ToArray();
@@ -49,5 +49,5 @@
     }
 
-    public Guid AddJob(DT.Task dto) {
+    public Guid AddTask(DT.Task dto) {
       using (var db = CreateContext()) {
         var entity = DT.Convert.ToEntity(dto);
@@ -62,5 +62,5 @@
     }
 
-    public void UpdateJob(DT.Task dto) {
+    public void UpdateTask(DT.Task dto) {
       using (var db = CreateContext()) {
         var entity = db.Tasks.FirstOrDefault(x => x.TaskId == dto.Id);
@@ -76,20 +76,20 @@
     }
 
-    public void DeleteJob(Guid id) {
+    public void DeleteTask(Guid id) {
       using (var db = CreateContext()) {
         var entity = db.Tasks.FirstOrDefault(x => x.TaskId == id);
         if (entity != null) db.Tasks.DeleteOnSubmit(entity);
-        db.SubmitChanges(); // JobData and child jobs are deleted by db-trigger
+        db.SubmitChanges(); // taskData and child tasks are deleted by db-trigger
       }
     }
 
     /// <summary>
-    /// returns all parent jobs which are waiting for their child jobs to finish
+    /// returns all parent tasks which are waiting for their child tasks to finish
     /// </summary>
-    /// <param name="resourceIds">list of resourceids which for which the jobs should be valid</param>
-    /// <param name="count">maximum number of jobs to return</param>
-    /// <param name="finished">if true, all parent jobs which have FinishWhenChildJobsFinished=true are returned, otherwise only FinishWhenChildJobsFinished=false are returned</param>
+    /// <param name="resourceIds">list of resourceids which for which the task should be valid</param>
+    /// <param name="count">maximum number of task to return</param>
+    /// <param name="finished">if true, all parent task which have FinishWhenChildJobsFinished=true are returned, otherwise only FinishWhenChildJobsFinished=false are returned</param>
     /// <returns></returns>
-    public IEnumerable<DT.Task> GetParentJobs(IEnumerable<Guid> resourceIds, int count, bool finished) {
+    public IEnumerable<DT.Task> GetParentTasks(IEnumerable<Guid> resourceIds, int count, bool finished) {
       using (var db = CreateContext()) {
         var query = from ar in db.AssignedResources
@@ -103,5 +103,5 @@
                                || child.State == TaskState.Aborted
                                || child.State == TaskState.Failed).All(x => x)
-                       && (from child in db.Tasks // avoid returning WaitForChildJobs jobs where no child-jobs exist (yet)
+                       && (from child in db.Tasks // avoid returning WaitForChildTasks task where no child-task exist (yet)
                            where child.ParentTaskId == ar.Task.TaskId
                            select child).Count() > 0
@@ -112,8 +112,8 @@
     }
 
-    public IEnumerable<DT.Task> GetWaitingJobs(DT.Slave slave, int count) {
+    public IEnumerable<DT.Task> GetWaitingTasks(DT.Slave slave, int count) {
       using (var db = CreateContext()) {
         var resourceIds = GetParentResources(slave.Id).Select(r => r.Id);
-        var waitingParentJobs = GetParentJobs(resourceIds, count, false);
+        var waitingParentJobs = GetParentTasks(resourceIds, count, false);
         if (count > 0 && waitingParentJobs.Count() >= count) return waitingParentJobs.Take(count).ToArray();
 
@@ -124,18 +124,18 @@
                        && ar.Task.CoresNeeded <= slave.FreeCores
                        && ar.Task.MemoryNeeded <= slave.FreeMemory
-                    orderby ar.Task.Priority descending, db.Random() // take random job to avoid the race condition that occurs when this method is called concurrently (the same job would be returned)
+                    orderby ar.Task.Priority descending, db.Random() // take random task to avoid the race condition that occurs when this method is called concurrently (the same task would be returned)
                     select DT.Convert.ToDto(ar.Task);
-        var waitingJobs = (count == 0 ? query : query.Take(count)).ToArray();
-        return waitingJobs.Union(waitingParentJobs).OrderByDescending(x => x.Priority);
-      }
-    }
-
-    public DT.Task UpdateJobState(Guid jobId, TaskState jobState, Guid? slaveId, Guid? userId, string exception) {
-      using (var db = CreateContext()) {
-        var job = db.Tasks.SingleOrDefault(x => x.TaskId == jobId);
-        job.State = jobState;
+        var waitingTasks = (count == 0 ? query : query.Take(count)).ToArray();
+        return waitingTasks.Union(waitingParentJobs).OrderByDescending(x => x.Priority);
+      }
+    }
+
+    public DT.Task UpdateTaskState(Guid taskId, TaskState taskState, Guid? slaveId, Guid? userId, string exception) {
+      using (var db = CreateContext()) {
+        var job = db.Tasks.SingleOrDefault(x => x.TaskId == taskId);
+        job.State = taskState;
         db.StateLogs.InsertOnSubmit(new StateLog {
-          TaskId = jobId,
-          State = jobState,
+          TaskId = taskId,
+          State = taskState,
           SlaveId = slaveId,
           UserId = userId,
@@ -144,5 +144,5 @@
         });
         db.SubmitChanges();
-        job = db.Tasks.SingleOrDefault(x => x.TaskId == jobId);
+        job = db.Tasks.SingleOrDefault(x => x.TaskId == taskId);
         return DT.Convert.ToDto(job);
       }
@@ -151,5 +151,5 @@
 
     #region TaskData Methods
-    public DT.TaskData GetJobData(Guid id) {
+    public DT.TaskData GetTaskData(Guid id) {
       using (var db = CreateContext(true)) {
         return DT.Convert.ToDto(db.TaskDatas.SingleOrDefault(x => x.TaskId == id));
@@ -157,5 +157,5 @@
     }
 
-    public IEnumerable<DT.TaskData> GetJobDatas(Expression<Func<TaskData, bool>> predicate) {
+    public IEnumerable<DT.TaskData> GetTaskDatas(Expression<Func<TaskData, bool>> predicate) {
       using (var db = CreateContext(true)) {
         return db.TaskDatas.Where(predicate).Select(x => DT.Convert.ToDto(x)).ToArray();
@@ -163,5 +163,5 @@
     }
 
-    public Guid AddJobData(DT.TaskData dto) {
+    public Guid AddTaskData(DT.TaskData dto) {
       using (var db = CreateContext(true)) {
         var entity = DT.Convert.ToEntity(dto);
@@ -172,5 +172,5 @@
     }
 
-    public void UpdateJobData(DT.TaskData dto) {
+    public void UpdateTaskData(DT.TaskData dto) {
       using (var db = CreateContext(true)) {
         var entity = db.TaskDatas.FirstOrDefault(x => x.TaskId == dto.TaskId);
@@ -181,5 +181,5 @@
     }
 
-    public void DeleteJobData(Guid id) {
+    public void DeleteTaskData(Guid id) {
       using (var db = CreateContext()) {
         var entity = db.TaskDatas.FirstOrDefault(x => x.TaskId == id); // check if all the byte[] is loaded into memory here. otherwise work around to delete without loading it
@@ -231,5 +231,5 @@
 
     #region Job Methods
-    public DT.Job GetHiveExperiment(Guid id) {
+    public DT.Job GetJob(Guid id) {
       using (var db = CreateContext()) {
         return AddStatsToExperiment(db, DT.Convert.ToDto(db.Jobs.SingleOrDefault(x => x.JobId == id)));
@@ -248,5 +248,5 @@
     }
 
-    public IEnumerable<DT.Job> GetHiveExperiments(Expression<Func<Job, bool>> predicate) {
+    public IEnumerable<DT.Job> GetJobs(Expression<Func<Job, bool>> predicate) {
       using (var db = CreateContext()) {
         return db.Jobs.Where(predicate).Select(x => AddStatsToExperiment(db, DT.Convert.ToDto(x))).ToArray();
@@ -254,5 +254,5 @@
     }
 
-    public Guid AddHiveExperiment(DT.Job dto) {
+    public Guid AddJob(DT.Job dto) {
       using (var db = CreateContext()) {
         var entity = DT.Convert.ToEntity(dto);
@@ -263,5 +263,5 @@
     }
 
-    public void UpdateHiveExperiment(DT.Job dto) {
+    public void UpdateJob(DT.Job dto) {
       using (var db = CreateContext()) {
         var entity = db.Jobs.FirstOrDefault(x => x.JobId == dto.Id);
@@ -272,5 +272,5 @@
     }
 
-    public void DeleteHiveExperiment(Guid id) {
+    public void DeleteJob(Guid id) {
       using (var db = CreateContext()) {
         var entity = db.Jobs.FirstOrDefault(x => x.JobId == id);
@@ -282,11 +282,11 @@
 
     #region JobPermission Methods
-    public DT.JobPermission GetHiveExperimentPermission(Guid hiveExperimentId, Guid grantedUserId) {
-      using (var db = CreateContext()) {
-        return DT.Convert.ToDto(db.JobPermissions.SingleOrDefault(x => x.JobId == hiveExperimentId && x.GrantedUserId == grantedUserId));
-      }
-    }
-
-    public IEnumerable<DT.JobPermission> GetHiveExperimentPermissions(Expression<Func<JobPermission, bool>> predicate) {
+    public DT.JobPermission GetJobPermission(Guid jobId, Guid grantedUserId) {
+      using (var db = CreateContext()) {
+        return DT.Convert.ToDto(db.JobPermissions.SingleOrDefault(x => x.JobId == jobId && x.GrantedUserId == grantedUserId));
+      }
+    }
+
+    public IEnumerable<DT.JobPermission> GetJobPermissions(Expression<Func<JobPermission, bool>> predicate) {
       using (var db = CreateContext()) {
         return db.JobPermissions.Where(predicate).Select(x => DT.Convert.ToDto(x)).ToArray();
@@ -294,5 +294,5 @@
     }
 
-    public void AddHiveExperimentPermission(DT.JobPermission dto) {
+    public void AddJobPermission(DT.JobPermission dto) {
       using (var db = CreateContext()) {
         var entity = DT.Convert.ToEntity(dto);
@@ -302,5 +302,5 @@
     }
 
-    public void UpdateHiveExperimentPermission(DT.JobPermission dto) {
+    public void UpdateJobPermission(DT.JobPermission dto) {
       using (var db = CreateContext()) {
         var entity = db.JobPermissions.FirstOrDefault(x => x.JobId == dto.JobId && x.GrantedUserId == dto.GrantedUserId);
@@ -311,7 +311,7 @@
     }
 
-    public void DeleteHiveExperimentPermission(Guid hiveExperimentId, Guid grantedUserId) {
-      using (var db = CreateContext()) {
-        var entity = db.JobPermissions.FirstOrDefault(x => x.JobId == hiveExperimentId && x.GrantedUserId == grantedUserId);
+    public void DeleteJobPermission(Guid jobId, Guid grantedUserId) {
+      using (var db = CreateContext()) {
+        var entity = db.JobPermissions.FirstOrDefault(x => x.JobId == jobId && x.GrantedUserId == grantedUserId);
         if (entity != null) db.JobPermissions.DeleteOnSubmit(entity);
         db.SubmitChanges();
@@ -322,21 +322,21 @@
     /// Sets the permissions for a experiment. makes sure that only one permission per user exists.
     /// </summary>
-    public void SetHiveExperimentPermission(Guid hiveExperimentId, Guid grantedByUserId, Guid grantedUserId, Permission permission) {
-      using (var db = CreateContext()) {
-        JobPermission hiveExperimentPermission = db.JobPermissions.SingleOrDefault(x => x.JobId == hiveExperimentId && x.GrantedUserId == grantedUserId);
-        if (hiveExperimentPermission != null) {
+    public void SetJobPermission(Guid jobId, Guid grantedByUserId, Guid grantedUserId, Permission permission) {
+      using (var db = CreateContext()) {
+        JobPermission jobPermission = db.JobPermissions.SingleOrDefault(x => x.JobId == jobId && x.GrantedUserId == grantedUserId);
+        if (jobPermission != null) {
           if (permission == Permission.NotAllowed) {
             // not allowed, delete
-            db.JobPermissions.DeleteOnSubmit(hiveExperimentPermission);
+            db.JobPermissions.DeleteOnSubmit(jobPermission);
           } else {
             // update
-            hiveExperimentPermission.Permission = permission;
-            hiveExperimentPermission.GrantedByUserId = grantedByUserId; // update grantedByUserId, always the last "granter" is stored
+            jobPermission.Permission = permission;
+            jobPermission.GrantedByUserId = grantedByUserId; // update grantedByUserId, always the last "granter" is stored
           }
         } else {
           // insert
           if (permission != Permission.NotAllowed) {
-            hiveExperimentPermission = new JobPermission() { JobId = hiveExperimentId, GrantedByUserId = grantedByUserId, GrantedUserId = grantedUserId, Permission = permission };
-            db.JobPermissions.InsertOnSubmit(hiveExperimentPermission);
+            jobPermission = new JobPermission() { JobId = jobId, GrantedByUserId = grantedByUserId, GrantedUserId = grantedUserId, Permission = permission };
+            db.JobPermissions.InsertOnSubmit(jobPermission);
           }
         }
@@ -613,23 +613,23 @@
 
     #region Authorization Methods
+    public Permission GetPermissionForTask(Guid taskId, Guid userId) {
+      using (var db = CreateContext()) {
+        return GetPermissionForJob(GetJobForTask(taskId), userId);
+      }
+    }
+
     public Permission GetPermissionForJob(Guid jobId, Guid userId) {
       using (var db = CreateContext()) {
-        return GetPermissionForExperiment(GetExperimentForJob(jobId), userId);
-      }
-    }
-
-    public Permission GetPermissionForExperiment(Guid experimentId, Guid userId) {
-      using (var db = CreateContext()) {
-        Job hiveExperiment = db.Jobs.SingleOrDefault(x => x.JobId == experimentId);
-        if (hiveExperiment == null) return Permission.NotAllowed;
-        if (hiveExperiment.OwnerUserId == userId) return Permission.Full;
-        JobPermission permission = db.JobPermissions.SingleOrDefault(p => p.JobId == experimentId && p.GrantedUserId == userId);
+        Job job = db.Jobs.SingleOrDefault(x => x.JobId == jobId);
+        if (job == null) return Permission.NotAllowed;
+        if (job.OwnerUserId == userId) return Permission.Full;
+        JobPermission permission = db.JobPermissions.SingleOrDefault(p => p.JobId == jobId && p.GrantedUserId == userId);
         return permission != null ? permission.Permission : Permission.NotAllowed;
       }
     }
 
-    public Guid GetExperimentForJob(Guid jobId) {
-      using (var db = CreateContext()) {
-        return db.Tasks.Single(j => j.TaskId == jobId).JobId;
+    public Guid GetJobForTask(Guid taskId) {
+      using (var db = CreateContext()) {
+        return db.Tasks.Single(j => j.TaskId == taskId).JobId;
       }
     }
@@ -765,5 +765,5 @@
         }
 
-        // execution times only of finished jobs - necessary to compute efficieny
+        // execution times only of finished task - necessary to compute efficieny
         var executionTimesFinishedJobs = from job in db.Tasks
                                          where job.State == TaskState.Finished
@@ -778,5 +778,5 @@
         }
 
-        // start to end times only of finished jobs - necessary to compute efficiency
+        // start to end times only of finished task - necessary to compute efficiency
         var startToEndTimesFinishedJobs = from job in db.Tasks
                                           where job.State == TaskState.Finished
@@ -817,10 +817,10 @@
 
     #region Helpers
-    private void CollectChildJobs(HiveDataContext db, Guid parentJobId, List<Task> collection) {
-      var jobs = db.Tasks.Where(j => j.ParentTaskId == parentJobId);
-      foreach (var job in jobs) {
-        collection.Add(job);
-        if (job.IsParentTask)
-          CollectChildJobs(db, job.TaskId, collection);
+    private void CollectChildTasks(HiveDataContext db, Guid parentTaskId, List<Task> collection) {
+      var tasks = db.Tasks.Where(j => j.ParentTaskId == parentTaskId);
+      foreach (var task in tasks) {
+        collection.Add(task);
+        if (task.IsParentTask)
+          CollectChildTasks(db, task.TaskId, collection);
       }
     }
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/HiveService.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/HiveService.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/HiveService.cs	(revision 6743)
@@ -61,151 +61,151 @@
 
     #region Job Methods
-    public Guid AddJob(Task job, TaskData jobData, IEnumerable<Guid> resourceIds) {
-      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
-      return trans.UseTransaction(() => {
-        job.Id = dao.AddJob(job);
-        jobData.TaskId = job.Id;
-        jobData.LastUpdate = DateTime.Now;
+    public Guid AddTask(Task task, TaskData taskData, IEnumerable<Guid> resourceIds) {
+      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
+      return trans.UseTransaction(() => {
+        task.Id = dao.AddTask(task);
+        taskData.TaskId = task.Id;
+        taskData.LastUpdate = DateTime.Now;
         foreach (Guid slaveGroupId in resourceIds) {
-          dao.AssignJobToResource(job.Id, slaveGroupId);
-        }
-        dao.AddJobData(jobData);
-        dao.UpdateJobState(job.Id, DA.TaskState.Waiting, null, userManager.CurrentUserId, null);
-        return jobData.TaskId;
+          dao.AssignJobToResource(task.Id, slaveGroupId);
+        }
+        dao.AddTaskData(taskData);
+        dao.UpdateTaskState(task.Id, DA.TaskState.Waiting, null, userManager.CurrentUserId, null);
+        return taskData.TaskId;
       }, false, true);
     }
 
-    public Guid AddChildJob(Guid parentJobId, Task job, TaskData jobData) {
-      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
-      return trans.UseTransaction(() => {
-        job.ParentTaskId = parentJobId;
-        return AddJob(job, jobData, dao.GetAssignedResources(parentJobId).Select(x => x.Id));
+    public Guid AddChildTask(Guid parentTaskId, Task task, TaskData taskData) {
+      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
+      return trans.UseTransaction(() => {
+        task.ParentTaskId = parentTaskId;
+        return AddTask(task, taskData, dao.GetAssignedResources(parentTaskId).Select(x => x.Id));
       }, false, true);
     }
 
-    public Task GetJob(Guid jobId) {
-      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
+    public Task GetTask(Guid taskId) {
+      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
+      author.AuthorizeForTask(taskId, Permission.Read);
+      return dao.GetTask(taskId);
+    }
+
+    public IEnumerable<Task> GetTasks() {
+      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
+      var tasks = dao.GetTasks(x => true);
+      foreach (var task in tasks)
+        author.AuthorizeForTask(task.Id, Permission.Read);
+      return tasks;
+    }
+
+    public IEnumerable<LightweightTask> GetLightweightTasks(IEnumerable<Guid> taskIds) {
+      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
+      var tasks = dao.GetTasks(x => taskIds.Contains(x.TaskId)).Select(x => new LightweightTask(x)).ToArray();
+      foreach (var task in tasks)
+        author.AuthorizeForTask(task.Id, Permission.Read);
+      return tasks;
+    }
+
+    public IEnumerable<LightweightTask> GetLightweightChildTasks(Guid? parentTaskId, bool recursive, bool includeParent) {
+      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
+      var tasks = GetChildTasks(parentTaskId, recursive, includeParent).Select(x => new LightweightTask(x)).ToArray();
+      foreach (var task in tasks)
+        author.AuthorizeForTask(task.Id, Permission.Read);
+      return tasks;
+    }
+
+    public IEnumerable<LightweightTask> GetLightweightJobTasks(Guid jobId) {
+      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
       author.AuthorizeForJob(jobId, Permission.Read);
-      return dao.GetJob(jobId);
-    }
-
-    public IEnumerable<Task> GetJobs() {
-      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
-      var jobs = dao.GetJobs(x => true);
-      foreach (var job in jobs)
-        author.AuthorizeForJob(job.Id, Permission.Read);
-      return jobs;
-    }
-
-    public IEnumerable<LightweightTask> GetLightweightJobs(IEnumerable<Guid> jobIds) {
-      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
-      var jobs = dao.GetJobs(x => jobIds.Contains(x.TaskId)).Select(x => new LightweightTask(x)).ToArray();
-      foreach (var job in jobs)
-        author.AuthorizeForJob(job.Id, Permission.Read);
-      return jobs;
-    }
-
-    public IEnumerable<LightweightTask> GetLightweightChildJobs(Guid? parentJobId, bool recursive, bool includeParent) {
-      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
-      var jobs = GetChildJobs(parentJobId, recursive, includeParent).Select(x => new LightweightTask(x)).ToArray();
-      foreach (var job in jobs)
-        author.AuthorizeForJob(job.Id, Permission.Read);
-      return jobs;
-    }
-
-    public IEnumerable<LightweightTask> GetLightweightExperimentJobs(Guid experimentId) {
-      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
-      author.AuthorizeForExperiment(experimentId, Permission.Read);
-      return dao.GetJobs(x => x.JobId == experimentId).Select(x => new LightweightTask(x)).ToArray();
-    }
-
-    public TaskData GetJobData(Guid jobId) {
-      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
-      author.AuthorizeForJob(jobId, Permission.Read);
-      return dao.GetJobData(jobId);
-    }
-
-    public void UpdateJob(Task job) {
-      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
-      author.AuthorizeForJob(job.Id, Permission.Full);
-      trans.UseTransaction(() => {
-        dao.UpdateJob(job);
-      });
-    }
-
-    public void UpdateJobData(Task job, TaskData jobData) {
-      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
-      author.AuthorizeForJob(job.Id, Permission.Full);
-      author.AuthorizeForJob(jobData.TaskId, Permission.Full);
+      return dao.GetTasks(x => x.JobId == jobId).Select(x => new LightweightTask(x)).ToArray();
+    }
+
+    public TaskData GetTaskData(Guid taskId) {
+      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
+      author.AuthorizeForTask(taskId, Permission.Read);
+      return dao.GetTaskData(taskId);
+    }
+
+    public void UpdateTask(Task taskDto) {
+      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
+      author.AuthorizeForTask(taskDto.Id, Permission.Full);
+      trans.UseTransaction(() => {
+        dao.UpdateTask(taskDto);
+      });
+    }
+
+    public void UpdateTaskData(Task task, TaskData taskData) {
+      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
+      author.AuthorizeForTask(task.Id, Permission.Full);
+      author.AuthorizeForTask(taskData.TaskId, Permission.Full);
       //trans.UseTransaction(() => { // cneumuel: try without transaction
-      jobData.LastUpdate = DateTime.Now;
-      dao.UpdateJob(job);
-      dao.UpdateJobData(jobData);
+      taskData.LastUpdate = DateTime.Now;
+      dao.UpdateTask(task);
+      dao.UpdateTaskData(taskData);
       //}, false, true);
     }
 
-    public void DeleteJob(Guid jobId) {
-      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
-      author.AuthorizeForJob(jobId, Permission.Full);
-      trans.UseTransaction(() => {
-        dao.DeleteJob(jobId);
-      });
-    }
-
-    public void DeleteChildJobs(Guid parentJobId) {
-      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
-      author.AuthorizeForJob(parentJobId, Permission.Full);
-      trans.UseTransaction(() => {
-        var jobs = GetChildJobs(parentJobId, true, false);
-        foreach (var job in jobs) {
-          dao.DeleteJob(job.Id);
-          dao.DeleteJobData(job.Id);
+    public void DeleteTask(Guid taskId) {
+      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
+      author.AuthorizeForTask(taskId, Permission.Full);
+      trans.UseTransaction(() => {
+        dao.DeleteTask(taskId);
+      });
+    }
+
+    public void DeleteChildTasks(Guid parentTaskId) {
+      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
+      author.AuthorizeForTask(parentTaskId, Permission.Full);
+      trans.UseTransaction(() => {
+        var tasks = GetChildTasks(parentTaskId, true, false);
+        foreach (var task in tasks) {
+          dao.DeleteTask(task.Id);
+          dao.DeleteTaskData(task.Id);
         };
       });
     }
 
-    public Task UpdateJobState(Guid jobId, TaskState jobState, Guid? slaveId, Guid? userId, string exception) {
-      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
-      author.AuthorizeForJob(jobId, Permission.Full);
-      return trans.UseTransaction(() => {
-        Task job = dao.UpdateJobState(jobId, DataTransfer.Convert.ToEntity(jobState), slaveId, userId, exception);
-
-        if (job.Command.HasValue && job.Command.Value == Command.Pause && job.State == TaskState.Paused) {
-          job.Command = null;
-        } else if (job.Command.HasValue && job.Command.Value == Command.Abort && job.State == TaskState.Aborted) {
-          job.Command = null;
-        } else if (job.Command.HasValue && job.Command.Value == Command.Stop && job.State == TaskState.Aborted) {
-          job.Command = null;
-        } else if (jobState == TaskState.Paused && !job.Command.HasValue) {
-          // slave paused and uploaded the job (no user-command) -> set waiting.
-          job = dao.UpdateJobState(jobId, DataTransfer.Convert.ToEntity(TaskState.Waiting), slaveId, userId, exception);
-        }
-
-        dao.UpdateJob(job);
-        return job;
-      });
-    }
-
-    public IEnumerable<Task> GetJobsByResourceId(Guid resourceId) {
-      authen.AuthenticateForAnyRole(HiveRoles.Administrator);
-      var jobs = trans.UseTransaction(() => dao.GetJobsByResourceId(resourceId));
-      foreach (var job in jobs)
-        author.AuthorizeForJob(job.Id, Permission.Read);
-      return jobs;
+    public Task UpdateTaskState(Guid taskId, TaskState taskState, Guid? slaveId, Guid? userId, string exception) {
+      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
+      author.AuthorizeForTask(taskId, Permission.Full);
+      return trans.UseTransaction(() => {
+        Task task = dao.UpdateTaskState(taskId, DataTransfer.Convert.ToEntity(taskState), slaveId, userId, exception);
+
+        if (task.Command.HasValue && task.Command.Value == Command.Pause && task.State == TaskState.Paused) {
+          task.Command = null;
+        } else if (task.Command.HasValue && task.Command.Value == Command.Abort && task.State == TaskState.Aborted) {
+          task.Command = null;
+        } else if (task.Command.HasValue && task.Command.Value == Command.Stop && task.State == TaskState.Aborted) {
+          task.Command = null;
+        } else if (taskState == TaskState.Paused && !task.Command.HasValue) {
+          // slave paused and uploaded the task (no user-command) -> set waiting.
+          task = dao.UpdateTaskState(taskId, DataTransfer.Convert.ToEntity(TaskState.Waiting), slaveId, userId, exception);
+        }
+
+        dao.UpdateTask(task);
+        return task;
+      });
+    }
+
+    public IEnumerable<Task> GetTasksByResourceId(Guid resourceId) {
+      authen.AuthenticateForAnyRole(HiveRoles.Administrator);
+      var tasks = trans.UseTransaction(() => dao.GetJobsByResourceId(resourceId));
+      foreach (var task in tasks)
+        author.AuthorizeForTask(task.Id, Permission.Read);
+      return tasks;
     }
     #endregion
 
     #region Task Control Methods
-    public void StopJob(Guid jobId) {
-      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
-      author.AuthorizeForJob(jobId, Permission.Full);
-      trans.UseTransaction(() => {
-        var job = dao.GetJob(jobId);
-        if (job.State == TaskState.Calculating || job.State == TaskState.Transferring) {
-          job.Command = Command.Stop;
-          dao.UpdateJob(job);
+    public void StopTask(Guid taskId) {
+      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
+      author.AuthorizeForTask(taskId, Permission.Full);
+      trans.UseTransaction(() => {
+        var task = dao.GetTask(taskId);
+        if (task.State == TaskState.Calculating || task.State == TaskState.Transferring) {
+          task.Command = Command.Stop;
+          dao.UpdateTask(task);
         } else {
-          if (job.State != TaskState.Aborted && job.State != TaskState.Finished && job.State != TaskState.Failed) {
-            job = UpdateJobState(jobId, TaskState.Aborted, null, null, string.Empty);
+          if (task.State != TaskState.Aborted && task.State != TaskState.Finished && task.State != TaskState.Failed) {
+            task = UpdateTaskState(taskId, TaskState.Aborted, null, null, string.Empty);
           }
         }
@@ -213,25 +213,25 @@
     }
 
-    public void PauseJob(Guid jobId) {
-      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
-      author.AuthorizeForJob(jobId, Permission.Full);
-      trans.UseTransaction(() => {
-        var job = dao.GetJob(jobId);
+    public void PauseTask(Guid taskId) {
+      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
+      author.AuthorizeForTask(taskId, Permission.Full);
+      trans.UseTransaction(() => {
+        var job = dao.GetTask(taskId);
         if (job.State == TaskState.Calculating || job.State == TaskState.Transferring) {
           job.Command = Command.Pause;
-          dao.UpdateJob(job);
+          dao.UpdateTask(job);
         } else {
-          job = UpdateJobState(jobId, TaskState.Paused, null, null, string.Empty);
-        }
-      });
-    }
-
-    public void RestartJob(Guid jobId) {
-      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
-      author.AuthorizeForJob(jobId, Permission.Full);
-      trans.UseTransaction(() => {
-        Task job = dao.UpdateJobState(jobId, DA.TaskState.Waiting, null, userManager.CurrentUserId, string.Empty);
-        job.Command = null;
-        dao.UpdateJob(job);
+          job = UpdateTaskState(taskId, TaskState.Paused, null, null, string.Empty);
+        }
+      });
+    }
+
+    public void RestartTask(Guid taskId) {
+      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
+      author.AuthorizeForTask(taskId, Permission.Full);
+      trans.UseTransaction(() => {
+        Task task = dao.UpdateTaskState(taskId, DA.TaskState.Waiting, null, userManager.CurrentUserId, string.Empty);
+        task.Command = null;
+        dao.UpdateTask(task);
       });
     }
@@ -239,93 +239,93 @@
 
     #region Job Methods
-    public Job GetHiveExperiment(Guid id) {
-      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
-      author.AuthorizeForExperiment(id, Permission.Read);
-      var hiveExperiment = dao.GetHiveExperiments(x =>
+    public Job GetJob(Guid id) {
+      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
+      author.AuthorizeForJob(id, Permission.Read);
+      var job = dao.GetJobs(x =>
             x.JobId == id
             && (x.OwnerUserId == userManager.CurrentUserId || x.JobPermissions.Count(hep => hep.Permission != DA.Permission.NotAllowed && hep.GrantedUserId == userManager.CurrentUserId) > 0)
           ).FirstOrDefault();
-      if (hiveExperiment != null) {
-        hiveExperiment.Permission = DT.Convert.ToDto(dao.GetPermissionForExperiment(hiveExperiment.Id, userManager.CurrentUserId));
-        hiveExperiment.OwnerUsername = userManager.GetUserById(hiveExperiment.OwnerUserId).UserName;
+      if (job != null) {
+        job.Permission = DT.Convert.ToDto(dao.GetPermissionForJob(job.Id, userManager.CurrentUserId));
+        job.OwnerUsername = userManager.GetUserById(job.OwnerUserId).UserName;
       }
-      return hiveExperiment;
-    }
-
-    public IEnumerable<Job> GetHiveExperiments() {
-      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
-      var hiveExperiments = dao.GetHiveExperiments(x => x.OwnerUserId == userManager.CurrentUserId || x.JobPermissions.Count(hep => hep.Permission != DA.Permission.NotAllowed && hep.GrantedUserId == userManager.CurrentUserId) > 0);
-      foreach (var he in hiveExperiments) {
-        author.AuthorizeForExperiment(he.Id, Permission.Read);
-        he.Permission = DT.Convert.ToDto(dao.GetPermissionForExperiment(he.Id, userManager.CurrentUserId));
-        he.OwnerUsername = userManager.GetUserById(he.OwnerUserId).UserName;
+      return job;
+    }
+
+    public IEnumerable<Job> GetJobs() {
+      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
+      var jobs = dao.GetJobs(x => x.OwnerUserId == userManager.CurrentUserId || x.JobPermissions.Count(hep => hep.Permission != DA.Permission.NotAllowed && hep.GrantedUserId == userManager.CurrentUserId) > 0);
+      foreach (var job in jobs) {
+        author.AuthorizeForJob(job.Id, Permission.Read);
+        job.Permission = DT.Convert.ToDto(dao.GetPermissionForJob(job.Id, userManager.CurrentUserId));
+        job.OwnerUsername = userManager.GetUserById(job.OwnerUserId).UserName;
       }
-      return hiveExperiments;
-    }
-
-    public IEnumerable<Job> GetAllHiveExperiments() {
-      authen.AuthenticateForAnyRole(HiveRoles.Administrator);
-      var hiveExperiments = dao.GetHiveExperiments(x => true);
-      foreach (var he in hiveExperiments) { // no authorization here, since this method is admin-only! (admin is allowed to read all jobs)
-        he.Permission = DT.Convert.ToDto(dao.GetPermissionForExperiment(he.Id, userManager.CurrentUserId));
-        he.OwnerUsername = userManager.GetUserById(he.OwnerUserId).UserName;
+      return jobs;
+    }
+
+    public IEnumerable<Job> GetAllJobs() {
+      authen.AuthenticateForAnyRole(HiveRoles.Administrator);
+      var jobs = dao.GetJobs(x => true);
+      foreach (var job in jobs) { // no authorization here, since this method is admin-only! (admin is allowed to read all task)
+        job.Permission = DT.Convert.ToDto(dao.GetPermissionForJob(job.Id, userManager.CurrentUserId));
+        job.OwnerUsername = userManager.GetUserById(job.OwnerUserId).UserName;
       }
-      return hiveExperiments;
-    }
-
-    public Guid AddHiveExperiment(Job hiveExperimentDto) {
-      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
-      return trans.UseTransaction(() => {
-        hiveExperimentDto.OwnerUserId = userManager.CurrentUserId;
-        hiveExperimentDto.DateCreated = DateTime.Now;
-        return dao.AddHiveExperiment(hiveExperimentDto);
-      });
-    }
-
-    public void UpdateHiveExperiment(Job hiveExperimentDto) {
-      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
-      author.AuthorizeForExperiment(hiveExperimentDto.Id, Permission.Full);
-      trans.UseTransaction(() => {
-        dao.UpdateHiveExperiment(hiveExperimentDto);
-      });
-    }
-
-    public void DeleteHiveExperiment(Guid hiveExperimentId) {
-      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
-      author.AuthorizeForExperiment(hiveExperimentId, Permission.Full);
-      trans.UseTransaction(() => {
-        dao.DeleteHiveExperiment(hiveExperimentId); // child jobs will be deleted by db-trigger
-      });
-    }
-    #endregion
-
-    #region HiveExperimentPermission Methods
-    public void GrantPermission(Guid hiveExperimentId, Guid grantedUserId, Permission permission) {
-      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
-      trans.UseTransaction(() => {
-        Job he = dao.GetHiveExperiment(hiveExperimentId);
-        if (he == null) throw new FaultException<FaultReason>(new FaultReason("Could not find hiveExperiment with id " + hiveExperimentId));
-        Permission perm = DT.Convert.ToDto(dao.GetPermissionForExperiment(he.Id, userManager.CurrentUserId));
+      return jobs;
+    }
+
+    public Guid AddJob(Job jobDto) {
+      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
+      return trans.UseTransaction(() => {
+        jobDto.OwnerUserId = userManager.CurrentUserId;
+        jobDto.DateCreated = DateTime.Now;
+        return dao.AddJob(jobDto);
+      });
+    }
+
+    public void UpdateJob(Job jobDto) {
+      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
+      author.AuthorizeForJob(jobDto.Id, Permission.Full);
+      trans.UseTransaction(() => {
+        dao.UpdateJob(jobDto);
+      });
+    }
+
+    public void DeleteJob(Guid jobId) {
+      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
+      author.AuthorizeForJob(jobId, Permission.Full);
+      trans.UseTransaction(() => {
+        dao.DeleteJob(jobId); // child task will be deleted by db-trigger
+      });
+    }
+    #endregion
+
+    #region JobPermission Methods
+    public void GrantPermission(Guid jobId, Guid grantedUserId, Permission permission) {
+      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
+      trans.UseTransaction(() => {
+        Job job = dao.GetJob(jobId);
+        if (job == null) throw new FaultException<FaultReason>(new FaultReason("Could not find task with id " + jobId));
+        Permission perm = DT.Convert.ToDto(dao.GetPermissionForJob(job.Id, userManager.CurrentUserId));
         if (perm != Permission.Full) throw new FaultException<FaultReason>(new FaultReason("Not allowed to grant permissions for this experiment"));
-        dao.SetHiveExperimentPermission(hiveExperimentId, userManager.CurrentUserId, grantedUserId, DT.Convert.ToEntity(permission));
-      });
-    }
-
-    public void RevokePermission(Guid hiveExperimentId, Guid grantedUserId) {
-      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
-      trans.UseTransaction(() => {
-        Job he = dao.GetHiveExperiment(hiveExperimentId);
-        if (he == null) throw new FaultException<FaultReason>(new FaultReason("Could not find hiveExperiment with id " + hiveExperimentId));
-        DA.Permission perm = dao.GetPermissionForExperiment(he.Id, userManager.CurrentUserId);
+        dao.SetJobPermission(jobId, userManager.CurrentUserId, grantedUserId, DT.Convert.ToEntity(permission));
+      });
+    }
+
+    public void RevokePermission(Guid jobId, Guid grantedUserId) {
+      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
+      trans.UseTransaction(() => {
+        Job job = dao.GetJob(jobId);
+        if (job == null) throw new FaultException<FaultReason>(new FaultReason("Could not find task with id " + jobId));
+        DA.Permission perm = dao.GetPermissionForJob(job.Id, userManager.CurrentUserId);
         if (perm != DA.Permission.Full) throw new FaultException<FaultReason>(new FaultReason("Not allowed to grant permissions for this experiment"));
-        dao.SetHiveExperimentPermission(hiveExperimentId, userManager.CurrentUserId, grantedUserId, DA.Permission.NotAllowed);
-      });
-    }
-    public IEnumerable<JobPermission> GetHiveExperimentPermissions(Guid hiveExperimentId) {
-      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
-      return trans.UseTransaction(() => {
-        DA.Permission currentUserPermission = dao.GetPermissionForExperiment(hiveExperimentId, userManager.CurrentUserId);
+        dao.SetJobPermission(jobId, userManager.CurrentUserId, grantedUserId, DA.Permission.NotAllowed);
+      });
+    }
+    public IEnumerable<JobPermission> GetJobPermissions(Guid jobId) {
+      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
+      return trans.UseTransaction(() => {
+        DA.Permission currentUserPermission = dao.GetPermissionForJob(jobId, userManager.CurrentUserId);
         if (currentUserPermission != DA.Permission.Full) throw new FaultException<FaultReason>(new FaultReason("Not allowed to list permissions for this experiment"));
-        return dao.GetHiveExperimentPermissions(x => x.JobId == hiveExperimentId);
+        return dao.GetJobPermissions(x => x.JobId == jobId);
       });
     }
@@ -591,17 +591,17 @@
 
     #region Helper Methods
-    private IEnumerable<Task> GetChildJobs(Guid? parentJobId, bool recursive, bool includeParent) {
-      var jobs = new List<Task>(dao.GetJobs(x => parentJobId == null ? !x.ParentTaskId.HasValue : x.ParentTaskId.Value == parentJobId));
+    private IEnumerable<Task> GetChildTasks(Guid? parentTaskId, bool recursive, bool includeParent) {
+      var tasks = new List<Task>(dao.GetTasks(x => parentTaskId == null ? !x.ParentTaskId.HasValue : x.ParentTaskId.Value == parentTaskId));
 
       if (recursive) {
         var childs = new List<Task>();
-        foreach (var job in jobs) {
-          childs.AddRange(GetChildJobs(job.Id, recursive, false));
-        }
-        jobs.AddRange(childs);
+        foreach (var task in tasks) {
+          childs.AddRange(GetChildTasks(task.Id, recursive, false));
+        }
+        tasks.AddRange(childs);
       }
 
-      if (includeParent) jobs.Add(GetJob(parentJobId.Value));
-      return jobs;
+      if (includeParent) tasks.Add(GetTask(parentTaskId.Value));
+      return tasks;
     }
     #endregion
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/Interfaces/IAuthorizationManager.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/Interfaces/IAuthorizationManager.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/Interfaces/IAuthorizationManager.cs	(revision 6743)
@@ -30,7 +30,7 @@
     void Authorize(Guid userId);
 
+    void AuthorizeForTask(Guid taskId, Permission requiredPermission);
+
     void AuthorizeForJob(Guid jobId, Permission requiredPermission);
-
-    void AuthorizeForExperiment(Guid experimentId, Permission requiredPermission);
   }
 }
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/Interfaces/IEventManager.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/Interfaces/IEventManager.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/Interfaces/IEventManager.cs	(revision 6743)
@@ -22,5 +22,5 @@
 namespace HeuristicLab.Services.Hive {
   /// <summary>
-  /// The only object in hive which holds a state. Must allow restarts without resetting all jobs
+  /// The only object in hive which holds a state. Must allow restarts without resetting all task
   /// </summary>
   public interface IEventManager {
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/Interfaces/IHiveDao.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/Interfaces/IHiveDao.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/Interfaces/IHiveDao.cs	(revision 6743)
@@ -29,20 +29,20 @@
   public interface IHiveDao {
     #region Task Methods
-    DT.Task GetJob(Guid id);
-    IEnumerable<DT.Task> GetJobs(Expression<Func<Task, bool>> predicate);
-    Guid AddJob(DT.Task dto);
-    void UpdateJob(DT.Task dto);
-    void DeleteJob(Guid id);
-    IEnumerable<DT.Task> GetWaitingJobs(DT.Slave slave, int count);
-    IEnumerable<DT.Task> GetParentJobs(IEnumerable<Guid> resourceIds, int count, bool finished);
-    DT.Task UpdateJobState(Guid jobId, TaskState jobState, Guid? slaveId, Guid? userId, string exception);
+    DT.Task GetTask(Guid id);
+    IEnumerable<DT.Task> GetTasks(Expression<Func<Task, bool>> predicate);
+    Guid AddTask(DT.Task dto);
+    void UpdateTask(DT.Task dto);
+    void DeleteTask(Guid id);
+    IEnumerable<DT.Task> GetWaitingTasks(DT.Slave slave, int count);
+    IEnumerable<DT.Task> GetParentTasks(IEnumerable<Guid> resourceIds, int count, bool finished);
+    DT.Task UpdateTaskState(Guid taskId, TaskState taskState, Guid? slaveId, Guid? userId, string exception);
     #endregion
 
     #region TaskData Methods
-    DT.TaskData GetJobData(Guid id);
-    IEnumerable<DT.TaskData> GetJobDatas(Expression<Func<TaskData, bool>> predicate);
-    Guid AddJobData(DT.TaskData dto);
-    void UpdateJobData(DT.TaskData dto);
-    void DeleteJobData(Guid id);
+    DT.TaskData GetTaskData(Guid id);
+    IEnumerable<DT.TaskData> GetTaskDatas(Expression<Func<TaskData, bool>> predicate);
+    Guid AddTaskData(DT.TaskData dto);
+    void UpdateTaskData(DT.TaskData dto);
+    void DeleteTaskData(Guid id);
     #endregion
 
@@ -55,19 +55,19 @@
     #endregion
 
-    #region HiveExperiment Methods
-    DT.Job GetHiveExperiment(Guid id);
-    IEnumerable<DT.Job> GetHiveExperiments(Expression<Func<Job, bool>> predicate);
-    Guid AddHiveExperiment(DT.Job dto);
-    void UpdateHiveExperiment(DT.Job dto);
-    void DeleteHiveExperiment(Guid id);
+    #region Job Methods
+    DT.Job GetJob(Guid id);
+    IEnumerable<DT.Job> GetJobs(Expression<Func<Job, bool>> predicate);
+    Guid AddJob(DT.Job dto);
+    void UpdateJob(DT.Job dto);
+    void DeleteJob(Guid id);
     #endregion
 
-    #region HiveExperimentPermission Methods
-    DT.JobPermission GetHiveExperimentPermission(Guid hiveExperimentId, Guid grantedUserId);
-    IEnumerable<DT.JobPermission> GetHiveExperimentPermissions(Expression<Func<JobPermission, bool>> predicate);
-    void AddHiveExperimentPermission(DT.JobPermission dto);
-    void UpdateHiveExperimentPermission(DT.JobPermission dto);
-    void DeleteHiveExperimentPermission(Guid hiveExperimentId, Guid grantedUserId);
-    void SetHiveExperimentPermission(Guid hiveExperimentId, Guid grantedByUserId, Guid grantedUserId, Permission permission);
+    #region JobPermission Methods
+    DT.JobPermission GetJobPermission(Guid jobId, Guid grantedUserId);
+    IEnumerable<DT.JobPermission> GetJobPermissions(Expression<Func<JobPermission, bool>> predicate);
+    void AddJobPermission(DT.JobPermission dto);
+    void UpdateJobPermission(DT.JobPermission dto);
+    void DeleteJobPermission(Guid jobId, Guid grantedUserId);
+    void SetJobPermission(Guid jobId, Guid grantedByUserId, Guid grantedUserId, Permission permission);
     #endregion
 
@@ -86,7 +86,4 @@
     void UpdatePluginData(DT.PluginData dto);
     void DeletePluginData(Guid id);
-    #endregion
-
-    #region Calendar Methods
     #endregion
 
@@ -121,7 +118,7 @@
 
     #region Authorization Methods
+    Permission GetPermissionForTask(Guid taskId, Guid userId);
     Permission GetPermissionForJob(Guid jobId, Guid userId);
-    Permission GetPermissionForExperiment(Guid experimentId, Guid userId);
-    Guid GetExperimentForJob(Guid jobId);
+    Guid GetJobForTask(Guid taskId);
     #endregion
 
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/Manager/AuthorizationManager.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/Manager/AuthorizationManager.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/Manager/AuthorizationManager.cs	(revision 6743)
@@ -33,16 +33,16 @@
     }
 
+    public void AuthorizeForTask(Guid taskId, DT.Permission requiredPermission) {
+      if (ServiceLocator.Instance.AuthenticationManager.IsInRole(HiveRoles.Slave)) return; // slave-users can access all tasks
+
+      Permission permission = ServiceLocator.Instance.HiveDao.GetPermissionForTask(taskId, ServiceLocator.Instance.UserManager.CurrentUserId);
+      if (permission == Permission.NotAllowed || (permission != DT.Convert.ToEntity(requiredPermission) && DT.Convert.ToEntity(requiredPermission) == Permission.Full))
+        throw new SecurityException("Current user is not authorized to access task");
+    }
+
     public void AuthorizeForJob(Guid jobId, DT.Permission requiredPermission) {
-      if (ServiceLocator.Instance.AuthenticationManager.IsInRole(HiveRoles.Slave)) return; // slave-users can access all jobs
-
       Permission permission = ServiceLocator.Instance.HiveDao.GetPermissionForJob(jobId, ServiceLocator.Instance.UserManager.CurrentUserId);
       if (permission == Permission.NotAllowed || (permission != DT.Convert.ToEntity(requiredPermission) && DT.Convert.ToEntity(requiredPermission) == Permission.Full))
-        throw new SecurityException("Current user is not authorized to access job");
-    }
-
-    public void AuthorizeForExperiment(Guid experimentId, DT.Permission requiredPermission) {
-      Permission permission = ServiceLocator.Instance.HiveDao.GetPermissionForExperiment(experimentId, ServiceLocator.Instance.UserManager.CurrentUserId);
-      if (permission == Permission.NotAllowed || (permission != DT.Convert.ToEntity(requiredPermission) && DT.Convert.ToEntity(requiredPermission) == Permission.Full))
-        throw new SecurityException("Current user is not authorized to access experiment");
+        throw new SecurityException("Current user is not authorized to access task");
     }
   }
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/Manager/EventManager.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/Manager/EventManager.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/Manager/EventManager.cs	(revision 6743)
@@ -29,5 +29,5 @@
 namespace HeuristicLab.Services.Hive {
   /// <summary>
-  /// This class offers methods for cleaning up offline slaves and jobs
+  /// This class offers methods for cleaning up offline slaves and task
   /// </summary>
   public class EventManager : IEventManager {
@@ -45,6 +45,6 @@
       log.Log("EventManager.Cleanup()");
       SetTimeoutSlavesOffline();
-      SetTimeoutJobsWaiting();
-      FinishParentJobs();
+      SetTimeoutTasksWaiting();
+      FinishParentTasks();
       UpdateStatistics();
     }
@@ -72,5 +72,5 @@
 
     /// <summary>
-    /// Searches for slaves which are timed out, puts them and their jobs offline
+    /// Searches for slaves which are timed out, puts them and their task offline
     /// </summary>
     private void SetTimeoutSlavesOffline() {
@@ -79,5 +79,5 @@
         if (!slave.LastHeartbeat.HasValue || (DateTime.Now - slave.LastHeartbeat.Value) > HeuristicLab.Services.Hive.Properties.Settings.Default.SlaveHeartbeatTimeout) {
           slave.SlaveState = DT.SlaveState.Offline;
-          SetJobsWaiting(slave.Id);
+          SetTasksWaiting(slave.Id);
           dao.UpdateSlave(slave);
         }
@@ -86,32 +86,32 @@
 
     /// <summary>
-    /// Looks for parent jobs which have FinishWhenChildJobsFinished and set their state to finished
+    /// Looks for parent tasks which have FinishWhenChildJobsFinished and set their state to finished
     /// </summary>
-    private void FinishParentJobs() {
-      var parentJobsToFinish = dao.GetParentJobs(dao.GetResources(x => true).Select(x => x.Id), 0, true);
-      foreach (var job in parentJobsToFinish) {
-        dao.UpdateJobState(job.Id, TaskState.Finished, null, null, string.Empty);
+    private void FinishParentTasks() {
+      var parentTasksToFinish = dao.GetParentTasks(dao.GetResources(x => true).Select(x => x.Id), 0, true);
+      foreach (var task in parentTasksToFinish) {
+        dao.UpdateTaskState(task.Id, TaskState.Finished, null, null, string.Empty);
       }
     }
 
-    private void SetJobsWaiting(Guid slaveId) {
-      var jobs = dao.GetJobs(x => x.State == TaskState.Calculating).Where(x => x.StateLog.Last().SlaveId == slaveId);
-      foreach (var j in jobs) {
-        DT.Task job = dao.UpdateJobState(j.Id, TaskState.Waiting, slaveId, null, "Slave timed out.");
-        job.Command = null;
-        dao.UpdateJob(job);
+    private void SetTasksWaiting(Guid slaveId) {
+      var tasks = dao.GetTasks(x => x.State == TaskState.Calculating).Where(x => x.StateLog.Last().SlaveId == slaveId);
+      foreach (var j in tasks) {
+        DT.Task task = dao.UpdateTaskState(j.Id, TaskState.Waiting, slaveId, null, "Slave timed out.");
+        task.Command = null;
+        dao.UpdateTask(task);
       }
     }
 
     /// <summary>
-    /// Looks for jobs which have not sent heartbeats for some time and reschedules them for calculation
+    /// Looks for task which have not sent heartbeats for some time and reschedules them for calculation
     /// </summary>
-    private void SetTimeoutJobsWaiting() {
-      var jobs = dao.GetJobs(x => (x.State == TaskState.Calculating && (DateTime.Now - x.LastHeartbeat) > HeuristicLab.Services.Hive.Properties.Settings.Default.CalculatingJobHeartbeatTimeout)
+    private void SetTimeoutTasksWaiting() {
+      var tasks = dao.GetTasks(x => (x.State == TaskState.Calculating && (DateTime.Now - x.LastHeartbeat) > HeuristicLab.Services.Hive.Properties.Settings.Default.CalculatingJobHeartbeatTimeout)
                                || (x.State == TaskState.Transferring && (DateTime.Now - x.LastHeartbeat) > HeuristicLab.Services.Hive.Properties.Settings.Default.TransferringJobHeartbeatTimeout));
-      foreach (var j in jobs) {
-        DT.Task job = dao.UpdateJobState(j.Id, TaskState.Waiting, null, null, "Slave timed out.");
-        job.Command = null;
-        dao.UpdateJob(job);
+      foreach (var j in tasks) {
+        DT.Task task = dao.UpdateTaskState(j.Id, TaskState.Waiting, null, null, "Slave timed out.");
+        task.Command = null;
+        dao.UpdateTask(task);
       }
     }
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/Manager/HeartbeatManager.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/Manager/HeartbeatManager.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/Manager/HeartbeatManager.cs	(revision 6743)
@@ -54,10 +54,10 @@
         dao.UpdateSlave(slave);
 
-        // update job data
-        actions.AddRange(UpdateJobs(heartbeat, slave.IsAllowedToCalculate));
+        // update task data
+        actions.AddRange(UpdateTasks(heartbeat, slave.IsAllowedToCalculate));
 
-        // assign new job
+        // assign new task
         if (heartbeat.AssignJob && slave.IsAllowedToCalculate && heartbeat.FreeCores > 0) {
-          var availableJobs = dao.GetWaitingJobs(slave, 1);
+          var availableJobs = dao.GetWaitingTasks(slave, 1);
           if (availableJobs.Count() > 0) {
             var job = availableJobs.First();
@@ -71,21 +71,21 @@
 
     // returns true if assignment was successful
-    private bool AssignJob(Slave slave, Task job) {
-      // load job again and check if it is still available (this is an attempt to reduce the race condition which causes multiple heartbeats to get the same job assigned)
-      if (dao.GetJob(job.Id).State != TaskState.Waiting) return false;
+    private bool AssignJob(Slave slave, Task task) {
+      // load task again and check if it is still available (this is an attempt to reduce the race condition which causes multiple heartbeats to get the same task assigned)
+      if (dao.GetTask(task.Id).State != TaskState.Waiting) return false;
 
-      job = dao.UpdateJobState(job.Id, DataAccess.TaskState.Transferring, slave.Id, null, null);
+      task = dao.UpdateTaskState(task.Id, DataAccess.TaskState.Transferring, slave.Id, null, null);
 
-      // from now on the job has some time to send the next heartbeat (ApplicationConstants.TransferringJobHeartbeatTimeout)
-      job.LastHeartbeat = DateTime.Now;
-      dao.UpdateJob(job);
+      // from now on the task has some time to send the next heartbeat (ApplicationConstants.TransferringJobHeartbeatTimeout)
+      task.LastHeartbeat = DateTime.Now;
+      dao.UpdateTask(task);
       return true;
     }
 
     /// <summary>
-    /// Update the progress of each job
-    /// Checks if all the jobs sent by heartbeat are supposed to be calculated by this slave
+    /// Update the progress of each task
+    /// Checks if all the task sent by heartbeat are supposed to be calculated by this slave
     /// </summary>
-    private IEnumerable<MessageContainer> UpdateJobs(Heartbeat heartbeat, bool IsAllowedToCalculate) {
+    private IEnumerable<MessageContainer> UpdateTasks(Heartbeat heartbeat, bool IsAllowedToCalculate) {
       List<MessageContainer> actions = new List<MessageContainer>();
 
@@ -98,7 +98,7 @@
         // process the jobProgresses
         foreach (var jobProgress in heartbeat.JobProgress) {
-          Task curJob = dao.GetJob(jobProgress.Key);
+          Task curJob = dao.GetTask(jobProgress.Key);
           if (curJob == null) {
-            // job does not exist in db
+            // task does not exist in db
             actions.Add(new MessageContainer(MessageContainer.MessageType.AbortTask, jobProgress.Key));
             DA.LogFactory.GetLogger(this.GetType().Namespace).Log("Job does not exist in DB: " + jobProgress.Key);
@@ -108,9 +108,9 @@
               actions.Add(new MessageContainer(MessageContainer.MessageType.AbortTask, curJob.Id));
               DA.LogFactory.GetLogger(this.GetType().Namespace).Log("The slave " + heartbeat.SlaveId + " is not supposed to calculate Job: " + curJob);
-            } else if (!JobIsAllowedToBeCalculatedBySlave(heartbeat.SlaveId, curJob)) {
-              // assigned resources ids of job do not match with slaveId (and parent resourceGroupIds); this might happen when slave is moved to different group
+            } else if (!TaskIsAllowedToBeCalculatedBySlave(heartbeat.SlaveId, curJob)) {
+              // assigned resources ids of task do not match with slaveId (and parent resourceGroupIds); this might happen when slave is moved to different group
               actions.Add(new MessageContainer(MessageContainer.MessageType.PauseTask, curJob.Id));
             } else {
-              // save job execution time
+              // save task execution time
               curJob.ExecutionTime = jobProgress.Value;
               curJob.LastHeartbeat = DateTime.Now;
@@ -127,5 +127,5 @@
                   break;
               }
-              dao.UpdateJob(curJob);
+              dao.UpdateTask(curJob);
             }
           }
@@ -135,6 +135,6 @@
     }
 
-    private bool JobIsAllowedToBeCalculatedBySlave(Guid slaveId, Task curJob) {
-      var assignedResourceIds = dao.GetAssignedResources(curJob.Id).Select(x => x.Id);
+    private bool TaskIsAllowedToBeCalculatedBySlave(Guid slaveId, Task curTask) {
+      var assignedResourceIds = dao.GetAssignedResources(curTask.Id).Select(x => x.Id);
       var slaveResourceIds = dao.GetParentResources(slaveId).Select(x => x.Id);
       return assignedResourceIds.Any(x => slaveResourceIds.Contains(x));
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/MessageContainer.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/MessageContainer.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/MessageContainer.cs	(revision 6743)
@@ -37,15 +37,15 @@
     public enum MessageType {
       // *** commands from hive server ***
-      CalculateTask, // slave should calculate a job. the job is already assigned to the slave
-      StopTask,   // slave should stop the job and submit results
+      CalculateTask, // slave should calculate a task. the task is already assigned to the slave
+      StopTask,   // slave should stop the task and submit results
       StopAll,   // stop all and submit results
-      AbortTask,  // slave should shut the job down immediately without submitting results
-      AbortAll,  // slave should abort all jobs immediately
-      PauseTask,  // pause the job and submit the results   
-      PauseAll,  // pause all jobs and submit results
+      AbortTask,  // slave should shut the task down immediately without submitting results
+      AbortAll,  // slave should abort all task immediately
+      PauseTask,  // pause the task and submit the results   
+      PauseAll,  // pause all task and submit results
       Restart,   // restart operation after Sleep
       Sleep,     // disconnect from server, but don't shutdown
       ShutdownSlave,  // slave should shutdown immediately without submitting results
-      SayHello,  // Slave should say hello, because he is unknown to the server
+      SayHello,  // Slave should say hello, because job is unknown to the server
     };
 
Index: /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/ServiceContracts/IHiveService.cs
===================================================================
--- /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/ServiceContracts/IHiveService.cs	(revision 6742)
+++ /branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/ServiceContracts/IHiveService.cs	(revision 6743)
@@ -33,84 +33,84 @@
     #region Task Methods
     [OperationContract]
-    Guid AddJob(Task job, TaskData jobData, IEnumerable<Guid> resourceIds);
-
-    [OperationContract]
-    Guid AddChildJob(Guid parentJobId, Task job, TaskData jobData);
-
-    [OperationContract]
-    Task GetJob(Guid jobId);
-
-    [OperationContract]
-    IEnumerable<Task> GetJobs();
-
-    [OperationContract]
-    IEnumerable<LightweightTask> GetLightweightJobs(IEnumerable<Guid> jobIds);
-
-    [OperationContract]
-    IEnumerable<LightweightTask> GetLightweightChildJobs(Guid? parentJobId, bool recursive, bool includeParent);
-
-    [OperationContract]
-    IEnumerable<LightweightTask> GetLightweightExperimentJobs(Guid experimentId);
-
-    [OperationContract]
-    TaskData GetJobData(Guid jobId);
-
-    [OperationContract]
-    void UpdateJob(Task jobDto);
-
-    [OperationContract]
-    void UpdateJobData(Task jobDto, TaskData jobDataDto);
-
-    [OperationContract]
-    void DeleteJob(Guid jobId);
-
-    [OperationContract]
-    void DeleteChildJobs(Guid parentJobId);
-
-    [OperationContract]
-    Task UpdateJobState(Guid jobId, TaskState jobState, Guid? slaveId, Guid? userId, string exception);
-    #endregion
-
-    #region Job Control Methods
-    [OperationContract]
-    void StopJob(Guid jobId);
-
-    [OperationContract]
-    void PauseJob(Guid jobId);
-
-    [OperationContract]
-    void RestartJob(Guid jobId);
+    Guid AddTask(Task task, TaskData taskData, IEnumerable<Guid> resourceIds);
+
+    [OperationContract]
+    Guid AddChildTask(Guid parentTaskId, Task task, TaskData taskData);
+
+    [OperationContract]
+    Task GetTask(Guid taskId);
+
+    [OperationContract]
+    IEnumerable<Task> GetTasks();
+
+    [OperationContract]
+    IEnumerable<LightweightTask> GetLightweightTasks(IEnumerable<Guid> taskIds);
+
+    [OperationContract]
+    IEnumerable<LightweightTask> GetLightweightChildTasks(Guid? parentTaskId, bool recursive, bool includeParent);
+
+    [OperationContract]
+    IEnumerable<LightweightTask> GetLightweightJobTasks(Guid jobId);
+
+    [OperationContract]
+    TaskData GetTaskData(Guid taskId);
+
+    [OperationContract]
+    void UpdateTask(Task taskDto);
+
+    [OperationContract]
+    void UpdateTaskData(Task taskDto, TaskData taskDataDto);
+
+    [OperationContract]
+    void DeleteTask(Guid taskId);
+
+    [OperationContract]
+    void DeleteChildTasks(Guid parentTaskId);
+
+    [OperationContract]
+    Task UpdateTaskState(Guid taskId, TaskState taskState, Guid? slaveId, Guid? userId, string exception);
+    #endregion
+
+    #region Task Control Methods
+    [OperationContract]
+    void StopTask(Guid taskId);
+
+    [OperationContract]
+    void PauseTask(Guid taskId);
+
+    [OperationContract]
+    void RestartTask(Guid taskId);
     #endregion
 
     #region Job Methods
     [OperationContract]
-    Job GetHiveExperiment(Guid id);
+    Job GetJob(Guid id);
 
     /// <summary>
-    /// Returns all experiments for the current user
+    /// Returns all task for the current user
     /// </summary>
     [OperationContract]
-    IEnumerable<Job> GetHiveExperiments();
+    IEnumerable<Job> GetJobs();
 
     /// <summary>
-    /// Returns all experiments in the hive (only for admins)
+    /// Returns all task in the hive (only for admins)
     /// </summary>
     /// <returns></returns>
     [OperationContract]
-    IEnumerable<Job> GetAllHiveExperiments();
-
-    [OperationContract]
-    Guid AddHiveExperiment(Job hiveExperimentDto);
-
-    [OperationContract]
-    void UpdateHiveExperiment(Job hiveExperimentDto);
-
-    [OperationContract]
-    void DeleteHiveExperiment(Guid hiveExperimentId);
-    #endregion
-
-    #region HiveExperimentPermission Methods
-    [OperationContract]
-    void GrantPermission(Guid hiveExperimentId, Guid grantedUserId, Permission permission);
+    IEnumerable<Job> GetAllJobs();
+
+    [OperationContract]
+    Guid AddJob(Job jobDto);
+
+    [OperationContract]
+    void UpdateJob(Job jobDto);
+
+    [OperationContract]
+    void DeleteJob(Guid JobId);
+    #endregion
+
+    #region JobPermission Methods
+    [OperationContract]
+    void GrantPermission(Guid jobId, Guid grantedUserId, Permission permission);
 
     [OperationContract]
@@ -118,8 +118,8 @@
 
     [OperationContract]
-    IEnumerable<JobPermission> GetHiveExperimentPermissions(Guid hiveExperimentId);
-
-    [OperationContract]
-    bool IsAllowedPrivileged(); // current user may execute privileged jobs
+    IEnumerable<JobPermission> GetJobPermissions(Guid jobId);
+
+    [OperationContract]
+    bool IsAllowedPrivileged(); // current user may execute privileged task
     #endregion
 
@@ -140,13 +140,18 @@
     [OperationContract]
     Plugin GetPlugin(Guid pluginId);
+
     [OperationContract]
     Plugin GetPluginByHash(byte[] hash);
+
     [OperationContract]
     [FaultContract(typeof(PluginAlreadyExistsFault))]
     Guid AddPlugin(Plugin plugin, List<PluginData> pluginData);
+
     [OperationContract]
     IEnumerable<Plugin> GetPlugins();
+
     [OperationContract]
     IEnumerable<PluginData> GetPluginDatas(List<Guid> pluginIds);
+
     [OperationContract]
     void DeletePlugin(Guid pluginId);
@@ -194,5 +199,5 @@
 
     [OperationContract]
-    IEnumerable<Task> GetJobsByResourceId(Guid resourceId);
+    IEnumerable<Task> GetTasksByResourceId(Guid resourceId);
 
     [OperationContract]
