On Reporting

Uncategorized

“We need to give the customer a report…”

If I had a dime for every time I heard that, I could at least buy a cup of coffee. We assume that customers like to stare at raw data, try to make decisions from it, and then go change something. I doubt that.

Reports fall in to a few broad categories:
• Lists of items that I need to do (pick lists, for example)
• Data I need to submit to a bureaucrat (tax forms)
• Summary information that tells me the current state of affairs (balance sheets)
• Raw/semi-processed data to make a decision (inventory on hand v. demand, as a contrived example)
In the case of lists, sometimes the best way to present the information is as a list report that we display on a screen or print. Then the user can take that report and use it to do their work, checking off items as they go. For simple cases and short lists, this is a fine solution.

The problem is, if they want to generate a list from a computer, it is a long list. It might even be a list that several people are working on. Reports are a horrible solution in this case. It is better to have a real application that can take into account things like changes to the list, work other people are doing, etc.

In the case of data to submit, just about every possible recipient of this data can accept a data feed. We can do this in the form of a report, but often it is better to just build up an automated interface.

When we need to give the user a summary of the current state, a report can be a pretty good solution. A well-formed report will have the information necessary for discussing the state with others. It can be portable (either by viewing it on a tablet or printing it out). It is concise and easy to find the information you need. These kinds of reports are rare. There are examples of mediocre attempts at this, so we know it is possible, but the reports that achieve this goal are a rare breed indeed.

The final case is happens a lot and I believe is the key problem with reports. We give the user some information, expect them to process it themselves, and then come back to our software to make some sort of change. We have turned the human into a computer that is subservient to a real computer.

Why does this happen? It happens because we are too lazy to do the analysis to figure out how the “algorithm” the human is using works. That might be because there are decisions made that are difficult to encode. It could be because we’re afraid we’ll get it wrong so we don’t even try.

Sometimes it is because we are afraid the user won’t trust our answer. There are ways to address this. We can show the user what we plan to do and allow them to confirm or override. We might have to display more information to the user so they can make that decision. Over time the user will trust the code and just let it do the work. At this point we have a happy user. To do this we need to iterate over the solution and get user feedback.

There are so many horror stories of how software makes people’s jobs harder. It’s ironic, because this software was sold to make their lives easier. We need to remember why we are building the software and do the hard things that will make our user’s lives easier. That is what they want.

Advertisements

Reusability is a Deal with the Devil

Uncategorized

OK, it’s not, but it has some similarities… 🙂

Reusability sounds like a great thing. Build something and reuse it often. What’s not to like? Well, a few of things.

If you build something with the intent of being able to reuse it, by definition you are building more than you need right now. It takes extra effort to build in the extensibility points. You need to test for the hypothetical future cases.

There are cases where this extra effort is worthwhile. If you know you are going to be building a lot of similar applications the work you are saving yourself should offset the extra work. When you are building an interface to third party systems it makes sense to build in extension points. If your business is to build libraries for other developers, of course they need to be reusable. But these are rare cases and usually only need limited reusability.

If you have existing code and want to make it reusable, that effort has a cost. If the current codebase is not good, you will pay a lot to make it reusable, and not just immediately. The code will always be buggy because it started that way. To further tax the debt metaphor, you will pay interest on that code forever.

There are times when it might be OK to take current code and reuse it. In these cases you will want to copy and paste it into a new project. It should not keep any ties to its past life. It is serving a different purpose. The chance that it will solve the same problems is low. Trying to keep it in sync will just lead to more bugs.

If you really need to reuse code, you have to have automated tests around it. You need that safety net. Without it, as the code evolves away from its original purpose, bugs will creep in. A change to business logic to solve the current problem may have hidden impacts on other parts of the codebase. Automated tests will save you from a 4 hour hunt for that method you didn’t know existed because of a dependency injection trick.

If you need to get a feature done fast, reuse is your solid fair weather friend. Just be careful when the weather changes.