Stack Overflow Podcast – Episode #30

Released: April 19, 2011
Hosts: Joel Spolsky (A), Jeff Atwood (B)
Guest: Richard White (C), Founder of UserVoice.com

Episode Overview

In this episode, Joel and Jeff sit down with Richard White of UserVoice to explore how modern software teams track bugs and features, the pitfalls of user feedback systems, and the influence of community-driven tools like UserVoice and Stack Overflow. The trio covers the philosophy of product development, the challenges of interpreting user requests, community dynamics in voting systems, and takes a deep dive into the difference between bugs and features. They also discuss real-world programming challenges like the halting problem and NP-completeness, providing engaging insights for developers of all backgrounds.

Key Discussion Points & Insights

1. The Genesis of UserVoice

[01:13 – 05:35]

• Origins & Early Pain Points:
  • Richard White shares that UserVoice was born from the chaos of handling customer feedback at his startup Kiko—the “tar pit” of calendaring. He explains, “My day after launch was like spending half my day reading blog comments and message board posts and emails and all these things about what you should do. ... Just kind of a failure feedback system.” [02:07]
• Reddit Inspiration:
  • UserVoice drew inspiration from Reddit’s voting model, but targeted a persistent, prioritized feedback system instead of short-lived “news-like” spikes.
  • Richard credits Joel’s writing on budgets for feature requests as an influence: “I was reading one of your articles talking about giving developers $50 to spend on line items for your next release... That put those two ideas together.” [02:54]
• Design Choices – Vote Limitations:
  • UserVoice constrains users to a limited number of votes to force prioritization ("the intersection of popular and important").
  • “90% of people come to UserVoice with one idea, the other 10% spend every single vote we give them.” [03:40]

2. Is UserVoice a Bug Tracker? The Blurry Line Between Bugs and Features

[07:42 – 13:47]

• Product Input vs. Direct Democracy:
  • Joel raises the idea that direct democracy in user feedback isn’t always optimal, especially if you blindly implement the most-requested features:
    “If you really created a software product and then literally only implemented the things that people voted for, what does that product look like?” [06:38]
  • Richard affirms: “We actively say no. It's an input ... But no, I surely consider it. ... It's just good as triage.” [06:40]
• Pacifying Users and Teams:
  • User feedback platforms, including bug trackers, often serve to pacify both users and developers:
    “It's a pacifier for your complaining users ... It's a much better record than message boards or blog comments or emails.” [08:03]
• The Feature/Bug Continuum:
  • Jeff: “It totally blurs the line between features and bugs, which I think was kind of non-existent to begin with.” [08:19]
    “To the extent you have a conversation with your users ... they probably care more about features unless there’s an actual showstopper bug.” [09:06]
  • The frictionless nature of UserVoice is lauded for lowering barriers to contribution, e.g., smart pre-emptive search before submission. [10:11]

3. User Feedback in Practice at Stack Overflow

[10:18 – 13:26]

• Intersection of Priorities:
  • Joel and Jeff discuss how the top UserVoice requests don’t always match the internal roadmap:
    • Joel: “The things that I see on UserVoice are not our actual priorities.” [10:18]
    • Jeff: “Maybe these are our priorities ... but they're not our priorities. That's the difference.” [10:45]
  • Richard: “The goal is to help you prioritize ... It will help you smooth out the rough edges and see obvious gaps, but not drive innovation.” [12:29]
• Innovation vs. Incrementalism:
  • Joel: “You very, very rarely does somebody invent something that surprises you. ... You don’t really get the big awesome new inventions from your users.” [12:08]

4. The Politics of Voting: Swarms and External Influence

[14:26 – 21:18]

• Case Study: ObamaCTO.org and Political Feedback:
  • Richard discusses high-profile, often chaotic, use cases such as political party crowdsourcing (e.g., “rebuildtheparty.com” or “obamacto.org”), and the challenge of dealing with “swarms” or coordinated voting by external communities.
    • “Anytime someone figures out the Republicans are doing something online, FARC shows up and they voted up 'Truck Nuts for Everyone.'” [15:17]
    • Joel calls out “the internet T.E.D. offensive” where external communities coordinate to tip the scales (“mass roving communities”). [19:32]
• Coping with Noise:
  • The conclusion is that these swarms are temporary and native communities eventually reassert themselves:
    “All you can do is kind of let them have their day ... There's really not fighting that battle.” [20:32]

5. UserVoice’s Influence on Stack Overflow’s Design

[21:43 – 24:08]

• UI Inspiration:
  • Jeff credits UserVoice’s interface, especially its tab structure and notification bar, as direct influences on Stack Overflow’s own design:
    “Imitation is always the sincerest form of flattery.” [22:24]

6. Signal vs. Noise in User Feedback

[24:08 – 24:44]

• Declining User Requests:
  • Jeff is lauded for candor in frequently marking requests as declined:
    • “You've declined 48% of the ideas on there, which I think is awesome actually.” [24:08 — Richard]
    • By comparison, other communities (like Copilot) are much more hesitant.

7. Community Questions: Developer Productivity and “Getting in the Zone”

[28:02 – 33:15]

