This is my commentary on what I believe are features of good software. Since I'm a software developer, my views are most likely different from the average user.
High level of customizability
It is unlikely that any good software comes exactly as EVERY user would like it. People are different and some people will love one feature while others will hate it. Because of this, each piece of software should support a high level of customizability. Such customizability should start at installation where the users can choose what to components to install and where to install them. A rich set of runtime options should be available to the user.
Customizability is especially important when features require changes to the host OS. It is possible that features may conflict with other software, thus it is important that features can be disabled.
The plugin architecture employed by Eclipse and Firefox are good examples of allowing high levels of customizability.
Being user-friendly means being friendly to ALL users, not just the average Joe
Good software caters to average users, power users, and developers. Although the average user may not know what an error message may mean it doesn't mean that the error should be hidden in some obscure log file, or discarded entirely. The user may be a developer and can help determine the root of the problem and fix it.
The average joe may do nearly everything with the mouse, but this doesn't mean that there shouldn't be shortcut keys. Power users may want to invoke the program's functions via the keyboard so the programs should support this. While it is best to have shortcut keys similar to all other programs, it is best to allow the user to specify what keys to use.
Although it may be good to hide advanced options from the average user, they shouldn't be hidden so well nobody can find them. Even worse is the case when these options could be changed, but no interface is provided to change these options.
Truly excellent programs offer both a GUI and command line interface to perform common tasks. Even GUI-only programs should offer command line options to affect how it starts up. Any command line options available must be clearly documented.
No registry keys
The Windows registry may be good for some things but it is not a good place to store user preferences or application information. The registry is hard or unsafe to manually modify. Registry keys are hard or impossible to revert. Registry changes are often left behind after uninstallation, unnecessarily cluttering the registry.
Plain text files are best. These can be INI files, properties files, XML files, or even some other type of file. The important thing is that these files are both readable and editable by humans.
Keep things together
All files relevant to a piece of software should be put under a single directory. Allowable exceptions to this include putting application-wide or user-specific preferences in the directory that is designated for storying such preferences. Even so, it is best to keep things together. Systems supporting symbolic links should put links to directories and folders that aren't under the main application directory. Temporary files stored in system temporary directories are also acceptable, but these should be easily found and easily removed.
Keep your hands out of my OS
Good software shouldn't install services, run something on startup, put anything in the system tray, modify file associations, change icons, modify system files, automatically update, add shell extensions, or make any other significant changes to the OS and its UI without explicit direction from the installing user.
Do one thing and do it well
I don't want a web browser, an email client, a music player, and an IDE all rolled into one. Applications with multiple functions rarely do an excellent job of handling all those functions. Applications with a single function often do their jobs very well.
Lose that unnecessary weight
Good software should be lightweight. In other words, it should be as light on system resources as possible. System resources include RAM, CPU cycles, IO, network bandwidth, and even screen real estate. The difference between Foxit Reader and Adobe Reader is a good example of differences in weight. Foxit Reader starts immediately, using a minimum of RAM and CPU. Adobe Reader, on the other hand takes several seconds to start up, and will sometimes even install a pre-loader to pull some of its libraries into memory to allow the program to start faster. In short, all bloatware should die.
Clean up after yourself
When good software gets uninstalled it should leave NO trace that it was ever there, unless the user explicitly chooses to leave files behind. All application files, registry changes, user preferences, and temporary files should be gone. Any files that aren't removed should be explicitly specified to the user. This allows the user to manually remove the files or otherwsican be done.
Make it easy to find
Good software puts functions or actions in places where users expect to find them. Menus, key shortcuts, and context menus should be well thought-out. I shouldn't have to read the help file to know how to initiate some action or process. It should be easily found from the menu or toolbar. User interface conventions should be followed unless there is a good reason not to follow them.