What features any good application should care about 'By-Design'

Question

I know that the default answer is "it depends", but I want to know the feature list you are working from in developing a good application.

I'm particularly interested in features that need to be cared about at design time because adding them late will cost us a lot.

Please list one feature per answer so we can vote for the most important features.

Any extra info, like your own war stories, will be appreciated.

I ask this question to enhance my application from day zero, and I think I'm not the only one with this target, so please write whatever feature YOU think should be exist in a good application.

Answer 1

Logging and error handling

Answer 2

Personally the good feature that I was not giving it the intention it should take is
Extensibility

It helps my application community to grow up - which is good for marketing wise & technical wise and it helps me focus on my core business and leave the cool features to be built by its users

Answer 3

Search. It should be easy to find the search textbox, and the results should be as good as possible.

Answer 4

Shortcut keys (ctrl-f, etc...)

Answer 5

Modularity - Productivity - Extensibility

That's are the overall design goals of - let's say - Smart Client Software Factory. And it works.

Answer 6

Crash reporting, because it will crash, and the development team needs to know when it does, so you can stay on top of problems...

Answer 7

Performance (read that as latency if you wish).

Despite zillions of people shouting premature optimisation across the board, it is a simple functional requirement. Be different and defy with better quality (or design for performance, not premature-optimisation pickers).

There are no other projects in the world requiring perf-retrofitting more than VM like solution in Java and CLR. It is a glaring artifact of their every product, technology, edition and of course bloat called: .NET 3.5 and say Oracle 200MB client (lol).

VMs just suck in every new feature perf-hit, edition and build apps on that and you honestly need a Cray.

Scalability is totally different story, but man, people just won't use high-latency apps and most CLR ones (apart from web stuff that is just plain simple and unapplicable 60% of the time say, like this site/app ) are just that. Load something serious them up and you'll be running to unmanaged office, unmanaged IDE, unmanaged database, unmanaged game, umanaged browser and so on and on.

Somebody should whack the GC lovers with a bat and tell them to wake up..

Answer 8

Design from User Stories, intentionally deferring database design decisions until at least the first cut at the top-level stories are created. Far, far too often, the components of various user procedures are distorted by the requirements of relational integrity and table maintenance procedures. How often have we all seen a new sales order being entered, and the user is required to navigate several forms to fill in customer details (sometimes requiring phone calls and/or fake data for unknown), mandatory fields that really aren't, credit information that really comes from another department, cancelled entries due to incomplete information discovered several pages deep, etc.

Too seldom does anyone maintain and review usablity metrix like pages navigated, keystrokes entered, interrupted tasks; though the mission of the customer and the productivity of the users should be the primary determinants of software quality.

Answer 9

Interface complexity tiering, with the most common and desirable actions extremely simple and obvious to carry out, while less common and less desirable actions are reached through greater complexity.

Answer 10

Internationalization.
Adding it as an after thought can be expensive

Potential pitfalls:

• non-English OSes (don't assume "Program Files" directory name for example)
• reference data (translating display text)
• images (text in images would need to be translated)
• UI layout (padding for longer text after translation)
• multi-lingual installers, EULAs etc
• hard coded strings!
• not specifying culture specific formatters
• currency, time localization (e.g. use of comma vs period in currency)
• design approach: embedded resources vs satellite assemblies (i.e. "language packs")
• database design: how to store/lookup language specific values

Answer 11

Usability - No matter how extensible and error free our application is, its success will usually depend upon how much the end users will like it. It could be coded like trash underneath, but if it's easy to use and very intuitive to learn, it will still be a winner.

Never forget that to the end user, the UI is the program. Make a high degree of usability a feature for all your applications.

Someone in the comments asked how to implement usability as a feature -- unfortunately it's not something you can make a feature request on (e.g., "make this website usable") but it's more like a set of guidelines you should follow when designing your UI, much like the guidelines you follow during coding that makes your programs extensible.

This post is hardly enough space for that. I highly recommend Don't Make Me Think by Steve Krug as a starting point for any person concerned about usability.

Answer 12

Regression testing: the ability to easily, routinely verify that key functionality elements continue to perform as expected as the system is modified. (This is an more specific element of 'extensibility'.)

Answer 13

Introspection: the ability for the system to programmatically make predictive determinations about its own structure and behavior. (Analogous to reflection at the language level, and a key element of extensibility.)

Answer 14

Security. Pretty amusing, if unsurprising, that this is the fourteenth answer to go up.

Answer 15

Input focus defaulting: In any interface presentation where the user is expected to do any typing, input focus should default to the location they are most likely to want to begin typing. (This is a specific feature in the Usability area.)

In the case of Web forms, it unfortunately needs to be noted that the focus defaulting also should not interfere with the user if they have already begun typing when the focus defaulting is checked.

(Shameless plug: I maintain some generalized Javascript that addresses this for Web forms.)

Answer 16

Simplicity - Do what the users want and expect in as few clicks as possible.

Stackoverflow is a wonderful example of this. The interface isn't loaded down with chrome. The largest graphic on the website is about 3k.

Answer 17

Mouse-free operation: To whatever extent feasible, the application should facilitate the user interacting with it without the use of the mouse. (File under Usability, Accessibility.)

This doesn't necessarily mean going to great lengths to support mouseless usage; more just refraining from forcing the use of the mouse where it shouldn't be required. For example, don't defeat the default form-submission behavior when pressing enter in a Web form unless you're going to do something more useful with it.

Answer 18

Comments. Implement an internal standard comment system (first, document it!) - an automated comment documentation system may be right, or just a set of standard program header comments and comment conventions. Let programmers know in advance how you expect the code to be commented. Have cross-programmer code reviews, checking readability/understandability with an eye to future modification: if you're the next person to work on this code, will it make sense to you?

Answer 19

User Interface/Experience Design Many technological innovations rely upon UI design to elevate their technical complexity to a usable product. Technology alone [usually] does not win user acceptance and subsequent marketability.

From IBM:

In software development, design is widely misunderstood and undervalued. Often no explicit user interface design is done separately from the code. Iterative design then becomes recoding. This is a short-sighted strategy because it results in significantly more code being written in the long run. Because design is unavoidable, the real issue is whether it is left implicit in the software being developed, or made explicit and captured separately. The useful debate is about how to do design work well, and how to capture it in an optimal form for communicating to those who implement it.

Answer 20

Reporting
because it always hurts to run one report that reads data from almost every table in the database
I once saw a presentation (which I can't find it any more) talking about database design pattern for data warehouses, with amazon showcase
on of the solutions was to make a special denormalized database which reports are published to it every certain period

Answer 21

Tagging

not just in community-centric application but also for Line-Of-Business applications By allowing tagging, Employee can create new tag with 'Watch this' which he can attach for student record, received receipt and ect...

Answer 22

Undo

Every application (except those, like compilers, with no interactive user interface) should keep track of every user event (navigation, modification of documents & preferences, etc) so that the user can backtrack from his current state.

Even applications with no mutable data still usually allow the user to navigate. A browser "back button" is a great example of an Undo Feature.

Answer 23

Inbox
although it seems to be a very small to mention, but it really has big effect on the usability of the application and the performance too Imagine if user can ask a heavy report that may take some minutes to generate,
instead of 'click and wait' he can choose 'send me the latest report when it is ready'

Answer 24

* Most recent actions/Hot Actions *

I love this feature everywhere I see it:

• Wikipedia - What was just changed?
• Stack overflow - Where are the really active questions (where's the action!)
• Blogs/Inbox - Almost every blog sorts this way for a reason

Even when I'm on a website like Reddit, many of us search for the stuff that's being commented on the most, because that's the interesting stuff.

For example, I wish it were the default for answers, because this answer will be ignored! :)

Answer 25

Automation - if application does not require UI for operation, then enable ability to execute using command line or script. Found many good FTP tools (archive tools too) that fundamentally do not need a UI to do the intended job, but are not script-able or do not have command line capability.

Answer 26

Testability. When you have that, modularity, separation of concerns, reuse, proper error handling and many other good things come free.

Answer 27

Unicode support, because no good comes of your presentation layer encoding being ISO-8859-1 and your persistence layer encoding being UTF-8.