Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable.Views/3.3/ProblemDefinitionScriptView.Designer.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable.Views/3.3/ProblemDefinitionScriptView.Designer.cs	(revision 11866)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable.Views/3.3/ProblemDefinitionScriptView.Designer.cs	(revision 11880)
@@ -142,5 +142,5 @@
       this.Controls.Add(this.splitContainer2);
       this.Name = "ProblemDefinitionScriptView";
-      this.Controls.SetChildIndex(this.compilationLabel, 0);
+      this.Controls.SetChildIndex(this.infoTextLabel, 0);
       this.Controls.SetChildIndex(this.compileButton, 0);
       this.Controls.SetChildIndex(this.splitContainer2, 0);
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/Encoding.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/Encoding.cs	(revision 11866)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/Encoding.cs	(revision 11880)
@@ -52,6 +52,6 @@
         encodingOperators = new HashSet<IOperator>(value, new TypeEqualityComparer<IOperator>());
 
-        T newSolutionCreator = (T)encodingOperators.FirstOrDefault(o => o.GetType() == solutionCreator.GetType());
-        if (newSolutionCreator == null) newSolutionCreator = encodingOperators.OfType<T>().First();
+        T newSolutionCreator = (T)encodingOperators.FirstOrDefault(o => o.GetType() == solutionCreator.GetType()) ??
+                               encodingOperators.OfType<T>().First();
         SolutionCreator = newSolutionCreator;
         OnOperatorsChanged();
@@ -83,8 +83,7 @@
     [StorableConstructor]
     protected Encoding(bool deserializing) : base(deserializing) { }
-
     protected Encoding(Encoding<T> original, Cloner cloner)
       : base(original, cloner) {
-      encodingOperators = new HashSet<IOperator>(original.Operators.Select(cloner.Clone));
+      encodingOperators = new HashSet<IOperator>(original.Operators.Select(cloner.Clone), new TypeEqualityComparer<IOperator>());
       solutionCreator = cloner.Clone(original.solutionCreator);
     }
@@ -97,5 +96,4 @@
     public void ConfigureOperator(IOperator @operator) { ConfigureOperators(new[] { @operator }); }
     public abstract void ConfigureOperators(IEnumerable<IOperator> operators);
-
 
     public event EventHandler SolutionCreatorChanged;
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Interfaces/IMultiObjectiveProblemDefinition.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Interfaces/IMultiObjectiveProblemDefinition.cs	(revision 11866)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Interfaces/IMultiObjectiveProblemDefinition.cs	(revision 11880)
@@ -27,5 +27,5 @@
     bool[] Maximization { get; }
     double[] Evaluate(Individual individual, IRandom random);
-    void Analyze(Individual[] individuals, double[][] qualities, ResultCollection results);
+    void Analyze(Individual[] individuals, double[][] qualities, ResultCollection results, IRandom random);
   }
 }
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Interfaces/ISingleObjectiveProblemDefinition.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Interfaces/ISingleObjectiveProblemDefinition.cs	(revision 11866)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Interfaces/ISingleObjectiveProblemDefinition.cs	(revision 11880)
@@ -28,5 +28,5 @@
     bool Maximization { get; }
     double Evaluate(Individual individual, IRandom random);
-    void Analyze(Individual[] individuals, double[] qualities, ResultCollection results);
+    void Analyze(Individual[] individuals, double[] qualities, ResultCollection results, IRandom random);
     IEnumerable<Individual> GetNeighbors(Individual individual, IRandom random);
   }
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Interfaces/internal/IMultiObjectiveAnalysisOperator.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Interfaces/internal/IMultiObjectiveAnalysisOperator.cs	(revision 11866)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Interfaces/internal/IMultiObjectiveAnalysisOperator.cs	(revision 11880)
@@ -21,9 +21,10 @@
 
 using System;
+using HeuristicLab.Core;
 using HeuristicLab.Optimization;
 
 namespace HeuristicLab.Problems.Programmable {
   internal interface IMultiObjectiveAnalysisOperator : IEncodingOperator, IAnalyzer {
-    Action<Individual[], double[][], ResultCollection> AnalyzeAction { get; set; }
+    Action<Individual[], double[][], ResultCollection, IRandom> AnalyzeAction { get; set; }
   }
 }
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Interfaces/internal/ISingleObjectiveAnalysisOperator.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Interfaces/internal/ISingleObjectiveAnalysisOperator.cs	(revision 11866)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Interfaces/internal/ISingleObjectiveAnalysisOperator.cs	(revision 11880)
@@ -21,9 +21,10 @@
 
 using System;
