ab-split 1.0.0

data/lib/split/dashboard/views/_controls.erb

@@ -0,0 +1,18 @@
+<% if experiment.has_winner? %>
+  <form action="<%= url "/reopen?experiment=#{experiment.name}" %>" method='post' onclick="return confirmReopen()">
+    <input type="submit" value="Reopen Experiment">
+  </form>
+<% end %>
+<% if experiment.start_time %>
+  <form action="<%= url "/reset?experiment=#{experiment.name}" %>" method='post' onclick="return confirmReset()">
+    <input type="submit" value="Reset Data">
+  </form>
+<% else%>
+  <form action="<%= url "/start?experiment=#{experiment.name}" %>" method='post'>
+    <input type="submit" value="Start">
+  </form>
+<% end %>
+<form action="<%= url "/experiment?experiment=#{experiment.name}" %>" method='post' onclick="return confirmDelete()">
+  <input type="hidden" name="_method" value="delete"/>
+  <input type="submit" value="Delete" class="red">
+</form>

data/lib/split/dashboard/views/_experiment.erb

@@ -0,0 +1,155 @@
+<% unless goal.nil? %>
+  <% experiment_class = "experiment experiment_with_goal" %>
+<% else %>
+  <% experiment_class = "experiment" %>
+<% end %>
+
+<% experiment.calc_winning_alternatives %>
+<%
+  extra_columns = []
+  experiment.alternatives.each do |alternative|
+    extra_info = alternative.extra_info || {}
+    extra_columns += extra_info.keys
+  end
+
+  extra_columns.uniq!
+  summary_texts = {}
+  extra_columns.each do |column|
+    extra_infos = experiment.alternatives.map(&:extra_info).select{|extra_info| extra_info && extra_info[column] }
+    if extra_infos[0][column].kind_of?(Numeric)
+      summary_texts[column] = extra_infos.inject(0){|sum, extra_info| sum += extra_info[column]}
+    else
+      summary_texts[column] = "N/A"
+    end
+  end
+%>
+
+
+<div class="<%= experiment_class %>" data-name="<%= experiment.name %>" data-complete="<%= experiment.has_winner? %>">
+  <div class="experiment-header">
+    <h2>
+      Experiment: <%= experiment.name %>
+      <% if experiment.version > 1 %><span class='version'>v<%= experiment.version %></span><% end %>
+      <% unless goal.nil? %><span class='goal'>Goal:<%= goal %></span><% end %>
+      <% metrics = @metrics.select {|metric| metric.experiments.include? experiment} %>
+      <% unless metrics.empty? %>
+        <span class='goal'>Metrics:<%= metrics.map(&:name).join(', ') %></span>
+      <% end %>
+    </h2>
+
+    <% if goal.nil? %>
+      <div class='inline-controls'>
+        <small><%= experiment.start_time ? experiment.start_time.strftime('%Y-%m-%d') : 'Unknown' %></small>
+        <%= erb :_controls, :locals => {:experiment => experiment} %>
+      </div>
+    <% end %>
+  </div>
+  <table>
+    <tr>
+      <th>Alternative Name</th>
+      <th>Participants</th>
+      <th>Non-finished</th>
+      <th>Completed</th>
+      <th>Conversion Rate</th>
+      <% extra_columns.each do |column| %>
+        <th><%= column %></th>
+      <% end %>
+      <th>
+        <form>
+          <select id="dropdown-<%=experiment.jstring(goal)%>" name="dropdown-<%=experiment.jstring(goal)%>">
+            <option value="confidence-<%=experiment.jstring(goal)%>">Confidence</option>
+            <option value="probability-<%=experiment.jstring(goal)%>">Probability of being Winner</option>
+          </select>
+        </form>
+      </th>
+      <th>Finish</th>
+    </tr>
+
+    <% total_participants = total_completed = total_unfinished = 0 %>
+    <% experiment.alternatives.each do |alternative| %>
+      <tr>
+        <td>
+          <%= alternative.name %>
+          <% if alternative.control? %>
+            <em>control</em>
+          <% end %>
+          <form action="<%= url('force_alternative') + '?experiment=' + experiment.name %>" method='post'>
+            <input type='hidden' name='alternative' value='<%= h alternative.name %>'>
+            <input type="submit" value="Force for current user" class="green">
+          </form>
+        </td>
+        <td><%= alternative.participant_count %></td>
+        <td><%= alternative.unfinished_count %></td>
+        <td><%= alternative.completed_count(goal) %></td>
+        <td>
+          <%= number_to_percentage(alternative.conversion_rate(goal)) %>%
+          <% if experiment.control.conversion_rate(goal) > 0 && !alternative.control? %>
+            <% if alternative.conversion_rate(goal) > experiment.control.conversion_rate(goal) %>
+              <span class='better'>
+                +<%= number_to_percentage((alternative.conversion_rate(goal)/experiment.control.conversion_rate(goal))-1) %>%
+              </span>
+            <% elsif alternative.conversion_rate(goal) < experiment.control.conversion_rate(goal) %>
+              <span class='worse'>
+                <%= number_to_percentage((alternative.conversion_rate(goal)/experiment.control.conversion_rate(goal))-1) %>%
+              </span>
+            <% end  %>
+          <% end %>
+        </td>
+        <script type="text/javascript" id="sourcecode">
+          $(document).ready(function(){
+            $('.probability-<%=experiment.jstring(goal)%>').hide();
+            $('#dropdown-<%=experiment.jstring(goal)%>').change(function() {
+              $('.box-<%=experiment.jstring(goal)%>').hide();
+              $('.' + $(this).val()).show();
+            });
+          });
+        </script>
+        <% extra_columns.each do |column| %>
+          <td><%= alternative.extra_info && alternative.extra_info[column] %></td>
+        <% end %>
+        <td>
+          <div class="box-<%=experiment.jstring(goal)%> confidence-<%=experiment.jstring(goal)%>">
+            <span title='z-score: <%= round(alternative.z_score(goal), 3) %>'><%= confidence_level(alternative.z_score(goal)) %></span>
+            <br>
+          </div>
+          <div class="box-<%=experiment.jstring(goal)%> probability-<%=experiment.jstring(goal)%>">
+            <span title="p_winner: <%= round(alternative.p_winner(goal), 3) %>"><%= number_to_percentage(round(alternative.p_winner(goal), 3)) %>%</span>
+          </div>
+        </td>
+        <td>
+          <% if experiment.has_winner? %>
+            <% if experiment.winner.name == alternative.name %>
+              Winner
+            <% else %>
+              Loser
+            <% end %>
+          <% else %>
+            <form action="<%= url('experiment') + '?experiment=' + experiment.name %>" method='post' onclick="return confirmWinner()">
+              <input type='hidden' name='alternative' value='<%= h alternative.name %>'>
+              <input type="submit" value="Use this" class="green">
+            </form>
+          <% end %>
+        </td>
+      </tr>
+
+      <% total_participants += alternative.participant_count %>
+      <% total_unfinished += alternative.unfinished_count %>
+      <% total_completed += alternative.completed_count(goal) %>
+    <% end %>
+
+    <tr class="totals">
+      <td>Totals</td>
+      <td><%= total_participants %></td>
+      <td><%= total_unfinished %></td>
+      <td><%= total_completed %></td>
+      <td>N/A</td>
+      <% extra_columns.each do |column| %>
+        <td>
+          <%= summary_texts[column] %>
+        </td>
+      <% end %>
+      <td>N/A</td>
+      <td>N/A</td>
+    </tr>
+  </table>
+</div>

