Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/Encoding.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/Encoding.cs	(revision 11546)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/Encoding.cs	(revision 11550)
@@ -41,6 +41,11 @@
     protected Encoding(string name) : base(name) { }
 
-    public virtual IEnumerable<IValueParameter> EncodingParameters {
+    public virtual IEnumerable<IValueParameter> Parameters {
       get { return Enumerable.Empty<IValueParameter>(); }
+    }
+
+    public virtual IEnumerable<IOperator> Operators {
+      get { return Enumerable.Empty<IOperator>(); }
+      protected set { }
     }
 
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/RealEncoding.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/RealEncoding.cs	(revision 11546)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/RealEncoding.cs	(revision 11550)
@@ -24,4 +24,5 @@
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using System.Text;
 using HeuristicLab.Common;
@@ -38,5 +39,5 @@
   [StorableClass]
   public sealed class RealEncoding : Encoding {
-
+    #region Encoding Parameters
     [Storable]
     private IFixedValueParameter<IntValue> lengthParameter;
@@ -63,6 +64,18 @@
     }
 
-    public override IEnumerable<IValueParameter> EncodingParameters {
-      get { return base.EncodingParameters.Concat(new IValueParameter[] { LengthParameter, BoundsParameter }); }
+    public override IEnumerable<IValueParameter> Parameters {
+      get { return base.Parameters.Concat(new IValueParameter[] { LengthParameter, BoundsParameter }); }
+    }
+    #endregion
+
+    private List<IOperator> encodingOperators = new List<IOperator>();
+    [Storable]
+    public override IEnumerable<IOperator> Operators {
+      get { return encodingOperators; }
+      protected set { encodingOperators = new List<IOperator>(value); }
+    }
+
+    public IRealVectorCreator DefaultSolutionCreator {
+      get { return Operators.OfType<UniformRandomRealVectorCreator>().First(); }
     }
 
@@ -76,13 +89,5 @@
     }
 
-    public IRealVectorCreator DefaultSolutionCreator {
-      get {
-        var creator = new UniformRandomRealVectorCreator();
-        creator.RealVectorParameter.ActualName = Name;
-        creator.LengthParameter.ActualName = LengthParameter.Name;
-        creator.BoundsParameter.ActualName = BoundsParameter.Name;
-        return creator;
-      }
-    }
+
 
     [StorableConstructor]
@@ -91,4 +96,5 @@
     private void AfterDeserialization() {
       RegisterParameterEvents();
+      DiscoverOperators();
     }
 
@@ -98,6 +104,9 @@
       lengthParameter = cloner.Clone(original.lengthParameter);
       boundsParameter = cloner.Clone(original.boundsParameter);
+      encodingOperators = original.Operators.Select(cloner.Clone).ToList();
       RegisterParameterEvents();
     }
+
+
 
     public RealEncoding(string name, int length, double min, double max)
@@ -112,4 +121,5 @@
       boundsParameter = new ValueParameter<DoubleMatrix>(Name + "Bounds", bounds);
       RegisterParameterEvents();
+      DiscoverOperators();
     }
 
@@ -128,42 +138,55 @@
       boundsParameter = new ValueParameter<DoubleMatrix>(Name + "Bounds", bounds);
       RegisterParameterEvents();