+using HeuristicLab.Core;
 using HeuristicLab.Optimization;
 
 namespace HeuristicLab.Problems.Programmable {
   internal interface ISingleObjectiveAnalysisOperator : IEncodingOperator {
-    Action<Individual[], double[], ResultCollection> AnalyzeAction { get; set; }
+    Action<Individual[], double[], ResultCollection, IRandom> AnalyzeAction { get; set; }
   }
 }
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/BasicProblem.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/BasicProblem.cs	(revision 11866)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/BasicProblem.cs	(revision 11880)
@@ -139,5 +139,5 @@
 
       var operators = oldOperators.Intersect(newOperators, comparer).Select(op => cloner.Clone(op));
-      operators = operators.Union(newOperators, comparer);
+      operators = operators.Union(newOperators, comparer).ToList();
 
       newEncoding.ConfigureOperators(operators);
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/MultiObjectiveBasicProblem.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/MultiObjectiveBasicProblem.cs	(revision 11866)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/MultiObjectiveBasicProblem.cs	(revision 11880)
@@ -57,5 +57,5 @@
     public abstract bool[] Maximization { get; }
     public abstract double[] Evaluate(Individual individual, IRandom random);
-    public virtual void Analyze(Individual[] individuals, double[][] qualities, ResultCollection results) { }
+    public virtual void Analyze(Individual[] individuals, double[][] qualities, ResultCollection results, IRandom random) { }
 
     protected override void OnEncodingChanged() {
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/MultiObjectiveProgrammableProblem.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/MultiObjectiveProgrammableProblem.cs	(revision 11866)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/MultiObjectiveProgrammableProblem.cs	(revision 11880)
@@ -50,6 +50,5 @@
       try {
         ProblemScript.Compile();
-      }
-      catch (InvalidOperationException) {
+      } catch (InvalidOperationException) {
         //Compilation error
       }
@@ -72,6 +71,5 @@
       try {
         ProblemScript.Compile();
-      }
-      catch (InvalidOperationException) {
+      } catch (InvalidOperationException) {
         //Compilation error
       }
@@ -96,6 +94,6 @@
     }
 
-    public override void Analyze(Individual[] individuals, double[][] qualities, ResultCollection results) {
-      ProblemDefinition.Analyze(individuals, qualities, results);
+    public override void Analyze(Individual[] individuals, double[][] qualities, ResultCollection results, IRandom random) {
+      ProblemDefinition.Analyze(individuals, qualities, results, random);
     }
   }
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/OneMaxNew.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/OneMaxNew.cs	(revision 11866)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/OneMaxNew.cs	(revision 11880)
@@ -55,6 +55,6 @@
     }
 
-    public override void Analyze(Individual[] individuals, double[] qualities, ResultCollection results) {
-      base.Analyze(individuals, qualities, results);
+    public override void Analyze(Individual[] individuals, double[] qualities, ResultCollection results, IRandom random) {
+      base.Analyze(individuals, qualities, results, random);
       var best = individuals.Zip(qualities, (i, q) => new { Individual = i, Quality = q }).OrderByDescending(z => z.Quality).First();
       if (!results.ContainsKey("Best Solution")) {
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/Scripts/MultiObjectiveProblemDefinitionScript.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/Scripts/MultiObjectiveProblemDefinitionScript.cs	(revision 11866)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/Scripts/MultiObjectiveProblemDefinitionScript.cs	(revision 11880)
@@ -60,6 +60,6 @@
     }
 
-    void IMultiObjectiveProblemDefinition.Analyze(Individual[] individuals, double[][] qualities, ResultCollection results) {
-      CompiledProblemDefinition.Analyze(individuals, qualities, results);
+    void IMultiObjectiveProblemDefinition.Analyze(Individual[] individuals, double[][] qualities, ResultCollection results, IRandom random) {
+      CompiledProblemDefinition.Analyze(individuals, qualities, results, random);
     }
   }
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/Scripts/ProblemDefinitionScript.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/Scripts/ProblemDefinitionScript.cs	(revision 11866)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/Scripts/ProblemDefinitionScript.cs	(revision 11880)
@@ -76,7 +76,7 @@
         inst.Initialize();
         CompiledProblemDefinition = inst;
-      }
-      catch {
+      } catch (Exception e) {
         compiledProblemDefinition = null;
+        throw;
       }
       return assembly;
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/Scripts/SingleObjectiveProblemDefinitionScript.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/Scripts/SingleObjectiveProblemDefinitionScript.cs	(revision 11866)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/Scripts/SingleObjectiveProblemDefinitionScript.cs	(revision 11880)
@@ -60,6 +60,6 @@
     }
 
