replicator.org ... raising the abstraction.

One of my projects in which I have invested about 9 months of work is approaching a new stage what I am starting to call software post-production.

I’ve reused the term from movie productions because of the similar intent: Movies need to go through post-production to enhance their visual and audible appearance. Post-production is the process that converts a draft-product in a sellable product.

From Wikipedia:

Post-production is the general term for all stages of production occurring after the actual end of shooting and/or recording the completed work.

Over the last few years, the requirements and user expectations for Desktop Applications, especially the ones for the Windows Operating System, have been grown so much, that the process of preparing them deserves its own name.

Software Post-Production starts when the software is considered “feature complete”, meaning that all essential “customer stories” have been implemented and tested.

I’ve collected a number points that I think are worth to be considered in the “post-production” stage:

Appearance & Usability

• Create a nice and fast setup with a minimal user interface.
• Create nice icons and graphics. If not already done, let design the product logo and register trademarks.
• Do a lot of usability testing ... may add additional iterations to optimize the user interface.
• Avoid presenting information that is not required, i.e. don’t display an upload progress bar when there is nothing being transferred.
• Add additional information that is readily available and may be of interest to the user (for example show when the user has last updated the software)
• Focus on the context of the user: Avoid interruptions at all costs, if they are inevitable, make the transition as smooth as possible.
• For each step of in a user story, think about what the user may likely want to do next, and try to support him.
• Avoid clutter at all cost ... anything that supports clutter will lead to clutter, e.g. sort list entries in advance, or support snapping your windows to screen or other windows’ edges
• Store and restore changes made by the user (i.e. store the size of resizable windows)
• Consider choosing color schemes that can be discriminated by color-blind people
• Test your software with different font sizes and screen resolutions and allow users to modify the application’s font.
• Adjust color schemes to match the appearance of the operating system.
• Try to avoid visual distractions don’t let your UI flicker or scroll randomly.
• Don’t put the user into “tunnel realities” e.g. make lists large enough to hold a reasonable number of entries, use more screen estate when the user interacts.
• Consider different devices e.g. test if there is a touch device attached, render larger input elements.
• Design for elderly people if possible: A 70 year old will probably have a very low hit rate for a 16 pixel button on a 100 dpi screen.
• Announce possibilities gently For example: pop up a notification after installation to announce the availability of the tray icon.

• Prepare for localization Extract strings into resources, evaluate tool support and build up a network of native translators.

Security & General Paranoia

• Encrypt user configuration files to prevent accidental or deliberate modification
• Verify user input
• Use all possible means to store entered user information safely, like account passwords.
• Use all possible means to transmit user information safely on network connections.

• Track down all situations where the user has to be informed that something unsecure or spooky happens (for example: inform the user that an initially secure internet connection has fallen back to an unsecure one because of an invalid certificate)

Robustness

• Try to support a fluent user experience, even if exceptional situations happen: For example: when uploading of a file gets interrupted, try to continue at that point in the next attempt.
• Avoid the potential corruption of any user or configuration file. Think in transactions when accessing the file system (i.e. use rename instead of copy).
• May add a bug-reporting tool that catches all serious crashes and reports them after user approval.

• Test the software on all different OS versions.

Performance

• Never let the user wait. If a lengthy task is run, put the application into the background and inform the user gently when it is done.

• Never show a progress bar if the length of the task can not be estimated reliably. Ask for patience and show an activity indicator instead.

Distribution & Licensing

• Try to secure your code, obfuscate and sign assemblies. Remove unused library code, Try to merge modules together.
• Find a and implement a licensing scheme, offer trial editions.
• Consider offering a registration free download
• Build marketing in, allow users to buy a license or access a help forum directly from within the software. Make it easy for users to give away a link of your software. Support collaboration.

• Don’t kill all functionality when the trial period is over. Leave “read-only” features enabled, for example in a text editor: allow displaying documents.

Marketing & Audience

• Prepare the product web-site for the public beta and release (register domains, rent a server, etc.)
• Prepare a public bug tracker, forum, mailing list to keep control
• Research news channels, forums to cheaply advertise your product

• Find an marketing agency and start publishing magazine announcements

Legal

• Review all dependencies, libraries, graphics and their associated licenses, show appropriate credits, ensure that all required usage rights are backed up by contracts.
• If not done already: found a company to make selling software legal
• Find an attorney, prepare the software license

• Check for local patent laws all over the world. May disallow installation of the software in certain countries.

As you can see, post-production contains of a lot of details that need to be considered before releasing a software product.

Producing and selling software got a lot more complex compared to a few years before. Public consciousness regarding software quality has grown and standards have improved considerably. Striving to make software more usable and robust comes with a cost that users will honor.

yours
armin

If you have some more points to consider, just add a comment, I’ll be glad to add them up to this list.