Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/EngineBase.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/EngineBase.cs	(revision 1994)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/EngineBase.cs	(revision 2027)
@@ -188,5 +188,5 @@
       myExecutionStack.Clear();
       if (OperatorGraph.InitialOperator != null)
-        myExecutionStack.Push(new AtomicOperation(OperatorGraph.InitialOperator, GlobalScope));
+        myExecutionStack.Push(new AtomicOperation(OperatorGraph.InitialOperator, new Environment(), GlobalScope));
       OnInitialized();
     }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/Environment.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/Environment.cs	(revision 1994)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/Environment.cs	(revision 2027)
@@ -27,15 +27,19 @@
 namespace HeuristicLab.Core {
   public class Environment : ItemBase, IEnvironment {
-    private Environment parent;
+    private IEnvironment parent;
+    private Dictionary<string, string> aliases;
 
     /// <summary>
     /// Initializes a new instance of <see cref="Environment"/>.
     /// </summary>
-    public Environment() { }
+    public Environment() {
+      aliases = new Dictionary<string, string>();
+    }
     /// <summary>
     /// Initializes a new instance of <see cref="Environment"/> with the given <paramref name="parent"/>.
     /// </summary>
     /// <param name="parnet">The parent environment.</param>
-    public Environment(Environment parent) {
+    public Environment(IEnvironment parent)
+      : this() {
       this.parent = parent;
     }
@@ -51,6 +55,22 @@
       Environment clone = new Environment();
       clonedObjects.Add(Guid, clone);
-      clone.parent = (Environment)Auxiliary.Clone(parent, clonedObjects);
+      clone.parent = (IEnvironment)Auxiliary.Clone(parent, clonedObjects);
       return clone;
+    }
+
+    public void AddAlias(string oldName, string newName) {
+      aliases.Add(oldName, newName);
+    }
+    public void RemoveAlias(string name) {
+      aliases.Remove(name);
+    }
+
+    public string TranslateName(string name) {
+      string translatedName = name;
+      if (aliases.ContainsKey(translatedName))
+        translatedName = aliases[translatedName];
+      if (parent != null)
+        translatedName = parent.TranslateName(translatedName);
+      return translatedName;
     }
 
@@ -83,5 +103,5 @@
     public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
       base.Populate(node, restoredObjects);
-      parent = (Environment)PersistenceManager.Restore(node.SelectSingleNode("ParentEnvironment"), restoredObjects);
+      parent = (IEnvironment)PersistenceManager.Restore(node.SelectSingleNode("ParentEnvironment"), restoredObjects);
     }
     #endregion
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/HeuristicLab.Core-3.2.csproj
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/HeuristicLab.Core-3.2.csproj	(revision 1994)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/HeuristicLab.Core-3.2.csproj	(revision 2027)
@@ -126,5 +126,31 @@
     </Compile>
     <Compile Include="AliasEventArgs.cs" />
+    <Compile Include="Interfaces\IVariablesContainer.cs" />
+    <Compile Include="VariablesContainerView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="VariablesContainerView.Designer.cs">
+      <DependentUpon>VariablesContainerView.cs</DependentUpon>
+    </Compile>
+    <Compile Include="Parameter.cs" />
+    <Compile Include="OperatorBaseParametersView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="OperatorBaseParametersView.Designer.cs">
+      <DependentUpon>OperatorBaseParametersView.cs</DependentUpon>
+    </Compile>
+    <Compile Include="ParameterView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="ParameterView.Designer.cs">
+      <DependentUpon>ParameterView.cs</DependentUpon>
+    </Compile>
     <Compile Include="Environment.cs" />
+    <Compile Include="OperatorBaseView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="OperatorBaseView.Designer.cs">
+      <DependentUpon>OperatorBaseView.cs</DependentUpon>
+    </Compile>
     <Compile Include="ParameterEventArgs.cs" />
     <Compile Include="ParameterType.cs" />
@@ -143,16 +169,4 @@
     <Compile Include="NameChangingEventArgs.cs" />
     <Compile Include="OperationEventArgs.cs" />
-    <Compile Include="OperatorBaseVariablesView.cs">
-      <SubType>UserControl</SubType>
-    </Compile>
-    <Compile Include="OperatorBaseVariablesView.Designer.cs">
-      <DependentUpon>OperatorBaseVariablesView.cs</DependentUpon>
-    </Compile>
-    <Compile Include="OperatorBaseVariableInfosView.cs">
-      <SubType>UserControl</SubType>
-    </Compile>
-    <Compile Include="OperatorBaseVariableInfosView.Designer.cs">
-      <DependentUpon>OperatorBaseVariableInfosView.cs</DependentUpon>
-    </Compile>
     <Compile Include="ExceptionEventArgs.cs" />
     <Compile Include="Interfaces\IConstrainedItem.cs" />
@@ -200,10 +214,4 @@
     <Compile Include="OperatorIndexEventArgs.cs" />
     <Compile Include="ScopeEventArgs.cs" />
-    <Compile Include="OperatorBaseView.cs">
-      <SubType>UserControl</SubType>
-    </Compile>
-    <Compile Include="OperatorBaseView.Designer.cs">
-      <DependentUpon>OperatorBaseView.cs</DependentUpon>
-    </Compile>
     <Compile Include="OperatorGraphView.cs">
       <SubType>UserControl</SubType>
@@ -295,14 +303,18 @@
       <SubType>Designer</SubType>
     </EmbeddedResource>
+    <EmbeddedResource Include="OperatorBaseParametersView.resx">
+      <DependentUpon>OperatorBaseParametersView.cs</DependentUpon>
+      <SubType>Designer</SubType>
+    </EmbeddedResource>
+    <EmbeddedResource Include="VariablesContainerView.resx">
+      <DependentUpon>VariablesContainerView.cs</DependentUpon>
+      <SubType>Designer</SubType>
+    </EmbeddedResource>
+    <EmbeddedResource Include="ParameterView.resx">
+      <DependentUpon>ParameterView.cs</DependentUpon>
+      <SubType>Designer</SubType>
+    </EmbeddedResource>
     <EmbeddedResource Include="OperatorBaseDescriptionView.resx">
       <DependentUpon>OperatorBaseDescriptionView.cs</DependentUpon>
-      <SubType>Designer</SubType>
-    </EmbeddedResource>
-    <EmbeddedResource Include="OperatorBaseVariablesView.resx">
-      <DependentUpon>OperatorBaseVariablesView.cs</DependentUpon>
-      <SubType>Designer</SubType>
-    </EmbeddedResource>
-    <EmbeddedResource Include="OperatorBaseVariableInfosView.resx">
-      <DependentUpon>OperatorBaseVariableInfosView.cs</DependentUpon>
       <SubType>Designer</SubType>
     </EmbeddedResource>
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/Interfaces/IEnvironment.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/Interfaces/IEnvironment.cs	(revision 1994)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/Interfaces/IEnvironment.cs	(revision 2027)
@@ -27,4 +27,7 @@
   public interface IEnvironment : IItem {
     string TranslateName(string name);
+
+    void AddAlias(string oldName, string newName);
+    void RemoveAlias(string name);
   }
 }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/Interfaces/IOperator.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/Interfaces/IOperator.cs	(revision 1994)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/Interfaces/IOperator.cs	(revision 2027)
@@ -49,7 +49,28 @@
 
     /// <summary>
+    /// Gets a list of all sub operators.
+    /// </summary>
+    IList<IOperator> SubOperators { get; }
+    /// <summary>
     /// Gets a collection of all variable (parameter) infos.
     /// </summary>
     ICollection<IParameter> Parameters { 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);
 
     /// <summary>
@@ -75,5 +96,5 @@
     /// <param name="scope">The scope where to execute the current instance.</param>
     /// <returns>The next operation.</returns>
-    IOperation Execute(IEnvironment environment, IScope scope);
+    IOperation Execute(IEnvironment env, IScope scope);
     /// <summary>
     /// Aborts the current operator.
@@ -88,5 +109,13 @@
     /// Occurs when the breakpoint flag of the current instance was changed.
     /// </summary>
-    event EventHandler BreakpointChanged; 
+    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.
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/Interfaces/IScope.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/Interfaces/IScope.cs	(revision 1994)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/Interfaces/IScope.cs	(revision 2027)
@@ -29,5 +29,5 @@
   /// Interface for a hierarchical container of variables (containing variables and subscopes). 
   /// </summary>
-  public interface IScope : IItem {
+  public interface IScope : IItem, IVariablesContainer {
     /// <summary>
     /// Gets the name of the current instance.
@@ -35,8 +35,4 @@
     string Name { get; }
 
-    /// <summary>
-    /// Gets the varibles of the current scope.
-    /// </summary>
-    ICollection<IVariable> Variables { get; }
     /// <summary>
     /// Gets all subscopes in the current scope.
@@ -50,21 +46,4 @@
     void SetParent(IScope scope);
 
-    /// <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 variable to the curent instance.
-    /// </summary>
-    /// <param name="variable">The variable to add.</param>
-    void AddVariable(IVariable variable);
-    /// <summary>
-    /// Deletes a variable with the specified <paramref name="name"/> from the current instance.
-    /// </summary>
-    /// <param name="name">The name of the variable to delete.</param>
-    void RemoveVariable(string name);
-    
     /// <inheritdoc cref="GetVariableValue(string, bool)"/>
     /// <typeparam name="T">The type of the value that is searched.</typeparam>
@@ -125,12 +104,4 @@
 
     /// <summary>
-    /// Occurs when a variable has been added to the current instance.
-    /// </summary>
-    event EventHandler<VariableEventArgs> VariableAdded;
-    /// <summary>
-    /// Occurs when a variable has been deleted from the current instance.
-    /// </summary>
-    event EventHandler<VariableEventArgs> VariableRemoved;
-    /// <summary>
     /// Occurs when a sub scope has been added to the current instance.
     /// </summary>
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/Interfaces/IVariablesContainer.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/Interfaces/IVariablesContainer.cs	(revision 2027)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/Interfaces/IVariablesContainer.cs	(revision 2027)
@@ -0,0 +1,63 @@
+#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 {
+  /// <summary>
+  /// Interface for a container of variables.
+  /// </summary>
+  public interface IVariablesContainer : IItem {
+    /// <summary>
+    /// Gets the contained varibles.
+    /// </summary>
+    ICollection<IVariable> Variables { get; }
+
+    /// <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 variable to the curent instance.
+    /// </summary>
+    /// <param name="variable">The variable to add.</param>
+    void AddVariable(IVariable variable);
+    /// <summary>
+    /// Deletes a variable with the specified <paramref name="name"/> from the current instance.
+    /// </summary>
+    /// <param name="name">The name of the variable to delete.</param>
+    void RemoveVariable(string name);
+
+    /// <summary>
+    /// Occurs when a variable has been added to the current instance.
+    /// </summary>
+    event EventHandler<VariableEventArgs> VariableAdded;
+    /// <summary>
+    /// Occurs when a variable has been deleted from the current instance.
+    /// </summary>
+    event EventHandler<VariableEventArgs> VariableRemoved;
+  }
+}
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/OperatorBase.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/OperatorBase.cs	(revision 1994)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/OperatorBase.cs	(revision 2027)
@@ -29,5 +29,5 @@
   /// The base class for all operators.
   /// </summary>
-  public abstract class OperatorBase : ConstrainedItemBase, IOperator {
+  public abstract class OperatorBase : ItemBase, IOperator {
     private string myName;
     /// <summary>
@@ -80,13 +80,8 @@
       get { return mySubOperators.AsReadOnly(); }
     }
-    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; }
+    private Dictionary<string, IParameter> myParameters;
+    /// <inheritdoc/>
+    public virtual ICollection<IParameter> Parameters {
+      get { return myParameters.Values; }
     }
 
@@ -100,6 +95,5 @@
       myBreakpoint = false;
       mySubOperators = new List<IOperator>();
-      myVariableInfos = new Dictionary<string, IVariableInfo>();
-      myVariables = new Dictionary<string, IVariable>();
+      myParameters = new Dictionary<string, IParameter>();
     }
 
@@ -116,10 +110,7 @@
       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)Auxiliary.Clone(parameter, clonedObjects));
       return clone;
     }
@@ -142,31 +133,4 @@
       OnSubOperatorAdded(subOperator, mySubOperators.Count - 1);
     }
-    /// <inheritdoc cref="IOperator.TryAddSubOperator(HeuristicLab.Core.IOperator)"/>
-    /// <param name="subOperator">The sub operator to add.</param>
-    /// <remarks>Calls <see cref="OnSubOperatorAdded"/>.</remarks>
-    public virtual bool TryAddSubOperator(IOperator subOperator) {
-      mySubOperators.Add(subOperator);
-      if (IsValid()) {
-        OnSubOperatorAdded(subOperator, mySubOperators.Count - 1);
-        return true;
-      } else {
-        mySubOperators.RemoveAt(mySubOperators.Count - 1);
-        return false;
-      }
-    }
-    /// <inheritdoc cref="HeuristicLab.Core.IOperator.TryAddSubOperator(HeuristicLab.Core.IOperator, 
-    /// out System.Collections.Generic.ICollection&lt;HeuristicLab.Core.IConstraint&gt;)"/>
-    /// <param name="subOperator">The sub operator to add.</param>
-    /// <remarks>Calls <see cref="OnSubOperatorAdded"/>.</remarks>
-    public virtual bool TryAddSubOperator(IOperator subOperator, out ICollection<IConstraint> violatedConstraints) {
-      mySubOperators.Add(subOperator);
-      if (IsValid(out violatedConstraints)) {
-        OnSubOperatorAdded(subOperator, mySubOperators.Count - 1);
-        return true;
-      } else {
-        mySubOperators.RemoveAt(mySubOperators.Count - 1);
-        return false;
-      }
-    }
     /// <inheritdoc cref="HeuristicLab.Core.IOperator.AddSubOperator(HeuristicLab.Core.IOperator, int)"/>
     /// <param name="subOperator">The sub operator to add.</param>
@@ -176,31 +140,4 @@
       OnSubOperatorAdded(subOperator, index);
     }
-    /// <inheritdoc cref="IOperator.TryAddSubOperator(HeuristicLab.Core.IOperator, int)"/>
-    /// <param name="subOperator">The sub operator to add.</param>
-    /// <remarks>Calls <see cref="OnSubOperatorAdded"/>.</remarks>
-    public virtual bool TryAddSubOperator(IOperator subOperator, int index) {
-      mySubOperators.Insert(index, subOperator);
-      if (IsValid()) {
-        OnSubOperatorAdded(subOperator, index);
-        return true;
-      } else {
-        mySubOperators.RemoveAt(index);
-        return false;
-      }
-    }
-    /// <inheritdoc cref="IOperator.TryAddSubOperator(HeuristicLab.Core.IOperator, int, out
-    /// System.Collections.Generic.ICollection&lt;HeuristicLab.Core.IConstraint&gt;)"/>
-    /// <param name="subOperator">The sub operator to add.</param>
-    /// <remarks>Calls <see cref="OnSubOperatorAdded"/>.</remarks>
-    public virtual bool TryAddSubOperator(IOperator subOperator, int index, out ICollection<IConstraint> violatedConstraints) {
-      mySubOperators.Insert(index, subOperator);
-      if (IsValid(out violatedConstraints)) {
-        OnSubOperatorAdded(subOperator, index);
-        return true;
-      } else {
-        mySubOperators.RemoveAt(index);
-        return false;
-      }
-    }
     /// <inheritdoc/>
     /// <remarks>Calls <see cref="OnSubOperatorRemoved"/>.</remarks>
@@ -210,37 +147,11 @@
       OnSubOperatorRemoved(op, index);
     }