+      DiscoverOperators();
     }
 
     private void OnLengthParameterChanged() {
       RegisterLengthParameterEvents();
+      ConfigureOperators(Operators);
     }
     private void OnBoundsParameterChanged() {
       RegisterBoundsParameterEvents();
-    }
-    private void RegisterParameterEvents()
-    {
+      ConfigureOperators(Operators);
+    }
+    private void RegisterParameterEvents() {
       RegisterLengthParameterEvents();
       RegisterBoundsParameterEvents();
     }
     private void RegisterLengthParameterEvents() {
-      //TODO fire correct event
-      LengthParameter.ValueChanged += (o, s) => ConfigureOperators(Enumerable.Empty<IOperator>());
-      LengthParameter.Value.ValueChanged += (o, s) => ConfigureOperators(Enumerable.Empty<IOperator>());
+      LengthParameter.ValueChanged += (o, s) => ConfigureOperators(Operators);
+      LengthParameter.Value.ValueChanged += (o, s) => ConfigureOperators(Operators);
     }
     private void RegisterBoundsParameterEvents() {
-      //TODO fire correct event
-      BoundsParameter.ValueChanged += (o, s) => ConfigureOperators(Enumerable.Empty<IOperator>());
-      boundsParameter.Value.ToStringChanged += (o, s) => ConfigureOperators(Enumerable.Empty<IOperator>());
-    }
-
-    public void DiscoverOperators() {
-      var types = new List<Type>()
-      {
+      BoundsParameter.ValueChanged += (o, s) => ConfigureOperators(Operators);
+      boundsParameter.Value.ToStringChanged += (o, s) => ConfigureOperators(Operators);
+    }
+
+    #region Operator Discovery
+    private static readonly IEnumerable<Type> encodingSpecificOperatorTypes;
+    static RealEncoding() {
+      encodingSpecificOperatorTypes = new List<Type>() {
         typeof (IRealVectorCreator),
         typeof (IRealVectorCrossover),
         typeof (IRealVectorManipulator),
         typeof (IRealVectorStdDevStrategyParameterOperator),
+        typeof (IRealVectorSwarmUpdater),
         typeof (IRealVectorParticleCreator),
         typeof (IRealVectorParticleUpdater),
-        typeof (IRealVectorParticleUpdater),
+        typeof (IRealVectorMultiNeighborhoodShakingOperator),
+        typeof (IRealVectorBoundsChecker),
+        typeof (IRealVectorMoveOperator),
+        typeof (IRealVectorMoveGenerator)
       };
-      var discoveredTypes = ApplicationManager.Manager.GetTypes(types, true, false, false);
-      var operators = discoveredTypes.Select(t => (IOperator)Activator.CreateInstance(t)).ToList();
-    }
+    }
+    private void DiscoverOperators() {
+      var pluginDescription = ApplicationManager.Manager.GetDeclaringPlugin(typeof(IRealVectorOperator));
+      var discoveredTypes = ApplicationManager.Manager.GetTypes(encodingSpecificOperatorTypes, pluginDescription, true, false, false);
+      var operators = discoveredTypes.Select(t => (IOperator)Activator.CreateInstance(t));
+      var newOperators = operators.Except(encodingOperators, new TypeEqualityComparer<IOperator>()).ToList();
+
+      ConfigureOperators(newOperators);
+      encodingOperators.AddRange(newOperators);
+    }
+    #endregion
 
     public void ConfigureOperators(IEnumerable<IOperator> operators) {
@@ -176,6 +199,10 @@
       ConfigureParticleUpdaters(operators.OfType<IRealVectorParticleUpdater>());
       ConfigureShakingOperators(operators.OfType<IRealVectorMultiNeighborhoodShakingOperator>());
-    }
-
+      ConfigureBoundsCheckers(operators.OfType<IRealVectorBoundsChecker>());
+      ConfigureMoveOperators(operators.OfType<IRealVectorMoveOperator>());
+      ConfigureMoveGenerators(operators.OfType<IRealVectorMoveGenerator>());
+    }
+
+    #region Specific Operator Wiring
     private void ConfigureCreators(IEnumerable<IRealVectorCreator> creators) {
       foreach (var creator in creators) {
@@ -260,4 +287,20 @@
       }
     }