data/lib/split/dashboard/views/_experiment_with_goal_header.erb

@@ -0,0 +1,8 @@
+<div class="experiment">
+  <div class="experiment-header">
+      <div class='inline-controls'>
+        <small><%= experiment.start_time ? experiment.start_time.strftime('%Y-%m-%d') : 'Unknown' %></small>
+        <%= erb :_controls, :locals => {:experiment => experiment} %>
+      </div>
+  </div>
+</div>

data/lib/split/dashboard/views/index.erb

@@ -0,0 +1,26 @@
+<% if @experiments.any? %>
+  <p class="intro">The list below contains all the registered experiments along with the number of test participants, completed and conversion rate currently in the system.</p>
+
+  <input type="text" placeholder="Begin typing to filter" id="filter" />
+  <input type="button" id="toggle-completed" value="Hide completed" />
+  <input type="button" id="toggle-active" value="Hide active" />
+  <input type="button" id="clear-filter" value="Clear filters" />
+
+  <% paginated(@experiments).each do |experiment| %>
+    <% if experiment.goals.empty? %>
+      <%= erb :_experiment, :locals => {:goal => nil, :experiment => experiment} %>
+    <% else %>
+      <%= erb :_experiment_with_goal_header, :locals => {:experiment => experiment} %>
+      <% experiment.goals.each do |g| %>
+        <%= erb :_experiment, :locals => {:goal => g, :experiment => experiment} %>
+      <% end %>
+    <% end %>
+  <% end %>
+
+  <div class="pagination">
+    <%= pagination(@experiments) %>
+  </div>
+<% else %>
+  <p class="intro">No experiments have started yet, you need to define them in your code and introduce them to your users.</p>
+  <p class="intro">Check out the <a href='https://github.com/splitrb/split#readme'>Readme</a> for more help getting started.</p>
+<% end %>