-    /// <inheritdoc/>
-    /// <remarks>Calls <see cref="OnSubOperatorRemoved"/>.</remarks>
-    public virtual bool TryRemoveSubOperator(int index) {
-      IOperator op = mySubOperators[index];
-      mySubOperators.RemoveAt(index);
-      if (IsValid()) {
-        OnSubOperatorRemoved(op, index);
-        return true;
-      } else {
-        mySubOperators.Insert(index, op);
-        return false;
-      }
-    }
-    /// <inheritdoc/>
-    /// <remarks>Calls <see cref="OnSubOperatorRemoved"/>.</remarks>
-    public virtual bool TryRemoveSubOperator(int index, out ICollection<IConstraint> violatedConstraints) {
-      IOperator op = mySubOperators[index];
-      mySubOperators.RemoveAt(index);
-      if (IsValid(out violatedConstraints)) {
-        OnSubOperatorRemoved(op, index);
-        return true;
-      } else {
-        mySubOperators.Insert(index, op);
-        return false;
-      }
-    }
     #endregion
 
-    #region VariableInfo Methods
-    /// <inheritdoc/>
-    public virtual IVariableInfo GetVariableInfo(string formalName) {
-      IVariableInfo info;
-      if (myVariableInfos.TryGetValue(formalName, out info))
+    #region Parameter Methods
+    /// <inheritdoc/>
+    public virtual IParameter GetParameter(string name) {
+      IParameter info;
+      if (myParameters.TryGetValue(name, out info))
         return info;
       else
@@ -249,235 +160,24 @@
     /// <inheritdoc/>
     /// <remarks>Calls <see cref="OnVariableInfoAdded"/>.</remarks>
-    public virtual void AddVariableInfo(IVariableInfo variableInfo) {
-      myVariableInfos.Add(variableInfo.FormalName, variableInfo);
-      OnVariableInfoAdded(variableInfo);
-    }
-    /// <inheritdoc/>
-    /// <remarks>Calls <see cref="OnVariableInfoAdded"/>.</remarks>
-    public virtual bool TryAddVariableInfo(IVariableInfo variableInfo) {
-      myVariableInfos.Add(variableInfo.FormalName, variableInfo);
-      if (IsValid()) {
-        OnVariableInfoAdded(variableInfo);
-        return true;
-      } else {
-        myVariableInfos.Remove(variableInfo.FormalName);
-        return false;
-      }
-    }
-    /// <inheritdoc/>
-    /// <remarks>Calls <see cref="OnVariableInfoAdded"/>.</remarks>
-    public virtual bool TryAddVariableInfo(IVariableInfo variableInfo, out ICollection<IConstraint> violatedConstraints) {
-      myVariableInfos.Add(variableInfo.FormalName, variableInfo);
-      if (IsValid(out violatedConstraints)) {
-        OnVariableInfoAdded(variableInfo);
-        return true;
-      } else {
-        myVariableInfos.Remove(variableInfo.FormalName);
-        return false;
-      }
+    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);
-      }
-    }
-    /// <inheritdoc/>
-    /// <remarks>Calls <see cref="OnVariableInfoRemoved"/>.</remarks>
-    public virtual bool TryRemoveVariableInfo(string formalName) {
-      IVariableInfo variableInfo;
-      if (myVariableInfos.TryGetValue(formalName, out variableInfo)) {
-        myVariableInfos.Remove(formalName);
-        if (IsValid()) {
-          OnVariableInfoRemoved(variableInfo);
-          return true;
-        } else {
-          myVariableInfos.Add(formalName, variableInfo);
-          return false;
-        }
-      }
-      return true;
-    }
-    /// <inheritdoc/>
-    /// <remarks>Calls <see cref="OnVariableInfoRemoved"/>.</remarks>
-    public virtual bool TryRemoveVariableInfo(string formalName, out ICollection<IConstraint> violatedConstraints) {
-      IVariableInfo variableInfo;
-      if (myVariableInfos.TryGetValue(formalName, out variableInfo)) {
-        myVariableInfos.Remove(formalName);
-        if (IsValid(out violatedConstraints)) {
-          OnVariableInfoRemoved(variableInfo);
-          return true;
-        } else {
-          myVariableInfos.Add(formalName, variableInfo);
-          return false;
-        }
-      }
-      violatedConstraints = new List<IConstraint>();
-      return true;
+    public virtual void RemoveParameter(string name) {
+      IParameter parameter;
+      if (myParameters.TryGetValue(name, out parameter)) {
+        myParameters.Remove(name);
+        OnParameterRemoved(parameter);
+      }
     }
     #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="OnVariableAdded"/> and adds <c>NameChanging</c> and <c>NameChanged</c>
-    /// event handlers.</remarks>
-    public virtual bool TryAddVariable(IVariable variable) {
-      myVariables.Add(variable.Name, variable);
-      if (IsValid()) {
-        variable.NameChanging += new EventHandler<NameChangingEventArgs>(Variable_NameChanging);
-        variable.NameChanged += new EventHandler(Variable_NameChanged);
-        OnVariableAdded(variable);
-        return true;
-      } else {
-        myVariableInfos.Remove(variable.Name);
-        return false;
-      }
-    }
-    /// <inheritdoc/>
-    /// <remarks>Calls <see cref="OnVariableAdded"/> and adds <c>NameChanging</c> and <c>NameChanged</c>
-    /// event handlers.</remarks>
-    public virtual bool TryAddVariable(IVariable variable, out ICollection<IConstraint> violatedConstraints) {
-      myVariables.Add(variable.Name, variable);
-      if (IsValid(out violatedConstraints)) {
-        variable.NameChanging += new EventHandler<NameChangingEventArgs>(Variable_NameChanging);
-        variable.NameChanged += new EventHandler(Variable_NameChanged);
-        OnVariableAdded(variable);
-        return true;
-      } else {
-        myVariableInfos.Remove(variable.Name);
-        return false;
-      }
-    }
-    /// <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);
-      }
-    }
-    /// <inheritdoc/>
-    /// <remarks>Calls <see cref="OnVariableRemoved"/> and removes <c>NameChanging</c> and <c>NameChanged</c>
-    /// event handlers.</remarks>
-    public virtual bool TryRemoveVariable(string name) {
-      IVariable variable;
-      if (myVariables.TryGetValue(name, out variable)) {
-        myVariables.Remove(name);
-        if (IsValid()) {
-          variable.NameChanging -= new EventHandler<NameChangingEventArgs>(Variable_NameChanging);
-          variable.NameChanged -= new EventHandler(Variable_NameChanged);
-          OnVariableRemoved(variable);
-          return true;
-        } else {
-          myVariables.Add(name, variable);
-          return false;
-        }
-      }
-      return true;
-    }
-    /// <inheritdoc/>
-    /// <remarks>Calls <see cref="OnVariableRemoved"/> and removes <c>NameChanging</c> and <c>NameChanged</c>
-    /// event handlers.</remarks>
-    public virtual bool TryRemoveVariable(string name, out ICollection<IConstraint> violatedConstraints) {
-      IVariable variable;
-      if (myVariables.TryGetValue(name, out variable)) {
-        myVariables.Remove(name);
-        if (IsValid(out violatedConstraints)) {
-          variable.NameChanging -= new EventHandler<NameChangingEventArgs>(Variable_NameChanging);
-          variable.NameChanged -= new EventHandler(Variable_NameChanged);
-          OnVariableRemoved(variable);
-          return true;
-        } else {
-          myVariables.Add(name, variable);
-          return false;
-        }
-      }
-      violatedConstraints = new List<IConstraint>();
-      return true;
-    }
-    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);
-      }
-    }
-    #endregion
-    /// <inheritdoc/>
-    public virtual IOperation Execute(IScope scope) {
+    /// <inheritdoc/>
+    public virtual IOperation Execute(IEnvironment env, 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);
+      IOperation next = Apply(env, scope);
 
       OnExecuted();
@@ -494,5 +194,5 @@
     /// <param name="scope">The scope where to execute the operator</param>
     /// <returns><c>null</c>.</returns>
-    public virtual IOperation Apply(IScope scope) {
+    public virtual IOperation Apply(IEnvironment env, IScope scope) {
       return null;
     }
@@ -540,42 +240,22 @@
     }
     /// <inheritdoc/>
-    public event EventHandler<VariableInfoEventArgs> VariableInfoAdded;
-    /// <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;
-    /// <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));
+    public event EventHandler<ParameterEventArgs> ParameterAdded;
+    /// <summary>
+    /// Fires a new <c>ParameterAdded</c> event.
+    /// </summary>
+    /// <param name="parameter">The parameter that has been added.</param>
+    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>ParameterRemoved</c> event.
+    /// </summary>
+    /// <param name="parameter">The parameter that has been removed.</param>
+    protected virtual void OnParameterRemoved(IParameter parameter) {
+      if (ParameterRemoved != null)
+        ParameterRemoved(this, new ParameterEventArgs(parameter));
     }
     /// <inheritdoc/>
@@ -642,12 +322,8 @@
         subOperatorsNode.AppendChild(PersistenceManager.Persist(SubOperators[i], document, persistedObjects));
       node.AppendChild(subOperatorsNode);
-      XmlNode infosNode = document.CreateNode(XmlNodeType.Element, "VariableInfos", null);
-      foreach (IVariableInfo info in myVariableInfos.Values)
-        infosNode.AppendChild(PersistenceManager.Persist(info, document, persistedObjects));
-      node.AppendChild(infosNode);
-      XmlNode variablesNode = document.CreateNode(XmlNodeType.Element, "Variables", null);
-      foreach (IVariable variable in myVariables.Values)
-        variablesNode.AppendChild(PersistenceManager.Persist(variable, document, persistedObjects));
-      node.AppendChild(variablesNode);
+      XmlNode parametersNode = document.CreateNode(XmlNodeType.Element, "Parameters", null);
+      foreach (IParameter parameter in myParameters.Values)
+        parametersNode.AppendChild(PersistenceManager.Persist(parameter, document, persistedObjects));
+      node.AppendChild(parametersNode);
       return node;
     }
@@ -668,12 +344,8 @@
       for (int i = 0; i < subOperatorsNode.ChildNodes.Count; i++)
         AddSubOperator((IOperator)PersistenceManager.Restore(subOperatorsNode.ChildNodes[i], restoredObjects));
