When developing any application, getting proper user feedback during the early stages is essential if you want to have the application suit your customers’ needs. Often this is done with staged tests, but with web applications you can have the benefit of using an online method of retrieving your users’ opinions.

However, doing so can be tricky. If you want to get feedback, you can implement your own system for soliciting it, however, this takes up extra time that could be used to further develop your core web application. Alternatively, there are some existing online services that can provide survey-like questionnaires to users, but honestly, these present more trouble to the user than they’re worth.

When I first started using Stack Overflow, I noticed that the feedback service they had been using, UserVoice, was an elegant and functional solution to this problem.

UserVoice takes care of the problem for you, by providing you with an easy-to-use comment and feedback forum. (It can also be a place where users can submit bug reports, as well) However, it’s more than just a forum: By allowing users to “vote” on particular topics, it allows clustering of the most popular ideas/requests, thus bringing them to your attention the most. It also helps prevent duplicate topics from being submitted, and is a great “Digg-style” way of using the “wisdom of the crowds”, as they say.

There are some drawbacks, of course. If you’re using it to allow users to submit bugs, I wouldn’t rely on it as your sole bug tracker. Instead, I’d use it to receive the reports, then parse through and verify them before adding them to a proper bug tracker (like Trac) where they can be better integrated into your development work-flow. Furthermore, if you have a popular site, the feedback forums can still become deluged in too many requests/ideas, but that is a problem no matter what type of system you’re using for feedback. And, as mentioned before, the voting system helps to bring to your attention the most popular ones so that you can further make a value judgment.

I’ve since launched a feedback forum for RunTrackr, my side project for the past little while. I encourage you to give UserVoice a try, since it’s so easy to get started - you’re literally up and running inside of two minutes. At a minimum, give their home page a visit - it does a great job of explaining the process in a simple and easy-to-understand manner.

When Stack Overflow publicly launched back in September, I registered immediately after learning about it from a coworker. The product of Joel Spolsky and Jeff Atwood (among others), the site aimed to be a collaborative Q&A site focused on programming and software development. You could ask questions or provide answers to any of them. In their own words it was combination of “Wikis, Blogs, Forums, and Digg/Reddit”. Furthermore, they made no attempt at hiding the fact that they were designed to be better than other questionable sites, such as Experts-Exchange.

Though I registered over two months ago I’ve mostly been lurking since, but have been most astounded by the rate at which questions - often complex and very specific issues - get answered. Since the site allows users to rate/vote up other people’s answers, it provides an incentive for users to give good answers that will be recognized by others, gaining them points and increasing their “reputation score”. In this sense, it’s like Digg, but with a global ranking system.

I finally entered to the fray, answering a question about JavaScript the other day. It was actually a chore to find an unanswered question that I could answer, so I happily typed out my reply and finished it as fast as I could. This allowed to me to earn my first set of points! Neat! I am now hooked, and can easily see how the site and its concept has attracted such a passionate audience.

