2000 feature requests: Our foray into Uservoice

Question: What do you do with two thousand feature requests sitting in an issue-tracking system?

Answer: Nothing.

We have so many requests because we make it clear that we want to hear from our customers.  And they talk to us... a lot!  It's great that so many people have submitted so many ideas, but we're drowning.

How do you prioritize 2000 items?  How do you know which ones were really important to the requestor and which were just a passing fancy?  How do you track which ones are related or are duplicates or have a common solution?  How do you have separate discussions internally and with customers to dig up the root problems?

You don't.

And anyway you only have time to implement a tiny fraction of the requests, so almost all the time you spend getting the list ship-shape is wasted on features you'll never implement.

You could ignore feature requests entirely on the theory that the important stuff is requested often enough that priority makes itself apparent.  This works if your product is extremely simple, and if you've decided it won't have many features.  If you can get away with such a product, by all means do!  But not all software can be simple.

Besides, I like the fact that we get feature requests.  Our customers tell us what to build -- it's a logical way to create a product people will pay for.  But thousands of feature requests areimpossible to manage; it's almost the same as having none.

Enter Uservoice.  What a great name; it says what it does, it's evocative, it's even empowering ("giving users a voice").  The concept is simple: Anyone can post feature requests and vote on their favorite ones.  Each request has a mini discussion forum.  The most popular requests rise to the top of the list.

Want to see it in action?  Visit our page: http://feedback.codecollab.com/

We're going to push the hell out of Uservoice.  For example, we're putting a "Suggest" button in the menubar of every screen in our software.  Every feature request sent to tech support will be redirected there, and we'll be going through our feature backlog redirecting folks to the new site.

The hope is that users will self-organize.  Popular features will have more discussion, not just amongst users (because who can agree on the best way to implement something?) but between our developers and our beloved users.  Now we can ask questions of everyone interested in a certain feature, hopefully getting to the heart of the real pain that our users are sharing.  We could never do that with a massive list of line-items in an issue tracker.

If this works, the same technique could be used for all sorts of things:

• We're setting up an private Uservoice site to track marketing ideas -- we have 50-100 ideas and we'd like to start internal discussions on which ones to try next.
• Have one Uservoice site for existing customers and a separate one for potential customers just trying it out.
• Let your customers give you feedback on your website.
  
• If you're a consultant, lawyer, speaker or other professional you could use it for anonymous feedback.
  
• Company "management" could demonstrate they care about doing a good job by opening a personal, anonymous site for feedback (like glassdoor, but private).

I'll keep you posted as we learn more about Uservoice's shortcomings and advantages.

If you have experience with Uservoice or any other self-organizing feedback system, or if you've contributed to our feedback site, please help us all by leaving a comment!

Is it OK to Sucks?

I first read that bizzare phrase -- is it OK to sucks? -- in a Slashdot article seven years ago. Companies like Lockheed Martin were suing people who registered LockheedMartinSucks.com and a big battle ensued over the line between free speech and trademark violation.

I had that phrase in mind when I suggested that the title on our full page advertisement should read:

Peer code review doesn't have to SUCK.

We were brainstorming.  There were other ideas.  I had to admit it might offend some readers.  I lost.  Fine.

We went to press and the ad did really well.  We scored in the top 95 percentile on various measures in an independent test.  We got a surge in folks trying our stuff and asking questions.  So no regrets... but still... "suck" is funny...

Six months later I got the SD West 2007 Conference Guide.  On the inside front cover was a letter from the conference organizer entitled, "A Conference that Doesn't Suck."  Hey!

Then I find David Platt is giving a talk called "Why Software Sucks."  The work "suck" appears three times in the course description.  In fact he even wrote a book with that title.

Nowadays it seems like every day I see a company with big-name customers who uses the word "suck" on their front page.

Turns out it is OK to sucks!

It's better than OK.  Small businesses have to get noticed with no money.  The least you can do is give yourself a notable phrase.  Or image:

Take a chance.  Risk offending.  If you don't offend some people, you're not saying anything worth hearing.  Being notable beats being forgotten.  For every person who is offended there's another who just fell in love.

Procrastinate for Success!

I'm a habitual procrastinator. It's a funadamental component of my psyche. It's also an important factor in success at running a small business. Here's why.


In a small company you're overwhelmed with things to do. At Smart Bear we still have a dense whiteboard full of marketing ideas we don't have time for, dozens of index cards with cool features we don't have time to implement, and 7,000 open issues and minor feature requests in Fogbugz we don't even have time to look at.