data/lib/split/dashboard/views/layout.erb

@@ -0,0 +1,27 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta content='text/html; charset=utf-8' http-equiv='Content-Type'>
+<link href="<%= url 'reset.css' %>" media="screen" rel="stylesheet" type="text/css">
+<link href="<%= url 'style.css' %>" media="screen" rel="stylesheet" type="text/css">
+<script type="text/javascript" src='<%= url 'dashboard.js' %>'></script>
+<script type="text/javascript" src='<%= url 'jquery-1.11.1.min.js' %>'></script>
+<script type="text/javascript" src='<%= url 'dashboard-filtering.js' %>'></script>
+<title>Split</title>
+
+</head>
+<body>
+  <div class="header">
+    <h1>Split Dashboard</h1>
+    <p class="environment"><%= @current_env %></p>
+  </div>
+
+  <div id="main">
+    <%= yield %>
+  </div>
+
+  <div id="footer">
+    <p>Powered by <a href="https://github.com/splitrb/split">Split</a> v<%=Split::VERSION %></p>
+  </div>
+</body>
+</html>

data/lib/split/encapsulated_helper.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+require "split/helper"
+
+# Split's helper exposes all kinds of methods we don't want to
+# mix into our model classes.
+#
+# This module exposes only two methods:
+#  - ab_test()
+#  - ab_finished()
+# that can safely be mixed into any class.
+#
+# Passes the instance of the class that it's mixed into to the
+# Split persistence adapter as context.
+#
+module Split
+  module EncapsulatedHelper
+
+    class ContextShim
+      include Split::Helper
+      public :ab_test, :ab_finished
+
+      def initialize(context)
+        @context = context
+      end
+
+      def ab_user
+        @ab_user ||= Split::User.new(@context)
+      end
+    end
+
+    def ab_test(*arguments,&block)
+      split_context_shim.ab_test(*arguments,&block)
+    end
+
+    private
+
+    # instantiate and memoize a context shim in case of multiple ab_test* calls
+    def split_context_shim
+      @split_context_shim ||= ContextShim.new(self)
+    end
+  end
+end

data/lib/split/engine.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+module Split
+  class Engine < ::Rails::Engine
+    initializer "split" do |app|
+      if Split.configuration.include_rails_helper
+        ActiveSupport.on_load(:action_controller) do
+          ::ActionController::Base.send :include, Split::Helper
+          ::ActionController::Base.helper Split::Helper
+          ::ActionController::Base.send :include, Split::CombinedExperimentsHelper
+          ::ActionController::Base.helper Split::CombinedExperimentsHelper
+        end
+      end
+    end
+  end
+end

data/lib/split/exceptions.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module Split
+  class InvalidPersistenceAdapterError < StandardError; end
+  class ExperimentNotFound < StandardError; end
+  class InvalidExperimentsFormatError < StandardError; end
+end

data/lib/split/experiment.rb