-      XmlNode infosNode = node.SelectSingleNode("VariableInfos");
-      myVariableInfos.Clear();
-      foreach (XmlNode infoNode in infosNode.ChildNodes)
-        AddVariableInfo((IVariableInfo)PersistenceManager.Restore(infoNode, restoredObjects));
-      XmlNode variablesNode = node.SelectSingleNode("Variables");
-      myVariables.Clear();
-      foreach (XmlNode variableNode in variablesNode.ChildNodes)
-        AddVariable((IVariable)PersistenceManager.Restore(variableNode, restoredObjects));
+      XmlNode parametersNode = node.SelectSingleNode("Parameters");
+      myParameters.Clear();
+      foreach (XmlNode parameterNode in parametersNode.ChildNodes)
+        AddParameter((IParameter)PersistenceManager.Restore(parameterNode, restoredObjects));
     }
     #endregion
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/OperatorBaseParametersView.Designer.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/OperatorBaseParametersView.Designer.cs	(revision 2027)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/OperatorBaseParametersView.Designer.cs	(revision 2027)
@@ -0,0 +1,139 @@
+#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.Windows.Forms;
+
+namespace HeuristicLab.Core {
+  partial class OperatorBaseParametersView {
+    /// <summary> 
+    /// Required designer variable.
+    /// </summary>
+    private System.ComponentModel.IContainer components = null;
+
+    /// <summary> 
+    /// Clean up any resources being used.
+    /// </summary>
+    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+    protected override void Dispose(bool disposing) {
+      if (disposing && (components != null)) {
+        components.Dispose();
+      }
+      base.Dispose(disposing);
+    }
+
+    #region Component Designer generated code
+
+    /// <summary> 
+    /// Required method for Designer support - do not modify 
+    /// the contents of this method with the code editor.
+    /// </summary>
+    private void InitializeComponent() {
+      this.splitContainer = new System.Windows.Forms.SplitContainer();
+      this.parametersGroupBox = new System.Windows.Forms.GroupBox();
+      this.parametersListView = new System.Windows.Forms.ListView();
+      this.columnHeader1 = new System.Windows.Forms.ColumnHeader();
+      this.parameterDetailsGroupBox = new System.Windows.Forms.GroupBox();
+      this.splitContainer.Panel1.SuspendLayout();
+      this.splitContainer.Panel2.SuspendLayout();
+      this.splitContainer.SuspendLayout();
+      this.parametersGroupBox.SuspendLayout();
+      this.SuspendLayout();
+      // 
+      // splitContainer
+      // 
+      this.splitContainer.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.splitContainer.Location = new System.Drawing.Point(0, 0);
+      this.splitContainer.Name = "splitContainer";
+      // 
+      // splitContainer.Panel1
+      // 
+      this.splitContainer.Panel1.Controls.Add(this.parametersGroupBox);
+      // 
+      // splitContainer.Panel2
+      // 
+      this.splitContainer.Panel2.Controls.Add(this.parameterDetailsGroupBox);
+      this.splitContainer.Size = new System.Drawing.Size(423, 333);
+      this.splitContainer.SplitterDistance = 203;
+      this.splitContainer.TabIndex = 0;
+      // 
+      // parametersGroupBox
+      // 
+      this.parametersGroupBox.Controls.Add(this.parametersListView);
+      this.parametersGroupBox.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.parametersGroupBox.Location = new System.Drawing.Point(0, 0);
+      this.parametersGroupBox.Name = "parametersGroupBox";
+      this.parametersGroupBox.Size = new System.Drawing.Size(203, 333);
+      this.parametersGroupBox.TabIndex = 0;
+      this.parametersGroupBox.TabStop = false;
+      this.parametersGroupBox.Text = "&Parameters";
+      // 
+      // parametersListView
+      // 
+      this.parametersListView.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] {
+            this.columnHeader1});
+      this.parametersListView.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.parametersListView.HeaderStyle = System.Windows.Forms.ColumnHeaderStyle.None;
+      this.parametersListView.HideSelection = false;
+      this.parametersListView.Location = new System.Drawing.Point(3, 16);
+      this.parametersListView.Name = "parametersListView";
+      this.parametersListView.Size = new System.Drawing.Size(197, 314);
+      this.parametersListView.Sorting = System.Windows.Forms.SortOrder.Ascending;
+      this.parametersListView.TabIndex = 0;
+      this.parametersListView.UseCompatibleStateImageBehavior = false;
+      this.parametersListView.View = System.Windows.Forms.View.Details;
+      this.parametersListView.SelectedIndexChanged += new System.EventHandler(this.parametersListView_SelectedIndexChanged);
+      this.parametersListView.SizeChanged += new System.EventHandler(this.parametersListView_SizeChanged);
+      // 
+      // parameterDetailsGroupBox
+      // 
+      this.parameterDetailsGroupBox.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.parameterDetailsGroupBox.Location = new System.Drawing.Point(0, 0);
+      this.parameterDetailsGroupBox.Name = "parameterDetailsGroupBox";
+      this.parameterDetailsGroupBox.Size = new System.Drawing.Size(216, 333);
+      this.parameterDetailsGroupBox.TabIndex = 0;
+      this.parameterDetailsGroupBox.TabStop = false;
+      this.parameterDetailsGroupBox.Text = "&Details";
+      // 
+      // OperatorBaseParametersView
+      // 
+      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.Controls.Add(this.splitContainer);
+      this.Name = "OperatorBaseParametersView";
+      this.Size = new System.Drawing.Size(423, 333);
+      this.splitContainer.Panel1.ResumeLayout(false);
+      this.splitContainer.Panel2.ResumeLayout(false);
+      this.splitContainer.ResumeLayout(false);
+      this.parametersGroupBox.ResumeLayout(false);
+      this.ResumeLayout(false);
+
+    }
+
+    #endregion
+
+    private System.Windows.Forms.ColumnHeader columnHeader1;
+    protected SplitContainer splitContainer;
+    protected GroupBox parametersGroupBox;
+    protected ListView parametersListView;
+    protected GroupBox parameterDetailsGroupBox;
+  }
+}
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/OperatorBaseParametersView.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/OperatorBaseParametersView.cs	(revision 2027)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/OperatorBaseParametersView.cs	(revision 2027)
@@ -0,0 +1,172 @@
+#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.ComponentModel;
+using System.Drawing;
+using System.Data;
+using System.Text;
+using System.Windows.Forms;
+
+namespace HeuristicLab.Core {
+  /// <summary>
+  /// The visual representation of the information of the variables of an operator.
+  /// </summary>
+  public partial class OperatorBaseParametersView : ViewBase {
+    /// <summary>
+    /// Gets or sets the operator whose variable infos should be represented visually.
+    /// </summary>
+    /// <remarks>Uses property <see cref="ViewBase.Item"/> of base class <see cref="ViewBase"/>.
+    /// No own data storage present.</remarks>
+    public IOperator Operator {
+      get { return (IOperator)Item; }
+      set { base.Item = value; }
+    }
+    /// <summary>
+    /// Gets all selected variable infos.
+    /// <note type="caution"> Variable infos are returned read-only!</note>
+    /// </summary>
+    public ICollection<IParameter> SelectedParameter {
+      get {
+        List<IParameter> selected = new List<IParameter>();
+        foreach (ListViewItem item in parametersListView.SelectedItems)
+          selected.Add((IParameter)item.Tag);
+        return selected.AsReadOnly();
+      }
+    }
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="OperatorBaseVariableInfosView"/> with caption "Operator".
+    /// </summary>
+    public OperatorBaseParametersView() {
+      InitializeComponent();
+      parametersListView.Columns[0].Width = Math.Max(0, parametersListView.Width - 25);
+      Caption = "Operator";
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="OperatorBaseVariableInfosView"/> with the given operator
+    /// <paramref name="op"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="OperatorBaseVariableInfosView()"/>.</remarks>
+    /// <param name="op">The operator whose variable infos should be displayed.</param>
+    public OperatorBaseParametersView(IOperator op)
+      : this() {
+      Operator = op;
+    }
+
+    /// <summary>
+    /// Removes the eventhandlers from the underlying <see cref="IOperator"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.RemoveItemEvents"/> of base class <see cref="ViewBase"/>.</remarks>
+    protected override void RemoveItemEvents() {
+      Operator.ParameterAdded -= new EventHandler<ParameterEventArgs>(OperatorBase_ParameterAdded);
+      Operator.ParameterRemoved -= new EventHandler<ParameterEventArgs>(OperatorBase_ParameterRemoved);
+      base.RemoveItemEvents();
+    }
+    /// <summary>
+    /// Adds eventhandlers to the underlying <see cref="IOperator"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.AddItemEvents"/> of base class <see cref="ViewBase"/>.</remarks>
+    protected override void AddItemEvents() {
+      base.AddItemEvents();
+      Operator.ParameterAdded += new EventHandler<ParameterEventArgs>(OperatorBase_ParameterAdded);
+      Operator.ParameterRemoved += new EventHandler<ParameterEventArgs>(OperatorBase_ParameterRemoved);
+    }
+
+    /// <summary>
+    /// Updates all controls with the latest data of the model.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.UpdateControls"/> of base class <see cref="ViewBase"/>.</remarks>
+    protected override void UpdateControls() {
+      base.UpdateControls();
+      parameterDetailsGroupBox.Controls.Clear();
+      if (Operator == null) {
+        Caption = "Operator";
+        parametersListView.Enabled = false;
+        parameterDetailsGroupBox.Enabled = false;
+      } else {
+        Caption = Operator.Name + " (" + Operator.GetType().Name + ")";
+        parametersListView.Enabled = true;
+        parametersListView.Items.Clear();
+        foreach (IParameter parameter in Operator.Parameters) {
+          ListViewItem item = new ListViewItem();
+          item.Text = parameter.Name;
+          item.Tag = parameter;
+          parametersListView.Items.Add(item);
+        }
+        if (parametersListView.Items.Count > 0)
+          parametersListView.SelectedIndices.Add(0);
+      }
+    }
+
+    private void parametersListView_SelectedIndexChanged(object sender, EventArgs e) {
+      if (parameterDetailsGroupBox.Controls.Count > 0)
+        parameterDetailsGroupBox.Controls[0].Dispose();
+      parameterDetailsGroupBox.Controls.Clear();
+      parameterDetailsGroupBox.Enabled = false;
+      if (parametersListView.SelectedItems.Count == 1) {
+        IParameter parameter = (IParameter)parametersListView.SelectedItems[0].Tag;
+        Control control = (Control)parameter.CreateView();
+        parameterDetailsGroupBox.Controls.Add(control);
+        control.Dock = DockStyle.Fill;
+        parameterDetailsGroupBox.Enabled = true;
+      }
+      OnSelectedParametersChanged();
+    }
+
+    /// <summary>
+    /// Occurs when the variables were changed, whose infos should be displayed.
+    /// </summary>
+    public event EventHandler SelectedParametersChanged;
+    /// <summary>
+    /// Fires a new <c>SelectedVariableInfosChanged</c>.
+    /// </summary>
+    protected virtual void OnSelectedParametersChanged() {
+      if (SelectedParametersChanged != null)
+        SelectedParametersChanged(this, new EventArgs());
+    }
+
+    #region Size Changed Events
+    private void parametersListView_SizeChanged(object sender, EventArgs e) {
+      if (parametersListView.Columns.Count > 0)
+        parametersListView.Columns[0].Width = Math.Max(0, parametersListView.Width - 25);
+    }
+    #endregion
+
+    #region OperatorBase Events
+    private void OperatorBase_ParameterAdded(object sender, ParameterEventArgs e) {
+      ListViewItem item = new ListViewItem();
+      item.Text = e.Parameter.Name;
+      item.Tag = e.Parameter;
+      parametersListView.Items.Add(item);
+    }
+    private void OperatorBase_ParameterRemoved(object sender, ParameterEventArgs e) {
+      ListViewItem itemToDelete = null;
+      foreach (ListViewItem item in parametersListView.Items) {
+        if (item.Tag == e.Parameter)
+          itemToDelete = item;
+      }
+      parametersListView.Items.Remove(itemToDelete);
+    }
+    #endregion
+  }
+}
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/OperatorBaseParametersView.resx
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/OperatorBaseParametersView.resx	(revision 2027)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/OperatorBaseParametersView.resx	(revision 2027)
@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/OperatorBaseVariablesView.Designer.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/OperatorBaseVariablesView.Designer.cs	(revision 1994)
+++ 	(revision )
@@ -1,177 +1,0 @@
-#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.Windows.Forms;
-
-namespace HeuristicLab.Core {
-  partial class OperatorBaseVariablesView {
-    /// <summary> 
-    /// Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary> 
-    /// Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing) {
-      if (chooseItemDialog != null) chooseItemDialog.Dispose();
-      foreach (ListViewItem item in variablesListView.Items) {
-        ((IVariable)item.Tag).NameChanged -= new EventHandler(Variable_NameChanged);
-      }
-      if (disposing && (components != null)) {
-        components.Dispose();
-      }
-      base.Dispose(disposing);
-    }
-
-    #region Component Designer generated code
-
-    /// <summary> 
-    /// Required method for Designer support - do not modify 
-    /// the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent() {
-      this.removeVariableButton = new System.Windows.Forms.Button();
-      this.addVariableButton = new System.Windows.Forms.Button();
-      this.splitContainer = new System.Windows.Forms.SplitContainer();
-      this.variablesGroupBox = new System.Windows.Forms.GroupBox();
-      this.variablesListView = new System.Windows.Forms.ListView();
-      this.columnHeader2 = new System.Windows.Forms.ColumnHeader();
-      this.variableDetailsGroupBox = new System.Windows.Forms.GroupBox();
-      this.splitContainer.Panel1.SuspendLayout();
-      this.splitContainer.Panel2.SuspendLayout();
-      this.splitContainer.SuspendLayout();
-      this.variablesGroupBox.SuspendLayout();
-      this.SuspendLayout();
-      // 
-      // removeVariableButton
-      // 
-      this.removeVariableButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
-      this.removeVariableButton.Enabled = false;
-      this.removeVariableButton.Location = new System.Drawing.Point(81, 310);
-      this.removeVariableButton.Name = "removeVariableButton";
-      this.removeVariableButton.Size = new System.Drawing.Size(75, 23);
-      this.removeVariableButton.TabIndex = 2;
-      this.removeVariableButton.Text = "&Remove";
-      this.removeVariableButton.UseVisualStyleBackColor = true;
-      this.removeVariableButton.Click += new System.EventHandler(this.removeVariableButton_Click);
-      // 
-      // addVariableButton
-      // 
-      this.addVariableButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
-      this.addVariableButton.Location = new System.Drawing.Point(0, 310);
-      this.addVariableButton.Name = "addVariableButton";
-      this.addVariableButton.Size = new System.Drawing.Size(75, 23);
-      this.addVariableButton.TabIndex = 1;
-      this.addVariableButton.Text = "&Add...";
-      this.addVariableButton.UseVisualStyleBackColor = true;
-      this.addVariableButton.Click += new System.EventHandler(this.addVariableButton_Click);
-      // 
-      // splitContainer
-      // 
-      this.splitContainer.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
-                  | System.Windows.Forms.AnchorStyles.Left)
-                  | System.Windows.Forms.AnchorStyles.Right)));
-      this.splitContainer.Location = new System.Drawing.Point(0, 0);
-      this.splitContainer.Name = "splitContainer";
-      // 
-      // splitContainer.Panel1
-      // 
-      this.splitContainer.Panel1.Controls.Add(this.variablesGroupBox);
-      // 
-      // splitContainer.Panel2
-      // 
-      this.splitContainer.Panel2.Controls.Add(this.variableDetailsGroupBox);
-      this.splitContainer.Size = new System.Drawing.Size(423, 304);
-      this.splitContainer.SplitterDistance = 212;
-      this.splitContainer.TabIndex = 0;
-      // 
-      // variablesGroupBox
-      // 
-      this.variablesGroupBox.Controls.Add(this.variablesListView);
-      this.variablesGroupBox.Dock = System.Windows.Forms.DockStyle.Fill;
-      this.variablesGroupBox.Location = new System.Drawing.Point(0, 0);
-      this.variablesGroupBox.Name = "variablesGroupBox";
-      this.variablesGroupBox.Size = new System.Drawing.Size(212, 304);
-      this.variablesGroupBox.TabIndex = 0;
-      this.variablesGroupBox.TabStop = false;
-      this.variablesGroupBox.Text = "&Variables";
-      // 
-      // variablesListView
-      // 
-      this.variablesListView.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] {
-            this.columnHeader2});
-      this.variablesListView.Dock = System.Windows.Forms.DockStyle.Fill;
-      this.variablesListView.HeaderStyle = System.Windows.Forms.ColumnHeaderStyle.None;
-      this.variablesListView.HideSelection = false;
-      this.variablesListView.Location = new System.Drawing.Point(3, 16);
-      this.variablesListView.Name = "variablesListView";
-      this.variablesListView.Size = new System.Drawing.Size(206, 285);
-      this.variablesListView.Sorting = System.Windows.Forms.SortOrder.Ascending;
-      this.variablesListView.TabIndex = 0;
-      this.variablesListView.UseCompatibleStateImageBehavior = false;
-      this.variablesListView.View = System.Windows.Forms.View.Details;
-      this.variablesListView.SelectedIndexChanged += new System.EventHandler(this.variablesListView_SelectedIndexChanged);
-      this.variablesListView.SizeChanged += new System.EventHandler(this.variablesListView_SizeChanged);
-      this.variablesListView.KeyDown += new System.Windows.Forms.KeyEventHandler(this.variablesListView_KeyDown);
-      // 
-      // variableDetailsGroupBox
-      // 
-      this.variableDetailsGroupBox.Dock = System.Windows.Forms.DockStyle.Fill;
-      this.variableDetailsGroupBox.Location = new System.Drawing.Point(0, 0);
-      this.variableDetailsGroupBox.Name = "variableDetailsGroupBox";
-      this.variableDetailsGroupBox.Size = new System.Drawing.Size(207, 304);
-      this.variableDetailsGroupBox.TabIndex = 0;
-      this.variableDetailsGroupBox.TabStop = false;
-      this.variableDetailsGroupBox.Text = "&Details";
-      // 
-      // OperatorBaseVariablesView
-      // 
-      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-      this.Controls.Add(this.splitContainer);
-      this.Controls.Add(this.removeVariableButton);
-      this.Controls.Add(this.addVariableButton);
-      this.Name = "OperatorBaseVariablesView";
-      this.Size = new System.Drawing.Size(423, 333);
-      this.splitContainer.Panel1.ResumeLayout(false);
-      this.splitContainer.Panel2.ResumeLayout(false);
-      this.splitContainer.ResumeLayout(false);
-      this.variablesGroupBox.ResumeLayout(false);
-      this.ResumeLayout(false);
-
-    }
-
-    #endregion
-
-    private ColumnHeader columnHeader2;
-    protected SplitContainer splitContainer;
-    protected GroupBox variablesGroupBox;
-    protected ListView variablesListView;
-    protected GroupBox variableDetailsGroupBox;
-    protected Button removeVariableButton;
-    protected Button addVariableButton;
-
-
-  }
-}
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/OperatorBaseVariablesView.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/OperatorBaseVariablesView.cs	(revision 1994)
+++ 	(revision )
@@ -1,219 +1,0 @@
-#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.ComponentModel;
-using System.Drawing;
-using System.Data;
-using System.Text;
-using System.Windows.Forms;
-
-namespace HeuristicLab.Core {
-  /// <summary>
-  /// The visual representation of the variables of an operator.
-  /// </summary>
-  public partial class OperatorBaseVariablesView : ViewBase {
-    private ChooseItemDialog chooseItemDialog;
-
-    /// <summary>
-    /// Gets or sets the operator whose variables to represent.
-    /// </summary>
-    /// <remarks>Uses property <see cref="ViewBase.Item"/> of base class <see cref="ViewBase"/>.
-    /// No own data storage present.</remarks>
-    public IOperator Operator {
-      get { return (IOperator)Item; }
-      set { base.Item = value; }
-    }
-
-    /// <summary>
-    /// Initializes a new instance of <see cref="OperatorBaseVariablesView"/> with caption "Operator".
-    /// </summary>
-    public OperatorBaseVariablesView() {
-      InitializeComponent();
-      variablesListView.Columns[0].Width = Math.Max(0, variablesListView.Width - 25);
-      Caption = "Operator";
-    }
-    /// <summary>
-    /// Initializes a new instance of <see cref="OperatorBaseVariablesView"/> with the given 
-    /// operator <paramref name="op"/>.
-    /// </summary>
-    /// <remarks>Calls <see cref="OperatorBaseVariablesView"/>.</remarks>
-    /// <param name="op">The operator whose variables should be represented visually.</param>
-    public OperatorBaseVariablesView(IOperator op)
-      : this() {
-      Operator = op;
-    }
-
-    /// <summary>
-    /// Removes the eventhandlers from the unterlying <see cref="IOperator"/>.
-    /// </summary>
-    /// <remarks>Calls <see cref="ViewBase.RemoveItemEvents"/> of base class <see cref="ViewBase"/>.</remarks>
-    protected override void RemoveItemEvents() {
-      Operator.VariableAdded -= new EventHandler<VariableEventArgs>(OperatorBase_VariableAdded);
-      Operator.VariableRemoved -= new EventHandler<VariableEventArgs>(OperatorBase_VariableRemoved);
-      base.RemoveItemEvents();
-    }
-    /// <summary>
-    /// Adds eventhandlers to the underlying <see cref="IOperator"/>.
-    /// </summary>
-    /// <remarks>Calls <see cref="ViewBase.AddItemEvents"/> of base class <see cref="ViewBase"/>.</remarks>
-    protected override void AddItemEvents() {
-      base.AddItemEvents();
-      Operator.VariableAdded += new EventHandler<VariableEventArgs>(OperatorBase_VariableAdded);
-      Operator.VariableRemoved += new EventHandler<VariableEventArgs>(OperatorBase_VariableRemoved);
-    }
-
-    /// <summary>
-    /// Updates all controls with the latest data of the model.
-    /// </summary>
-    /// <remarks>Calls <see cref="ViewBase.UpdateControls"/> of base class <see cref="ViewBase"/>.</remarks>
-    protected override void UpdateControls() {
-      base.UpdateControls();
-      variableDetailsGroupBox.Controls.Clear();
-      if (Operator == null) {
-        Caption = "Operator";
-        variablesListView.Enabled = false;
-        variableDetailsGroupBox.Enabled = false;
-        removeVariableButton.Enabled = false;
-      } else {
-        Caption = Operator.Name + " (" + Operator.GetType().Name + ")";
-        variablesListView.Enabled = true;
-        foreach (ListViewItem item in variablesListView.Items) {
-          ((IVariable)item.Tag).NameChanged -= new EventHandler(Variable_NameChanged);
-        }
-        variablesListView.Items.Clear();
-        foreach (IVariable variable in Operator.Variables) {
-          ListViewItem item = new ListViewItem();
-          item.Text = variable.Name;
-          item.Tag = variable;
-          variablesListView.Items.Add(item);
-          variable.NameChanged += new EventHandler(Variable_NameChanged);
-        }
-        if (variablesListView.Items.Count > 0)
-          variablesListView.SelectedIndices.Add(0);
-      }
-    }
-
-    private void variablesListView_SelectedIndexChanged(object sender, EventArgs e) {
-      if (variableDetailsGroupBox.Controls.Count > 0)
-        variableDetailsGroupBox.Controls[0].Dispose();
-      variableDetailsGroupBox.Controls.Clear();
-      variableDetailsGroupBox.Enabled = false;
-      removeVariableButton.Enabled = false;
-      if (variablesListView.SelectedItems.Count > 0) {
-        removeVariableButton.Enabled = true;
-      }
-      if (variablesListView.SelectedItems.Count == 1) {
-        IVariable variable = (IVariable)variablesListView.SelectedItems[0].Tag;
-        Control editor = (Control)variable.CreateView();
-        variableDetailsGroupBox.Controls.Add(editor);
-        editor.Dock = DockStyle.Fill;
-        variableDetailsGroupBox.Enabled = true;
-      }
-    }
-
-    #region Size Changed Events
-    private void variablesListView_SizeChanged(object sender, EventArgs e) {
-      if (variablesListView.Columns.Count > 0)
-        variablesListView.Columns[0].Width = Math.Max(0, variablesListView.Width - 25);
-    }
-    #endregion
-
-    #region Key Events
-    private void variablesListView_KeyDown(object sender, KeyEventArgs e) {
-      if (e.KeyCode == Keys.Delete) {
-        if (variablesListView.SelectedItems.Count > 0) {
-          foreach (ListViewItem item in variablesListView.SelectedItems)
-            Operator.RemoveVariable(((IVariable)item.Tag).Name);
-        }
-      }
-    }
-    #endregion
-
-    #region Button Events
-    private void addVariableButton_Click(object sender, EventArgs e) {
-      if (chooseItemDialog == null) {
-        chooseItemDialog = new ChooseItemDialog();
-        chooseItemDialog.Caption = "Add Variable";
-      }
-      if (chooseItemDialog.ShowDialog(this) == DialogResult.OK) {
-        IVariable newVariable = new Variable(chooseItemDialog.Item.GetType().Name, chooseItemDialog.Item);
-        int index = 1;
-        bool valid = true;
-        string name = null;
-        do {
-          valid = true;
-          name = newVariable.Name + " (" + index.ToString() + ")";
-          foreach (IVariable existingVariable in Operator.Variables) {
-            if (existingVariable.Name == name) {
-              valid = false;
-              index++;
-            }
-          }
-        } while (!valid);
-        newVariable.Name = name;
-        Operator.AddVariable(newVariable);
-      }
-    }
-    private void removeVariableButton_Click(object sender, EventArgs e) {
-      if (variablesListView.SelectedItems.Count > 0) {
-        foreach (ListViewItem item in variablesListView.SelectedItems)
-          Operator.RemoveVariable(((IVariable)item.Tag).Name);
-      }
-    }
-    #endregion
-
-    #region Variable Events
-    private void Variable_NameChanged(object sender, EventArgs e) {
-      IVariable variable = (IVariable)sender;
-      foreach (ListViewItem item in variablesListView.Items) {
-        if (item.Tag == variable)
-          item.Text = variable.Name;
-      }
-    }
-    #endregion
-
-    #region OperatorBase Events
-    private void OperatorBase_VariableAdded(object sender, VariableEventArgs e) {
-      ListViewItem item = new ListViewItem();
-      item.Text = e.Variable.Name;
-      item.Tag = e.Variable;
-      variablesListView.Items.Add(item);
-      // select the new item
-      foreach(ListViewItem oldSelected in variablesListView.SelectedItems) {
-        oldSelected.Selected = false;
-      }
-      item.Selected = true;
-      e.Variable.NameChanged += new EventHandler(Variable_NameChanged);
-    }
-    private void OperatorBase_VariableRemoved(object sender, VariableEventArgs e) {
-      ListViewItem itemToDelete = null;
-      foreach (ListViewItem item in variablesListView.Items) {
-        if (item.Tag == e.Variable)
-          itemToDelete = item;
-      }
-      e.Variable.NameChanged -= new EventHandler(Variable_NameChanged);
-      variablesListView.Items.Remove(itemToDelete);
-    }
-    #endregion
-  }
-}
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/OperatorBaseVariablesView.resx
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/OperatorBaseVariablesView.resx	(revision 1994)
+++ 	(revision )
@@ -1,120 +1,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/OperatorBaseView.Designer.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/OperatorBaseView.Designer.cs	(revision 1994)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/OperatorBaseView.Designer.cs	(revision 2027)
@@ -49,16 +49,10 @@
     private void InitializeComponent() {
       this.tabControl = new System.Windows.Forms.TabControl();
-      this.variableInfosTabPage = new System.Windows.Forms.TabPage();
-      this.operatorBaseVariableInfosView = new HeuristicLab.Core.OperatorBaseVariableInfosView();
-      this.variablesTabPage = new System.Windows.Forms.TabPage();
-      this.operatorBaseVariablesView = new HeuristicLab.Core.OperatorBaseVariablesView();
-      this.constraintsTabPage = new System.Windows.Forms.TabPage();
-      this.constrainedItemBaseView = new HeuristicLab.Core.ConstrainedItemBaseView();
+      this.parametersTabPage = new System.Windows.Forms.TabPage();
+      this.operatorBaseParametersView = new HeuristicLab.Core.OperatorBaseParametersView();
       this.descriptionTabPage = new System.Windows.Forms.TabPage();
       this.operatorBaseDescriptionView = new HeuristicLab.Core.OperatorBaseDescriptionView();
       this.tabControl.SuspendLayout();
-      this.variableInfosTabPage.SuspendLayout();
-      this.variablesTabPage.SuspendLayout();
-      this.constraintsTabPage.SuspendLayout();
+      this.parametersTabPage.SuspendLayout();
       this.descriptionTabPage.SuspendLayout();
       this.SuspendLayout();
@@ -66,7 +60,5 @@
       // tabControl
       // 
-      this.tabControl.Controls.Add(this.variableInfosTabPage);
-      this.tabControl.Controls.Add(this.variablesTabPage);
-      this.tabControl.Controls.Add(this.constraintsTabPage);
+      this.tabControl.Controls.Add(this.parametersTabPage);
       this.tabControl.Controls.Add(this.descriptionTabPage);
       this.tabControl.Dock = System.Windows.Forms.DockStyle.Fill;
@@ -77,66 +69,24 @@
       this.tabControl.TabIndex = 0;
       // 
-      // variableInfosTabPage
+      // parametersTabPage
       // 
-      this.variableInfosTabPage.Controls.Add(this.operatorBaseVariableInfosView);
-      this.variableInfosTabPage.Location = new System.Drawing.Point(4, 22);
-      this.variableInfosTabPage.Name = "variableInfosTabPage";
-      this.variableInfosTabPage.Padding = new System.Windows.Forms.Padding(3);
-      this.variableInfosTabPage.Size = new System.Drawing.Size(415, 307);
-      this.variableInfosTabPage.TabIndex = 0;
-      this.variableInfosTabPage.Text = "Variable Infos";
-      this.variableInfosTabPage.UseVisualStyleBackColor = true;
+      this.parametersTabPage.Controls.Add(this.operatorBaseParametersView);
+      this.parametersTabPage.Location = new System.Drawing.Point(4, 22);
+      this.parametersTabPage.Name = "parametersTabPage";
+      this.parametersTabPage.Padding = new System.Windows.Forms.Padding(3);
+      this.parametersTabPage.Size = new System.Drawing.Size(415, 307);
+      this.parametersTabPage.TabIndex = 0;
+      this.parametersTabPage.Text = "Parameters";
+      this.parametersTabPage.UseVisualStyleBackColor = true;
       // 
       // operatorBaseVariableInfosView
       // 
-      this.operatorBaseVariableInfosView.Caption = "Operator";
-      this.operatorBaseVariableInfosView.Dock = System.Windows.Forms.DockStyle.Fill;
-      this.operatorBaseVariableInfosView.Location = new System.Drawing.Point(3, 3);
-      this.operatorBaseVariableInfosView.Name = "operatorBaseVariableInfosView";
-      this.operatorBaseVariableInfosView.Operator = null;
-      this.operatorBaseVariableInfosView.Size = new System.Drawing.Size(409, 301);
-      this.operatorBaseVariableInfosView.TabIndex = 0;
-      // 
-      // variablesTabPage
-      // 
-      this.variablesTabPage.Controls.Add(this.operatorBaseVariablesView);
-      this.variablesTabPage.Location = new System.Drawing.Point(4, 22);
-      this.variablesTabPage.Name = "variablesTabPage";
-      this.variablesTabPage.Padding = new System.Windows.Forms.Padding(3);
-      this.variablesTabPage.Size = new System.Drawing.Size(415, 307);
-      this.variablesTabPage.TabIndex = 1;
-      this.variablesTabPage.Text = "Local Variables";
-      this.variablesTabPage.UseVisualStyleBackColor = true;
-      // 
-      // operatorBaseVariablesView
-      // 
-      this.operatorBaseVariablesView.Caption = "Operator";
-      this.operatorBaseVariablesView.Dock = System.Windows.Forms.DockStyle.Fill;
-      this.operatorBaseVariablesView.Location = new System.Drawing.Point(3, 3);
-      this.operatorBaseVariablesView.Name = "operatorBaseVariablesView";
-      this.operatorBaseVariablesView.Operator = null;
-      this.operatorBaseVariablesView.Size = new System.Drawing.Size(409, 301);
-      this.operatorBaseVariablesView.TabIndex = 0;
-      // 
-      // constraintsTabPage
-      // 
-      this.constraintsTabPage.Controls.Add(this.constrainedItemBaseView);
-      this.constraintsTabPage.Location = new System.Drawing.Point(4, 22);
-      this.constraintsTabPage.Name = "constraintsTabPage";
-      this.constraintsTabPage.Padding = new System.Windows.Forms.Padding(3);
-      this.constraintsTabPage.Size = new System.Drawing.Size(415, 307);
-      this.constraintsTabPage.TabIndex = 2;
-      this.constraintsTabPage.Text = "Constraints";
-      this.constraintsTabPage.UseVisualStyleBackColor = true;
-      // 
-      // constrainedItemBaseView
-      // 
-      this.constrainedItemBaseView.Caption = "Constrained Data";
-      this.constrainedItemBaseView.ConstrainedItem = null;
-      this.constrainedItemBaseView.Dock = System.Windows.Forms.DockStyle.Fill;
-      this.constrainedItemBaseView.Location = new System.Drawing.Point(3, 3);
-      this.constrainedItemBaseView.Name = "constrainedItemBaseView";
-      this.constrainedItemBaseView.Size = new System.Drawing.Size(409, 301);
-      this.constrainedItemBaseView.TabIndex = 0;
+      this.operatorBaseParametersView.Caption = "Operator";
+      this.operatorBaseParametersView.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.operatorBaseParametersView.Location = new System.Drawing.Point(3, 3);
+      this.operatorBaseParametersView.Name = "operatorBaseVariableInfosView";
+      this.operatorBaseParametersView.Operator = null;
+      this.operatorBaseParametersView.Size = new System.Drawing.Size(409, 301);
+      this.operatorBaseParametersView.TabIndex = 0;
       // 
       // descriptionTabPage
@@ -170,7 +120,5 @@
       this.Size = new System.Drawing.Size(423, 333);
       this.tabControl.ResumeLayout(false);
-      this.variableInfosTabPage.ResumeLayout(false);
-      this.variablesTabPage.ResumeLayout(false);
-      this.constraintsTabPage.ResumeLayout(false);
+      this.parametersTabPage.ResumeLayout(false);
       this.descriptionTabPage.ResumeLayout(false);
       this.ResumeLayout(false);
@@ -181,10 +129,6 @@
 
     protected TabControl tabControl;
-    protected TabPage variableInfosTabPage;
-    protected TabPage variablesTabPage;
-    private TabPage constraintsTabPage;
-    protected ConstrainedItemBaseView constrainedItemBaseView;
-    protected OperatorBaseVariableInfosView operatorBaseVariableInfosView;
-    protected OperatorBaseVariablesView operatorBaseVariablesView;
+    protected TabPage parametersTabPage;
+    protected OperatorBaseParametersView operatorBaseParametersView;
     private TabPage descriptionTabPage;
     private OperatorBaseDescriptionView operatorBaseDescriptionView;
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/OperatorBaseView.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/OperatorBaseView.cs	(revision 1994)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/OperatorBaseView.cs	(revision 2027)
@@ -66,7 +66,5 @@
     /// </summary>
     protected override void RemoveItemEvents() {
-      operatorBaseVariableInfosView.Operator = null;
-      operatorBaseVariablesView.Operator = null;
-      constrainedItemBaseView.ConstrainedItem = null;
+      operatorBaseParametersView.Operator = null;
       operatorBaseDescriptionView.Operator = null;
       base.RemoveItemEvents();
@@ -77,7 +75,5 @@
     protected override void AddItemEvents() {
       base.AddItemEvents();
-      operatorBaseVariableInfosView.Operator = Operator;
-      operatorBaseVariablesView.Operator = Operator;
-      constrainedItemBaseView.ConstrainedItem = Operator;
+      operatorBaseParametersView.Operator = Operator;
       operatorBaseDescriptionView.Operator = Operator;
     }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/OperatorGraphView.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/OperatorGraphView.cs	(revision 1994)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/OperatorGraphView.cs	(revision 2027)
@@ -350,37 +350,13 @@
               IOperator newParent = (IOperator)node.Parent.Tag;
               int newIndex = node.Index;
-              ICollection<IConstraint> violatedConstraints;
-              ICollection<IConstraint> violatedConstraints2;
-              oldParent.TryRemoveSubOperator(oldIndex, out violatedConstraints);
-              newParent.TryAddSubOperator(op, newIndex, out violatedConstraints2);
-              if ((violatedConstraints.Count == 0) && (violatedConstraints2.Count == 0)) {
-                graphTreeView.SelectedNode = parentNode.Nodes[newIndex];
-              } else {
-                List<IConstraint> allViolatedConstraints = new List<IConstraint>(violatedConstraints);
-                allViolatedConstraints.AddRange(violatedConstraints2);
-                if (Auxiliary.ShowIgnoreConstraintViolationMessageBox(allViolatedConstraints) == DialogResult.Yes) {
-                  if (violatedConstraints.Count > 0)
-                    oldParent.RemoveSubOperator(oldIndex);
-                  if (violatedConstraints2.Count > 0)
-                    newParent.AddSubOperator(op, newIndex);
-                  graphTreeView.SelectedNode = parentNode.Nodes[newIndex];
-                } else {
-                  if (violatedConstraints.Count == 0)
-                    oldParent.AddSubOperator(op, oldIndex);
-                  if (violatedConstraints2.Count == 0)
-                    newParent.RemoveSubOperator(newIndex);
-                }
-              }
+              oldParent.RemoveSubOperator(oldIndex);
+              newParent.AddSubOperator(op, newIndex);
+              graphTreeView.SelectedNode = parentNode.Nodes[newIndex];
             }
           } else {
             if (node != null) {
               IOperator parent = (IOperator)node.Tag;
-              ICollection<IConstraint> violatedConstraints;
-              if (parent.TryAddSubOperator(op, out violatedConstraints)) {
-                graphTreeView.SelectedNode = node.Nodes[node.Nodes.Count - 1];
-              } else if (Auxiliary.ShowIgnoreConstraintViolationMessageBox(violatedConstraints) == DialogResult.Yes) {
-                parent.AddSubOperator(op);
-                graphTreeView.SelectedNode = node.Nodes[node.Nodes.Count - 1];
-              }
+              parent.AddSubOperator(op);
+              graphTreeView.SelectedNode = node.Nodes[node.Nodes.Count - 1];
             }
           }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/Parameter.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/Parameter.cs	(revision 2027)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/Parameter.cs	(revision 2027)