• How Developers Get Into Flow:
  • The team explores a frequently asked Stack Overflow question: “What tricks do you use to get yourself in the zone?” [28:52]
    • Jeff: “Start anywhere, but start where your heart leads you ... that's your gateway drug to the rest of the problem.” [31:15]
    • Joel: “Pick some very, very small piece of [the problem] and just commit to doing that.” [32:05]
    • Richard: “I have a list of things that I just want because they're cool ... It's my guilty pleasure to get me into the app.” [32:23]

8. Tech Stack, Testing, and Deployment Philosophies

[33:15 – 36:29]

• Ruby on Rails & Testing:
  • Richard: “Not quite 5,500 [lines of code], about half test code...we smoke test APIs and high-level stuff, but we're not, like, crazy TDD Rails guys.” [33:31]
  • Discussion on dynamic vs. static typing and the importance of robust testing when using dynamic languages ("the compiler’s not going to catch anything"). [34:25]
• Startup Phase and Release Cadence:
  • Richard notes early users forgive more bugs; expectations shift as paying customers arrive. [35:24]

9. Enterprise & White-Label Versions

[36:08 – 36:46]

• UserVoice is rolling out integration features, SSO, API access, and white-labeled offerings to attract enterprise clients. [36:12]

10. Deep Dive: NP-Complete and the Halting Problem

[37:29 – 53:04]

• Understanding NP-Complete:
  • Jeff and Joel explain NP-completeness and its relevance, referencing active Stack Overflow threads. “What is an NP complete problem and why is it such an important topic in computer science?” [37:35]
  • Joel: “If you had an algorithm for the knapsack problem, then I could use your algorithm to solve the traveling salesman problem ... all the NP complete problems are interchangeable.” [40:12]
• The Halting Problem:
  • Joel describes the halting problem’s role in static analysis and why it's generally unsolvable for arbitrary code. [43:04]
  • Jeff relates this to practical debugging, e.g., thread timing and crash reproduction (using research tools from Microsoft). [49:47]

11. OpenID & User Authentication

[53:15 – 58:55]

• Desire for Better OpenID Integration:
  • Jeff pushes Richard for OpenID support on UserVoice (“Can we commit publicly to OpenID on UserVoice on this podcast?”). [53:30]
  • Richard and Jeff discuss ease-of-use solutions like RPX Now, emphasizing the importance of user experience for authentication systems. [54:10]
  • Richard: “All my criticism of OpenID is about user experience ... The people who have been most successful with it have not even told you that it's OpenID—it’s like a bad brand at this point.” [58:01]

Notable Quotes & Memorable Moments

• Richard White on Feature Voting:
  “So the goal is to kind of flatten out that. Kind of flatten out that priority a little bit better ... It's a currency of influence, if you will.” [03:40]

• Joel Spolsky on Innovation:
  “You very, very rarely does somebody invent something that surprises you ... You don't really get that from the users of your product.” [12:08]

• Jeff Atwood on Declining Feedback:
  "You've declined 48% of the ideas on there, which I think is awesome actually." [24:08]

• Richard White: Pacifier for Complaining Users:
  “It's clearly...a pacifier, both for users and for people like ourselves running things. It's a much better record than message boards or blog comments or emails or whatnot.” [08:03]

• Joel, on External Influence in Voting Systems:
  “What I believe is that when you do something strongly political, you get a lot of visitors coming in that are not actually your native audience ... mass roving communities.” [19:32]

• Jeff Atwood, On Getting in the Zone:
  "Start anywhere, but start where your heart leads you. If there's something algorithmic...that's your gateway drug to the rest of the problem." [31:15]

• Richard White, On Ruby on Rails:
  "It almost writes itself, you know, it almost crashes itself too." [33:22]

Timestamps for Important Segments

• [01:13]: Richard introduces UserVoice origins
• [03:40]: Limiting votes and its rationale
• [06:40]: Democracy in feedback software
• [08:03]: UserVoice as “pacifier” for teams/users
• [12:08]: Why user feedback rarely delivers surprise innovation
• [15:17]: “Truck Nuts for Everyone” and political swarms
• [21:43]: UserVoice’s influence on Stack Overflow UI
• [24:08]: Developer transparency (declining user feedback)
• [28:52]: Community Q: “Getting into the zone”
• [33:31]: Ruby on Rails & testing strategy at UserVoice
• [36:12]: UserVoice’s enterprise/white-label strategy
• [37:35]: NP-completeness & explanations
• [43:04]: The halting problem in practice
• [53:30]: OpenID and user experience
• [58:01]: Critique of OpenID’s UI/brand pitfalls

Final Thoughts

This episode is a deep, discursive look at the challenges of building platforms that not just track but interpret user needs in a modern, participatory way. Highlights include sharp, candid discussion on democracy in software, practical considerations for crowdsourcing feedback, technical asides on computer science theory, and the real-world challenge of managing both users and their expectations.

“The value is in putting everyone in the same room so you at least have that input.” – Richard White [12:29]

“Imitation is the sincerest form of flattery.” – Jeff Atwood on borrowing UI ideas [22:24]

If you’re interested in where community-driven software is headed, and how to balance user input against vision, this episode is essential.

For more, visit uservoice.com or check out the full archive at blog.StackOverflow.com.