@@ -0,0 +1,486 @@
+# frozen_string_literal: true
+module Split
+  class Experiment
+    attr_accessor :name
+    attr_accessor :goals
+    attr_accessor :alternative_probabilities
+    attr_accessor :metadata
+
+    attr_reader :alternatives
+    attr_reader :resettable
+
+    DEFAULT_OPTIONS = {
+      :resettable => true
+    }
+
+    def initialize(name, options = {})
+      options = DEFAULT_OPTIONS.merge(options)
+
+      @name = name.to_s
+
+      alternatives = extract_alternatives_from_options(options)
+
+      if alternatives.empty? && (exp_config = Split.configuration.experiment_for(name))
+        options = {
+          alternatives: load_alternatives_from_configuration,
+          goals: Split::GoalsCollection.new(@name).load_from_configuration,
+          metadata: load_metadata_from_configuration,
+          resettable: exp_config[:resettable],
+          algorithm: exp_config[:algorithm]
+        }
+      else
+        options[:alternatives] = alternatives
+      end
+
+      set_alternatives_and_options(options)
+    end
+
+    def self.finished_key(key)
+      "#{key}:finished"
+    end
+
+    def set_alternatives_and_options(options)
+      options_with_defaults = DEFAULT_OPTIONS.merge(
+        options.reject { |k, v| v.nil? }
+      )
+
+      self.alternatives = options_with_defaults[:alternatives]
+      self.goals = options_with_defaults[:goals]
+      self.resettable = options_with_defaults[:resettable]
+      self.algorithm = options_with_defaults[:algorithm]
+      self.metadata = options_with_defaults[:metadata]
+    end
+
+    def extract_alternatives_from_options(options)
+      alts = options[:alternatives] || []
+
+      if alts.length == 1
+        if alts[0].is_a? Hash
+          alts = alts[0].map{|k,v| {k => v} }
+        end
+      end
+
+      if alts.empty?
+        exp_config = Split.configuration.experiment_for(name)
+        if exp_config
+          alts = load_alternatives_from_configuration
+          options[:goals] = Split::GoalsCollection.new(@name).load_from_configuration
+          options[:metadata] = load_metadata_from_configuration
+          options[:resettable] = exp_config[:resettable]
+          options[:algorithm] = exp_config[:algorithm]
+        end
+      end
+
+      options[:alternatives] = alts
+
+      set_alternatives_and_options(options)
+
+      # calculate probability that each alternative is the winner
+      @alternative_probabilities = {}
+      alts
+    end
+
+    def save
+      validate!
+
+      if new_record?
+        start unless Split.configuration.start_manually
+        persist_experiment_configuration
+      elsif experiment_configuration_has_changed?
+        reset unless Split.configuration.reset_manually
+        persist_experiment_configuration
+      end
+
+      redis.hset(experiment_config_key, :resettable, resettable)
+      redis.hset(experiment_config_key, :algorithm, algorithm.to_s)
+      self
+    end
+
+    def validate!
+      if @alternatives.empty? && Split.configuration.experiment_for(@name).nil?
+        raise ExperimentNotFound.new("Experiment #{@name} not found")
+      end
+      @alternatives.each {|a| a.validate! }
+      goals_collection.validate!
+    end
+
+    def new_record?
+      !redis.exists(name)
+    end
+
+    def ==(obj)
+      self.name == obj.name
+    end
+
+    def [](name)
+      alternatives.find{|a| a.name == name}
+    end
+
+    def algorithm
+      @algorithm ||= Split.configuration.algorithm
+    end
+
+    def algorithm=(algorithm)
+      @algorithm = algorithm.is_a?(String) ? algorithm.constantize : algorithm
+    end
+
+    def resettable=(resettable)
+      @resettable = resettable.is_a?(String) ? resettable == 'true' : resettable
+    end
+
+    def alternatives=(alts)
+      @alternatives = alts.map do |alternative|
+        if alternative.kind_of?(Split::Alternative)
+          alternative
+        else
+          Split::Alternative.new(alternative, @name)
+        end
+      end
+    end
+
+    def winner
+      experiment_winner = redis.hget(:experiment_winner, name)
+      if experiment_winner
+        Split::Alternative.new(experiment_winner, name)
+      else
+        nil
+      end
+    end
+
+    def has_winner?
+      return @has_winner if defined? @has_winner
+      @has_winner = !winner.nil?
+    end
+
+    def winner=(winner_name)
+      redis.hset(:experiment_winner, name, winner_name.to_s)
+      @has_winner = true
+    end
+
+    def participant_count
+      alternatives.inject(0){|sum,a| sum + a.participant_count}
+    end
+
+    def control
+      alternatives.first
+    end
+
+    def reset_winner
+      redis.hdel(:experiment_winner, name)
+      @has_winner = false
+    end
+
+    def start
+      redis.hset(:experiment_start_times, @name, Time.now.to_i)
+    end
+
+    def start_time
+      t = redis.hget(:experiment_start_times, @name)
+      if t
+        # Check if stored time is an integer
+        if t =~ /^[-+]?[0-9]+$/
+          Time.at(t.to_i)
+        else
+          Time.parse(t)
+        end
+      end
+    end
+
+    def next_alternative
+      winner || random_alternative
+    end
+
+    def random_alternative
+      if alternatives.length > 1
+        algorithm.choose_alternative(self)
+      else
+        alternatives.first
+      end
+    end
+
+    def version
+      @version ||= (redis.get("#{name}:version").to_i || 0)
+    end
+
+    def increment_version
+      @version = redis.incr("#{name}:version")
+    end
+
+    def key
+      if version.to_i > 0
+        "#{name}:#{version}"
+      else
+        name
+      end
+    end
+
+    def goals_key
+      "#{name}:goals"
+    end
+
+    def finished_key
+      self.class.finished_key(key)
+    end
+
+    def metadata_key
+      "#{name}:metadata"
+    end
+
+    def resettable?
+      resettable
+    end
+
+    def reset
+      Split.configuration.on_before_experiment_reset.call(self)
+      alternatives.each(&:reset)
+      reset_winner
+      Split.configuration.on_experiment_reset.call(self)
+      increment_version
+    end
+
+    def delete
+      Split.configuration.on_before_experiment_delete.call(self)
+      if Split.configuration.start_manually
+        redis.hdel(:experiment_start_times, @name)
+      end
+      reset_winner
+      redis.srem(:experiments, name)
+      remove_experiment_configuration
+      Split.configuration.on_experiment_delete.call(self)
+      increment_version
+    end
+
+    def delete_metadata
+      redis.del(metadata_key)
+    end
+
+    def load_from_redis
+      exp_config = redis.hgetall(experiment_config_key)
+
+      options = {
+        resettable: exp_config['resettable'],
+        algorithm: exp_config['algorithm'],
+        alternatives: load_alternatives_from_redis,
+        goals: Split::GoalsCollection.new(@name).load_from_redis,
+        metadata: load_metadata_from_redis
+      }
+
+      set_alternatives_and_options(options)
+    end
+
+    def calc_winning_alternatives
+      # Cache the winning alternatives so we recalculate them once per the specified interval.
+      intervals_since_epoch =
+        Time.now.utc.to_i / Split.configuration.winning_alternative_recalculation_interval
+
+      if self.calc_time != intervals_since_epoch
+        if goals.empty?
+          self.estimate_winning_alternative
+        else
+          goals.each do |goal|
+            self.estimate_winning_alternative(goal)
+          end
+        end
+
+        self.calc_time = intervals_since_epoch
+
+        self.save
+      end
+    end
+
+    def estimate_winning_alternative(goal = nil)
+      # initialize a hash of beta distributions based on the alternatives' conversion rates
+      beta_params = calc_beta_params(goal)
+
+      winning_alternatives = []
+
+      Split.configuration.beta_probability_simulations.times do
+        # calculate simulated conversion rates from the beta distributions
+        simulated_cr_hash = calc_simulated_conversion_rates(beta_params)
+
+        winning_alternative = find_simulated_winner(simulated_cr_hash)
+
+        # push the winning pair to the winning_alternatives array
+        winning_alternatives.push(winning_alternative)
+      end
+
+      winning_counts = count_simulated_wins(winning_alternatives)
+
+      @alternative_probabilities = calc_alternative_probabilities(winning_counts, Split.configuration.beta_probability_simulations)
+
+      write_to_alternatives(goal)
+
+      self.save
+    end
+
+    def write_to_alternatives(goal = nil)
+      alternatives.each do |alternative|
+        alternative.set_p_winner(@alternative_probabilities[alternative], goal)
+      end
+    end
+
+    def calc_alternative_probabilities(winning_counts, number_of_simulations)
+      alternative_probabilities = {}
+      winning_counts.each do |alternative, wins|
+        alternative_probabilities[alternative] = wins / number_of_simulations.to_f
+      end
+      return alternative_probabilities
+    end
+
+    def count_simulated_wins(winning_alternatives)
+       # initialize a hash to keep track of winning alternative in simulations
+      winning_counts = {}
+      alternatives.each do |alternative|
+        winning_counts[alternative] = 0
+      end
+      # count number of times each alternative won, calculate probabilities, place in hash
+      winning_alternatives.each do |alternative|
+        winning_counts[alternative] += 1
+      end
+      return winning_counts
+    end
+
+    def find_simulated_winner(simulated_cr_hash)
+      # figure out which alternative had the highest simulated conversion rate
+      winning_pair = ["",0.0]
+      simulated_cr_hash.each do |alternative, rate|
+        if rate > winning_pair[1]
+          winning_pair = [alternative, rate]
+        end
+      end
+      winner = winning_pair[0]
+      return winner
+    end
+
+    def calc_simulated_conversion_rates(beta_params)
+      # initialize a random variable (from which to simulate conversion rates ~beta-distributed)
+      rand = SimpleRandom.new
+      rand.set_seed
+
+      simulated_cr_hash = {}
+
+      # create a hash which has the conversion rate pulled from each alternative's beta distribution
+      beta_params.each do |alternative, params|
+        alpha = params[0]
+        beta = params[1]
+        simulated_conversion_rate = rand.beta(alpha, beta)
+        simulated_cr_hash[alternative] = simulated_conversion_rate
+      end
+
+      return simulated_cr_hash
+    end
+
+    def calc_beta_params(goal = nil)
+      beta_params = {}
+      alternatives.each do |alternative|
+        conversions = goal.nil? ? alternative.completed_count : alternative.completed_count(goal)
+        alpha = 1 + conversions
+        beta = 1 + alternative.participant_count - conversions
+
+        params = [alpha, beta]
+
+        beta_params[alternative] = params
+      end
+      return beta_params
+    end
+
+    def calc_time=(time)
+      redis.hset(experiment_config_key, :calc_time, time)
+    end
+
+    def calc_time
+      redis.hget(experiment_config_key, :calc_time).to_i
+    end
+
+    def jstring(goal = nil)
+      js_id = if goal.nil?
+                name
+              else
+                name + "-" + goal
+              end
+      js_id.gsub('/', '--')
+    end
+
+    protected
+
+    def experiment_config_key
+      "experiment_configurations/#{@name}"
+    end
+
+    def load_metadata_from_configuration
+      Split.configuration.experiment_for(@name)[:metadata]
+    end
+
+    def load_metadata_from_redis
+      meta = redis.get(metadata_key)
+      JSON.parse(meta) unless meta.nil?
+    end
+
+    def load_alternatives_from_configuration
+      alts = Split.configuration.experiment_for(@name)[:alternatives]
+      raise ArgumentError, "Experiment configuration is missing :alternatives array" unless alts
+      if alts.is_a?(Hash)
+        alts.keys
+      else
+        alts.flatten
+      end
+    end
+
+    def load_alternatives_from_redis
+      alternatives = case redis.type(@name)
+                     when 'set' # convert legacy sets to lists
+                       alts = redis.smembers(@name)
+                       redis.del(@name)
+                       alts.reverse.each {|a| redis.lpush(@name, a) }
+                       redis.lrange(@name, 0, -1)
+                     else
+                       redis.lrange(@name, 0, -1)
+                     end
+      alternatives.map do |alt|
+        alt = begin
+                JSON.parse(alt)
+              rescue
+                alt
+              end
+        Split::Alternative.new(alt, @name)
+      end
+    end
+
+    private
+
+    def redis
+      Split.redis
+    end
+
+    def redis_interface
+      RedisInterface.new
+    end
+
+    def persist_experiment_configuration
+      redis_interface.add_to_set(:experiments, name)
+      redis_interface.persist_list(name, @alternatives.map{|alt| {alt.name => alt.weight}.to_json})
+      goals_collection.save
+      redis.set(metadata_key, @metadata.to_json) unless @metadata.nil?
+    end
+
+    def remove_experiment_configuration
+      @alternatives.each(&:delete)
+      goals_collection.delete
+      delete_metadata
+      redis.del(@name)
+    end
+
+    def experiment_configuration_has_changed?
+      existing_alternatives = load_alternatives_from_redis
+      existing_goals = Split::GoalsCollection.new(@name).load_from_redis
+      existing_metadata = load_metadata_from_redis
+      existing_alternatives.map(&:to_s) != @alternatives.map(&:to_s) ||
+        existing_goals != @goals ||
+        existing_metadata != @metadata
+    end
+
+    def goals_collection
+      Split::GoalsCollection.new(@name, @goals)
+    end
+  end
+end