@@ -0,0 +1,178 @@
+#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 {
+  /// <summary>
+  /// Class for storing meta-information about parameters of an operator.
+  /// </summary>
+  public class Parameter : ItemBase, IParameter {
+    private string myName;
+    /// <summary>
+    /// Gets or sets the name of the current instance.
+    /// </summary>
+    /// <remarks>Calls <see cref="OnActualNameChanged"/> in the setter.</remarks>
+    public string Name {
+      get { return myName; }
+    }
+    private string myDescription;
+    /// <summary>
+    /// Gets the description of the current instance.
+    /// </summary>
+    public string Description {
+      get { return myDescription; }
+    }
+    private Type myDataType;
+    /// <summary>
+    /// Gets the data type of the parameter.
+    /// </summary>
+    public Type DataType {
+      get { return myDataType; }
+    }
+    private ParameterType myType;
+    /// <summary>
+    /// Gets the type of the parameter (input, output, both).
+    /// </summary>
+    public ParameterType Type {
+      get { return myType; }
+    }
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="Parameter"/> with name "Anonymous",
+    /// no description, and a <c>null</c> data type. The type of 
+    /// the parameter is input.
+    /// </summary>
+    public Parameter() {
+      myName = "Anonymous";
+      myDescription = "";
+      myDataType = null;
+      myType = ParameterType.In;
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="Parameter"/> with the given parameters.
+    /// </summary>
+    /// <remarks>Calls <see cref="Parameter()"/>.</remarks>
+    /// <param name="name">The name of the current instance.</param>
+    /// <param name="description">The description of the current instance.</param>
+    /// <param name="dataType">The data type of the parameter.</param>
+    /// <param name="type">The type of the parameter.</param>
+    public Parameter(string name, string description, Type dataType, ParameterType type)
+      : this() {
+      myName = name;
+      myDescription = description;
+      myDataType = dataType;
+      myType = type;
+    }
+
+    /// <summary>
+    /// Creates a new instance of <see cref="ParameterView"/> to represent the current instance
+    /// visually.
+    /// </summary>
+    /// <returns>The created view as <see cref="ParameterView"/>.</returns>
+    public override IView CreateView() {
+      return new ParameterView(this);
+    }
+
+    /// <summary>
+    /// Clones the current instance (deep clone).
+    /// </summary>
+    /// <param name="clonedObjects">Dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
+    /// <returns>The cloned object as <see cref="Parameter"/>.</returns>
+    public override object Clone(IDictionary<Guid, object> clonedObjects) {
+      Parameter clone = new Parameter();
+      clonedObjects.Add(Guid, clone);
+      clone.myName = Name;
+      clone.myDescription = Description;
+      clone.myDataType = DataType;
+      clone.myType = Type;
+      return clone;
+    }
+
+    #region Persistence Methods
+    /// <summary>
+    /// Saves the current instance as <see cref="XmlNode"/> in the specified <paramref name="document"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="StorableBase.GetXmlNode"/> of base class <see cref="ItemBase"/>. <br/>
+    /// A quick overview how the single elements of the current instance are saved:
+    /// <list type="bullet">
+    /// <item>
+    /// <term>Name: </term>
+    /// <description>Saved as <see cref="XmlAttribute"/> with tag name <c>Name</c>.</description>
+    /// </item>
+    /// <item>
+    /// <term>Description: </term>
+    /// <description>Saved as <see cref="XmlAttribute"/> with tag name <c>Description</c>.</description>
+    /// </item>
+    /// <item><term>Data type: </term>
+    /// <description>Saved as <see cref="XmlAttribute"/> with tag name <c>DataType</c>.</description>
+    /// </item>
+    /// <item>
+    /// <term>Type: </term>
+    /// <description>Saved as <see cref="XmlAttribute"/> with tag name <c>ParameterType</c>.</description>
+    /// </item>
+    /// </list></remarks>
+    /// <param name="name">The (tag)name of the <see cref="XmlNode"/>.</param>
+    /// <param name="document">The <see cref="XmlDocument"/> where to save the data.</param>
+    /// <param name="persistedObjects">The dictionary of all already persisted objects. (Needed to avoid cycles.)</param>
+    /// <returns>The saved <see cref="XmlNode"/>.</returns>
+    public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid,IStorable> persistedObjects) {
+      XmlNode node = base.GetXmlNode(name, document, persistedObjects);
+      XmlAttribute nameAttribute = document.CreateAttribute("Name");
+      nameAttribute.Value = Name;
+      node.Attributes.Append(nameAttribute);
+
+      XmlAttribute descriptionAttribute = document.CreateAttribute("Description");
+      descriptionAttribute.Value = Description;
+      node.Attributes.Append(descriptionAttribute);
+
+      XmlAttribute dataTypeAttribute = document.CreateAttribute("DataType");
+      dataTypeAttribute.Value = PersistenceManager.BuildTypeString(DataType);
+      node.Attributes.Append(dataTypeAttribute);
+
+      XmlAttribute typeAttribute = document.CreateAttribute("ParameterType");
+      typeAttribute.Value = Type.ToString();
+      node.Attributes.Append(typeAttribute);
+
+      return node;
+    }
+    /// <summary>
+    /// Loads the persisted parameter from the specified <paramref name="node"/>.
+    /// </summary>
+    /// <remarks>See <see cref="GetXmlNode"/> for further information on how the parameter must be 
+    /// saved. <br/>
+    /// Calls <see cref="StorableBase.Populate"/> of base class <see cref="ItemBase"/>.</remarks>
+    /// <param name="node">The <see cref="XmlNode"/> where the parameter is saved.</param>
+    /// <param name="restoredObjects">The dictionary of all already restored objects. 
+    /// (Needed to avoid cycles.)</param>
+    public override void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
+      base.Populate(node, restoredObjects);
+      myName = node.Attributes["ActualName"].Value;
+      myDescription = node.Attributes["Description"].Value;
+      myDataType = System.Type.GetType(node.Attributes["DataType"].Value, true);
+      myType = (ParameterType)Enum.Parse(typeof(ParameterType), node.Attributes["ParameterType"].Value);
+    }
+    #endregion
+  }
+}
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/ParameterView.Designer.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/ParameterView.Designer.cs	(revision 2027)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/ParameterView.Designer.cs	(revision 2027)
@@ -0,0 +1,165 @@
+#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
+
+namespace HeuristicLab.Core {
+  partial class ParameterView {
+    /// <summary> 
+    /// Required designer variable.
+    /// </summary>
+    private System.ComponentModel.IContainer components = null;
+
+    /// <summary> 
+    /// Clean up any resources being used.
+    /// </summary>
+    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+    protected override void Dispose(bool disposing) {
+      if (disposing && (components != null)) {
+        components.Dispose();
+      }
+      base.Dispose(disposing);
+    }
+
+    #region Component Designer generated code
+
+    /// <summary> 
+    /// Required method for Designer support - do not modify 
+    /// the contents of this method with the code editor.
+    /// </summary>
+    private void InitializeComponent() {
+      this.dataTypeLabel = new System.Windows.Forms.Label();
+      this.dataTypeTextBox = new System.Windows.Forms.TextBox();
+      this.descriptionLabel = new System.Windows.Forms.Label();
+      this.descriptionTextBox = new System.Windows.Forms.TextBox();
+      this.typeLabel = new System.Windows.Forms.Label();
+      this.typeTextBox = new System.Windows.Forms.TextBox();
+      this.nameTextBox = new System.Windows.Forms.TextBox();
+      this.nameLabel = new System.Windows.Forms.Label();
+      this.SuspendLayout();
+      // 
+      // dataTypeLabel
+      // 
+      this.dataTypeLabel.AutoSize = true;
+      this.dataTypeLabel.Location = new System.Drawing.Point(3, 29);
+      this.dataTypeLabel.Name = "dataTypeLabel";
+      this.dataTypeLabel.Size = new System.Drawing.Size(60, 13);
+      this.dataTypeLabel.TabIndex = 2;
+      this.dataTypeLabel.Text = "&Data Type:";
+      // 
+      // dataTypeTextBox
+      // 
+      this.dataTypeTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.dataTypeTextBox.Location = new System.Drawing.Point(72, 26);
+      this.dataTypeTextBox.Name = "dataTypeTextBox";
+      this.dataTypeTextBox.ReadOnly = true;
+      this.dataTypeTextBox.Size = new System.Drawing.Size(197, 20);
+      this.dataTypeTextBox.TabIndex = 3;
+      // 
+      // descriptionLabel
+      // 
+      this.descriptionLabel.AutoSize = true;
+      this.descriptionLabel.Location = new System.Drawing.Point(3, 81);
+      this.descriptionLabel.Name = "descriptionLabel";
+      this.descriptionLabel.Size = new System.Drawing.Size(63, 13);
+      this.descriptionLabel.TabIndex = 6;
+      this.descriptionLabel.Text = "&Description:";
+      // 
+      // descriptionTextBox
+      // 
+      this.descriptionTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
+                  | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.descriptionTextBox.Location = new System.Drawing.Point(72, 78);
+      this.descriptionTextBox.Multiline = true;
+      this.descriptionTextBox.Name = "descriptionTextBox";
+      this.descriptionTextBox.ReadOnly = true;
+      this.descriptionTextBox.Size = new System.Drawing.Size(197, 131);
+      this.descriptionTextBox.TabIndex = 7;
+      // 
+      // typeLabel
+      // 
+      this.typeLabel.AutoSize = true;
+      this.typeLabel.Location = new System.Drawing.Point(3, 55);
+      this.typeLabel.Name = "typeLabel";
+      this.typeLabel.Size = new System.Drawing.Size(34, 13);
+      this.typeLabel.TabIndex = 4;
+      this.typeLabel.Text = "&Type:";
+      // 
+      // typeTextBox
+      // 
+      this.typeTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.typeTextBox.Location = new System.Drawing.Point(72, 52);
+      this.typeTextBox.Name = "typeTextBox";
+      this.typeTextBox.ReadOnly = true;
+      this.typeTextBox.Size = new System.Drawing.Size(197, 20);
+      this.typeTextBox.TabIndex = 5;
+      // 
+      // nameTextBox
+      // 
+      this.nameTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.nameTextBox.Location = new System.Drawing.Point(72, 0);
+      this.nameTextBox.Name = "nameTextBox";
+      this.nameTextBox.ReadOnly = true;
+      this.nameTextBox.Size = new System.Drawing.Size(197, 20);
+      this.nameTextBox.TabIndex = 1;
+      // 
+      // nameLabel
+      // 
+      this.nameLabel.AutoSize = true;
+      this.nameLabel.Location = new System.Drawing.Point(3, 3);
+      this.nameLabel.Name = "nameLabel";
+      this.nameLabel.Size = new System.Drawing.Size(38, 13);
+      this.nameLabel.TabIndex = 0;
+      this.nameLabel.Text = "&Name:";
+      // 
+      // ParameterView
+      // 
+      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.Controls.Add(this.dataTypeTextBox);
+      this.Controls.Add(this.typeTextBox);
+      this.Controls.Add(this.descriptionTextBox);
+      this.Controls.Add(this.nameTextBox);
+      this.Controls.Add(this.dataTypeLabel);
+      this.Controls.Add(this.typeLabel);
+      this.Controls.Add(this.nameLabel);
+      this.Controls.Add(this.descriptionLabel);
+      this.Name = "ParameterView";
+      this.Size = new System.Drawing.Size(269, 209);
+      this.ResumeLayout(false);
+      this.PerformLayout();
+
+    }
+
+    #endregion
+
+    private System.Windows.Forms.Label dataTypeLabel;
+    private System.Windows.Forms.TextBox dataTypeTextBox;
+    private System.Windows.Forms.Label descriptionLabel;
+    private System.Windows.Forms.TextBox descriptionTextBox;
+    private System.Windows.Forms.Label typeLabel;
+    private System.Windows.Forms.TextBox typeTextBox;
+    private System.Windows.Forms.TextBox nameTextBox;
+    private System.Windows.Forms.Label nameLabel;
+  }
+}
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/ParameterView.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/ParameterView.cs	(revision 2027)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/ParameterView.cs	(revision 2027)
@@ -0,0 +1,88 @@
+#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.ComponentModel;
+using System.Drawing;
+using System.Data;
+using System.Text;
+using System.Windows.Forms;
+
+namespace HeuristicLab.Core {
+  /// <summary>
+  /// The visual representation of <see cref="IVariableInfo"/>.
+  /// </summary>
+  public partial class ParameterView : ViewBase {
+    /// <summary>
+    /// Gets or sets the variable information to represent visually.
+    /// </summary>
+    /// <remarks>Uses property <see cref="ViewBase.Item"/> of base class <see cref="ViewBase"/>.
+    /// No own data storage present.</remarks>
+    public IParameter Parameter {
+      get { return (IParameter)Item; }
+      set { base.Item = value; }
+    }
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="VariableInfoView"/> with caption "Variable Info".
+    /// </summary>
+    public ParameterView() {
+      InitializeComponent();
+      Caption = "Parameter";
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="VariableInfoView"/> 
+    /// with the given <paramref name="variableInfo"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="VariableInfoView()"/>.</remarks>
+    /// <param name="variableInfo">The variable info to represent visually.</param>
+    public ParameterView(IParameter parameter)
+      : this() {
+      Parameter = parameter;
+    }
+
+    /// <summary>
+    /// Updates all controls with the latest data of the model.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.UpdateControls"/> of base class <see cref="ViewBase"/>.</remarks>
+    protected override void UpdateControls() {
+      base.UpdateControls();
+      Caption = "Parameter";
+      if (Parameter == null) {
+        nameTextBox.Enabled = false;
+        dataTypeTextBox.Enabled = false;
+        typeTextBox.Enabled = false;
+        descriptionTextBox.Enabled = false;
+      } else {
+        Caption = Parameter.Name + " (" + Parameter.GetType().Name + ")";
+        nameTextBox.Text = Parameter.Name;
+        nameTextBox.Enabled = true;
+        dataTypeTextBox.Text = Parameter.DataType.FullName;
+        dataTypeTextBox.Enabled = true;
+        typeTextBox.Text = Parameter.Type.ToString();
+        typeTextBox.Enabled = true;
+        descriptionTextBox.Text = Parameter.Description;
+        descriptionTextBox.Enabled = true;
+      }
+    }
+  }
+}
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/ParameterView.resx
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/ParameterView.resx	(revision 2027)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/ParameterView.resx	(revision 2027)
@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/Scope.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/Scope.cs	(revision 1994)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/Scope.cs	(revision 2027)
@@ -45,9 +45,4 @@
       get { return myVariables.Values; }
     }
