vanity 0.2.2 → 0.3.0

data/CHANGELOG

@@ -1,3 +1,17 @@
+0.3.0 (2009-11-13)
+* Added: score now includes least performing alternatives, names and values.
+* Added: shiny reports.
+* Added: Rails console shows current experiments status and also allows you to
+choose which alternative you want to see.
+* Changed: letters instead of numbers for options (option 1 => option A).
+* Changed: experiment.alternatives is now an immutable snapshot.
+* Changed: experiment.score returns populated alternative objects instead of
+structs.
+* Changed: experiment.chooses uses Redis to store state, better for (when we
+get to) browser integration.
+* Changed: experiment.chooses skips recording participant or conversion.
+* Changed: to MIT license.
+
 0.2.2 (2009-11-12)
 * Added: vanity binary, with single command for generating a report.
 * Added: return alternative by value from experiment.alternative(val) method.

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2009 Assaf Arkin
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README.rdoc

@@ -1,6 +1,8 @@
-Vanity is an Experience Driven-Development framework for Rails.
+Vanity is an Experiment Driven Development framework for Rails.
 
-Requires Ruby 1.9 and Redis 1.0 or later.
+http://farm3.static.flickr.com/2540/4099665871_497f274f68_o.jpg
+
+Requires Ruby 1.9.1 or later, Redis 1.0 or later.
 
 
 == A/B Testing with Rails (in 5 easy steps)
@@ -38,116 +40,13 @@ Measure conversion:
 
 Check the report:
 
-  vanity
-
-
-== A/B Tests
-
-Each A/B experiment represents several (two or more) alternatives.  Use the
-ab_test method to choose an alternative. Call ab_test without a block to return
-the value of the chosen alternative.  Call ab_test with a block to yield with
-the value.
-
-Here are some examples:
-
-  def index
-    if ab_test(:new_page) # classic false/true test
-      render action: "new_page"
-    else
-      render action: "index"
-    end
-  end
-    
-  def index
-    # alternatives are names of templates 
-    render template: ab_test(:new_page)
-  end
-   
-  <%= if ab_test(:banner) %>100% less complexity!<% end %>
-  
-  <%= ab_test(:greeting) %> <%= current_user.name %>
-   
-  <% ab_test :features do |count| %>
-    <%= count %> features to choose from!
-  <% end %>
-
-To measure conversion, call ab_goal! with the experiment's name.  Typically,
-you would do that from a controller action, for example:
-
-  def create
-    ab_goal! :new_page
-    ...
-  end
-
-To measure conversion, simply call ab_goal! with the experiment name.  From the
-Vanity identity set by the filter we know which alternative was presented by
-ab_test, and can correlate conversions to alternative.  It's that simple!
-
-
-== Managing Identity
-
-For effective A/B tests, you want to:
-- Randomly show different alternatives to different people
-- Consistently show the same alternatives to the same person
-- Know which alternative caused a conversion
-- When running multiple tests at once, keep them independent
-
-If you don't use any other mechanism, Vanity will assign a random value to a
-persistent cookie and use it to track the same visitor on subsequent visits.
-Cookie tracking is enabled by use_vanity.
-
-If you keep track of users, you would want to use the user's identity instead.
-Using user identity is more reliable than a cookie tied to a single Web
-browser.
+  vanity --output vanity.html
 
-To do that, call use_vanity with the name of a method which returns an object
-with the desired id attribute.  Alternatively, you can use a proc.  These two
-examples are equivalent:
-
-  use_vanity :current_user
-  use_vanity { |controller| controller.current_user.id }
-
-There are times when you would want to use a different identity to distinguish
-test alternatives.  For example, your application may have groups and you may
-want to A/B test an option that will be available (or not) to all people in the
-same group.
-
-You can tell Vanity to use a different identity on a particular controller
-using use_vanity.  Alternatively, you can configure the experiment to extract
-the identity.  The following example will apply to all controllers that have a
-project attribute (without affecting other experiments):
-
-  example "New feature" do
-    description "New feature only available to some groups"
-    identify { |controller| controller.project.id }
-  end
-
-
-== Configuring Vanity
-
-Vanity will work out of the box on a default configuration.  Assuming you're
-using Redis on localhost, post 6379, there's nothing special to do.
-
-If you run a different setup, use the playground object to configure Vanity.
-For example:
-
-  Vanity.playground.host = "redis.local"
-  Vanity.playground.password = "supersecret"
+Learn more about Vanity: http://assaf.github.com/vanity
 
 
 == Credits
 