And that's now, with five years of work and fifteen employees. It was hundred times worse at the beginning with just one person to do all the work.

This one person must have worked tirelessly. (He did.) This person must have been willing to do every kind of job. (He was.) This person must have been hyper-organized, allowing nothing to slip through the cracks, spending precious time on only the most high-valued tasks, not just working on whatever this person felt like at the time. (Ummmmmm... <looks sheepishly at toes>... not so much.)

"Don't put off 'till tomorrow what you can put off 'till the day after tomorrow." Thanks, Mark, for guiding the overwhelmed.

You really do have too much to do. Prioritization might be best in theory, but plain, gut-feel procrastination might be the right way to go. 

Many things blow over if you just ignore them. The big feature you got worked up about yesterday seems unimportant in the cold light of today. A feature a customer says is vital turns out to be something suggested by their intern, not something actually stopping a sale. An apparent fundamental bug turns out to be a misconfiguration. An important meeting turns out to be unimportant.

Besides, a lot of those tasks aren't as important as you think. Even something critical like accounting can be put off. Late fees, lost receipts, penalties from the IRS: financial burdens more than compensated by additional revenue gained by signing up one more customer.

Financial tasks in particular also have the property of being faster to do in a big sweep rather than as they trickle in. It's faster to enter 100 receipts into Quickbooks once a month than to enter three a day. Little tasks like that still have context-switch overhead, plus you get fast at typing and keyboard shortcuts when you're doing the same action hundreds of times in a row.

Finally, sometimes you've got to let yourself do fun stuff at the expense of priorities. Most of what you do in a little company isn't what you enjoy doing; it's easy to become frustrated and burned-out. So sometimes you need to allow yourself to recover with plain fun. Whatever the cost of putting off duties, burn-out is even more costly.

Yeah I know I'm rationalizing.  But you can't do everything, so don't.  And don't beat yourself up over it.

Labels Matter

A dour-faced executive glanced around the oak conference table, somehow able to look simultaneously down and into everyone's eyes in turn. He said: "The question is, where can we get more resources for Mike. Roger, can your group relinquish some resources for three months?" Roger frowned and pondered. I wondered what a "resource" was and how many Roger had.

It was a brief consulting engagement. Version 3.0 was behind schedule. I was privy to this product planning meeting but still naive about corporate lingo. At first I thought "resources" meant money or time but it didn't compute.

Finally I realized that "resource" meant "human." Or, in this case, "software developer." Oh.

The dehumanizing effect of labelling anyone as a "resource," a category which might also include electricity, water, natural gas, and hogheads (hogs head? hog's head? hog's heads?), is obvious enough. But more interesting is the effect it had in the meeting.

In Orwell's 1984, a tyrannical government has forced upon its citizens a language called Newspeak. Newspeak has no words for concepts like disagreement, revolution, or individualism. The theory was that people cannot engage in these thoughts if there are no words to express them.

So back to the executive and the oak conference table and "resource reassignment." Did using the generic word "resource" have an effect on the planning session?

Oh yes. In that meeting it was determined that two resources would be temporarily reassigned from Roger's group to Mike's, so Mike could complete his features on schedule. Is that sensible?

If you're talking about human beings, of course not. Two people were assigned to a project they knew nothing about. We've known forever that adding people to a late project only makes it later; the absurdity is multiplied by re-reassigning those people three months later, just when they might finally be up to speed.

But when you're talking about "resources," it makes sense. Resources are fungible. Money is a resource; it can be moved from one department to another with a click in a spreadsheet. The analogy to human beings is completely wrong, which leads to completely wrong decisions.

But the moral isn't "Don't label." In fact, we can do better than "Labels must be accurate." Maybe you can use labels to advantage.

What if you called your software developers "The Talent." Like Hollywood stars. The Talent are not interchangable. The Talent demand respect, but they are expected to produce. The Talent can be opinionated, judgemental, and tempermental, but it's worth placating them so long as they churn out great works that can be sold for millions of dollars.

Which label will help attract and retain the best developers?

Labels matter.

What are your pet peaves when it comes to labels? Do you have a story of mislabling leading to wrong decisions? Leave a comment!

Ideas for Swarm

For this episode, a little less marketing, little more geek.

Ian Clark has some interesting results with a new distributed programming language called Swarm. As the founder of Freenet and other large-scale computing systems, his opinions on the subject are not idle thoughts.

He does a fine job of explaining Swarm with preliminary results, so I'll limit myself here to a pile of off-the-cuff reactions:

1. If keys in the store are an MD5 or SHA1 of the content they are storing, caching data across nodes becomes trivial. If stack state is stored like this as well (compute only on send?) and chained (one stack frame per hashed data element, each with a "pointer" to the hash of the next stack frame), transmission of continuations can also be saved.


2. The graphics are the compelling thing. It's what separates this from other projects. Emotional? Yes but adherence to a programming language is as much emotion as anything else. I say build visualization into the language itself. Make it trivial to produce. This is what everyone's going to share and talk about.


3. Use the JVM model; don't invent a new VM. But you need full control. So, start with a JVM interpreter written in Java (see joeq or jikes or write your own using ASM) which you could then modify. Then you inherit all existing Java libraries to your new language. You have to inherit a bunch of libraries, at least at first!
   
   This also opens the door for interesting optimizations, like identifying short stretches of bytecode where break-for-continuation is not permitted, breaking those out into dynamically-written subroutines, and allowing the underlying JVM to JIT it.
   
   
4. Scala might be fun to learn, but if this project gets going it will be hard enough to root out the bugs without the underlying language also riddled with bugs!  Not to mention the extra barrier to entry ("Wait, I have to learn Scala first?").
   
   
5. How does user interaction work when the execution is moved? Even something as simple as a command-line, much less a GUI. Doesn't this imply that at some point in the execution stack you have to return to the original machine?
   
   (More reason to use Java directly -- bridge between distributed-mode and local-mode for the non-distributed part of the work.)
   
   
6. Same question with external resources.  File system is easy, but what about a TCP connection or a database connection?  How shared across machines?  Or do you need a way to say "Send the execution to this specific node, the one that houses this resource?"  Maybe with an instruction that says "When this routine completes, redistribute this execution."  Maybe that instruction has a back-pointer to the original executing node, not requiring you to return there (i.e. what if that node is now overloaded?) but suggesting since that node does have all the necessary data cached.
   
   
7. In Java some critical, tight, high-performance routines are in C; in Swarm perhaps tight routines can be in Java!  Java Annotations might be a way to specify "don't distribute" on a method.
   
   
8. If you base on the JVM and use Annotations, perhaps existing code could be ported with no alteration! Or you can mix Swarm and plain Java with one line of code. This "easy to revert back" attribute is critical for adoption because people don't like lock-in.
   
   
9. How does synchonization work?  Locks-held need to be part of the continuation.  But are there other subtle issues?
   
   
10. You'll need your own synchronization of course.  Please please please use deadlock-detection, throwing an exception instead of just locking up.  It's not hard to implement.
    
    
11. Suggestion that MapReduce be the next thing that is implemented because it's the hot thing in distributed computation and folks are convinced that many useful things can be expressed that way. Demoing efficiency (and pretty pictures) here would be compelling to many people.
    
    
12. Fault tolerance. Probably don't have to have this at first, but need a thought-experiment-level concept of how to handle.
    
    
13. Computational caching. With SHA of input and full knowledge of bytecode, you could perhaps automatically cache the results of computation!  Think of algorithms where you should use functional programming. Or even just dynamic webpages where the home page doesn't change that often.
    
    
14. Consider JavaSpaces for object transfer?  Might solve some issues with fault tolerance.
    
    

Giving advice and asking questions is easy. Hopefully some brave souls will do the real work of getting Swarm up and running. Good luck Ian!

Giving it away

In The Coldest Call, Gerry Cullen gives us an pithy rule of sales:

If you can't give it away for free,
you can't sell it.

It sounds tautological at first, but it helps you create products that are easy to sell. Here's how.

Because of Smart Bear and this blog, I hear new company ideas all the time. When I start asking about new products, the conversation invariably looks like this:

Me: Would you get customers if your software were free?

Confident Entrepreneur: Of course! Why not take it if it's free?

Me: That's what I'm asking -- are there reasons people still wouldn't take your software even if it were free?

Confident Entrapreneur: Free is free. Of course they'd take it.

Not so fast there, pardner.

Let's say it's 1998 and you've invented a corporate-wide spam filter. Great timing -- the web is exploding, everyone has an email account, spam is choking in-boxes and wasting time. You've invented a box that sits in front of the mail server, tossing the garbage before it hits your server, much less your workstations and laptops.

So couldn't you give away a free spam filter?

Well. What happens when the filter accidentally marks something as spam when in fact it's a real email? Will we lose productivity as people get confused or spend time digging through a massive spam dumping ground looking for the message? Does email recovery require an administrator? Will he be drowned in requests? Will we have to hire a spam depository admin? Operating this system clearly costs time and money.