Another interesting aspect of the site is using it as a snapshot to see which topics are of interest in software development. By browsing the tags page, which lists the keywords most used by questions, it is easy to see that .NET topics (C#, ASP.NET) dominate the website, followed by Java and C++. PHP and JavaScript were quite a bit behind. This actually surprised me, given the prevalence of LAMP-oriented development.

But perhaps that’s because web development does not constitute a majority of software development. Furthermore, the topics that questions are being asked about does not necessarily correlate with the popularity of the topic - in fact, an extremely popular and established language might not have very many questions posted since the majority of the answers to questions will likely be found by a Google search. Nonetheless, the view of Stack Overflow provides an interesting zeitgeist into what’s actively being used.

I’ve also learned a bit from Stack Overflow beyond the actual content. In particular I was interested in their use of the UserVoice service to setup a community-driven bug report/feature request forum. I have since done the same for RunTrackr. The clean layout and easy to use navigation also provide some good examples of a simple but effective web UI.

* Sensationalist headline inspired by previous posts

Eclipse is my IDE of choice, as you’l probably have noticed from some of my previous articles. I had been wanting to write an article about why I use it (and why I switched to it), but kept putting it off. Recently, Matt Mullenweg wrote about his problems with Dreamweaver, and this perhaps prompted me to organize my notes on why I’ve chosen to use Eclipse. Don’t get me wrong - I’m not advocating that you immediately switch and throw out your current editing tool (the headline above, as noted, is purely for sensationalism) - but rather I’m just urging you to consider Eclipse for your next project.

Changing Gears

Like many, before switching to Eclipse I had been using a pure text editor, Ultraedit, for most of my web-development activities. Ultraedit seemed fine for most things, offering basic features like code highlight and autocompletion. However, it lacked a certain finesse when it came to dealing with larger projects. For example, if you’d defined a class, its members wouldn’t be available for autocompletion. Something else was needed. I finally decided to take the plunge, and switch over to Eclipse for all my development towards the end of the summer last year.

Some might wonder why I was even using a text-editor in the first place for development. For those coming from a traditional programming/development background, the idea of not using an IDE (Integrated Development Environment) is silly. This is because a lot of programming languages are compiled, and in this case, it just makes sense to use an IDE since it’s easier to write code, compile and debug using one tool instead of multiple ones.

However, for scripting languages, especially those meant to run on a web server, one can “get away” with not using an IDE quite easily. This is because the scripts are not run standalone but are almost always executed in the context of a web server; thus you’re usually editing code that you then run on a development web server, without the need for a special tool like a compiler. Additionally, it’s easy to view the output using any web browser. These reasons are what allowed me to persist in using a text-editor for so long.

No turning back

However, once I started using Eclipse, I was hooked. I downloaded Eclipse PDT (PHP Development Tools), which is basically a version of Eclipse bundled with the tools/plugins necessary for setting up a PHP development environment. Besides offering everything Ultraedit did, it also offered nice features like easy ‘Todo’ lists, (just type ‘todo’ anywhere in a comment and it’s automatically indexed by Eclipse into a list), code completion for built-in PHP functions and your own as well as a multitude of other advanced features that IDEs have. Oh, and it’s also FOSS. (Free and Open Source Software)

However, perhaps the best part about Eclipse is its robust and well-supported plugin system. This allows Eclipse to pretty much assume any feature that someone is willing to write a plugin for. This is what really sold me on Eclipse, because this almost makes its abilities endless. Some of the plugins I use are Subclipse for SVN integration, Mylyn for Trac integration and JSEclipse for JavaScript editing. This is part of the reason why Eclipse is the basis for many other IDEs out there.

Some other nice features are the ability to link the IDE in with the Zend Debugger, thus allowing for proper debugging sessions with PHP.

Spoiled

However, I’ve been pampered somewhat and have found a few things to complain about, at least when it comes to Eclipse PDT. I use Eclipse JDT (Java) a work and its advanced refactoring abilities are a feature I find myself wanting in the PDT version. Have you ever found yourself wanting to rename a variable to something more descriptive but putting it off because you’re afraid you’ll mess something up by forgetting to change the name somewhere?

With some IDEs, you’re left having to just do a search-and-replace in order to accomplish what should be a trivial name refactor. Even if your editor supports regex searches, things can still be tricky - what if you’ve used the same name, but in a different context, and thus shouldn’t change the variable there? The point is, the process still has to be human-supervised and is tedious. With Eclipse JDT’s advanced refactoring, you can rename the variable once - and the IDE is smart enough to know where else to change it to keep the code consistent - very neat, and I was amazed when I first used it. Other refactoring abilities include extracting methods out of blocks of code in order to clean up lengthy methods. All of this makes your life 10 times easier and allows you focus on real programming rather than annoying tasks.

However, Eclipse PDT doesn’t support this for PHP code, yet. I hear that it may be supported in a later release, so I have my fingers crossed. Perhaps accomplishing these refactoring tasks is easier in Java because of its compiled nature or because the JDT project has received more attention. It’s definitely possible in PHP, as some IDEs, such as the Zend Studio (which is based on Eclipse) support this ability. Zend Studio, however, is a commercial solution and I haven’t tried it out yet.

Nothing’s perfect

Eclipse does have its downsides as compared to a traditional text editor. First of all, it’s a memory hog - though most IDEs are. I have regularly seen Eclipse eat up 300-400 MB of RAM if I’ve been using it for a long time. However, it should be noted that I have not had it crash once, so it’s been rock-solid as far as stability goes. Nonetheless, I recommend you to have at least 2 GB of memory if you really want to use it properly, since you’re likely to have other programs open. This is especially important if you’re running Windows Vista. RAM is quiet cheap nowadays, and you can easily pick up 2 GB for $50 or less and upgrading is a painless process, so there’s no reason not to.

Finishing up

Eclipse has changed my life. Okay, so perhaps I’m exaggerating a bit. But, I can say that development, at least for me, would be much harder without Eclipse. If you’re still using a text editor for development, I urge you to give Eclipse a try - just for 30 days, and see how you like it. I don’t guarantee results as good as mine, but you may be pleasantly surprised.

Basically, a graphical command line is a command line that pops up on screen when you activate a keyboard shortcut/combo. This command line allows you to easily launch any program, file or action by easily typing its name. This offers you the advantage that good CLIs offer - such as auto-complete and speed-of-use, while retaining the advantages of the GUI. I recently learned of a Launchy, a nice program for Windows that offers these features. (Sort of like Quicksilver for Windows)

More than just a command line

Besides its fairly mundane appearance (though Launchy can be customized with skins), the Launchy interface can actually be one of the most powerful aspects of using your computer. When Launchy is first installed and running, you won’t notice a difference - in fact, you won’t even notice a space-stealing system tray icon. The command line window is brought up by pressing a user-defined hot-key. (By default it is alt-space, but I changed mine to ctrl-space, since the alt-space is already mapped to bring up a context menu for the current window, allowing you to minimize/maximize it fairly fast.)

Then, you simply start typing the name of what program you’d like to launch, and Launchy will look for matches. The list of matches pops up in an auto-complete list, and furthermore, Launchy seems to remember your usage habits somewhat, so next time you start typing, it’ll bring up the matches first that were previously used. Launchy is automatically configured to scan for all programs/links in your start menu, and also can be set up to scan other directories of your choosing. It automatically rebuilds the index after a user-defined period of time, so things are kept up to date.

The advantage of such a system might be lost on traditional GUI users, but anyone who dives into the command line will realize its benefit. Typically, input through a keyboard to accomplish actions is far more efficient that using a mouse. Take the Start Menu, for example. A typical computer will have dozens of programs available for launch, and finding the one you want in a menu can be a time-consuming and tedious task. By using Launchy, you can simply type a few letters of the program’s name, and it’ll pop up as an option. Launching a program takes far less time.

There are also a bunch of included plugins that allow for additional functionality. You can, for example, easily access all of your Firefox bookmarks, and also browse through directories/files from the command line of Launchy, further making it an indispensable application. However, perhaps the best part of Launchy is the fact that it’s open-source - that’s right, it costs nothing. So grab a copy of Launchy today!

An alternative to Launchy, which I have not tried, is Colibri. Give it a try, and let me know what you think.

More on why it’s better

As this article best describes it, a combination of the command line and GUIs is truly a best of both worlds solution. CLIs offer a “high bandwidth” input interface, meaning the choice of applications you can launch with just a few keystrokes is huge; this translates into a quick launch time because you can easily find what you want. GUIs offer a “high bandwidth” output interface, meaning they can convey a lot of information back to the user with graphics such as icons, drop-down menus, and the like. Combining the two gives a nice interface like that of Launchy’s.

In particular, I liked Launchy because I’ve been looking for ways to improve my productivity on the computer. Besides putting my most-used programs in the main level of my Start Menu (thus allowing them to be launched with two keystrokes), I was at a bit of a loss at what to do with other programs that I use less frequently. Launchy has solved those problems, essentially allowing me to launch most any program fairly fast. Windows Vista offers a similar feature in its new Start Menu (finding a program by typing), but I’m still running Windows XP and have no desire to upgrade to Vista anytime soon.

Perhaps the only problem with Launchy, has nothing really to do with Launchy at all. It is in fact the Paradox of the Active User, something that I’ve written about before in relation to design. Basically, the paradox can be summed up with the phrase, “Old Habits Die Hard”. Once most users have learned how to accomplish a particular task, they won’t be keen to learn a new way, even if that way is faster and more efficient - basically, they don’t like to take the time to learn a better way, even if in the long run it pays off.

I’ve been somewhat like this, having only recently enabled/started using keyboard shortcuts in Gmail and Google Reader. However, I’m trying to break these habits and by using Launchy more, I hope to transition to using the keyboard more to perform tasks, rather than just relying on the familiar but slow mouse.

Back in in June, the USPTO started a pilot project called “Peer-to-Patent” with the aims of opening up the patent review process to the public. By doing this, it hopes to leverage the help of the community in speeding up the patent process by having teams of volunteers looking for prior art that can determine the relevancy of the patent application. The IEEE Spectrum had a good article/interview with the founder of Peer-to-Patent; it’s a short read (2 pages), and I suggest you read it since it does a good job at explaining the goals and the means with which the project aims to accomplish them.

There is apparently a huge backlog in patent applications, so the needs for a project like this are obvious. However, will the “wisdom of the masses” prevail in helping to resolve the numerous problems in the patent system, evidenced by the seemingly endless litigation related to it?

Software only, for now

First of all, the USPTO is not opening the review process for all types of patents. Since Peer-to-Patent is a pilot project, for now, it’s only covering software patent applications. Additionally, inventors are not forced to submit their patent to this open process - it is a voluntary choice. However, if you choose to opt-in to this process, your application will skip the four-year backlog of applications submitted using the “regular process”, and will be reviewed in a much more timely manner - this is the incentive for the program, at least on the inventor’s side. So far, companies like GE, HP and IBM have opted to participate in the project this way.

Community involvement

Community is a two-step process, and anyone can choose to be involved in the review process. Your job, should you choose to accept it, will be to scour for “prior art” - publications or work that relates to the claims of the patent application, and that would help decide on its relevancy. You then post/upload your findings to the Peer-to-Patent website. 10 to 25 new patent applications are expected to be posted to the website every month, providing plenty of material for volunteers to search on.

The second part of the process involves deciding the 10 best pieces of prior art for each patent application. After a set amount of time, new submissions of prior art are closed off, and the community must then vote on which pieces of prior art they think are best. Each user/reviewer would get one vote, and the top 10 choices are then forwarded, along with the patent, to the USPTO for the final decision as to whether the patent is awarded or not.

So, the entire process isn’t decided online, but rather, this pilot project takes care of the first step of a patent application. The founder of Peer-to-Patent, Professor Beth Simone Noveck, describes it best:

If you think about the fact that a patent examiner now has between 18 and 20 hours for the total review of a patent application, 18 to 20 hours to decide whether that Blackberry patent application gets granted or whether the peanut butter and jelly application deserves a 20-year grant of monopoly rights, 18 to 20 hours is not a lot of time to complete all the research and do the review.

The process has the added benefit that an entire community is likely to have at least a few volunteers that have some special knowledge or experience related to the specific patent that a single reviewer would not have. This would allow them to find and explain prior art and its relevancy in a better way. After all, the field of even software patents is very broad, and must encompass an enormous amount of information.

The solution?

Peer-to-Patent has the potential to succeed, and hopefully with its success, will usher in a reform, at least in the area of hi-tech. There have been too many frivolous patents accompanied by frivolous lawsuits. In addition to impeding technological progress and development (the opposite aims of patent law), these lawsuits tie up courts and waste resources. With this project, prior art should hopefully be found before these bad patents are granted.

With the community only being involved in the first step of finding prior art, the USPTO still having the final say, I think a nice balance has been struck. This way, you still have some level of control and the USPTO can still use its own judgment. It’s not greatly different than Wikipedia, where some users have more control than others. And, let’s face it: There was no way the USPTO was going to completely relinquish control - that’s just too big of a step.

However, I can see some problems developing. First of all, anytime you have an online voting system, there is always the question of fraud. Since every user/member of the site has one vote in deciding which pieces of prior art they think are best for an application, how do prevent people from establishing multiple accounts and “gaming” the system? One way would be to request a credit card number, just for verification, but I believe this would be a huge impediment to participation. This is a serious issue, with sites like Digg constantly combating “gaming” of their system and other attempts at fraud. If Digg suffers from organized attempts at fraud from marketing services, you can almost be certain something like Peer-to-Patent will suffer from something similar.

In a worst-case scenario, I could see the litigious patent arguments in court merely being relocated to the online-forum of Peer-to-Patent. While this may be better than seeing them tie up the courts, you’ll remember that I’m not exactly agreeable with online debate. Furthermore, there are more serious concerns as well. Sneaky or unethical companies could secretly hire teams of “reviewers” to promote prior art, agreeable with their patent applications, to the top of the list, ensuring that the USPTO only sees these. This would be a clear abuse of the system, and a conflict of interest.

Optimistic

While it may seem that I’ve been pointing out the worst, I’m cautiously optimistic about Peer-to-Patent. I believe it has the potential to succeed, so as long as the creators are flexible and quick to respond to any deficiencies in the system, thus keeping it fair. And, let’s hope that they do succeed, as patent reform has been sorely needed for some time.