-EDD was all Nathaniel Talbott's idea, I had experience tests to finish for
-Apartly, there was coffee involved and out came the idea for Vanity.
-
-First experiment, A/B tests, heavily influenced by Patrick McKenzie's awesome
-A/Bingo (http://www.bingocardcreator.com/abingo)
-
-Pain points courtesy of Google Analytics's stylish graphs and too-many-clicks
-goal tracking process.
-
-
-
-== License
+Experiment Driven Development: Nathaniel Talbott (http://blog.talbott.ws).
 
-Vanity, copyright (C) 2009 Assaf Arkin, released under the "Use for good, not evil" license (www.json.org/license.html)
+Copyright (C) 2009 Assaf Arkin, released under the MIT license.

data/bin/vanity

@@ -7,8 +7,10 @@ require "optparse"
 
 playground = Vanity.playground
 options = Struct.new(:output).new
-OptionParser.new("", 24, "  ") do |opts|
-  opts.banner = "Usage: #{File.basename($0)} [options]\n"
+opts = OptionParser.new("", 24, "  ") do |opts|
+  opts.banner = "Usage: #{File.basename($0)} [options] command\n"
+  opts.banner << "Commands:\n"
+  opts.banner << "  report  Report on all running experiments"
 
   opts.separator ""
   opts.separator "General options:"
@@ -33,10 +35,15 @@ OptionParser.new("", 24, "  ") do |opts|
     puts "Vanity #{Vanity::Version::STRING}"
     exit
   end
-end.parse!(ARGV)
+end
+
+opts.parse!(ARGV)
+if ARGV.empty?
+  puts opts.banner
+  exit
+end
 
-cmds = ARGV.empty? ? ["report"] : ARGV
-cmds.each do |cmd|
+ARGV.each do |cmd|
   case cmd
   when "report"
     Vanity::Commands.report options.output

data/lib/vanity.rb

@@ -17,8 +17,8 @@ module Vanity
 end
 
 
-require File.join(File.dirname(__FILE__), "vanity/playground")
-require File.join(File.dirname(__FILE__), "vanity/experiment/base")
-require File.join(File.dirname(__FILE__), "vanity/experiment/ab_test")
-require File.join(File.dirname(__FILE__), "vanity/rails") if defined?(Rails)
-Vanity.autoload :Commands, File.join(File.dirname(__FILE__), "vanity/commands")
+require "vanity/playground"
+require "vanity/experiment/base"
+require "vanity/experiment/ab_test"
+require "vanity/rails" if defined?(Rails)
+Vanity.autoload :Commands, "vanity/commands"

data/lib/vanity/commands.rb

@@ -1 +1 @@
-require File.join(File.dirname(__FILE__), "commands/report")
+require "vanity/commands/report"

data/lib/vanity/commands/report.rb

@@ -2,16 +2,32 @@ require "erb"
 require "cgi"
 
 module Vanity
+  
+  # Render method available in templates (when running outside Rails).
+  module Render
+    
+    # Render the named template.  Used for reporting and the console.
+    def render(path, locals = {})
+      locals[:playground] = self
+      keys = locals.keys
+      struct = Struct.new(*keys)
+      struct.send :include, Render
+      locals = struct.new(*locals.values_at(*keys))
+      dir, base = File.split(path)
+      path = File.read(File.join(dir, "_#{base}"))
+      ERB.new(path, nil, '<').result(locals.instance_eval { binding })
+    end
+
+  end
+
   module Commands
     class << self
+      include Render
 
       # Generate a report with all available tests.  Outputs to the named file,
       # or stdout with no arguments.
       def report(output = nil)
-        require "erb"
-        erb = ERB.new(File.read("lib/vanity/report.erb"), nil, '<')
-        experiments = Vanity.playground.experiments
-        html = erb.result(binding)
+        html = render(Vanity.template("report"))
         if output
           File.open output, 'w' do |file|
             file.write html

data/lib/vanity/experiment/ab_test.rb

@@ -1,14 +1,15 @@
 module Vanity
   module Experiment
 
-    # Experiment alternative.  See AbTest#alternatives.
+    # Experiment alternative.  See AbTest#alternatives and AbTest#score.
     class Alternative
 
-      def initialize(experiment, id, value) #:nodoc:
+      def initialize(experiment, id, value, participants, converted, conversions) #:nodoc:
         @experiment = experiment
         @id = id
-        @name = "option #{(@id + 1)}"
+        @name = "option #{(@id + 65).chr}"
         @value = value
+        @participants, @converted, @conversions = participants, converted, conversions
       end
 
       # Alternative id, only unique for this experiment.
@@ -20,46 +21,38 @@ module Vanity
       # Alternative value.
       attr_reader :value
 
+      # Experiment this alternative belongs to.
+      attr_reader :experiment
+
       # Number of participants who viewed this alternative.
-      def participants
-        redis.scard(key("participants")).to_i
-      end
+      attr_reader :participants
 
       # Number of participants who converted on this alternative.
-      def converted
-        redis.scard(key("converted")).to_i
-      end
+      attr_reader :converted
 
       # Number of conversions for this alternative (same participant may be counted more than once).
-      def conversions
-        redis[key("conversions")].to_i
-      end
+      attr_reader :conversions
 
-      # Conversion rate calculated as converted/participants.
-      def conversion_rate
-        c, p = converted.to_f, participants.to_f
-        p > 0 ? c/p : 0.0
-      end
+      # Z-score for this alternative. Populated by AbTest#score.
+      attr_accessor :z_score
 
-      def <=>(other)
-        conversion_rate <=> other.conversion_rate 
-      end
+      # Confidence derived from z-score. Populated by AbTest#score.
+      attr_accessor :confidence
+    
+      # Difference from least performing alternative. Populated by AbTest#score.
+      attr_accessor :difference
 
-      def participating!(identity)
-        redis.sadd key("participants"), identity
+      # Conversion rate calculated as converted/participants, rounded to 3 places.
+      def conversion_rate
+        @rate ||= (participants > 0 ? (converted.to_f/participants.to_f).round(3) : 0.0)
       end
 
-      def conversion!(identity)
-        if redis.sismember(key("participants"), identity)
-          redis.sadd key("converted"), identity
-          redis.incr key("conversions")
-        end
+      def <=>(other) # sort by conversion rate
+        conversion_rate <=> other.conversion_rate 
       end
 
-      def destroy #:nodoc:
-        redis.del key("participants")
-        redis.del key("converted")
-        redis.del key("conversions")
+      def ==(other)
+        other && id == other.id && experiment == other.experiment
       end
 
       def to_s #:nodoc:
@@ -70,20 +63,6 @@ module Vanity
         "#{name}: #{value} #{converted}/#{participants}"
       end
 
-    protected
-
-      def key(name)
-        @experiment.key("alts:#{id}:#{name}")
-      end
-
-      def redis
-        @experiment.redis
-      end
-
-      def base
-        @base ||= @experiment.alternatives.first
-      end
-
     end
 
 
@@ -96,39 +75,60 @@ module Vanity
           confidence = AbTest::Z_TO_CONFIDENCE.find { |z,p| score >= z }
           confidence ? confidence.last : 0
         end
+
+        def friendly_name
+          "A/B Test" 
+        end
+
       end
 
       def initialize(*args) #:nodoc:
         super
+        @alternatives = [false, true]
       end
 
       # -- Alternatives --
 
-      # Call this method once to specify values for the A/B test.  At least two
-      # values are required.
-      #
-      # Call without argument to previously defined alternatives (see Alternative).
-      #
-      # For example:
+      # Call this method once to set alternative values for this experiment.
+      # Require at least two values.  For example:
       #   experiment "Background color" do
       #     alternatives "red", "blue", "orange"
       #   end
-      #
+      # 
+      # Call without arguments to obtain current list of alternatives.  For example:
       #   alts = experiment(:background_color).alternatives
       #   puts "#{alts.count} alternatives, with the colors: #{alts.map(&:value).join(", ")}"
+      #
+      # If you want to know how well each alternative is faring, use #score.
       def alternatives(*args)
-        args = [false, true] if args.empty?
-        @alternatives = []
-        args.each_with_index do |arg, i|
-          @alternatives << Alternative.new(self, i, arg)
+        unless args.empty?
+          @alternatives = args.clone
+        end
+        class << self
+          alias :alternatives :_alternatives
         end
-        class << self ; self ; end.send(:define_method, :alternatives) { @alternatives }
         alternatives
       end
 
+      def _alternatives #:nodoc:
+        alts = []
+        @alternatives.each_with_index do |value, i|
+          participants = redis.scard(key("alts:#{i}:participants")).to_i
+          converted = redis.scard(key("alts:#{i}:converted")).to_i
+          conversions = redis[key("alts:#{i}:conversions")].to_i
+          alts << Alternative.new(self, i, value, participants, converted, conversions)
+        end
+        alts
+      end
+
       # Returns an Alternative with the specified value.
       def alternative(value)
-        alternatives.find { |alt| alt.value == value }
+        if index = @alternatives.index(value)
+          participants = redis.scard(key("alts:#{index}:participants")).to_i
+          converted = redis.scard(key("alts:#{index}:converted")).to_i
+          conversions = redis[key("alts:#{index}:conversions")].to_i
+          Alternative.new(self, index, value, participants, converted, conversions)
+        end
       end
 
       # Sets this test to two alternatives: false and true.
@@ -148,15 +148,16 @@ module Vanity
       def choose
         if active?
           identity = identify
-          alt = alternative_for(identity)
-          alt.participating! identity
-          check_completion!
-          alt.value
-        elsif alternative = outcome
-          alternative.value
+          index = redis[key("participant:#{identity}:show")]
+          unless index
+            index = alternative_for(identity)
+            redis.sadd key("alts:#{index}:participants"), identity
+            check_completion!
+          end
         else
-          alternatives.first.value
+          index = redis[key("outcome")] || alternative_for(identify)
         end
+        @alternatives[index.to_i]
       end
 
       # Records a conversion.
@@ -164,12 +165,15 @@ module Vanity
       # For example:
       #   experiment(:which_blue).conversion!
       def conversion!
-        if active?
-          identity = identify
-          alt = alternative_for(identity)
-          alt.conversion! identity
-          check_completion!
+        return unless active?
+        identity = identify
+        return if redis[key("participants:#{identity}:show")]
+        index = alternative_for(identity)
+        if redis.sismember(key("alts:#{index}:participants"), identity)
+          redis.sadd key("alts:#{index}:converted"), identity
+          redis.incr key("alts:#{index}:conversions")
         end
+        check_completion!
       end
 
       
@@ -191,99 +195,113 @@ module Vanity
       #     experiment(:green_button).select(nil)
       #   end
       def chooses(value)
-        alternative = alternatives.find { |alt| alt.value == value }
-        raise ArgumentError, "No alternative #{value.inspect} for #{name}" unless alternative
-        Vanity.context.session[:vanity] ||= {}
-        Vanity.context.session[:vanity][id] = alternative.id
+        index = @alternatives.index(value)
+        raise ArgumentError, "No alternative #{value.inspect} for #{name}" unless index
+        identity = identify
+        redis[key("participant:#{identity}:show")] = index
+        self
+      end
+
+      def chosen?(alternative) #:nodoc:
+        identity = identify
+        index = redis[key("participant:#{identity}:show")]
+        index && index.to_i == alternative.id
+      end
+
+      # Used for testing.
+      def count(identity, value, *what) #:nodoc:
+        index = @alternatives.index(value)
+        raise ArgumentError, "No alternative #{value.inspect} for #{name}" unless index
+        if what.empty? || what.include?(:participant)
+          redis.sadd key("alts:#{index}:participants"), identity
+        end
+        if what.empty? || what.include?(:conversion)
+          redis.sadd key("alts:#{index}:converted"), identity
+          redis.incr key("alts:#{index}:conversions")
+        end
+        self
       end
 
 
       # -- Reporting --
 
-      # Returns an object with the following attributes:
-      # [:alts]  List of alternatives as structures (see below).
-      # [:best]  Best alternative.
-      # [:base]  Second best alternative.
-      # [:choice]  Choice alterntive, either selected outcome or best alternative (with confidence).
+      # Returns an object with the following methods:
+      # [:alts]   List of Alternative populated with interesting statistics.
+      # [:best]   Best performing alternative.
+      # [:base]   Second best performing alternative.
+      # [:least]  Least performing alternative (but more than zero conversion).
+      # [:choice] Choice alterntive, either the outcome or best alternative (if confidence >= 90%).
       #
-      # Each alternative is an object with the following attributes:
-      # [:id]    Identifier.
-      # [:conv]  Conversion rate (0.0 to 1.0, rounded to 3 places).
-      # [:pop]   Population size (participants).
-      # [:diff]  Difference from least performant altenative (percentage).
-      # [:z]     Z-score compared to base (above).
-      # [:conf]  Confidence based on z-score (0, 90, 95, 99, 99.9).
+      # Alternatives returned by this method are populated with the following attributes:
+      # [:z_score]    Z-score (relative to the base alternative).
+      # [:confidence] Confidence (z-score mapped to 0, 90, 95, 99 or 99.9%).
+      # [:difference] Difference from the least performant altenative.
       def score
-        struct = Struct.new(:id, :conv, :pop, :diff, :z, :conf)
-        alts = alternatives.map { |alt| struct.new(alt.id, alt.conversion_rate.round(3), alt.participants) }
+        alts = alternatives
         # sort by conversion rate to find second best and 2nd best
-        sorted = alts.sort_by(&:conv)
+        sorted = alts.sort_by(&:conversion_rate)
         base = sorted[-2]
         # calculate z-score
-        pc = base.conv
-        nc = base.pop
+        pc = base.conversion_rate
+        nc = base.participants
         alts.each do |alt|
-          p = alt.conv
-          n = alt.pop
-          alt.z = (p - pc) / ((p * (1-p)/n) + (pc * (1-pc)/nc)).abs ** 0.5
-          alt.conf = AbTest.confidence(alt.z)
+          p = alt.conversion_rate
+          n = alt.participants
+          alt.z_score = (p - pc) / ((p * (1-p)/n) + (pc * (1-pc)/nc)).abs ** 0.5
+          alt.confidence = AbTest.confidence(alt.z_score)
         end
         # difference is measured from least performant
-        if least = sorted.find { |alt| alt.conv > 0 }
+        if least = sorted.find { |alt| alt.conversion_rate > 0 }
           alts.each do |alt|
-            alt.diff = (alt.conv - least.conv) / least.conv * 100 if alt.conv > least.conv
+            if alt.conversion_rate > least.conversion_rate
+              alt.difference = (alt.conversion_rate - least.conversion_rate) / least.conversion_rate * 100
+            end
           end
         end
         # best alternative is one with highest conversion rate (best shot).
         # choice alternative can only pick best if we have high confidence (>90%).
-        best = sorted.last if sorted.last.conv > 0
-        choice = outcome ? alts[outcome.id] : (best && best.conf >= 90 ? best : nil)
-        Struct.new(:alts, :best, :base, :choice).new(alts, best, base, choice)
+        best = sorted.last if sorted.last.conversion_rate > 0.0
+        choice = outcome ? alts[outcome.id] : (best && best.confidence >= 90 ? best : nil)
+        Struct.new(:alts, :best, :base, :least, :choice).new(alts, best, base, least, choice)
       end
 
       # Use the score returned by #score to derive a conclusion.  Returns an
       # array of claims.
       def conclusion(score = score)
         claims = []
-        # find name form alt structure returned from score
-        name = ->(alt){ alternatives[alt.id].name }
         # only interested in sorted alternatives with conversion
-        sorted = score.alts.select { |alt| alt.conv > 0.0 }.sort_by(&:conv).reverse
+        sorted = score.alts.select { |alt| alt.conversion_rate > 0.0 }.sort_by(&:conversion_rate).reverse
         if sorted.size > 1
           # start with alternatives that have conversion, from best to worst,
           # then alternatives with no conversion.
           sorted |= score.alts
           # we want a result that's clearly better than 2nd best.
           best, second = sorted[0], sorted[1]
-          if best.conv > second.conv
-            diff = ((best.conv - second.conv) / second.conv * 100).round
-            better = " (%d%% better than %s)" % [diff, name[second]] if diff > 0
-            claims << "The best choice is %s: it converted at %.1f%%%s." % [name[best], best.conv * 100, better]
-            if best.conf >= 90
-              claims << "With %d%% probability this result is statistically significant." % score.best.conf
+          if best.conversion_rate > second.conversion_rate
+            diff = ((best.conversion_rate - second.conversion_rate) / second.conversion_rate * 100).round
+            better = " (%d%% better than %s)" % [diff, second.name] if diff > 0
+            claims << "The best choice is %s: it converted at %.1f%%%s." % [best.name, best.conversion_rate * 100, better]
+            if best.confidence >= 90
+              claims << "With %d%% probability this result is statistically significant." % score.best.confidence
             else
               claims << "This result is not statistically significant, suggest you continue this experiment."
             end
             sorted.delete best
           end
           sorted.each do |alt|
-            if alt.conv > 0.0
-              claims << "%s converted at %.1f%%." % [name[alt].capitalize, alt.conv * 100]
+            if alt.conversion_rate > 0.0
+              claims << "%s converted at %.1f%%." % [alt.name.gsub(/^o/, "O"), alt.conversion_rate * 100]
             else
-              claims << "%s did not convert." % name[alt].capitalize
+              claims << "%s did not convert." % alt.name.gsub(/^o/, "O")
             end
           end
         else
           claims << "This experiment did not run long enough to find a clear winner."
         end
-        claims << "#{name[score.choice].capitalize} selected as the best alternative." if score.choice
+        claims << "#{score.choice.name.gsub(/^o/, "O")} selected as the best alternative." if score.choice
         claims
       end
 
-      def humanize
-        "A/B Test" 
-      end
-
 
       # -- Completion --
 
@@ -311,40 +329,44 @@ module Vanity
         outcome && alternatives[outcome.to_i]
       end
 
-      def complete! #:nodoc:
+      def complete!
+        return unless active?
         super
         if @outcome_is
           begin
-            outcome = alternatives.find_index(@outcome_is.call)
+            result = @outcome_is.call
+            outcome = result.id if result && result.experiment == self
           rescue
             # TODO: logging
           end
-        end
-        unless outcome
+        else
           best = score.best
           outcome = best.id if best
         end
         # TODO: logging
-        redis.setnx key("outcome"), outcome
+        redis.setnx key("outcome"), outcome || 0
       end
 
       
       # -- Store/validate --
 
-      def save #:nodoc:
+      def save
         fail "Experiment #{name} needs at least two alternatives" unless alternatives.count >= 2
         super
       end
 
-      def reset! #:nodoc:
+      def reset!
+        @alternatives.count.times do |i|
+          redis.del key("alts:#{i}:participants")
+          redis.del key("alts:#{i}:converted")
+          redis.del key("alts:#{i}:conversions")
+        end
         redis.del key(:outcome)
-        alternatives.each(&:destroy)
         super
       end
 
-      def destroy #:nodoc:
-        redis.del key(:outcome)
-        alternatives.each(&:destroy)
+      def destroy
+        reset
         super
       end
 
@@ -355,10 +377,7 @@ module Vanity
       # identity, and randomly distributed alternatives for each identity (in the
       # same experiment).
       def alternative_for(identity)
-        session = Vanity.context.session[:vanity]
-        index = session && session[id]
-        index ||= Digest::MD5.hexdigest("#{name}/#{identity}").to_i(17) % alternatives.count
-        alternatives[index]
+        Digest::MD5.hexdigest("#{name}/#{identity}").to_i(17) % @alternatives.count
       end
 
       begin