+    private void ConfigureBoundsCheckers(IEnumerable<IRealVectorBoundsChecker> boundsCheckers) {
+      foreach (var boundsChecker in boundsCheckers) {
+        boundsChecker.RealVectorParameter.ActualName = Name;
+        boundsChecker.BoundsParameter.ActualName = BoundsParameter.Name;
+      }
+    }
+    private void ConfigureMoveOperators(IEnumerable<IRealVectorMoveOperator> moveOperators) {
+      foreach (var moveOperator in moveOperators)
+        moveOperator.RealVectorParameter.ActualName = Name;
+    }
+
+    private void ConfigureMoveGenerators(IEnumerable<IRealVectorMoveGenerator> moveGenerators) {
+      foreach (var moveGenerator in moveGenerators)
+        moveGenerator.BoundsParameter.ActualName = BoundsParameter.Name;
+    }
+    #endregion
   }
 }
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Interfaces/IEncoding.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Interfaces/IEncoding.cs	(revision 11546)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Interfaces/IEncoding.cs	(revision 11550)
@@ -27,6 +27,8 @@
 
 namespace HeuristicLab.Problems.Programmable {
-  interface IEncoding : INamedItem {
+  public interface IEncoding : INamedItem {
 
+    IEnumerable<IValueParameter> Parameters { get; }
+    IEnumerable<IOperator> Operators { get; }
     //event EventHandler ParameterConfigurationChanged;
   }
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Interfaces/IProblemDefinition.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Interfaces/IProblemDefinition.cs	(revision 11546)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Interfaces/IProblemDefinition.cs	(revision 11550)
@@ -26,5 +26,5 @@
 namespace HeuristicLab.Problems.Programmable {
   public interface IProblemDefinition : INamedItem {
-    Encoding Encoding { get; }
+    IEncoding Encoding { get; }
     IEnumerable<Individual> GetNeighbors(IRandom random, Individual individual);
 
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProblemScript.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProblemScript.cs	(revision 11546)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProblemScript.cs	(revision 11550)
@@ -124,5 +124,5 @@
     }
 
-    Encoding IProblemDefinition.Encoding {
+    IEncoding IProblemDefinition.Encoding {
       get { return Instance != null ? Instance.Encoding : null; }
     }
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProgrammableProblem.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProgrammableProblem.cs	(revision 11546)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProgrammableProblem.cs	(revision 11550)
@@ -58,6 +58,6 @@
     }
 
-    protected IValueParameter<Encoding> EncodingParameter {
-      get { return (IValueParameter<Encoding>)Parameters["Encoding"]; }
+    protected IValueParameter<IEncoding> EncodingParameter {
+      get { return (IValueParameter<IEncoding>)Parameters["Encoding"]; }
     }
 
@@ -80,5 +80,5 @@
       : base(new MultiObjectiveEvaluator(), new MultiEncodingCreator()) {
       Parameters.Add(new ValueParameter<IMultiObjectiveProblemDefinition>("ProblemDefinition", "Defines the problem.", new MultiObjectiveProblemScript() { Name = Name }));
-      Parameters.Add(new ValueParameter<Encoding>("Encoding", "Describes which parameters exist, what they're called, what type they are and their bounds if any."));
+      Parameters.Add(new ValueParameter<IEncoding>("Encoding", "Describes which parameters exist, what they're called, what type they are and their bounds if any."));
 
       DynamicEncodingParameters = new List<IParameter>();
@@ -140,5 +140,5 @@
       if (definition == null) return;
 
-      Encoding encoding = definition.Encoding;
+      IEncoding encoding = definition.Encoding;
       EncodingParameter.Value = encoding;
       Maximization = new BoolArray(definition.Maximization);
@@ -175,5 +175,5 @@
     }
 
-    protected virtual ISolutionCreator ConfigureCreator(Encoding encoding) {
+    protected virtual ISolutionCreator ConfigureCreator(IEncoding encoding) {
       #region Configure MultiEncoding Creator
       var multiEncoding = encoding as MultiEncoding;
@@ -217,5 +217,5 @@
       var realEnc = encoding as RealEncoding;
       if (realEnc != null) {
-        DynamicEncodingParameters.AddRange(realEnc.EncodingParameters);
+        DynamicEncodingParameters.AddRange(realEnc.Parameters);
         return realEnc.DefaultSolutionCreator;
       }
@@ -237,5 +237,5 @@
     }
 
-    protected virtual void ConfigureSingleEncodingOperators(ISolutionCreator newCreator, Encoding encoding) {
+    protected virtual void ConfigureSingleEncodingOperators(ISolutionCreator newCreator, IEncoding encoding) {
       // remove all multiencoding operators
       Operators.RemoveAll(x => x is MultiEncodingCrossover
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/ProblemDefinition.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/ProblemDefinition.cs	(revision 11546)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/ProblemDefinition.cs	(revision 11550)
@@ -31,6 +31,6 @@
   public abstract class ProblemDefinition : NamedItem, IProblemDefinition {
     [Storable(Name = "Encoding")]
-    private Encoding encoding;
-    public Encoding Encoding {
+    private IEncoding encoding;
+    public IEncoding Encoding {
       get { return encoding; }
       protected set {
@@ -48,7 +48,7 @@
       this.encoding = cloner.Clone(original.encoding);
     }
-    protected ProblemDefinition(Encoding encoding) : this(encoding, "ProblemDefinition") { }
-    protected ProblemDefinition(Encoding encoding, string name) : this(encoding, name, string.Empty) { }
-    protected ProblemDefinition(Encoding encoding, string name, string description)
+    protected ProblemDefinition(IEncoding encoding) : this(encoding, "ProblemDefinition") { }
+    protected ProblemDefinition(IEncoding encoding, string name) : this(encoding, name, string.Empty) { }
+    protected ProblemDefinition(IEncoding encoding, string name, string description)
       : base(name, description) {
       Encoding = encoding;
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProblemScript.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProblemScript.cs	(revision 11546)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProblemScript.cs	(revision 11550)
@@ -122,5 +122,5 @@
     }
 
-    Encoding IProblemDefinition.Encoding {
+    IEncoding IProblemDefinition.Encoding {
       get { return Instance != null ? Instance.Encoding : null; }
     }
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProgrammableProblem.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProgrammableProblem.cs	(revision 11546)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProgrammableProblem.cs	(revision 11550)
@@ -59,7 +59,8 @@
     }
 
-    protected IValueParameter<Encoding> EncodingParameter {
-      get { return (IValueParameter<Encoding>)Parameters["Encoding"]; }
-    }
+    protected IValueParameter<IEncoding> EncodingParameter {
+      get { return (IValueParameter<IEncoding>)Parameters["Encoding"]; }
+    }
+
 
     public ISingleObjectiveProblemDefinition ProblemDefinition {
@@ -70,4 +71,9 @@
     [Storable]
     protected List<IParameter> DynamicEncodingParameters;
+
+    protected override IEnumerable<IItem> GetOperators() {
+      return base.GetOperators().Concat(ProblemDefinition.Encoding.Operators);
+    }
+
 
     [StorableConstructor]
@@ -82,5 +88,5 @@
       : base(new SingleObjectiveEvaluator(), new MultiEncodingCreator()) {
       Parameters.Add(new ValueParameter<ISingleObjectiveProblemDefinition>("ProblemDefinition", "Defines the problem.", new SingleObjectiveProblemScript() { Name = Name }));
-      Parameters.Add(new ValueParameter<Encoding>("Encoding", "Describes the configuration of the encoding, what the variables are called, what type they are and their bounds if any."));
+      Parameters.Add(new ValueParameter<IEncoding>("Encoding", "Describes the configuration of the encoding, what the variables are called, what type they are and their bounds if any."));
 
       DynamicEncodingParameters = new List<IParameter>();
@@ -143,5 +149,5 @@
       if (definition == null) return;
 
-      Encoding encoding = definition.Encoding;
+      IEncoding encoding = definition.Encoding;
 
       EncodingParameter.Value = encoding;
@@ -181,9 +187,9 @@
     }
 
-    protected virtual ISolutionCreator ConfigureCreator(Encoding encoding) {
+    protected virtual ISolutionCreator ConfigureCreator(IEncoding encoding) {
       #region Configure RealVector Creator
       var realEnc = encoding as RealEncoding;
       if (realEnc != null) {
-        DynamicEncodingParameters.AddRange(realEnc.EncodingParameters);
+        DynamicEncodingParameters.AddRange(realEnc.Parameters);
         return realEnc.DefaultSolutionCreator;
       }
@@ -244,10 +250,9 @@
 
 
-    private IEnumerable<IOperator> GetDiscoveredOperators<T>() where T : class,IOperator
-    {
-        return ApplicationManager.Manager.GetInstances<T>()
-            .Except(Operators.OfType<T>(), new TypeEqualityComparer<T>());
-    }
-    protected virtual void ConfigureSingleEncodingOperators(ISolutionCreator newCreator, Encoding encoding) {
+    private IEnumerable<IOperator> GetDiscoveredOperators<T>() where T : class,IOperator {
+      return ApplicationManager.Manager.GetInstances<T>()
+          .Except(Operators.OfType<T>(), new TypeEqualityComparer<T>());
+    }
+    protected virtual void ConfigureSingleEncodingOperators(ISolutionCreator newCreator, IEncoding encoding) {
       // remove all multiencoding operators
       Operators.RemoveAll(x => x is MultiEncodingCrossover
@@ -266,29 +271,10 @@
           Operators.Remove(SolutionCreator);
           SolutionCreator = newCreator;
-          Operators.Add(SolutionCreator);
-        }
-
-        Operators.AddRange(GetDiscoveredOperators<IRealVectorCrossover>());
-        Operators.AddRange(GetDiscoveredOperators<IRealVectorManipulator>());
-        Operators.AddRange(GetDiscoveredOperators<IRealVectorStdDevStrategyParameterOperator>());
-        Operators.AddRange(GetDiscoveredOperators<IRealVectorParticleCreator>());
-        Operators.AddRange(GetDiscoveredOperators<IRealVectorParticleUpdater>());
-        Operators.AddRange(GetDiscoveredOperators<IRealVectorSwarmUpdater>());
-        Operators.AddRange(GetDiscoveredOperators<IRealVectorMultiNeighborhoodShakingOperator>());
-
-        foreach (var su in Operators.OfType<IRealVectorSwarmUpdater>()) {
+        }
+
+        foreach (var su in realEncoding.Operators.OfType<IRealVectorSwarmUpdater>()) {
           su.MaximizationParameter.ActualName = MaximizationParameter.Name;
         }
-        realEncoding.ConfigureOperators(Operators.OfType<IOperator>());
-      
-      } else {
-        Operators.RemoveAll(x => x is IRealVectorCrossover
-          || x is IRealVectorManipulator
-          || x is IRealVectorStdDevStrategyParameterOperator
-          || x is IRealVectorParticleCreator
-          || x is IRealVectorParticleUpdater
-          || x is IRealVectorSwarmUpdater
-          || x is IRealVectorMultiNeighborhoodShakingOperator);
-      }
+      } 
       #endregion
       #region Configure Operators for BinaryVectorEncoding
