Help us choose a sort order for the Stack Overflow homepage

Question

A overwhelming amount of feedback for Help us redesign the Stack Overflow homepage was: "Keep the way the front page looks, just tweak the question order"

Interesting algorithms were suggested by Kip and radp, but there was no real playground to experiment.

Enter Home Page MiniCollider™ Question Reordinator™

Users with 200 rep or more on Stack Overflow have access, it includes the 3000 last active questions, favorite tags, ignored tags and top tags you answered (with score and count).

You can play around with the question order, all you need is to plug in your ordering function:

function calculateWeight(q) {
    return 1 /* your magic ordering goes here */ ;
}


    /*
        available params on q:
            views, 
            score, 
            answer_count, 
            tags(array), 
            last_activity_delta, 
            creation_date_delta,
            has_accepted_answer,
            total_answer_score,
            is_closed

        globals:
            topTags array containing top tags for this user eg: {name: 'tag-name', count: 1, total_score: 1 }
            ignoredTags array of strings 
            interestingTags array of string 

    */ 

The experimental page lives at: https://stackoverflow.com/new-home

Once you get your magical ordering you can save a preset by clicking the "update" button. This will refresh the page and create a preset (which looks like http://stackoverflow.com?preset=41). You can refresh the page by pressing the refresh button at any time while debugging.

This allows you to do pretty cool things, like this preset by Nick Craver. The page is expensive to download, so there are limits; you may only access it once every 30 seconds.

Can't wait to see what cool presets you come up with! Please post your presets here with an explanation of why you think it is awesome.

_{Note: this new-home page is experimental, we are not going to keep the same architecture when we go live with the new design. The live design will perform all ordering, server side.}

Answer 1

Lucky Three design

Pull three interesting, fresh questions at the top. Keep the rest as is. Excerpt:

lucky_three_slots = 3

function calculateWeight(q) {
  if(lucky_three_slots){
    interestingness = is_question_interesting(q)
    if(interestingness === interesting_question &&
       q.total_answer_score <= 3 &&   //allow a few upvotes
       q.answer_count <= 3){          //bad question get more answers than votes.
        lucky_three_slots -= 1;       //take the slot
        return -lucky_three_slots;    //clamp to the top
      }                         //For an implementation detail, this function
  }                             //gets called on newest questions first, so the
  //otherwise, default sort     //lucky three questions happen to be sorted by
  return q.last_activity_delta; //time. This is cool, but still a side effect.
}

Answer 2

Adjusted freshness

My original idea, discussed at length here. Given the larger body of questions available, I've reduced the bonus factor.

function calculateWeight(q) {
  return q.last_activity_delta / Math.pow(bonus, get_interestingness_of(q));
}

---

Variant without the exponential growth

This variant applies the bonus for interesting/ignored tags only once. To balance, the bonus is heftier.

Answer 3

Somebody ... added a debugging weight column, so I would be crazy not to share this.

https://stackoverflow.com/new-home?preset=79

I added a bit of randomness to the mix so a few random questions show up in the list on every load.

function calculateWeight(q) {

    var score = getScore(q.tags); 

    q.weight = q.last_activity_delta / 15
         + (q.has_accepted_answer ? 100000 : 0)
         - (score || -1000)
         + Math.abs(q.total_answer_score) * 4000
         + q.answer_count * 100
         + q.views * 30
         - q.score * 500
         + (q.is_closed ? 100000 : 0);

    // give a random bonus to 1 / 10 questions in the last hour
    if (q.last_activity_delta < 60 * 60 && !q.has_accepted_answer && score == 0) 
    {
       if (Math.floor(Math.random()*5) < 1)
       {
         q.weight = q.weight - (q.views < 10 ? 2500 : 1500); 
       }
    }

    return q.weight;
}

Answer 4

I suggest this order by clause in SQL Server's SELECT statement:

order by score / (views + 1) desc, creation_date_delta desc

Explanation:

1. score is good. That's why rating is proportional to the score.

2. Views give change to get score. So if question got many views, but got no score -- that question is not really popular. That's why rating is inversely proportional to views.

3. I used "+ 1" in order to avoid division by zero. It also gives some advantage to questions with high score and high views versus questions with low score and low views. "+ 1" could be replaced with "+ 100" or something like that.

4. Order questions that got no score by age: youngest first. That's why "creation_date_delta desc". However I'm not sure what "_delta" means. If it's a timespan between today and creation_date -- then the sorting should be ASCending.

Alternative to "score / (views + 1) desc" It can be replaced with "square(score) / (views + 1) desc" That way high traffic questions would bubble up.