How much training is required to get people to use the new system? How many spam-filter-related questions will hit our internal help-desk? Support activities are expensive.

What if the spam filter box gets overloaded with too much mail? If there's a bug, is it possible to loose an email completely? What happens if the spam filter box crashes -- does email cease across the entire company? Losing email is unacceptable.

These concerns are so scary and costly that the spam filter might not be worth it, even for free. And if you're ambivalent about taking it for free, you're certainly not going to pay for it.

So how do you design a product that passes Gerry's test? Ask yourself brutal questions to root out how your product might cause more pain than it solves. Here's some to get you started:

If your product fails catastrophically, what's the impact?

Good answers include:

• Because the product is completely independent of any other system, in the worse case you're back to how things were before you bought our product.
  
• We'll show you how to configure other systems to silently and automatically route around the failure. During the trial period you can test this yourself.
  
• We have built-in support for switching back to the way you were doing it before.
  
• Administrators are instantly alerted of the failure
  
• You can use your existing monitoring/alerting system to detect failures
  
• We support live-redundancy and continuous backup

Is it easy to rip this out if I don't like it?

Good answers include:

• Since this system is completely independent of all other systems, you can just turn it off.
  
• All data in the system can be exported at any time in a standard, human-readable format (e.g. XML, CSV). (You can also use this for backup.)
  
• Because we handle catastrophic failure gracefully, you can literally pull the plug and everything else continues to work.
  

How much training does this require?

Good answers include:

• Our website has pre-recorded training presentations. We give you the source materials for free so you can customize for internal training classes.
  
• We have tutorials and screenshots showing how to do common tasks.
  
• We have excellent in-product help, as well as a printed manual.
  
• Accomplishing typical tasks is obvious.
  

Can my end users inadvertently break the product or prevent other users from using the product?

Good answers include:

• Each workstation is separate so it cannot break other people's workstations.
  
• The server has quotas, permissions, and other administrator-controlled limits to prevent excessive or improper use.
  
• We support running inside a virtual server so our software failures are isolated.
  
• We blast our software with load-testing, failure-case testing, and intrusion-testing, so we know that users can't break it with normal use.
  

If your company goes out of business, what's the impact on me?

Good answers include:

• Because you own the software/hardware and you host it yourself, inside your firewall, you're not affected.
  
• Because your license code is good forever -- only upgrades require you to give us more money -- the software continues to work.
  
• Although we charge a monthly fee, the license agreement states that if we go out of business you can continue using the software without charge.
  
• We'll put our software in escrow so if we cease support you have the ability to maintain the product yourself. (In this case it's reasonable to require the customer to pay all escrow costs.)
  
• Our software is open-source and licensed such that you can continue using it and changing it. (This works if you're selling professional services.)
  

With these questions in mind, here's some ideas for tweaking the corporate spam filter product:

• The filter runs as a plug-in to your existing mail server. The email admin therefore has full control over when it runs, making it trivial to disable.
  
• If the plug-in fails it makes a log in the mail system which can then be monitored by the same tool that already monitors the mail system.
  
• Because it's a plug-in, it scales as your mail server scales.
  
• Users get one email per day summarizing the mail that was marked spam. They can glance over it looking for things that are not spam, and use a link next to each one to recover it, in which case it's instantly delivered to their inbox. Thus they can help themselves most of the time without burdened email admins.
• The summary email can is clear enough that most people will understand it without training classes.
  
• Spam emails are stored in a special folder in the mail system, not in a proprietary format. Then data access and backup can be done with any email client, even if you uninstall the spam filter, even if the supplying company vanishes.
  

Does your product pass Gerry's test? Want to brainstorm about it? Leave a comment and let me know.

Customers over Employees

Alex Kjerulf articulates why customers can't always come first.

Let me get this straight: The company will side with petulant, unreasonable, angry, demanding customers instead of with me, its loyal employee? And this is meant to lead to better customer service?

Everyone says "put customers first."  They pay the bills, they're who the company exists to serve, they're the ones who must be satisfied, in their hands rests word-of-mouth, the most powerful force of marketing.

But what about employees? The ones who you'd like to be motivated to serve these customers, day in and day out. Where do they fit in the customer service model? When it comes down to employee happiness versus customer happiness, what do you do? And yes, it can come down to it.

Some customers are so poisonous to your poor employees that it's your duty to get rid of them.  Some you should wish on your competitors.  Sometimes the customer isn't right.

Maybe 1% of your customers are problematic, but they're a vocal and time-sucking and morale-draining 1%.  Is 1% more business worth it?