Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/AtomicOperation.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/AtomicOperation.cs	(revision 2033)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/AtomicOperation.cs	(revision 2042)
@@ -72,9 +72,9 @@
     /// <param name="clonedObjects">All already cloned objects. (Needed to avoid cycles.)</param>
     /// <returns>The cloned object as <see cref="AtomicOperation"/>.</returns>
-    public override object Clone(IDictionary<long, object> clonedObjects) {
+    public override ICloneable Clone(ICloner cloner) {
       AtomicOperation clone = new AtomicOperation();
-      clonedObjects.Add(clone.Id, clone);
-      clone.myOperator = (IOperator)Auxiliary.Clone(Operator, clonedObjects);
-      clone.myScope = (IScope)Auxiliary.Clone(Scope, clonedObjects);
+      cloner.AddClonedObject(this, clone);
+      clone.myOperator = (IOperator)cloner.Clone(Operator);
+      clone.myScope = (IScope)cloner.Clone(Scope);
       return clone;
     }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Auxiliary.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Auxiliary.cs	(revision 2033)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Auxiliary.cs	(revision 2042)
@@ -30,21 +30,4 @@
   /// </summary>
   public static class Auxiliary {
-    #region Cloning
-    /// <summary>
-    /// Clones the given <paramref name="obj"/> (deep clone).
-    /// </summary>
-    /// <remarks>Checks before clone if object has not already been cloned.</remarks>
-    /// <param name="obj">The object to clone.</param>
-    /// <param name="clonedObjects">A dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
-    /// <returns>The cloned object.</returns>
-    public static object Clone(ICloneable obj, IDictionary<long, object> clonedObjects) {
-      object clone;
-      if (clonedObjects.TryGetValue(obj.Id, out clone))
-        return clone;
-      else
-        return obj.Clone(clonedObjects);
-    }
-    #endregion
-
     #region Error Messages
     /// <summary>
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/CloneableBase.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/CloneableBase.cs	(revision 2033)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/CloneableBase.cs	(revision 2042)
@@ -31,23 +31,6 @@
   /// </summary>
   public abstract class CloneableBase : ICloneable {
-    /// <summary>
-    /// Gets a unique id (memory address) of the current instance. The id is used to
-    /// detect, if an object has already been cloned or not.
-    /// </summary>
-    public long Id {
-      get {
-        GCHandle handle = new GCHandle();
-        handle.Target = this;
-        return GCHandle.ToIntPtr(handle).ToInt64();
-      }
-    }
-
-    /// <summary>
-    /// Clones the current instance (deep clone).
-    /// </summary>
-    /// <remarks>Uses the <see cref="Auxiliary.Clone"/> method of the class <see cref="Auxiliary"/>.</remarks>
-    /// <returns>The clone.</returns>
     public object Clone() {
-      return Auxiliary.Clone(this, new Dictionary<long, object>());
+      return Clone(new Cloner());
     }
     /// <summary>
@@ -57,7 +40,7 @@
     /// <param name="clonedObjects">All already cloned objects.</param>
     /// <returns>The clone.</returns>
-    public virtual object Clone(IDictionary<long, object> clonedObjects) {
+    public virtual ICloneable Clone(ICloner cloner) {
       CloneableBase clone = (CloneableBase)Activator.CreateInstance(this.GetType());
-      clonedObjects.Add(clone.Id, clone);
+      cloner.AddClonedObject(this, clone);
       return clone;
     }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Cloner.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Cloner.cs	(revision 2042)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Cloner.cs	(revision 2042)
@@ -0,0 +1,58 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 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.Text;
+using System.Runtime.InteropServices;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  public class Cloner : ICloner {
+    private class ReferenceEqualityComparer : IEqualityComparer<ICloneable> {
+      public bool Equals(ICloneable x, ICloneable y) {
+        return object.ReferenceEquals(x, y);
+      }
+
+      public int GetHashCode(ICloneable obj) {
+        if (obj == null) return 0;
+        return obj.GetHashCode();
+      }
+    }
+
+    private Dictionary<ICloneable, ICloneable> mapping;
+
+    public Cloner() {
+      mapping = new Dictionary<ICloneable, ICloneable>(new ReferenceEqualityComparer());
+    }
+
+    public ICloneable Clone(ICloneable obj) {
+      ICloneable clone;
+      if (mapping.TryGetValue(obj, out clone))
+        return clone;
+      else
+        return obj.Clone(this);
+    }
+    public void AddClonedObject(ICloneable obj, ICloneable clone) {
+      mapping.Add(obj, clone);
+    }
+  }
+}
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/CompositeOperation.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/CompositeOperation.cs	(revision 2033)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/CompositeOperation.cs	(revision 2042)
@@ -84,10 +84,10 @@
     /// <param name="clonedObjects">A dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
     /// <returns>The cloned operation as <see cref="CompositeOperation"/>.</returns>
-    public override object Clone(IDictionary<long, object> clonedObjects) {
+    public override ICloneable Clone(ICloner cloner) {
       CompositeOperation clone = new CompositeOperation();
-      clonedObjects.Add(clone.Id, clone);
+      cloner.AddClonedObject(this, clone);
       clone.myExecuteInParallel = ExecuteInParallel;
       for (int i = 0; i < Operations.Count; i++)
-        clone.AddOperation((IOperation)Auxiliary.Clone(Operations[i], clonedObjects));
+        clone.AddOperation((IOperation)cloner.Clone(Operations[i]));
       return clone;
     }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/EngineBase.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/EngineBase.cs	(revision 2033)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/EngineBase.cs	(revision 2042)
@@ -130,13 +130,13 @@
     /// <param name="clonedObjects">Dictionary of all already clone objects. (Needed to avoid cycles.)</param>
     /// <returns>The cloned object as <see cref="EngineBase"/>.</returns>
-    public override object Clone(IDictionary<long, object> clonedObjects) {
-      EngineBase clone = (EngineBase)base.Clone(clonedObjects);
-      clone.myOperatorGraph = (IOperatorGraph)Auxiliary.Clone(OperatorGraph, clonedObjects);
-      clone.myGlobalScope = (IScope)Auxiliary.Clone(GlobalScope, clonedObjects);
+    public override ICloneable Clone(ICloner cloner) {
+      EngineBase clone = (EngineBase)base.Clone(cloner);
+      clone.myOperatorGraph = (IOperatorGraph)cloner.Clone(OperatorGraph);
+      clone.myGlobalScope = (IScope)cloner.Clone(GlobalScope);
       clone.myExecutionTime = ExecutionTime;
       IOperation[] operations = new IOperation[ExecutionStack.Count];
       ExecutionStack.CopyTo(operations, 0);
       for (int i = operations.Length - 1; i >= 0; i--)
-        clone.myExecutionStack.Push((IOperation)Auxiliary.Clone(operations[i], clonedObjects));
+        clone.myExecutionStack.Push((IOperation)cloner.Clone(operations[i]));
       clone.myRunning = Running;
       clone.myCanceled = Canceled;
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/HeuristicLab.Core-3.3.csproj
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/HeuristicLab.Core-3.3.csproj	(revision 2033)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/HeuristicLab.Core-3.3.csproj	(revision 2042)
@@ -125,4 +125,8 @@
     <Compile Include="CallGraph.cs" />
     <Compile Include="CallNode.cs" />
+    <Compile Include="Cloner.cs" />
+    <Compile Include="ParameterEventArgs.cs" />
+    <Compile Include="Interfaces\ICloner.cs" />
+    <Compile Include="Interfaces\ICloneable.cs" />
     <Compile Include="ParameterView.cs">
       <SubType>UserControl</SubType>
@@ -136,5 +140,4 @@
     <Compile Include="Interfaces\ICallNode.cs" />
     <Compile Include="Interfaces\ICallGraph.cs" />
-    <Compile Include="Interfaces\ICloneable.cs" />
     <Compile Include="KeyValueEventArgs.cs" />
     <Compile Include="OperatorBaseDescriptionView.cs">
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Interfaces/ICloneable.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Interfaces/ICloneable.cs	(revision 2033)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Interfaces/ICloneable.cs	(revision 2042)
@@ -30,15 +30,5 @@
   /// </summary>
   public interface ICloneable : System.ICloneable {
-    /// <summary>
-    /// Gets a unique id representing the current object. This id is used to check, if an object has 
-    /// already been cloned (to avoid cycles).
-    /// </summary>
-    long Id { get; }
-    /// <summary>
-    /// Clones the current instance, considering already cloned objects.
-    /// </summary>
-    /// <param name="clonedObjects">All already cloned objects. (Needed to avoid cycles.)</param>
-    /// <returns>The cloned object.</returns>
-    object Clone(IDictionary<long, object> clonedObjects);
+    ICloneable Clone(ICloner cloner);
   }
 }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Interfaces/ICloner.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Interfaces/ICloner.cs	(revision 2042)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Interfaces/ICloner.cs	(revision 2042)
@@ -0,0 +1,32 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 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.Text;
+using System.Xml;
+
+namespace HeuristicLab.Core {
+  public interface ICloner {
+    ICloneable Clone(ICloneable obj);
+    void AddClonedObject(ICloneable obj, ICloneable clone);
+  }
+}
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Interfaces/IOperator.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Interfaces/IOperator.cs	(revision 2033)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Interfaces/IOperator.cs	(revision 2042)
@@ -49,32 +49,7 @@
 
     /// <summary>
-    /// Gets a list of all sub operators.
-    /// </summary>
-    IList<IOperator> SubOperators { get; }
-    /// <summary>
     /// Gets a collection of all variable (parameter) infos.
     /// </summary>
-    ICollection<IVariableInfo> VariableInfos { get; }
-    /// <summary>
-    /// Gets a collection of all variables of the current operator.
-    /// </summary>
-    ICollection<IVariable> Variables { get; }
-
-    /// <summary>
-    /// Adds the given sub operator to the current instance.
-    /// </summary>
-    /// <param name="op">The operator to add.</param>
-    void AddSubOperator(IOperator op);
-    /// <summary>
-    /// Adds the given sub operator at a the specified <paramref name="index"/>.
-    /// </summary>
-    /// <param name="op">The operator to add.</param>
-    /// <param name="index">The position where to add the operator.</param>
-    void AddSubOperator(IOperator op, int index);
-    /// <summary>
-    /// Removes a sub operator at the specified <paramref name="index"/>.
-    /// </summary>
-    /// <param name="index">The position where to delete the operator.</param>
-    void RemoveSubOperator(int index);
+    ICollection<IParameter> Parameters { get; }
 
     /// <summary>
@@ -83,60 +58,15 @@
     /// <param name="formalName">The formal name of the variable info.</param>
     /// <returns>The variable info with the specified formal name.</returns>
-    IVariableInfo GetVariableInfo(string formalName);
+    IParameter GetParameter(string name);
     /// <summary>
     /// Adds the specified variable info to the current instance.
     /// </summary>
     /// <param name="variableInfo">The variable info to add.</param>
-    void AddVariableInfo(IVariableInfo variableInfo);
+    void AddParameter(IParameter parameter);
     /// <summary>
     /// Removes the variable info with the given formal name.
     /// </summary>
     /// <param name="formalName">The formal name of the variable info to remove.</param>
-    void RemoveVariableInfo(string formalName);
-
-    /// <summary>
-    /// Gets a variable with the given <paramref name="name"/>.
-    /// </summary>
-    /// <param name="name">The name of the variable.</param>
-    /// <returns>The variable with the specified name.</returns>
-    IVariable GetVariable(string name);
-    /// <summary>
-    /// Adds the specified <paramref name="variable"/> to the current instance.
-    /// </summary>
-    /// <param name="variable">The variable to add.</param>
-    void AddVariable(IVariable variable);
-    /// <summary>
-    /// Deletes the variable with the specified <paramref name="name"/>.
-    /// </summary>
-    /// <param name="name">The name of the variable to delete.</param>
-    void RemoveVariable(string name);
-
-    /// <inheritdoc cref="GetVariableValue(string, HeuristicLab.Core.IScope, bool)"/>
-    /// <typeparam name="T">The type of the value that is searched.</typeparam>       
-    T GetVariableValue<T>(string formalName, IScope scope, bool recursiveLookup) where T : class, IItem;
-    /// <inheritdoc cref="GetVariableValue(string, HeuristicLab.Core.IScope, bool, bool)"/>
-    /// <typeparam name="T">The type of the value that is searched.</typeparam>
-    T GetVariableValue<T>(string formalName, IScope scope, bool recursiveLookup, bool throwOnError) where T : class, IItem;
-    /// <inheritdoc cref="GetVariableValue(System.String, IScope, bool, bool)" 
-    /// select="summary"/>
-    /// <param name="formalName">The formal name of the variable info whose variable value is searched.</param>
-    /// <param name="scope">The scope where to look for the variable.</param>
-    /// <param name="recursiveLookup">Boolean value, whether also the parent scopes shall be searched if
-    /// the variable is not found in the specified <paramref name="scope"/>.</param>
-    /// <returns>The value of the searched variable or null if it is not found.</returns>
-    IItem GetVariableValue(string formalName, IScope scope, bool recursiveLookup);
-    /// <summary>
-    /// Gets the value of the variable in the specified <paramref name="scope"/>
-    /// whose variable(parameter) info has the specified <paramref name="formalName"/>.
-    /// </summary>
-    /// <param name="formalName">The formal name of the variable info whose variable value is searched.</param>
-    /// <param name="scope">The scope where to look for the variable.</param>
-    /// <param name="recursiveLookup">Boolean value, whether also the parent scopes shall be searched if
-    /// the variable is not found in the specified <paramref name="scope"/>.</param>
-    /// <param name="throwOnError">Boolean value, whether an exception shall be thrown, if the variable 
-    /// cannot be found or just <c>null</c> shall be returned.</param>
-    /// <returns>The value of the searched variable (or null if the variable is not 
-    /// found and <paramref name="throwOnError"/> is set to false).</returns>
-    IItem GetVariableValue(string formalName, IScope scope, bool recursiveLookup, bool throwOnError);
+    void RemoveParameter(string name);
 
     /// <summary>
@@ -160,27 +90,11 @@
     event EventHandler BreakpointChanged; 
     /// <summary>
-    /// Occurs when a sub operator has been added.
-    /// </summary>
-    event EventHandler<OperatorIndexEventArgs> SubOperatorAdded;
-    /// <summary>
-    /// Occurs when a sub operator has been deleted.
-    /// </summary>
-    event EventHandler<OperatorIndexEventArgs> SubOperatorRemoved;
-    /// <summary>
     /// Occurs when a variable info has been added.
     /// </summary>
-    event EventHandler<VariableInfoEventArgs> VariableInfoAdded;
+    event EventHandler<ParameterEventArgs> ParameterAdded;
     /// <summary>
     /// Occurs when a variable info has been deleted.
     /// </summary>
-    event EventHandler<VariableInfoEventArgs> VariableInfoRemoved;
-    /// <summary>
-    /// Occurs when a variable has been added.
-    /// </summary>
-    event EventHandler<VariableEventArgs> VariableAdded;
-    /// <summary>
-    /// Occurs when a variable has been deleted.
-    /// </summary>
-    event EventHandler<VariableEventArgs> VariableRemoved;
+    event EventHandler<ParameterEventArgs> ParameterRemoved;
     /// <summary>
     /// Occurs when the current instance is executed.
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Interfaces/IScope.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Interfaces/IScope.cs	(revision 2033)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Interfaces/IScope.cs	(revision 2042)
@@ -39,8 +39,4 @@
     /// </summary>
     ICollection<IVariable> Variables { get; }
-    /// <summary>
-    /// Gets all aliases of the current scope.
-    /// </summary>
-    IEnumerable<KeyValuePair<string, string>> Aliases { get; }
     /// <summary>
     /// Gets all subscopes in the current scope.
@@ -96,22 +92,4 @@
 
     /// <summary>
-    /// Gets the actual name of the given alias.
-    /// </summary>
-    /// <param name="name">The alias whose actual name is searched.</param>
-    /// <returns>The actual name.</returns>
-    string TranslateName(string name);
-    /// <summary>
-    /// Adds an alias to the current instance. 
-    /// </summary>
-    /// <param name="alias">The alias to add.</param>
-    /// <param name="name">The actual name of the alias.</param>
-    void AddAlias(string alias, string name);
-    /// <summary>
-    /// Deletes the specified <paramref name="alias"/> from the current instance.
-    /// </summary>
-    /// <param name="alias">The alias to delete.</param>
-    void RemoveAlias(string alias);
-
-    /// <summary>
     /// Adds the specified sub scope to the current instance.
     /// </summary>
@@ -149,12 +127,4 @@
     event EventHandler<VariableEventArgs> VariableRemoved;
     /// <summary>
-    /// Occurs when an alias has been added to the current instance.
-    /// </summary>
-    event EventHandler<AliasEventArgs> AliasAdded;
-    /// <summary>
-    /// Occurs when an alias has been removed from the current instance.
-    /// </summary>
-    event EventHandler<AliasEventArgs> AliasRemoved;
-    /// <summary>
     /// Occurs when a sub scope has been added to the current instance.
     /// </summary>
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/OperatorBase.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/OperatorBase.cs	(revision 2033)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/OperatorBase.cs	(revision 2042)
@@ -78,35 +78,8 @@
 
     [Storable]
-    private List<IOperator> mySubOperators;
-    /// <summary>
-    /// Gets a list of all suboperators.
-    /// <note type="caution"> Returns the suboperators read-only!</note>
-    /// </summary>
-    public virtual IList<IOperator> SubOperators {
-      get { return mySubOperators.AsReadOnly(); }
-    }
-
-    [Storable]
-    private Dictionary<string, IVariableInfo> myVariableInfos;
-    /// <inheritdoc/>
-    public virtual ICollection<IVariableInfo> VariableInfos {
-      get { return myVariableInfos.Values; }
-    }
-    
-    private Dictionary<string, IVariable> myVariables;
-    /// <inheritdoc/>    
-    public virtual ICollection<IVariable> Variables {
-      get { return myVariables.Values; }
-    }
-
-    [Storable(Name="Variables")]
-    private List<IVariable> VariablePersistence {
-      get { return new List<IVariable>(myVariables.Values); }
-      set {
-        myVariables.Clear();
-        foreach (IVariable var in value) {
-          AddVariable(var);
-        }
-      }
+    private Dictionary<string, IParameter> myParameters;
+    /// <inheritdoc/>
+    public virtual ICollection<IParameter> Parameters {
+      get { return myParameters.Values; }
     }
 
@@ -119,7 +92,5 @@
       myCanceled = false;
       myBreakpoint = false;
-      mySubOperators = new List<IOperator>();
-      myVariableInfos = new Dictionary<string, IVariableInfo>();
-      myVariables = new Dictionary<string, IVariable>();
+      myParameters = new Dictionary<string, IParameter>();
     }
 
@@ -130,16 +101,10 @@
     /// <param name="clonedObjects">Dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
     /// <returns>The cloned object as <see cref="OperatorBase"/>.</returns>
-    public override object Clone(IDictionary<long, object> clonedObjects) {
-      OperatorBase clone = (OperatorBase)base.Clone(clonedObjects);
+    public override ICloneable Clone(ICloner cloner) {
+      OperatorBase clone = (OperatorBase)base.Clone(cloner);
       clone.myName = Name;
-      clone.mySubOperators.Clear();
-      for (int i = 0; i < SubOperators.Count; i++)
-        clone.AddSubOperator((IOperator)Auxiliary.Clone(SubOperators[i], clonedObjects));
-      clone.myVariableInfos.Clear();
-      foreach (IVariableInfo variableInfo in myVariableInfos.Values)
-        clone.AddVariableInfo((IVariableInfo)Auxiliary.Clone(variableInfo, clonedObjects));
-      clone.myVariables.Clear();
-      foreach (IVariable variable in myVariables.Values)
-        clone.AddVariable((IVariable)Auxiliary.Clone(variable, clonedObjects));
+      clone.myParameters.Clear();
+      foreach (IParameter parameter in myParameters.Values)
+        clone.AddParameter((IParameter)cloner.Clone(parameter));
       return clone;
     }
@@ -154,34 +119,10 @@
     }
 
-    #region SubOperator Methods
-    /// <inheritdoc cref="HeuristicLab.Core.IOperator.AddSubOperator(HeuristicLab.Core.IOperator)"/>
-    /// <param name="subOperator">The sub operator to add.</param>
-    /// <remarks>Calls <see cref="OnSubOperatorAdded"/>.</remarks>
-    public virtual void AddSubOperator(IOperator subOperator) {
-      mySubOperators.Add(subOperator);
-      OnSubOperatorAdded(subOperator, mySubOperators.Count - 1);
-    }
-    /// <inheritdoc cref="HeuristicLab.Core.IOperator.AddSubOperator(HeuristicLab.Core.IOperator, int)"/>
-    /// <param name="subOperator">The sub operator to add.</param>
-    /// <remarks>Calls <see cref="OnSubOperatorAdded"/>.</remarks>
-    public virtual void AddSubOperator(IOperator subOperator, int index) {
-      mySubOperators.Insert(index, subOperator);
-      OnSubOperatorAdded(subOperator, index);
-    }
-    /// <inheritdoc/>
-    /// <remarks>Calls <see cref="OnSubOperatorRemoved"/>.</remarks>
-    public virtual void RemoveSubOperator(int index) {
-      IOperator op = mySubOperators[index];
-      mySubOperators.RemoveAt(index);
-      OnSubOperatorRemoved(op, index);
-    }
-    #endregion
-
-    #region VariableInfo Methods
-    /// <inheritdoc/>
-    public virtual IVariableInfo GetVariableInfo(string formalName) {
-      IVariableInfo info;
-      if (myVariableInfos.TryGetValue(formalName, out info))
-        return info;
+    #region Parameter Methods
+    /// <inheritdoc/>
+    public virtual IParameter GetParameter(string name) {
+      IParameter parameter;
+      if (myParameters.TryGetValue(name, out parameter))
+        return parameter;
       else
         return null;
@@ -189,95 +130,15 @@
     /// <inheritdoc/>
     /// <remarks>Calls <see cref="OnVariableInfoAdded"/>.</remarks>
-    public virtual void AddVariableInfo(IVariableInfo variableInfo) {
-      myVariableInfos.Add(variableInfo.FormalName, variableInfo);
-      OnVariableInfoAdded(variableInfo);
+    public virtual void AddParameter(IParameter parameter) {
+      myParameters.Add(parameter.Name, parameter);
+      OnParameterAdded(parameter);
     }
     /// <inheritdoc/>
     /// <remarks>Calls <see cref="OnVariableInfoRemoved"/>.</remarks>
-    public virtual void RemoveVariableInfo(string formalName) {
-      IVariableInfo variableInfo;
-      if (myVariableInfos.TryGetValue(formalName, out variableInfo)) {
-        myVariableInfos.Remove(formalName);
-        OnVariableInfoRemoved(variableInfo);
-      }
-    }
-    #endregion
-
-    #region Variable Methods
-    /// <inheritdoc/>
-    public virtual IVariable GetVariable(string name) {
-      IVariable variable;
-      if (myVariables.TryGetValue(name, out variable))
-        return variable;
-      else
-        return null;
-    }
-    /// <inheritdoc/>
-    /// <remarks>Calls <see cref="OnVariableAdded"/> and adds <c>NameChanging</c> and <c>NameChanged</c>
-    /// event handlers.</remarks>
-    public virtual void AddVariable(IVariable variable) {
-      myVariables.Add(variable.Name, variable);
-      variable.NameChanging += new EventHandler<NameChangingEventArgs>(Variable_NameChanging);
-      variable.NameChanged += new EventHandler(Variable_NameChanged);
-      OnVariableAdded(variable);
-    }
-    /// <inheritdoc/>
-    /// <remarks>Calls <see cref="OnVariableRemoved"/> and removes <c>NameChanging</c> and <c>NameChanged</c>
-    /// event handlers.</remarks>
-    public virtual void RemoveVariable(string name) {
-      IVariable variable;
-      if (myVariables.TryGetValue(name, out variable)) {
-        variable.NameChanging -= new EventHandler<NameChangingEventArgs>(Variable_NameChanging);
-        variable.NameChanged -= new EventHandler(Variable_NameChanged);
-        myVariables.Remove(name);
-        OnVariableRemoved(variable);
-      }
-    }
-    private void Variable_NameChanging(object sender, NameChangingEventArgs e) {
-      e.Cancel = myVariables.ContainsKey(e.Name);
-    }
-    private void Variable_NameChanged(object sender, EventArgs e) {
-      IVariable variable = (IVariable)sender;
-      string oldName = null;
-      foreach (KeyValuePair<string, IVariable> element in myVariables) {
-        if (element.Value == variable)
-          oldName = element.Key;
-      }
-      myVariables.Remove(oldName);
-      myVariables.Add(variable.Name, variable);
-    }
-    /// <inheritdoc cref="IOperator.GetVariableValue&lt;T&gt;(string, HeuristicLab.Core.IScope, bool)"/>
-    ///  <remarks>Calls <see cref="GetVariableValue&lt;T&gt;(string, HeuristicLab.Core.IScope, bool, bool)"/> 
-    /// with <c>throwOnError</c> set to <c>false</c>.</remarks>
-    public T GetVariableValue<T>(string formalName, IScope scope, bool recursiveLookup) where T : class, IItem {
-      return GetVariableValue<T>(formalName, scope, recursiveLookup, true);
-    }
-    /// <inheritdoc cref="IOperator.GetVariableValue&lt;T&gt;(string, HeuristicLab.Core.IScope, bool, bool)"/>
-    /// <remarks>Calls 
-    /// <see cref="GetVariableValue(string, HeuristicLab.Core.IScope, bool, bool)"/>.</remarks>
-    public T GetVariableValue<T>(string formalName, IScope scope, bool recursiveLookup, bool throwOnError) where T : class, IItem {
-      return (T)GetVariableValue(formalName, scope, recursiveLookup, throwOnError);
-    }
-    /// <inheritdoc cref="IOperator.GetVariableValue(string, HeuristicLab.Core.IScope, bool)"/>
-    /// <remarks>Calls <see cref="GetVariableValue(string, HeuristicLab.Core.IScope, bool, bool)"/> 
-    /// with <c>throwOnError</c> set to <c>false</c>.</remarks>
-    public IItem GetVariableValue(string formalName, IScope scope, bool recursiveLookup) {
-      return GetVariableValue(formalName, scope, recursiveLookup, true);
-    }
-    /// <inheritdoc cref="IOperator.GetVariableValue(string, HeuristicLab.Core.IScope, bool, bool)"/>
-    public virtual IItem GetVariableValue(string formalName, IScope scope, bool recursiveLookup, bool throwOnError) {
-      IVariableInfo info = GetVariableInfo(formalName);
-      if (info.Local) {
-        IVariable variable;
-        if (myVariables.TryGetValue(info.ActualName, out variable))
-          return variable.Value;
-        else {
-          if (throwOnError)
-            throw new ArgumentException("Variable " + info.ActualName + " not found");
-          else
-            return null;
-        }
-      } else {
-        return scope.GetVariableValue(formalName, recursiveLookup, throwOnError);
+    public virtual void RemoveParameter(string name) {
+      IParameter parameter;
+      if (myParameters.TryGetValue(name, out parameter)) {
+        myParameters.Remove(name);
+        OnParameterRemoved(parameter);
       }
     }
@@ -287,13 +148,5 @@
     public virtual IOperation Execute(IScope scope) {
       myCanceled = false;
-
-      foreach (IVariableInfo variableInfo in VariableInfos)
-        scope.AddAlias(variableInfo.FormalName, variableInfo.ActualName);
-
       IOperation next = Apply(scope);
-
-      foreach (IVariableInfo variableInfo in VariableInfos)
-        scope.RemoveAlias(variableInfo.FormalName);
-
       OnExecuted();
       return next;
@@ -333,64 +186,22 @@
     }
     /// <inheritdoc/>
-    public event EventHandler<OperatorIndexEventArgs> SubOperatorAdded;
-    /// <summary>
-    /// Fires a new <c>SubOperatorAdded</c> event.
-    /// </summary>
-    /// <param name="subOperator">The sub operator that has been added.</param>
-    /// <param name="index">The position where the operator has been added.</param>
-    protected virtual void OnSubOperatorAdded(IOperator subOperator, int index) {
-      if (SubOperatorAdded != null)
-        SubOperatorAdded(this, new OperatorIndexEventArgs(subOperator, index));
-    }
-    /// <inheritdoc/>
-    public event EventHandler<OperatorIndexEventArgs> SubOperatorRemoved;
-    /// <summary>
-    /// Fires a new <c>SubOperatorRemoved</c> event.
-    /// </summary>
-    /// <param name="subOperator">The sub operator that has been removed.</param>
-    /// <param name="index">The position where the operator has been removed.</param>
-    protected virtual void OnSubOperatorRemoved(IOperator subOperator, int index) {
-      if (SubOperatorRemoved != null)
-        SubOperatorRemoved(this, new OperatorIndexEventArgs(subOperator, index));
-    }
-    /// <inheritdoc/>
-    public event EventHandler<VariableInfoEventArgs> VariableInfoAdded;
+    public event EventHandler<ParameterEventArgs> ParameterAdded;
     /// <summary>
     /// Fires a new <c>VariableInfoAdded</c> event.
     /// </summary>
     /// <param name="variableInfo">The variable info that has been added.</param>
-    protected virtual void OnVariableInfoAdded(IVariableInfo variableInfo) {
-      if (VariableInfoAdded != null)
-        VariableInfoAdded(this, new VariableInfoEventArgs(variableInfo));
-    }
-    /// <inheritdoc/>
-    public event EventHandler<VariableInfoEventArgs> VariableInfoRemoved;
+    protected virtual void OnParameterAdded(IParameter parameter) {
+      if (ParameterAdded != null)
+        ParameterAdded(this, new ParameterEventArgs(parameter));
+    }
+    /// <inheritdoc/>
+    public event EventHandler<ParameterEventArgs> ParameterRemoved;
     /// <summary>
     /// Fires a new <c>VariableInfoRemoved</c> event.
     /// </summary>
     /// <param name="variableInfo">The variable info that has been removed.</param>
-    protected virtual void OnVariableInfoRemoved(IVariableInfo variableInfo) {
-      if (VariableInfoRemoved != null)
-        VariableInfoRemoved(this, new VariableInfoEventArgs(variableInfo));
-    }
-    /// <inheritdoc/>
-    public event EventHandler<VariableEventArgs> VariableAdded;
-    /// <summary>
-    /// Fires a new <c>VariableAdded</c> event.
-    /// </summary>
-    /// <param name="variable">The variable that has been added.</param>
-    protected virtual void OnVariableAdded(IVariable variable) {
-      if (VariableAdded != null)
-        VariableAdded(this, new VariableEventArgs(variable));
-    }
-    /// <inheritdoc/>
-    public event EventHandler<VariableEventArgs> VariableRemoved;
-    /// <summary>
-    /// Fires a new <c>VariableRemoved</c> event.
-    /// </summary>
-    /// <param name="variable">The variable that has been removed</param>
-    protected virtual void OnVariableRemoved(IVariable variable) {
-      if (VariableRemoved != null)
-        VariableRemoved(this, new VariableEventArgs(variable));
+    protected virtual void OnParameterRemoved(IParameter parameter) {
+      if (ParameterRemoved != null)
+        ParameterRemoved(this, new ParameterEventArgs(parameter));
     }
     /// <inheritdoc/>
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/OperatorGraph.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/OperatorGraph.cs	(revision 2033)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/OperatorGraph.cs	(revision 2042)
@@ -80,11 +80,11 @@
     /// <param name="clonedObjects">Dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
     /// <returns>The cloned object as <see cref="OperatorGraph"/>.</returns>
-    public override object Clone(IDictionary<long, object> clonedObjects) {
+    public override ICloneable Clone(ICloner cloner) {
       OperatorGraph clone = new OperatorGraph();
-      clonedObjects.Add(clone.Id, clone);
+      cloner.AddClonedObject(this, clone);
       foreach (IOperator op in Operators)
-        clone.AddOperator((IOperator)Auxiliary.Clone(op, clonedObjects));
+        clone.AddOperator((IOperator)cloner.Clone(op));
       if (InitialOperator != null)
-        clone.myInitialOperator = (IOperator)Auxiliary.Clone(InitialOperator, clonedObjects);
+        clone.myInitialOperator = (IOperator)cloner.Clone(InitialOperator);
       return clone;
     }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/OperatorGroup.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/OperatorGroup.cs	(revision 2033)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/OperatorGroup.cs	(revision 2042)
@@ -84,11 +84,11 @@
     /// <param name="clonedObjects">Dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
     /// <returns>The cloned object as <see cref="OperatorGroup"/>.</returns>
-    public override object Clone(IDictionary<long, object> clonedObjects) {
-      OperatorGroup clone = (OperatorGroup)base.Clone(clonedObjects);
+    public override ICloneable Clone(ICloner cloner) {
+      OperatorGroup clone = (OperatorGroup)base.Clone(cloner);
       clone.myName = Name;
       foreach (IOperatorGroup group in SubGroups)
-        clone.AddSubGroup((IOperatorGroup)Auxiliary.Clone(group, clonedObjects));
+        clone.AddSubGroup((IOperatorGroup)cloner.Clone(group));
       foreach (IOperator op in Operators)
-        clone.AddOperator((IOperator)Auxiliary.Clone(op, clonedObjects));
+        clone.AddOperator((IOperator)cloner.Clone(op));
       return clone;
     }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/OperatorLibrary.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/OperatorLibrary.cs	(revision 2033)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/OperatorLibrary.cs	(revision 2042)
@@ -70,8 +70,8 @@
     /// <param name="clonedObjects">Dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
     /// <returns>The cloned object as <see cref="OperatorLibrary"/>.</returns>
-    public override object Clone(IDictionary<long, object> clonedObjects) {
+    public override ICloneable Clone(ICloner cloner) {
       OperatorLibrary clone = new OperatorLibrary();
-      clonedObjects.Add(clone.Id, clone);
-      clone.myGroup = (IOperatorGroup)Auxiliary.Clone(Group, clonedObjects);
+      cloner.AddClonedObject(this, clone);
+      clone.myGroup = (IOperatorGroup)cloner.Clone(Group);
       return clone;
     }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Parameter.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Parameter.cs	(revision 2033)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Parameter.cs	(revision 2042)
@@ -69,7 +69,7 @@
     }
 
-    public override object Clone(IDictionary<long, object> clonedObjects) {
+    public override ICloneable Clone(ICloner cloner) {
       Parameter clone = new Parameter();
-      clonedObjects.Add(clone.Id, clone);
+      cloner.AddClonedObject(this, clone);
       clone.myName = Name;
       clone.myDescription = Description;
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/ParameterEventArgs.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/ParameterEventArgs.cs	(revision 2042)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/ParameterEventArgs.cs	(revision 2042)
@@ -0,0 +1,50 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 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.Text;
+
+namespace HeuristicLab.Core {
+  /// <summary>
+  /// Event arguments to be able to specify an affected parameter.
+  /// </summary>
+  public class ParameterEventArgs : ItemEventArgs {
+    /// <summary>
+    /// Gets the affected parameter.
+    /// </summary>
+    /// <remarks>Uses property <see cref="ItemEventArgs.Item"/> of base class <see cref="ItemEventArgs"/>.
+    /// No own data storage present.</remarks>
+    public IParameter Parameter {
+      get { return (IParameter)Item; }
+    }
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="VariableInfoEventArgs"/> with the specified 
+    /// <paramref name="parameter"/>.
+    /// </summary>
+    /// <remarks>Calls constructor of base class <see cref="ItemEventArgs"/>.</remarks>
+    /// <param name="variableInfo">The affected parameter.</param>
+    public ParameterEventArgs(IParameter parameter)
+      : base(parameter) {
+    }
+  }
+}
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Scope.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Scope.cs	(revision 2033)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Scope.cs	(revision 2042)
@@ -60,11 +60,4 @@
       }
     }
-    
-    [Storable]
-    private IDictionary<string, string> myAliases;
-    /// <inheritdoc/>
-    public IEnumerable<KeyValuePair<string, string>> Aliases {
-      get { return myAliases; }
-    }
 
     [Storable]
@@ -84,5 +77,4 @@
       myName = "Anonymous";
       myVariables = new Dictionary<string, IVariable>();
-      myAliases = new Dictionary<string, string>();
       mySubScopes = new List<IScope>();
     }
@@ -177,27 +169,4 @@
       }
     }
-    /// <inheritdoc/>
-    public string TranslateName(string name) {
-      while (myAliases.ContainsKey(name))
-        name = myAliases[name];
-      if (parent != null)
-        name = parent.TranslateName(name);
-      return name;
-    }
-    /// <inheritdoc/>
-    public void AddAlias(string alias, string name) {
-      RemoveAlias(alias);
-      if (alias != name) {
-        myAliases.Add(alias, name);
-        OnAliasAdded(alias);
-      }
-    }
-    /// <inheritdoc/>
-    public void RemoveAlias(string alias) {
-      if (myAliases.ContainsKey(alias)) {
-        myAliases.Remove(alias);
-        OnAliasRemoved(alias);
-      }
-    }
 
     /// <inheritdoc/>
@@ -256,14 +225,12 @@
 
     /// <inheritdoc/>
-    public override object Clone(IDictionary<long, object> clonedObjects) {
-      Scope clone = (Scope)base.Clone(clonedObjects);
+    public override ICloneable Clone(ICloner cloner) {
+      Scope clone = (Scope)base.Clone(cloner);
       clone.myName = Name;
 
       foreach (IVariable variable in myVariables.Values)
-        clone.AddVariable((IVariable)Auxiliary.Clone(variable, clonedObjects));
-      foreach (KeyValuePair<string, string> alias in myAliases)
-        clone.AddAlias(alias.Key, alias.Value);
+        clone.AddVariable((IVariable)cloner.Clone(variable));
       for (int i = 0; i < SubScopes.Count; i++)
-        clone.AddSubScope((IScope)Auxiliary.Clone(SubScopes[i], clonedObjects));
+        clone.AddSubScope((IScope)cloner.Clone(SubScopes[i]));
 
       return clone;
@@ -289,24 +256,4 @@
       if (VariableRemoved != null)
         VariableRemoved(this, new VariableEventArgs(variable));
-    }
-    /// <inheritdoc /> 
-    public event EventHandler<AliasEventArgs> AliasAdded;
-    /// <summary>
-    /// Fires a new <c>AliasAdded</c> event.
-    /// </summary>
-    /// <param name="alias">The alias that has been added.</param>
-    protected virtual void OnAliasAdded(string alias) {
-      if (AliasAdded != null)
-        AliasAdded(this, new AliasEventArgs(alias));
-    }
-    /// <inheritdoc/>
-    public event EventHandler<AliasEventArgs> AliasRemoved;
-    /// <summary>
-    /// Fires a new <c>AliasRemoved</c> event.
-    /// </summary>
-    /// <param name="alias">The alias that has been deleted.</param>
-    protected virtual void OnAliasRemoved(string alias) {
-      if (AliasRemoved != null)
-        AliasRemoved(this, new AliasEventArgs(alias));
     }
     /// <inheritdoc/>
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Variable.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Variable.cs	(revision 2033)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Variable.cs	(revision 2042)
@@ -102,10 +102,10 @@
     /// <param name="clonedObjects">Dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
     /// <returns>The cloned object as <see cref="Variable"/>.</returns>
-    public override object Clone(IDictionary<long, object> clonedObjects) {
+    public override ICloneable Clone(ICloner cloner) {
       Variable clone = new Variable();
-      clonedObjects.Add(clone.Id, clone);
+      cloner.AddClonedObject(this, clone);
       clone.myName = Name;
       if (Value != null)
-        clone.myValue = (IItem)Auxiliary.Clone(Value, clonedObjects);
+        clone.myValue = (IItem)cloner.Clone(Value);
       return clone;
     }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/VariableInfo.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/VariableInfo.cs	(revision 2033)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/VariableInfo.cs	(revision 2042)
@@ -145,7 +145,7 @@
     /// <param name="clonedObjects">Dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
     /// <returns>The cloned object as <see cref="VariableInfo"/>.</returns>
-    public override object Clone(IDictionary<long, object> clonedObjects) {
+    public override ICloneable Clone(ICloner cloner) {
       VariableInfo clone = new VariableInfo();
-      clonedObjects.Add(clone.Id, clone);
+      cloner.AddClonedObject(this, clone);
       clone.myActualName = ActualName;
       clone.myFormalName = FormalName;