-    private IDictionary<string, string> myAliases;
-    /// <inheritdoc/>
-    public IEnumerable<KeyValuePair<string, string>> Aliases {
-      get { return myAliases; }
-    }
     private List<IScope> mySubScopes;
     /// <summary>
@@ -65,5 +60,4 @@
       myName = "Anonymous";
       myVariables = new Dictionary<string, IVariable>();
-      myAliases = new Dictionary<string, string>();
       mySubScopes = new List<IScope>();
     }
@@ -144,5 +138,4 @@
     public IItem GetVariableValue(string name, bool recursiveLookup, bool throwOnError) {
       IVariable variable;
-      name = TranslateName(name);
       if (myVariables.TryGetValue(name, out variable)) {
         return variable.Value;
@@ -158,27 +151,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/>
@@ -238,9 +208,4 @@
         RemoveVariable(variableNames[j]);
 
-      KeyValuePair<string, string>[] aliases = new KeyValuePair<string,string>[myAliases.Count];
-      myAliases.CopyTo(aliases, 0);
-      for (int j = 0; j < aliases.Length; j++)
-        RemoveAlias(aliases[j].Key);
-
       while (SubScopes.Count > 0)
         RemoveSubScope(SubScopes[0]);
@@ -254,6 +219,4 @@
       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);
       for (int i = 0; i < SubScopes.Count; i++)
         clone.AddSubScope((IScope)Auxiliary.Clone(SubScopes[i], clonedObjects));
@@ -281,24 +244,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/>
@@ -380,17 +323,4 @@
       node.AppendChild(variables);
 
-      XmlNode aliases = document.CreateNode(XmlNodeType.Element, "Aliases", null);
-      foreach (KeyValuePair<string, string> alias in myAliases) {
-        XmlNode aliasNode = document.CreateNode(XmlNodeType.Element, "Alias", null);
-        XmlAttribute keyAttribute = document.CreateAttribute("Alias");
-        keyAttribute.Value = alias.Key;
-        aliasNode.Attributes.Append(keyAttribute);
-        XmlAttribute valueAttribute = document.CreateAttribute("Name");
-        valueAttribute.Value = alias.Value;
-        aliasNode.Attributes.Append(valueAttribute);
-        aliases.AppendChild(aliasNode);
-      }
-      node.AppendChild(aliases);
-
       XmlNode subScopes = document.CreateNode(XmlNodeType.Element, "SubScopes", null);
       for (int i = 0; i < SubScopes.Count; i++)
@@ -419,10 +349,4 @@
       }
 