-    void ISingleObjectiveProblemDefinition.Analyze(Individual[] individuals, double[] qualities, ResultCollection results) {
-      CompiledProblemDefinition.Analyze(individuals, qualities, results);
+    void ISingleObjectiveProblemDefinition.Analyze(Individual[] individuals, double[] qualities, ResultCollection results, IRandom random) {
+      CompiledProblemDefinition.Analyze(individuals, qualities, results, random);
     }
     IEnumerable<Individual> ISingleObjectiveProblemDefinition.GetNeighbors(Individual individual, IRandom random) {
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/Scripts/Templates/CompiledMultiObjectiveProblemDefinition.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/Scripts/Templates/CompiledMultiObjectiveProblemDefinition.cs	(revision 11866)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/Scripts/Templates/CompiledMultiObjectiveProblemDefinition.cs	(revision 11880)
@@ -14,4 +14,5 @@
 
     public override void Initialize() {
+      // Use vars.yourVariable to access variables in the variable store i.e. yourVariable
       // Define the solution encoding which can also consist of multiple vectors, examples below
       //Encoding = new BinaryEncoding("b", length: 5);
@@ -19,5 +20,5 @@
       //Encoding = new RealEncoding("r", length: 5, min: -1.0, max: 1.0);
       //Encoding = new PermutationEncoding("p", length: 5, type: PermutationTypes.Absolute);
-
+      // The encoding can also be a combination
       //Encoding = new MultiEncoding()
       //.Add(new BinaryEncoding("b", length: 5))
@@ -26,18 +27,19 @@
       //.Add(new PermutationEncoding("p", length: 5, type: PermutationTypes.Absolute))
       ;
+      // Add additional initialization code e.g. private variables that you need for evaluating
     }
 
     public double[] Evaluate(Individual individual, IRandom random) {
+      // Use vars.yourVariable to access variables in the variable store i.e. yourVariable
       var qualities = new[] { 0.0, 0.0 };
-      // use vars.yourVariable to access variables in the variable store i.e. yourVariable
-      // qualities = new [] { individual.RealVector("r").Sum(x => x * x), individual.RealVector("r").Sum(x => x * x * x) };
+      //qualities = new [] { individual.RealVector("r").Sum(x => x * x), individual.RealVector("r").Sum(x => x * x * x) };
       return qualities;
     }
 
-    public void Analyze(Individual[] individuals, double[][] qualities, ResultCollection results) {
-      // write or update results given the range of vectors and resulting qualities
-      // use e.g. vars.yourVariable to access variables in the variable store i.e. yourVariable
+    public void Analyze(Individual[] individuals, double[][] qualities, ResultCollection results, IRandom random) {
+      // Use vars.yourVariable to access variables in the variable store i.e. yourVariable
+      // Write or update results given the range of vectors and resulting qualities
     }
-    // implement further classes and methods
+    // Implement further classes and methods
   }
 }
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/Scripts/Templates/CompiledSingleObjectiveProblemDefinition.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/Scripts/Templates/CompiledSingleObjectiveProblemDefinition.cs	(revision 11866)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/Scripts/Templates/CompiledSingleObjectiveProblemDefinition.cs	(revision 11880)
@@ -14,10 +14,11 @@
 
     public override void Initialize() {
+      // Use vars.yourVariable to access variables in the variable store i.e. yourVariable
       // Define the solution encoding which can also consist of multiple vectors, examples below
       //Encoding = new BinaryEncoding("b", length: 5);
-      //Encoding = new IntegerEncoding("i", length: 5, min: 2, max: 14, step: 4);
+      //Encoding = new IntegerEncoding("i", length: 5, min: 2, max: 14, step: 2);
       //Encoding = new RealEncoding("r", length: 5, min: -1.0, max: 1.0);
       //Encoding = new PermutationEncoding("p", length: 5, type: PermutationTypes.Absolute);
-
+      // The encoding can also be a combination
       //Encoding = new MultiEncoding()
       //.Add(new BinaryEncoding("b", length: 5))
@@ -25,27 +26,34 @@
       //.Add(new RealEncoding("r", length: 5, min: -1.0, max: 1.0))
       //.Add(new PermutationEncoding("p", length: 5, type: PermutationTypes.Absolute))
-      //;
+      ;
+      // Add additional initialization code e.g. private variables that you need for evaluating
     }
 
     public double Evaluate(Individual individual, IRandom random) {
+      // Use vars.yourVariable to access variables in the variable store i.e. yourVariable
       var quality = 0.0;
-      // use vars.yourVariable to access variables in the variable store i.e. yourVariable
       //quality = individual.RealVector("r").Sum(x => x * x);
       return quality;
     }
 
-    public void Analyze(Individual[] individuals, double[] qualities, ResultCollection results) {
-      // write or update results given the range of vectors and resulting qualities
-      // use e.g. vars.yourVariable to access variables in the variable store i.e. yourVariable
+    public void Analyze(Individual[] individuals, double[] qualities, ResultCollection results, IRandom random) {
+      // Use vars.yourVariable to access variables in the variable store i.e. yourVariable
+      // Write or update results given the range of vectors and resulting qualities
+      // Uncomment the following lines if you want to retrieve the best individual
+      //var bestIndex = Maximization ?
+      //         qualities.Select((v, i) => Tuple.Create(i, v)).OrderByDescending(x => x.Item2).First().Item1
+      //       : qualities.Select((v, i) => Tuple.Create(i, v)).OrderBy(x => x.Item2).First().Item1;
+      //var best = individuals[bestIndex];
     }
 
     public IEnumerable<Individual> GetNeighbors(Individual individual, IRandom random) {
+      // Use vars.yourVariable to access variables in the variable store i.e. yourVariable
       // Create new vectors, based on the given one that represent small changes
-      // This method is only called from move-based algorithms (LocalSearch, SimulatedAnnealing, etc.)
+      // This method is only called from move-based algorithms (Local Search, Simulated Annealing, etc.)
       while (true) {
-        // this is not an infinite loop as only a finite amount of samples will be drawn
-        // it is possible to return a concrete amount of neighbors also
+        // Algorithm will draw only a finite amount of samples
+        // Change to a for-loop to return a concrete amount of neighbors
         var neighbor = individual.Copy();
-        //e.g. make a bit flip in a binary parameter
+        // For instance, perform a single bit-flip in a binary parameter
         //var bIndex = random.Next(neighbor.BinaryVector("b").Length);
         //neighbor.BinaryVector("b")[bIndex] = !neighbor.BinaryVector("b")[bIndex];
@@ -54,5 +62,5 @@
     }
 
-    // implement further classes and methods
+    // Implement further classes and methods
   }
 }
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/SingleObjectiveBasicProblem.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/SingleObjectiveBasicProblem.cs	(revision 11866)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/SingleObjectiveBasicProblem.cs	(revision 11880)
@@ -66,5 +66,5 @@
     public abstract bool Maximization { get; }
     public abstract double Evaluate(Individual individual, IRandom random);
-    public virtual void Analyze(Individual[] individuals, double[] qualities, ResultCollection results) { }
+    public virtual void Analyze(Individual[] individuals, double[] qualities, ResultCollection results, IRandom random) { }
     public virtual IEnumerable<Individual> GetNeighbors(Individual individual, IRandom random) {
       return Enumerable.Empty<Individual>();
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/SingleObjectiveProgrammableProblem.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/SingleObjectiveProgrammableProblem.cs	(revision 11866)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/SingleObjectiveProgrammableProblem.cs	(revision 11880)
@@ -51,6 +51,5 @@
       try {
         ProblemScript.Compile();
-      }
-      catch (InvalidOperationException) {
+      } catch (InvalidOperationException) {
         //Compilation error
       }
@@ -75,6 +74,5 @@
       try {
         ProblemScript.Compile();
-      }
-      catch (InvalidOperationException) {
+      } catch (InvalidOperationException) {
         //Compilation error
       }
@@ -97,6 +95,6 @@
     }
 
-    public override void Analyze(Individual[] individuals, double[] qualities, ResultCollection results) {
-      ProblemDefinition.Analyze(individuals, qualities, results);
+    public override void Analyze(Individual[] individuals, double[] qualities, ResultCollection results, IRandom random) {
+      ProblemDefinition.Analyze(individuals, qualities, results, random);
     }
     public override IEnumerable<Individual> GetNeighbors(Individual individual, IRandom random) {
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/MultiObjectiveAnalyzer.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/MultiObjectiveAnalyzer.cs	(revision 11866)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/MultiObjectiveAnalyzer.cs	(revision 11880)
@@ -13,5 +13,5 @@
   [Item("Multi-objective Analyzer", "Calls the Analyze method of the problem definition.")]
   [StorableClass]
-  public class MultiObjectiveAnalyzer : SingleSuccessorOperator, IMultiObjectiveAnalysisOperator {
+  public class MultiObjectiveAnalyzer : SingleSuccessorOperator, IMultiObjectiveAnalysisOperator, IStochasticOperator {
     public bool EnabledByDefault { get { return true; } }
 
@@ -28,5 +28,9 @@
     }
 
-    public Action<Individual[], double[][], ResultCollection> AnalyzeAction { get; set; }
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public Action<Individual[], double[][], ResultCollection, IRandom> AnalyzeAction { get; set; }
 
     [StorableConstructor]
@@ -47,4 +51,5 @@
       var encoding = EncodingParameter.ActualValue;
       var results = ResultsParameter.ActualValue;
+      var random = RandomParameter.ActualValue;
 
       IEnumerable<IScope> scopes = new[] { ExecutionContext.Scope };
@@ -53,5 +58,5 @@
 
       var individuals = scopes.Select(encoding.GetIndividual).ToArray();
-      AnalyzeAction(individuals, QualitiesParameter.ActualValue.Select(x => x.ToArray()).ToArray(), results);
+      AnalyzeAction(individuals, QualitiesParameter.ActualValue.Select(x => x.ToArray()).ToArray(), results, random);
       return base.Apply();
     }
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveAnalyzer.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveAnalyzer.cs	(revision 11866)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveAnalyzer.cs	(revision 11880)
@@ -13,5 +13,5 @@
   [Item("Single-objective Analyzer", "Calls the script's Analyze method to be able to write into the results collection.")]
   [StorableClass]
-  public sealed class SingleObjectiveAnalyzer : SingleSuccessorOperator, ISingleObjectiveAnalysisOperator, IAnalyzer {
+  public sealed class SingleObjectiveAnalyzer : SingleSuccessorOperator, ISingleObjectiveAnalysisOperator, IAnalyzer, IStochasticOperator {
     public bool EnabledByDefault { get { return true; } }
 
@@ -28,5 +28,9 @@
     }
 
-    public Action<Individual[], double[], ResultCollection> AnalyzeAction { get; set; }
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public Action<Individual[], double[], ResultCollection, IRandom> AnalyzeAction { get; set; }
 
     [StorableConstructor]
@@ -37,4 +41,5 @@
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The quality of the parameter vector."));
       Parameters.Add(new LookupParameter<ResultCollection>("Results", "The results collection to write to."));
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
     }
 
@@ -46,4 +51,5 @@
       var encoding = EncodingParameter.ActualValue;
       var results = ResultsParameter.ActualValue;
+      var random = RandomParameter.ActualValue;
 
       IEnumerable<IScope> scopes = new[] { ExecutionContext.Scope };
@@ -52,5 +58,5 @@
 
       var individuals = scopes.Select(encoding.GetIndividual).ToArray();
-      AnalyzeAction(individuals, QualityParameter.ActualValue.Select(x => x.Value).ToArray(), results);
+      AnalyzeAction(individuals, QualityParameter.ActualValue.Select(x => x.Value).ToArray(), results, random);
       return base.Apply();
     }
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveImprover.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveImprover.cs	(revision 11866)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveImprover.cs	(revision 11880)
@@ -34,5 +34,5 @@
   [Item("Single-objective Improver", "Improves a solution by calling GetNeighbors and Evaluate of the corresponding problem definition.")]
   [StorableClass]
-  public sealed class SingleObjectiveImprover : SingleSuccessorOperator, INeighborBasedOperator, ISingleObjectiveEvaluationOperator, IStochasticOperator {
+  public sealed class SingleObjectiveImprover : SingleSuccessorOperator, INeighborBasedOperator, IImprovementOperator, ISingleObjectiveEvaluationOperator, IStochasticOperator {
     public ILookupParameter<IRandom> RandomParameter {
       get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