-      XmlNode aliases = node.SelectSingleNode("Aliases");
-      if (aliases != null) {
-        foreach (XmlNode aliasNode in aliases.ChildNodes)
-          AddAlias(aliasNode.Attributes["Alias"].Value, aliasNode.Attributes["Name"].Value);
-      }
-
       XmlNode subScopes = node.SelectSingleNode("SubScopes");
       for (int i = 0; i < subScopes.ChildNodes.Count; i++) {
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/VariablesContainerView.Designer.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/VariablesContainerView.Designer.cs	(revision 2027)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/VariablesContainerView.Designer.cs	(revision 2027)
@@ -0,0 +1,177 @@
+#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.Windows.Forms;
+
+namespace HeuristicLab.Core {
+  partial class VariablesContainerView {
+    /// <summary> 
+    /// Required designer variable.
+    /// </summary>
+    private System.ComponentModel.IContainer components = null;
+
+    /// <summary> 
+    /// Clean up any resources being used.
+    /// </summary>
+    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+    protected override void Dispose(bool disposing) {
+      if (chooseItemDialog != null) chooseItemDialog.Dispose();
+      foreach (ListViewItem item in variablesListView.Items) {
+        ((IVariable)item.Tag).NameChanged -= new EventHandler(Variable_NameChanged);
+      }
+      if (disposing && (components != null)) {
+        components.Dispose();
+      }
+      base.Dispose(disposing);
+    }
+
+    #region Component Designer generated code
+
+    /// <summary> 
+    /// Required method for Designer support - do not modify 
+    /// the contents of this method with the code editor.
+    /// </summary>
+    private void InitializeComponent() {
+      this.removeVariableButton = new System.Windows.Forms.Button();
+      this.addVariableButton = new System.Windows.Forms.Button();
+      this.splitContainer = new System.Windows.Forms.SplitContainer();
+      this.variablesGroupBox = new System.Windows.Forms.GroupBox();
+      this.variablesListView = new System.Windows.Forms.ListView();
+      this.columnHeader2 = new System.Windows.Forms.ColumnHeader();
+      this.variableDetailsGroupBox = new System.Windows.Forms.GroupBox();
+      this.splitContainer.Panel1.SuspendLayout();
+      this.splitContainer.Panel2.SuspendLayout();
+      this.splitContainer.SuspendLayout();
+      this.variablesGroupBox.SuspendLayout();
+      this.SuspendLayout();
+      // 
+      // removeVariableButton
+      // 
+      this.removeVariableButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
+      this.removeVariableButton.Enabled = false;
+      this.removeVariableButton.Location = new System.Drawing.Point(81, 310);
+      this.removeVariableButton.Name = "removeVariableButton";
+      this.removeVariableButton.Size = new System.Drawing.Size(75, 23);
+      this.removeVariableButton.TabIndex = 2;
+      this.removeVariableButton.Text = "&Remove";
+      this.removeVariableButton.UseVisualStyleBackColor = true;
+      this.removeVariableButton.Click += new System.EventHandler(this.removeVariableButton_Click);
+      // 
+      // addVariableButton
+      // 
+      this.addVariableButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
+      this.addVariableButton.Location = new System.Drawing.Point(0, 310);
+      this.addVariableButton.Name = "addVariableButton";
+      this.addVariableButton.Size = new System.Drawing.Size(75, 23);
+      this.addVariableButton.TabIndex = 1;
+      this.addVariableButton.Text = "&Add...";
+      this.addVariableButton.UseVisualStyleBackColor = true;
+      this.addVariableButton.Click += new System.EventHandler(this.addVariableButton_Click);
+      // 
+      // splitContainer
+      // 
+      this.splitContainer.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
+                  | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.splitContainer.Location = new System.Drawing.Point(0, 0);
+      this.splitContainer.Name = "splitContainer";
+      // 
+      // splitContainer.Panel1
+      // 
+      this.splitContainer.Panel1.Controls.Add(this.variablesGroupBox);
+      // 
+      // splitContainer.Panel2
+      // 
+      this.splitContainer.Panel2.Controls.Add(this.variableDetailsGroupBox);
+      this.splitContainer.Size = new System.Drawing.Size(423, 304);
+      this.splitContainer.SplitterDistance = 212;
+      this.splitContainer.TabIndex = 0;
+      // 
+      // variablesGroupBox
+      // 
+      this.variablesGroupBox.Controls.Add(this.variablesListView);
+      this.variablesGroupBox.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.variablesGroupBox.Location = new System.Drawing.Point(0, 0);
+      this.variablesGroupBox.Name = "variablesGroupBox";
+      this.variablesGroupBox.Size = new System.Drawing.Size(212, 304);
+      this.variablesGroupBox.TabIndex = 0;
+      this.variablesGroupBox.TabStop = false;
+      this.variablesGroupBox.Text = "&Variables";
+      // 
+      // variablesListView
+      // 
+      this.variablesListView.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] {
+            this.columnHeader2});
+      this.variablesListView.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.variablesListView.HeaderStyle = System.Windows.Forms.ColumnHeaderStyle.None;
+      this.variablesListView.HideSelection = false;
+      this.variablesListView.Location = new System.Drawing.Point(3, 16);
+      this.variablesListView.Name = "variablesListView";
+      this.variablesListView.Size = new System.Drawing.Size(206, 285);
+      this.variablesListView.Sorting = System.Windows.Forms.SortOrder.Ascending;
+      this.variablesListView.TabIndex = 0;
+      this.variablesListView.UseCompatibleStateImageBehavior = false;
+      this.variablesListView.View = System.Windows.Forms.View.Details;
+      this.variablesListView.SelectedIndexChanged += new System.EventHandler(this.variablesListView_SelectedIndexChanged);
+      this.variablesListView.SizeChanged += new System.EventHandler(this.variablesListView_SizeChanged);
+      this.variablesListView.KeyDown += new System.Windows.Forms.KeyEventHandler(this.variablesListView_KeyDown);
+      // 
+      // variableDetailsGroupBox
+      // 
+      this.variableDetailsGroupBox.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.variableDetailsGroupBox.Location = new System.Drawing.Point(0, 0);
+      this.variableDetailsGroupBox.Name = "variableDetailsGroupBox";
+      this.variableDetailsGroupBox.Size = new System.Drawing.Size(207, 304);
+      this.variableDetailsGroupBox.TabIndex = 0;
+      this.variableDetailsGroupBox.TabStop = false;
+      this.variableDetailsGroupBox.Text = "&Details";
+      // 
+      // OperatorBaseVariablesView
+      // 
+      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.Controls.Add(this.splitContainer);
+      this.Controls.Add(this.removeVariableButton);
+      this.Controls.Add(this.addVariableButton);
+      this.Name = "OperatorBaseVariablesView";
+      this.Size = new System.Drawing.Size(423, 333);
+      this.splitContainer.Panel1.ResumeLayout(false);
+      this.splitContainer.Panel2.ResumeLayout(false);
+      this.splitContainer.ResumeLayout(false);
+      this.variablesGroupBox.ResumeLayout(false);
+      this.ResumeLayout(false);
+
+    }
+
+    #endregion
+
+    private ColumnHeader columnHeader2;
+    protected SplitContainer splitContainer;
+    protected GroupBox variablesGroupBox;
+    protected ListView variablesListView;
+    protected GroupBox variableDetailsGroupBox;
+    protected Button removeVariableButton;
+    protected Button addVariableButton;
+
+
+  }
+}
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/VariablesContainerView.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/VariablesContainerView.cs	(revision 2027)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/VariablesContainerView.cs	(revision 2027)
@@ -0,0 +1,219 @@
+#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.ComponentModel;
+using System.Drawing;
+using System.Data;
+using System.Text;
+using System.Windows.Forms;
+
+namespace HeuristicLab.Core {
+  /// <summary>
+  /// The visual representation of the variables in a container of variables.
+  /// </summary>
+  public partial class VariablesContainerView : ViewBase {
+    private ChooseItemDialog chooseItemDialog;
+
+    /// <summary>
+    /// Gets or sets the container whose variables to represent.
+    /// </summary>
+    /// <remarks>Uses property <see cref="ViewBase.Item"/> of base class <see cref="ViewBase"/>.
+    /// No own data storage present.</remarks>
+    public IVariablesContainer VariablesContainer {
+      get { return (IVariablesContainer)Item; }
+      set { base.Item = value; }
+    }
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="VariablesContainerView"/> with caption "Variables Container".
+    /// </summary>
+    public VariablesContainerView() {
+      InitializeComponent();
+      variablesListView.Columns[0].Width = Math.Max(0, variablesListView.Width - 25);
+      Caption = "Variables Container";
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="VariablesContainerView"/> with the given 
+    /// container <paramref name="container"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="VariablesContainerView"/>.</remarks>
+    /// <param name="op">The container whose variables should be represented visually.</param>
+    public VariablesContainerView(IVariablesContainer container)
+      : this() {
+      VariablesContainer = container;
+    }
+
+    /// <summary>
+    /// Removes the eventhandlers from the unterlying <see cref="IVariablesContainer"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.RemoveItemEvents"/> of base class <see cref="ViewBase"/>.</remarks>
+    protected override void RemoveItemEvents() {
+      VariablesContainer.VariableAdded -= new EventHandler<VariableEventArgs>(VariablesContainer_VariableAdded);
+      VariablesContainer.VariableRemoved -= new EventHandler<VariableEventArgs>(VariablesContainer_VariableRemoved);
+      base.RemoveItemEvents();
+    }
+    /// <summary>
+    /// Adds eventhandlers to the underlying <see cref="IVariablesContainer"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.AddItemEvents"/> of base class <see cref="ViewBase"/>.</remarks>
+    protected override void AddItemEvents() {
+      base.AddItemEvents();
+      VariablesContainer.VariableAdded += new EventHandler<VariableEventArgs>(VariablesContainer_VariableAdded);
+      VariablesContainer.VariableRemoved += new EventHandler<VariableEventArgs>(VariablesContainer_VariableRemoved);
+    }
+
+    /// <summary>
+    /// Updates all controls with the latest data of the model.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.UpdateControls"/> of base class <see cref="ViewBase"/>.</remarks>
+    protected override void UpdateControls() {
+      base.UpdateControls();
+      variableDetailsGroupBox.Controls.Clear();
+      if (VariablesContainer == null) {
+        Caption = "Variables Container";
+        variablesListView.Enabled = false;
+        variableDetailsGroupBox.Enabled = false;
+        removeVariableButton.Enabled = false;
+      } else {
+        Caption = "Variables Container (" + VariablesContainer.GetType().Name + ")";
+        variablesListView.Enabled = true;
+        foreach (ListViewItem item in variablesListView.Items) {
+          ((IVariable)item.Tag).NameChanged -= new EventHandler(Variable_NameChanged);
+        }
+        variablesListView.Items.Clear();
+        foreach (IVariable variable in VariablesContainer.Variables) {
+          ListViewItem item = new ListViewItem();
+          item.Text = variable.Name;
+          item.Tag = variable;
+          variablesListView.Items.Add(item);
+          variable.NameChanged += new EventHandler(Variable_NameChanged);
+        }
+        if (variablesListView.Items.Count > 0)
+          variablesListView.SelectedIndices.Add(0);
+      }
+    }
+
+    private void variablesListView_SelectedIndexChanged(object sender, EventArgs e) {
+      if (variableDetailsGroupBox.Controls.Count > 0)
+        variableDetailsGroupBox.Controls[0].Dispose();
+      variableDetailsGroupBox.Controls.Clear();
+      variableDetailsGroupBox.Enabled = false;
+      removeVariableButton.Enabled = false;
+      if (variablesListView.SelectedItems.Count > 0) {
+        removeVariableButton.Enabled = true;
+      }
+      if (variablesListView.SelectedItems.Count == 1) {
+        IVariable variable = (IVariable)variablesListView.SelectedItems[0].Tag;
+        Control editor = (Control)variable.CreateView();
+        variableDetailsGroupBox.Controls.Add(editor);
+        editor.Dock = DockStyle.Fill;
+        variableDetailsGroupBox.Enabled = true;
+      }
+    }
+
+    #region Size Changed Events
+    private void variablesListView_SizeChanged(object sender, EventArgs e) {
+      if (variablesListView.Columns.Count > 0)
+        variablesListView.Columns[0].Width = Math.Max(0, variablesListView.Width - 25);
+    }
+    #endregion
+
+    #region Key Events
+    private void variablesListView_KeyDown(object sender, KeyEventArgs e) {
+      if (e.KeyCode == Keys.Delete) {
+        if (variablesListView.SelectedItems.Count > 0) {
+          foreach (ListViewItem item in variablesListView.SelectedItems)
+            VariablesContainer.RemoveVariable(((IVariable)item.Tag).Name);
+        }
+      }
+    }
+    #endregion
+
+    #region Button Events
+    private void addVariableButton_Click(object sender, EventArgs e) {
+      if (chooseItemDialog == null) {
+        chooseItemDialog = new ChooseItemDialog();
+        chooseItemDialog.Caption = "Add Variable";
+      }
+      if (chooseItemDialog.ShowDialog(this) == DialogResult.OK) {
+        IVariable newVariable = new Variable(chooseItemDialog.Item.GetType().Name, chooseItemDialog.Item);
+        int index = 1;
+        bool valid = true;
+        string name = null;
+        do {
+          valid = true;
+          name = newVariable.Name + " (" + index.ToString() + ")";
+          foreach (IVariable existingVariable in VariablesContainer.Variables) {
+            if (existingVariable.Name == name) {
+              valid = false;
+              index++;
+            }
+          }
+        } while (!valid);
+        newVariable.Name = name;
+        VariablesContainer.AddVariable(newVariable);
+      }
+    }
+    private void removeVariableButton_Click(object sender, EventArgs e) {
+      if (variablesListView.SelectedItems.Count > 0) {
+        foreach (ListViewItem item in variablesListView.SelectedItems)
+          VariablesContainer.RemoveVariable(((IVariable)item.Tag).Name);
+      }
+    }
+    #endregion
+
+    #region Variable Events
+    private void Variable_NameChanged(object sender, EventArgs e) {
+      IVariable variable = (IVariable)sender;
+      foreach (ListViewItem item in variablesListView.Items) {
+        if (item.Tag == variable)
+          item.Text = variable.Name;
+      }
+    }
+    #endregion
+
+    #region OperatorBase Events
+    private void VariablesContainer_VariableAdded(object sender, VariableEventArgs e) {
+      ListViewItem item = new ListViewItem();
+      item.Text = e.Variable.Name;
+      item.Tag = e.Variable;
+      variablesListView.Items.Add(item);
+      // select the new item
+      foreach(ListViewItem oldSelected in variablesListView.SelectedItems) {
+        oldSelected.Selected = false;
+      }
+      item.Selected = true;
+      e.Variable.NameChanged += new EventHandler(Variable_NameChanged);
+    }
+    private void VariablesContainer_VariableRemoved(object sender, VariableEventArgs e) {
+      ListViewItem itemToDelete = null;
+      foreach (ListViewItem item in variablesListView.Items) {
+        if (item.Tag == e.Variable)
+          itemToDelete = item;
+      }
+      e.Variable.NameChanged -= new EventHandler(Variable_NameChanged);
+      variablesListView.Items.Remove(itemToDelete);
+    }
+    #endregion
+  }
+}
Index: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/VariablesContainerView.resx
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/VariablesContainerView.resx	(revision 2027)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/VariablesContainerView.resx	(revision 2027)
@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/ComparatorBase.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/ComparatorBase.cs	(revision 1994)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/ComparatorBase.cs	(revision 2027)
@@ -36,7 +36,7 @@
     /// </summary>
     protected ComparatorBase() {
-      AddVariableInfo(new VariableInfo("LeftSide", "Variable on the left side of the comparison", typeof(IItem), VariableKind.In));
-      AddVariableInfo(new VariableInfo("RightSide", "Variable on the right side of the comparison", typeof(IItem), VariableKind.In));
-      AddVariableInfo(new VariableInfo("Result", "Result of the comparison", typeof(BoolData), VariableKind.Out | VariableKind.New));
+      AddParameter(new Parameter("LeftSide", "Variable on the left side of the comparison", typeof(IItem), ParameterType.In));
+      AddParameter(new Parameter("RightSide", "Variable on the right side of the comparison", typeof(IItem), ParameterType.In));
+      AddParameter(new Parameter("Result", "Result of the comparison", typeof(BoolData), ParameterType.Out));
     }
 
@@ -50,18 +50,15 @@
     /// <param name="scope">The scope where to apply the compare operation.</param>
     /// <returns><c>null</c>.</returns>
-    public override IOperation Apply(IScope scope) {
-      BoolData result = GetVariableValue<BoolData>("Result", scope, false, false);
+    public override IOperation Apply(IEnvironment env, IScope scope) {
+      string resultName = env.TranslateName("Result");
+      BoolData result = scope.GetVariableValue<BoolData>(resultName, false, false);
       if (result == null) {
         result = new BoolData(true);
-        IVariableInfo info = GetVariableInfo("Result");
-        if (info.Local)
-          AddVariable(new Variable(info.ActualName, result));
-        else
-          scope.AddVariable(new Variable(scope.TranslateName(info.FormalName), result));
+        scope.AddVariable(new Variable(resultName, result));
       }
-      IItem leftSide = GetVariableValue<IItem>("LeftSide", scope, true);
+      IItem leftSide = scope.GetVariableValue<IItem>(env.TranslateName("LeftSide"), true);
       if (!(leftSide is IComparable)) throw new InvalidOperationException("Comparator: Left side needs to be of type IComparable");
       IComparable left = (IComparable)leftSide;
-      IItem rightSide = GetVariableValue<IItem>("RightSide", scope, true);
+      IItem rightSide = scope.GetVariableValue<IItem>(env.TranslateName("RightSide"), true);
       result.Data = Compare(left, rightSide);
       return null;
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/ConditionalBranch.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/ConditionalBranch.cs	(revision 1994)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/ConditionalBranch.cs	(revision 2027)
@@ -45,5 +45,5 @@
     public ConditionalBranch()
       : base() {
-      AddVariableInfo(new VariableInfo("Condition", "A boolean variable that decides the branch", typeof(BoolData), VariableKind.In));
+      AddParameter(new Parameter("Condition", "A boolean variable that decides the branch", typeof(BoolData), ParameterType.In));
     }
 
@@ -56,12 +56,11 @@
     /// <returns>A new <see cref="AtomicOperation"/> with either operator 1 or operator 2 applied
     /// to the given <paramref name="scope"/> or <c>null</c>.</returns>
-    public override IOperation Apply(IScope scope) {
-      BoolData resultData = GetVariableValue<BoolData>("Condition", scope, true);
-      bool result = resultData.Data;
+    public override IOperation Apply(IEnvironment env, IScope scope) {
+      bool result = scope.GetVariableValue<BoolData>(env.TranslateName("Condition"), true).Data;
 
       if ((result) && (SubOperators.Count > 0) && (SubOperators[0] != null))
-        return new AtomicOperation(SubOperators[0], scope);
+        return new AtomicOperation(SubOperators[0], env, scope);
       else if ((!result) && (SubOperators.Count > 1) && (SubOperators[1] != null))
-        return new AtomicOperation(SubOperators[1], scope);
+        return new AtomicOperation(SubOperators[1], env, scope);
       return null;
     }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/Counter.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/Counter.cs	(revision 1994)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/Counter.cs	(revision 2027)
@@ -43,5 +43,5 @@
     public Counter()
       : base() {
-      AddVariableInfo(new VariableInfo("Value", "Counter value", typeof(IntData), VariableKind.In | VariableKind.Out));
+      AddParameter(new Parameter("Value", "Counter value", typeof(IntData), ParameterType.InOut));
     }
 
@@ -51,6 +51,6 @@
     /// <param name="scope">The scope whose variable should be incremented.</param>
     /// <returns><c>null</c>.</returns>
-    public override IOperation Apply(IScope scope) {
-      IntData value = GetVariableValue<IntData>("Value", scope, true);
+    public override IOperation Apply(IEnvironment env, IScope scope) {
+      IntData value = scope.GetVariableValue<IntData>(env.TranslateName("Value"), true);
       value.Data++;
       return null;
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/DoubleCounter.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/DoubleCounter.cs	(revision 1994)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/DoubleCounter.cs	(revision 2027)
@@ -44,6 +44,6 @@
     public DoubleCounter()
       : base() {
-      AddVariableInfo(new VariableInfo("Value", "Counter value", typeof(DoubleData), VariableKind.In | VariableKind.Out));
-      AddVariableInfo(new VariableInfo("Interval", "Interval value", typeof(DoubleData), VariableKind.In));
+      AddParameter(new Parameter("Value", "Counter value", typeof(DoubleData), ParameterType.InOut));
+      AddParameter(new Parameter("Interval", "Interval value", typeof(DoubleData), ParameterType.In));
     }
 
@@ -53,7 +53,7 @@
     /// <param name="scope">The scope whose variable should be incremented.</param>
     /// <returns><c>null</c>.</returns>
-    public override IOperation Apply(IScope scope) {
-      DoubleData value = GetVariableValue<DoubleData>("Value", scope, true);
-      double interval = GetVariableValue<DoubleData>("Interval", scope, true).Data;
+    public override IOperation Apply(IEnvironment env, IScope scope) {
+      DoubleData value = scope.GetVariableValue<DoubleData>(env.TranslateName("Value"), true);
+      double interval = scope.GetVariableValue<DoubleData>(env.TranslateName("Interval"), true).Data;
       value.Data += interval;
       return null;
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/EmptyOperator.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/EmptyOperator.cs	(revision 1994)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/EmptyOperator.cs	(revision 2027)
@@ -47,5 +47,5 @@
     /// <param name="scope">The scope to apply the operator on.</param>
     /// <returns><c>null</c>.</returns>
-    public override IOperation Apply(IScope scope) {
+    public override IOperation Apply(IEnvironment environment, IScope scope) {
       return null;
     }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/HeuristicLab.Operators-3.2.csproj
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/HeuristicLab.Operators-3.2.csproj	(revision 1994)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/HeuristicLab.Operators-3.2.csproj	(revision 2027)
@@ -81,50 +81,63 @@
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="AddVariableInfoDialog.cs">
-      <SubType>Form</SubType>
+    <Compile Include="ComparatorBase.cs">
+      <SubType>Code</SubType>
     </Compile>
-    <Compile Include="AddVariableInfoDialog.Designer.cs">
-      <DependentUpon>AddVariableInfoDialog.cs</DependentUpon>
-    </Compile>
-    <Compile Include="CombinedOperator.cs" />
-    <Compile Include="CombinedOperatorView.cs">
-      <SubType>UserControl</SubType>
-    </Compile>
-    <Compile Include="CombinedOperatorView.Designer.cs">
-      <DependentUpon>CombinedOperatorView.cs</DependentUpon>
-    </Compile>
-    <Compile Include="ComparatorBase.cs" />
     <Compile Include="ConditionalBranch.cs">
       <SubType>Code</SubType>
     </Compile>
-    <Compile Include="DelegatingOperator.cs" />
-    <Compile Include="DoubleCounter.cs" />
-    <Compile Include="ScopeCleaner.cs" />
-    <Compile Include="StochasticMultiBranch.cs" />
-    <Compile Include="SubScopesMixer.cs" />
-    <Compile Include="DataCollector.cs" />
-    <Compile Include="EqualToComparator.cs" />
-    <Compile Include="GreaterOrEqualThanComparator.cs" />
-    <Compile Include="GreaterThanComparator.cs" />
-    <Compile Include="LessOrEqualThanComparator.cs" />
-    <Compile Include="LessThanComparator.cs" />
-    <Compile Include="OperatorExtractor.cs" />
-    <Compile Include="ParallelProcessor.cs" />
-    <Compile Include="EmptyOperator.cs" />
-    <Compile Include="SequentialProcessor.cs" />
-    <Compile Include="SingleObjectiveEvaluatorBase.cs" />
-    <Compile Include="Sorter.cs" />
-    <Compile Include="StochasticBranch.cs" />
-    <Compile Include="SubScopesRemover.cs" />
-    <Compile Include="UnequalToComparator.cs" />
-    <Compile Include="UniformSequentialSubScopesProcessor.cs" />
-    <Compile Include="UniformParallelSubScopesProcessor.cs" />
-    <Compile Include="ParallelSubScopesProcessor.cs" />
-    <Compile Include="SequentialSubScopesProcessor.cs" />
-    <Compile Include="SubScopesCreater.cs" />
-    <Compile Include="Counter.cs" />
+    <Compile Include="Counter.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="DoubleCounter.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="EmptyOperator.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="EqualToComparator.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="GreaterOrEqualThanComparator.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="GreaterThanComparator.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Include="HeuristicLabOperatorsPlugin.cs" />
+    <Compile Include="LessOrEqualThanComparator.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="LessThanComparator.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="ParallelProcessor.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="ParallelSubScopesProcessor.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="VariableInjector.cs" />
+    <Compile Include="SequentialProcessor.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="SequentialSubScopesProcessor.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="SubScopesCreater.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="UnequalToComparator.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="UniformParallelSubScopesProcessor.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="UniformSequentialSubScopesProcessor.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="VariableInjector.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Include="VariableInjectorView.cs">
       <SubType>UserControl</SubType>
@@ -135,8 +148,4 @@
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="..\..\HeuristicLab.Constraints\3.2\HeuristicLab.Constraints-3.2.csproj">
-      <Project>{FCD62C6F-4793-4593-AE9A-0BDCA256EE99}</Project>
-      <Name>HeuristicLab.Constraints-3.2</Name>
-    </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Core\3.2\HeuristicLab.Core-3.2.csproj">
       <Project>{F43B59AB-2B8C-4570-BC1E-15592086517C}</Project>
@@ -157,11 +166,6 @@
   </ItemGroup>
   <ItemGroup>
-    <EmbeddedResource Include="AddVariableInfoDialog.resx">
-      <DependentUpon>AddVariableInfoDialog.cs</DependentUpon>
-      <SubType>Designer</SubType>
-    </EmbeddedResource>
-    <EmbeddedResource Include="CombinedOperatorView.resx">
-      <DependentUpon>CombinedOperatorView.cs</DependentUpon>
-      <SubType>Designer</SubType>
+    <EmbeddedResource Include="VariableInjectorView.resx">
+      <DependentUpon>VariableInjectorView.cs</DependentUpon>
     </EmbeddedResource>
   </ItemGroup>
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/HeuristicLabOperatorsPlugin.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/HeuristicLabOperatorsPlugin.cs	(revision 1994)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/HeuristicLabOperatorsPlugin.cs	(revision 2027)
@@ -31,5 +31,4 @@
   [ClassInfo(Name = "HeuristicLab.Operators-3.2")]
   [PluginFile(Filename = "HeuristicLab.Operators-3.2.dll", Filetype = PluginFileType.Assembly)]
-  [Dependency(Dependency = "HeuristicLab.Constraints-3.2")]
   [Dependency(Dependency = "HeuristicLab.Core-3.2")]
   [Dependency(Dependency = "HeuristicLab.Data-3.2")]
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/ParallelProcessor.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/ParallelProcessor.cs	(revision 1994)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/ParallelProcessor.cs	(revision 2027)
@@ -42,9 +42,9 @@
     /// <returns>A new <see cref="CompositeOperation"/> with the <c>n</c> operators applied 
     /// to the given <paramref name="scope"/> with the <c>ExecuteInParallel</c> set to <c>true</c>.</returns>
-    public override IOperation Apply(IScope scope) {
+    public override IOperation Apply(IEnvironment env, IScope scope) {
       CompositeOperation next = new CompositeOperation();
       next.ExecuteInParallel = true;
       for (int i = 0; i < SubOperators.Count; i++)
-        next.AddOperation(new AtomicOperation(SubOperators[i], scope));
+        next.AddOperation(new AtomicOperation(SubOperators[i], env, scope));
       return next;
     }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/ParallelSubScopesProcessor.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/ParallelSubScopesProcessor.cs	(revision 1994)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/ParallelSubScopesProcessor.cs	(revision 2027)
@@ -42,9 +42,9 @@
     /// <returns>A new <see cref="CompositeOperation"/> with the <c>i</c>th operator applied
     /// on the <c>i</c>th sub scope, the <c>ExecuteInParallel</c> flag set to <c>true</c>.</returns>
-    public override IOperation Apply(IScope scope) {
+    public override IOperation Apply(IEnvironment env, IScope scope) {
       CompositeOperation next = new CompositeOperation();
       next.ExecuteInParallel = true;
       for (int i = 0; i < scope.SubScopes.Count; i++)
-        next.AddOperation(new AtomicOperation(SubOperators[i], scope.SubScopes[i]));
+        next.AddOperation(new AtomicOperation(SubOperators[i], env, scope.SubScopes[i]));
       return next;
     }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/SequentialProcessor.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/SequentialProcessor.cs	(revision 1994)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/SequentialProcessor.cs	(revision 2027)
@@ -42,8 +42,8 @@
     /// <returns>A new <see cref="CompositeOperation"/> with the <c>n</c> operators applied 
     /// to the given <paramref name="scope"/>.</returns>
-    public override IOperation Apply(IScope scope) {
+    public override IOperation Apply(IEnvironment env, IScope scope) {
       CompositeOperation next = new CompositeOperation();
       for (int i = 0; i < SubOperators.Count; i++)
-        next.AddOperation(new AtomicOperation(SubOperators[i], scope));
+        next.AddOperation(new AtomicOperation(SubOperators[i], env, scope));
       return next;
     }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/SequentialSubScopesProcessor.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/SequentialSubScopesProcessor.cs	(revision 1994)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/SequentialSubScopesProcessor.cs	(revision 2027)
@@ -42,8 +42,8 @@
     /// <returns>A new <see cref="CompositeOperation"/> with the <c>i</c>th operator applied
     /// on the <c>i</c>th sub scope.</returns>
-    public override IOperation Apply(IScope scope) {
+    public override IOperation Apply(IEnvironment env, IScope scope) {
       CompositeOperation next = new CompositeOperation();
       for (int i = 0; i < scope.SubScopes.Count; i++)
-        next.AddOperation(new AtomicOperation(SubOperators[i], scope.SubScopes[i]));
+        next.AddOperation(new AtomicOperation(SubOperators[i], env, scope.SubScopes[i]));
       return next;
     }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/SubScopesCreater.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/SubScopesCreater.cs	(revision 1994)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/SubScopesCreater.cs	(revision 2027)
@@ -41,5 +41,5 @@
     public SubScopesCreater()
       : base() {
-      AddVariableInfo(new VariableInfo("SubScopes", "Number of sub-scopes", typeof(IntData), VariableKind.In));
+      AddParameter(new Parameter("SubScopes", "Number of sub-scopes", typeof(IntData), ParameterType.In));
     }
 
@@ -49,6 +49,6 @@
     /// <param name="scope">The scope where to create the sub scopes.</param>
     /// <returns><c>null</c>.</returns>
-    public override IOperation Apply(IScope scope) {
-      IntData count = GetVariableValue<IntData>("SubScopes", scope, true);
+    public override IOperation Apply(IEnvironment env, IScope scope) {
+      IntData count = scope.GetVariableValue<IntData>(env.TranslateName("SubScopes"), true);
 
       for (int i = 0; i < count.Data; i++)
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/UniformParallelSubScopesProcessor.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/UniformParallelSubScopesProcessor.cs	(revision 1994)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/UniformParallelSubScopesProcessor.cs	(revision 2027)
@@ -43,9 +43,9 @@
     /// <returns>A new <see cref="CompositeOperation"/> with one operator and all sub scopes and
     /// the <c>ExecuteInParallel</c> flag set to <c>true</c>.</returns>
-    public override IOperation Apply(IScope scope) {
+    public override IOperation Apply(IEnvironment env, IScope scope) {
       CompositeOperation next = new CompositeOperation();
       next.ExecuteInParallel = true;
       for (int i = 0; i < scope.SubScopes.Count; i++)
-        next.AddOperation(new AtomicOperation(SubOperators[0], scope.SubScopes[i]));
+        next.AddOperation(new AtomicOperation(SubOperators[0], env, scope.SubScopes[i]));
       return next;
     }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/UniformSequentialSubScopesProcessor.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/UniformSequentialSubScopesProcessor.cs	(revision 1994)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/UniformSequentialSubScopesProcessor.cs	(revision 2027)
@@ -42,8 +42,8 @@
     /// <param name="scope">The scope on whose sub scopes the operator is applied.</param>
     /// <returns>A new <see cref="CompositeOperation"/> with one operator and all sub scopes.</returns>
-    public override IOperation Apply(IScope scope) {
+    public override IOperation Apply(IEnvironment env, IScope scope) {
       CompositeOperation next = new CompositeOperation();
       for (int i = 0; i < scope.SubScopes.Count; i++)
-        next.AddOperation(new AtomicOperation(SubOperators[0], scope.SubScopes[i]));
+        next.AddOperation(new AtomicOperation(SubOperators[0], env, scope.SubScopes[i]));
       return next;
     }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/VariableInjector.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/VariableInjector.cs	(revision 1994)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/VariableInjector.cs	(revision 2027)
@@ -30,11 +30,28 @@
   /// Class to inject local variables into the scope.
   /// </summary>
-  public class VariableInjector : OperatorBase {
-    private Dictionary<IVariable, IVariableInfo> variableVariableInfoTable;
-    private Dictionary<IVariableInfo, IVariable> variableInfoVariableTable;
+  public class VariableInjector : OperatorBase, IVariablesContainer {
+    private Dictionary<string, IVariable> myVariables;
+    /// <summary>
+    /// Gets a collection of all variables of the current operator.
+    /// </summary>
+    public virtual ICollection<IVariable> Variables {
+      get { return myVariables.Values; }
+    }
 
     /// <inheritdoc select="summary"/>
     public override string Description {
-      get { return @"TODO\r\nOperator description still missing ..."; }
+      get { return @"Injects new variable into a scope."; }
+    }
+
+    /// <summary>
+    /// Overrides the Parameters property so that a parameter is returned for each injected variable.
+    /// </summary>
+    public override ICollection<IParameter> Parameters {
+      get {
+        List<IParameter> parameters = new List<IParameter>();
+        foreach (IVariable variable in Variables)
+          parameters.Add(new Parameter(variable.Name, "Injected variable.", variable.Value.GetType(), ParameterType.Out));
+        return parameters;
+      }
     }
 
@@ -44,6 +61,5 @@
     public VariableInjector()
       : base() {
-      variableVariableInfoTable = new Dictionary<IVariable, IVariableInfo>();
-      variableInfoVariableTable = new Dictionary<IVariableInfo, IVariable>();
+      myVariables = new Dictionary<string, IVariable>();
     }
 
@@ -56,7 +72,5 @@
     /// <returns>The cloned object as <see cref="VariableInjector"/>.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      VariableInjector clone = new VariableInjector();
-      clonedObjects.Add(Guid, clone);
-      clone.Name = Name;
+      VariableInjector clone = (VariableInjector)base.Clone(clonedObjects);
       foreach (IVariable variable in Variables)
         clone.AddVariable((IVariable)Auxiliary.Clone(variable, clonedObjects));
@@ -65,26 +79,4 @@
 
     /// <summary>
-    /// Adds the specified <paramref name="variable"/> to the current instance to get injected.
-    /// </summary>
-    /// <param name="variable">The variable to add.</param>
-    /// <remarks>Calls private method <see cref="CreateVariableInfo"/> and <see cref="OperatorBase.AddVariable"/>
-    /// of base class <see cref="OperatorBase"/>.</remarks>
-    public override void AddVariable(IVariable variable) {
-      base.AddVariable(variable);
-      CreateVariableInfo(variable);
-    }
-
-    /// <summary>
-    /// Removes a variable with the specified <paramref name="name"/> from the current injector.
-    /// </summary>
-    /// <remarks>Calls private method <see cref="DeleteVariableInfo"/> and <see cref="OperatorBase.RemoveVariable"/>
-    /// of base class <see cref="OperatorBase"/>.</remarks>
-    /// <param name="name">The name of the </param>
-    public override void RemoveVariable(string name) {
-      DeleteVariableInfo(name);
-      base.RemoveVariable(name);
-    }
-
-    /// <summary>
     /// Adds the specified variables to the given <paramref name="scope"/> (and removes them first,
     /// if they already exist in the current scope).
@@ -92,5 +84,5 @@
     /// <param name="scope">The scope where to inject the variables.</param>
     /// <returns><c>null</c>.</returns>
-    public override IOperation Apply(IScope scope) {
+    public override IOperation Apply(IEnvironment env, IScope scope) {
       foreach (IVariable variable in Variables) {
         if (scope.GetVariable(variable.Name) != null)
@@ -109,54 +101,118 @@
     }
 
-    private void CreateVariableInfo(IVariable variable) {
-      IVariableInfo info = new VariableInfo(Guid.NewGuid().ToString(), "Injected variable", variable.Value.GetType(), VariableKind.New);
-      info.ActualName = variable.Name;
-      AddVariableInfo(info);
-      variableVariableInfoTable.Add(variable, info);
-      variableInfoVariableTable.Add(info, variable);
-      info.ActualNameChanged += new EventHandler(VariableInfo_ActualNameChanged);
+    /// <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>
+    public virtual IVariable GetVariable(string name) {
+      IVariable variable;
+      if (myVariables.TryGetValue(name, out variable))
+        return variable;
+      else
+        return null;
+    }
+    /// <summary>
+    /// Adds the specified <paramref name="variable"/> to the current instance.
+    /// </summary>
+    /// <param name="variable">The variable to add.</param>
+    public virtual void AddVariable(IVariable variable) {
+      myVariables.Add(variable.Name, variable);
+      variable.NameChanging += new EventHandler<NameChangingEventArgs>(Variable_NameChanging);
       variable.NameChanged += new EventHandler(Variable_NameChanged);
-    }
-    private void DeleteVariableInfo(string name) {
-      IVariable variable = GetVariable(name);
-      if (variable != null) {
-        IVariableInfo info = variableVariableInfoTable[variable];
-        RemoveVariableInfo(info.FormalName);
-        variableVariableInfoTable.Remove(variable);
-        variableInfoVariableTable.Remove(info);
-        info.ActualNameChanged -= new EventHandler(VariableInfo_ActualNameChanged);
+      OnVariableAdded(variable);
+    }
+    /// <summary>
+    /// Deletes the variable with the specified <paramref name="name"/>.
+    /// </summary>
+    /// <param name="name">The name of the variable to delete.</param>
+    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);
-      }
-    }
-
-    #region VariableInfo and Variable Events
-    private void VariableInfo_ActualNameChanged(object sender, EventArgs e) {
-      IVariableInfo info = (IVariableInfo)sender;
-      IVariable variable = variableInfoVariableTable[info];
-      variable.Name = info.ActualName;
+        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;
-      IVariableInfo info = variableVariableInfoTable[variable];
-      info.ActualName = variable.Name;
-    }
-    #endregion
+      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);
+    }
+
+    /// <summary>
+    /// Occurs when a variable has been added.
+    /// </summary>
+    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));
+    }
+    /// <summary>
+    /// Occurs when a variable has been deleted.
+    /// </summary>
+    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));
+    }
 
     #region Persistence Methods
     /// <summary>
     /// Saves the current instance as <see cref="XmlNode"/> in the specified <paramref name="document"/>.
-    /// <note type="caution"> Variable infos are not persisted!</note>
-    /// </summary>
-    /// <remarks>Calls <see cref="OperatorBase.GetXmlNode"/> of base class <see cref="OperatorBase"/>.</remarks>
+    /// </summary>
+    /// <remarks>
+    /// Calls <see cref="OperatorBase.GetXmlNode"/> of base class <see cref="OperatorBase"/>.
+    /// <br/>A quick overview how the single elements of the current instance are saved:
+    /// <list type="bullet">
+    /// <item>
+    /// <term>Variables: </term>
+    /// <description>Saved as child node with tag name <c>Variables</c>. All variables are themselves
+    /// saved as child nodes.</description>
+    /// </item> 
+    /// </list>
+    /// </remarks>
     /// <param name="name">The (tag)name of the <see cref="XmlNode"/>.</param>
     /// <param name="document">The <see cref="XmlDocument"/> where to save the data.</param>
     /// <param name="persistedObjects">The dictionary of all already persisted objects. (Needed to avoid cycles.)</param>
     /// <returns>The saved <see cref="XmlNode"/>.</returns>
-    public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid,IStorable> persistedObjects) {
+    public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
-      // variable infos should not be persisted
-      XmlNode infosNode = node.SelectSingleNode("VariableInfos");
-      infosNode.RemoveAll();
+      XmlNode variablesNode = document.CreateNode(XmlNodeType.Element, "Variables", null);
+      foreach (IVariable variable in myVariables.Values)
+        variablesNode.AppendChild(PersistenceManager.Persist(variable, document, persistedObjects));
+      node.AppendChild(variablesNode);
       return node;
+    }
+    /// <summary>
+    /// Loads the persisted variable injector from the specified <paramref name="node"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="OperatorBase.Populate"/> of base class 
+    /// <see cref="OperatorBase"/>.
+    /// For informations how the different elements must be saved please see <see cref="GetXmlNode"/>.</remarks>
+    /// <param name="node">The <see cref="XmlNode"/> where the operation is saved.</param>
+    /// <param name="restoredObjects">A dictionary of all already restored objects. (Needed to avoid cycles.)</param>
+    public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
+      base.Populate(node, restoredObjects);
+      XmlNode variablesNode = node.SelectSingleNode("Variables");
+      foreach (XmlNode variableNode in variablesNode.ChildNodes)
+        AddVariable((IVariable)PersistenceManager.Restore(variableNode, restoredObjects));
     }
     #endregion
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/VariableInjectorView.Designer.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/VariableInjectorView.Designer.cs	(revision 1994)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/VariableInjectorView.Designer.cs	(revision 2027)
@@ -45,9 +45,54 @@
     /// </summary>
     private void InitializeComponent() {
-      components = new System.ComponentModel.Container();
+      this.variablesTabPage = new System.Windows.Forms.TabPage();
+      this.variablesContainerView = new HeuristicLab.Core.VariablesContainerView();
+      this.tabControl.SuspendLayout();
+      this.parametersTabPage.SuspendLayout();
+      this.variablesTabPage.SuspendLayout();
+      this.SuspendLayout();
+      // 
+      // tabControl
+      // 
+      this.tabControl.Controls.Add(this.variablesTabPage);
+      this.tabControl.Controls.SetChildIndex(this.parametersTabPage, 0);
+      this.tabControl.Controls.SetChildIndex(this.variablesTabPage, 0);
+      // 
+      // variablesTabPage
+      // 
+      this.variablesTabPage.Controls.Add(this.variablesContainerView);
+      this.variablesTabPage.Location = new System.Drawing.Point(4, 22);
+      this.variablesTabPage.Name = "variablesTabPage";
+      this.variablesTabPage.Padding = new System.Windows.Forms.Padding(3);
+      this.variablesTabPage.Size = new System.Drawing.Size(415, 307);
+      this.variablesTabPage.TabIndex = 4;
+      this.variablesTabPage.Text = "Variables";
+      this.variablesTabPage.UseVisualStyleBackColor = true;
+      // 
+      // variablesContainerView
+      // 
+      this.variablesContainerView.Caption = "Variables Container";
+      this.variablesContainerView.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.variablesContainerView.Location = new System.Drawing.Point(3, 3);
+      this.variablesContainerView.Name = "variablesContainerView";
+      this.variablesContainerView.Size = new System.Drawing.Size(409, 301);
+      this.variablesContainerView.TabIndex = 0;
+      this.variablesContainerView.VariablesContainer = null;
+      // 
+      // VariableInjectorView
+      // 
+      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
       this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.Name = "VariableInjectorView";
+      this.tabControl.ResumeLayout(false);
+      this.parametersTabPage.ResumeLayout(false);
+      this.variablesTabPage.ResumeLayout(false);
+      this.ResumeLayout(false);
+
     }
 
     #endregion
+
+    private System.Windows.Forms.TabPage variablesTabPage;
+    private HeuristicLab.Core.VariablesContainerView variablesContainerView;
   }
 }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/VariableInjectorView.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/VariableInjectorView.cs	(revision 1994)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/VariableInjectorView.cs	(revision 2027)
@@ -60,4 +60,20 @@
       VariableInjector = variableInjector;
     }
+
+    /// <summary>
+    /// Removes event handlers in all children.
+    /// </summary>
+    protected override void RemoveItemEvents() {
+      variablesContainerView.VariablesContainer = null;
+      base.RemoveItemEvents();
+    }
+    /// <summary>
+    /// Adds event handlers in all children.
+    /// </summary>
+    protected override void AddItemEvents() {
+      base.AddItemEvents();
+      variablesContainerView.VariablesContainer = VariableInjector;
+    }
+
   }
 }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/VariableInjectorView.resx
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/VariableInjectorView.resx	(revision 2027)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/VariableInjectorView.resx	(revision 2027)
@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>
Index: branches/Operator Architecture Refactoring/HeuristicLab.SequentialEngine/3.2/SequentialEngine.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.SequentialEngine/3.2/SequentialEngine.cs	(revision 1994)
+++ branches/Operator Architecture Refactoring/HeuristicLab.SequentialEngine/3.2/SequentialEngine.cs	(revision 2027)
@@ -75,5 +75,5 @@
         try {
           currentOperator = atomicOperation.Operator;
-          next = atomicOperation.Operator.Execute(atomicOperation.Scope);
+          next = atomicOperation.Operator.Execute(atomicOperation.Environment, atomicOperation.Scope);
         }
         catch (Exception ex) {
