Discussion Locked

Should developers anticipate as much of user needs as possible?

0 helpful
36 replies
Closed to new repliesThis discussion is closed. It stays readable, but it takes no new replies.

After reading the blog Programming "how versus programming "why", I wanted to bring this topic up.

For two years at my current job, I was "given" the task of developing a database system. Throughout the process of development, it became visibly apparent that an user interface had to created because of the increase tasks required of the database. The users who will be using the system are at the very most very basic computer users. I truly had to be their translator when it came to helping them to understand what could be done and what could be possible to what's impossible. . This was very hard at times because there was no development structure. The database was a part of a much larger project that started two years before I was hired at my job. When I use "given" the takks of the database, it was that literally because of my background and basically not having anyone else to do it. So, using the RAD method was the only choice.

Because of the enourmous time constraints, I had no choice but to consider all possible tasks that would be needed of the database and user interface. Even though the end user input was constantly there and vice versa, I had an advantage. The division I work in allowed me to "learn the business". It wasn't a problem for me because it was something i jumped at the chance to do, plus it has the added benefit of helping me to understand better how to organize & store the data that would be going into the database.

During the initial development, I had the chance to work with someone who used to be a systems analyst. During one of our meetings to discuss the design tasks for that day, we talked about why I made certain design decisions with the user interface and then he said something I won't forget. He said that me (a developer in general) shouldn't try to anticipate all of the end user needs because it leads to trouble. I tend to think that he's right and wrong to that. I subscribe more to the wrong side of it because in my specific development situation, being about to anticipate what the users needed worked, by the fact of me "knowing the business". The systems analyst would was working with me didn't have that inside knowledge; I'm assuming he was coming from his past experiences. What to you the subscribers of TechRepublic think? Is there anytime when anticipating as much as possible helps? Whether we use MS Office of KOffice for Linux, they are attempts to anticipate a task we as users need.

36 replies

by stargazerr

But whatever you decide should be okayed by the end user, since they are the people who are going to end up using all the features you put in.

This way, they will be saved the trouble of thinking up and designing the main interface. And you, being the developer, can think of all the little details they will normally, overlook.

]:)

by tonythetiger

there's no reason the user has to know about the anticipation :)

I have been known to include something in my application that I [b]know[/b] they are going to need, but not make it visible [b]until[/b] they need it.

by jmwangala

If you took a situational approach you would realise that both of you are right. Imagine if all users of Microsoft Office had to okay the software design etc. I think a developer should go ahead to anticipate the needs of his users and incorporate them in the design and if possible obtain the OK from the users. Where a developer does not consult the end users there is a danger of ignoring certain issues which may seem trivial but yet necessary for ease of use of the software from the end user's point of view.
I think a mix of the two approaches is better - involve the end users but also anticipate as many uses (value added) as possible.

by jaqui

on the project itself.
In the example you used, you were creating a custom appication for a specific company. What that company needs the application do do, and how the end user will be able to accomplish it, is very much part of the project.

if you chose to develop an application to perform a specific task in the fashion you want it to. polish it up and make sure that there are no bugs or exploitable errors in it, then see if there is a market for it, no, end user needs are not taken into concideration. [ as feature requests for later versions, maybe ] The big difference being where the funding is coming from. if you are being paid to supply a tool for a,b,c,d purposes then you take those purposes into account. if you are developing a tool for yourself, then decide to clean it up and see if there is a market, the payment is nil unless there is a market.

by beilstwh

I have been programming software for almost 30 years and if there is one thing that I have learned is that you have to make your software interface idiot proof. You must anticipate all possible ways that a user can mess up and program to handle it, even if handling it is to issue an error message, because it is a 100 percent given that at one time or another the end user will put in garbage. Your system analyst sounds like someone with little experence in the real world. I have had a lot of hats (Programmer, DBA, Analyst, network admin, emain admin...) and unless you want to spend your time repairing data, handle it upfront.

by rayjeff

From the way he was talking to me, I don't think he's had much real world experience either. At my current job, he's the MIS director for the college. The reason he was working with me because of internal politics. You know..."someone was able to pull off the project before you could and now to not let everyone else know that they did all by themselves, you pull rank and come in as a "partner"".

Even with the non-experience (outside of academics)I had before the project, just some of the things he did if anyone had common sense, you could tell that they wouldn't work.

Idiot proof...or as close to idot proof as you can get it. That was my reasoning for telling him why I had to anticipate all of the end users needs. For one, they are mid 50s+ year old college professors. So that in itself is saying alot right there. And with them not being very computer-literate, someone or something has to bridge their gap to make it as easy for them as possible to use. And plus with me already working in the division and with the project overall, I had to know every single detail about every piece of data that comes in or out of the division (knowing the business). That was the one major advantage I had over the system analyst. But, I was wrong for using that knowledge.

by jamesrl

Much depends not on the method, but the approach.

In a traditional model, during the project definition phase, the users are asked about their requirements. In commercial products, marketing may ask customers, support staff (bug fixes, suggestions, enhancement requests logged with users). Internal software projects often hold a review meeting - often the users are presented with a barebones set of requirements and are asked to flesh them out.

In the RAD method, the programmer/analyst goes on much slimmer requirements and then shows a prototype to users to get feedback. This is often an interative approach - it may happen over and over.

I would say its dangerous to listen to the squeekiest wheels only - the BA/PA needs to take into account all users and also account for other requirements (supportability/system) requirements as well and try to achieve a balance. But ignoring user requirements is like turning the Titanic into the iceberg.

Some projects lend themselves better to one method or another, but in the end, its how well the PM and BA are focussed on the customer/user's needs.

James

by justin james

There's a LOT to this one. I'll be blogging about it shortly, because it is part of my current theme of the development process, the user/developer interaction, development tools... the whole ball of wax.

If the developer thinks that he knows every way that the user could possibly want to use their software, they have a bad case of developer hubris ("I know better than my users how they should be doing their jobs"). But software that is able to "anticipate" the user's needs, and present the proper information and controls in a contextually sensible fashion is software that is going to sell like hot cakes.

I don't want to go into too much detail here, esp. since I'm writing a blog post about it, but the concept of "anticipation" is one reason why I beleive that compiled languages need to "play better" with interpreted languages. Stay tuned to my blog over the next week or so to learn where this is going.

J.Ja

by wayne m.

Let's be careful of terminology here, but I would recommend that one focus on understanding the current needs and do not try to forecast, much less develop for future needs.

Let me be blunt. Any time spent working on future needs is directly delaying delivery of product to meet current needs. Most projects are backlogged, and the decision to be made is to trade-off delivery time for expansiveness of the solution to meet current needs.

I strongly feel that developers need direct exposure to the user environment. No requirements document or specification conveys the actual need. It is also unlikely that the users will be able to articulate their needs; the developer must experience it first hand.

As the developer will never become an expert in the users' area, I feel iteration, as tight as possible, is needed. This allows the developer to provide minimal solutions and expand them based on feedback. The tighter the feedback loop, the more minimal the solutions can be.

Do not try to anticipate the future. Do be as creative as possible in addressing the present.

by frankz

Agreed on Wayne's last point: Be flexible, and be as creative as possible, in addressing current needs. Quite often, you may find, this helps in addressing future needs too.

Take this simplistic example, for illustrative purposes only: The user tells you that when an order is confirmed, a notification must be sent to the Shipping Dept "ABC" and the order status must be set to "X".

Resist the urge to program the results into the application (i.e. notify Shipping Dept "ABC", set order status to "X").

Instead, develop a control screen that allows the user to specify both results:

When Order is confirmed, notify Department: ___

When Order is confirmed, set Order Status to: _

And if you want to add more flexibility, develop for the possibility of specifying multiple departments in the notification function (e.g. the Sales Department may also want to be notified of a confirmed order).

by tony hopkinson

I wouldn't write the UI to do that but the underlying function should be agnostic. Pass in the status letter and a list of people to notify. That adds very little to the development time and leaves your options open to add method of choosing status and recipient(s) later.

by wayne m.

Though I understand the difficulty of quickly coming up with a worthwhile example, that is also the difficutly in premature generalization.

The problem with the "enhancements" described is that they push decisions from the program onto an administrator without any indication that the changes will ever be need nor that the changes will function as later desired.

In any business system I have worked on, the work states were well defined and rarely changed. When they were changed, there were many additional changes to use the new states, and usually a data migration was required to translate the existing data and maintain the integrity of reports.

As for the notification, if it is either e-mail or SOA/ESB (Service Oriented Architecture, Enterprise Service Bus), there is already a mechanism in place to redirect the messages. There is no need to add this functionality into the code.

The problem with designing for future expectations is that there is no current need to evaluate the implementation against. There is simply no way to verify that the code correctly does what will be needed a year from now.

The configurability has merely deferred a one time decision by the developer and created a repeated task for an administrator and has increased the likelihood that at least some users will get non-functional software because it was not correctly configured.

In many cases, it is much easier to overlay a new feature onto existing code, than to try and resuurect the partially thought through intents of a long gone developer and modify the code to do what really needs to be done. [I hope my comments do not sound overly harsh, but I am quite passionate on meeting current needs now and future needs in the future. I am just using the proposed example as an alternative to dredging up some personal examples from the past.]

by rayjeff

I think for me, because when i first started on the project, I had no idea on where it was going. So I had to think about the present as well as the future needs of the application by the users. And what I began to see is when present needs changed, it changed the future need connected to it. So, it was a constant tug-of-war in my mind to know how far I should develop a certain area within the application.

"I strongly feel that developers need direct exposure to the user environment. No requirements document or specification conveys the actual need. It is also unlikely that the users will be able to articulate their needs; the developer must experience it first hand"

I agree 100%. I'm knee deep in my users' area. I really enjoy it because it gives me the opportunity to know what's going on. To understand what it all means as far as the actual usage of the data.

by tony hopkinson

To keep to a budget / deadline, you shouldn't go around adding unrequested functionality. However, if you can anticipate a use, generally it will happen so specifically designing it so it can't be done is a tad daft.

There's a big difference between future proofing a design and pre-empting it.

In the former you don't disallow a future option, in the latter you consult your astrologer, examine the entrails of a few chickens, perhaps a seance with Alan Turing's ghost and then guess and cross your fingers.

Trying to minimise the cost of a change is not implementing it now, it's making sure you don't have to rewrite everything from the ground up.

by tony hopkinson

I got asked to amend an ordering application so you could have more than one order per customer.
It's true! 6 months development effort and to cut costs (two weeks was the original estimate) they specifically designed it so you could not relate the order to the items on the order and the customer order was link 1 - 1.

The customer had said "oh we'll never need more than one order per customer", the BA agreed, the developer agreed and management said great two weeks off the cost.

Took me three months to bodge a link back in, restructuring the entire database , change two tiers of components and changing the UI to manage it. Not to mention migrating the data to the new structure, and the interface the billing system.

The thing was I don't know where they got two weeks from, my extimate would have two hours extra work and then maybe a week to actually implement.
Course the bodge wouldn't have took me as long as it did, if it weren't for three or four other catastrophic design 'decisions' with even less 'sense' behind them.

Now the developer would have been very wrong to implement a fully fledged system, but simply to add order number to the datbase and component structure would have saved them ?10,000 and they would have looked clever.

by jaqui

Tony,
think about what that company was saying by saying we will never need more than one sale per customer...

We are such a lousy company they'll never come back.

{lmao.gif}

by tony hopkinson

Not much but a bit. Still probably the stupidest design decision since integrating a browser into an OS though.

Also there was no split between provisioning and sales order (same object !). For telecomms !

The interface was a multi-multi-tab load everything at once job based on a worksheet originally used to collect the data from the customer by a sales rep.

The presentation layer objects used the matching database pairing. If you used the customer presentation object you had to gave 91 other units in the interface uses clause !

Just to cap it all off, in the billing interface unique customer id was the surname.

Total f*** up from start to end and without doubt the worst piece of design I've ever seen in the 28 years I've been coding.

And people wonder why I get anal about the basics of development.

I spent the first two weeks fixing about 50 memory leaks as well. Put in twenty orders and the PC ground to a halt.

Five months there, it was the first time I've ever been glad to be out of a job.

by jaqui

with making sure the foundation for any application is well thought out, so I don't wonder why you get anal about the basics. :)

sounds like they had a VB developer do the work.
drag and drop code generators create that bad of code.

by tony hopkinson

Still at least they didn't use the tropical fish example of how to do a database app (data aware controls). Just wish this over qualified fool who came up with it had been left with the enhancement instead of me.
What "twat" wrote this is much more fun when it turns out to be yourself when you obviously didn't know anything practical.

by michael.crocker

The Program Management Institue defines adding stuff that is not in the requirements as "gold plating". I have also seen problems when the developer assumes the role or user. The key here is to collect requirements that as as complete as posssible (due to lack of perfect knowledge there will be something missing). Most develoipers tend to work form the application view (what can the system/program do). Instead you should work from the business process view (what do the users do and how can the new system improve that?).

I think that you where moving toward that by working with the users to understand what the database can do for them. The comments of the System Analyst was correct form a strict "develop to the requirements" point of view. Unfortunately, ther are too many failed projects that met all the requirements but were not used.

Typically a Business System Anaylst or Project Manager should be working with the users to map the "AS-IS" and "TO-BE" processes which are then translated ito requirements.

by tony hopkinson

developer would write an application that could only ever do what the user required now as far as he understood the requirements in the first place.

Equally a developer that develops something different to what they were asked for is asking for it.

All you have to do is not take decisions you don't have to. 90% of the time it's really simple stuff.

We'll never ever ever want to link the Customers in the customer information database to customers in the order database.

I'll make Customer_ID the same data type just in case then.

There are only three possible statuses for an order.

Right'll I'll provide a list of status codes instead of hard coding

Extra cost to doing this nothing to very very little.
Cost if they change their mind anything thing from Oh to Arrgh!!!!

Always look for no-brainers.

Here's a classic.

I want to look at all the items in the current finacial period. Last period at the same time, no, no need for that.

function get_current_fiscalItems : ItemsList;
begin
Result := get_fiscalitems(gblCurrentPeriod);
End;

function get_fiscalitems(aperiod : PeriodID);
Var
Index : Integer;
begin
For Index:= 0 To allFiscalItems.Count - 1 Do
Begin
If allFiscalItems[Inde].PeriodID = aPeriod Then
Result.AddCopy(allFisacalItems[Index]);
End;
End;

Now how many times have you seen that simple level of abstraction missed ? and to save what five minutes developement time ?

Now YOU could easily add this, but it's always going to cost more to do it second time around. For a start everything that uses it is going to have to be regression tested.

Gold plating is for ponces, I like steel, preferably quarter inch think. With a good layer of kevlar underneath.

by wayne m.

I've become more and more of an advocate of not generalizing until the need requires it. I am not convinced there is a cost savings incurred by implementing the generalization now instead of later.

It is difficult to argue against any single instance of generalization, but across a software deliverable, I have noted the following issues seem to crop up.

In a current development, it seems that at least one of the "5 minute" efforts blows up and becomes one of the major time sinks. It is very difficult to put the genie back in the bottle and go back and rewrite to the specific version instead of spending just 5 more minutes on trying to get the generalized version to work.

In a future release, the generalization can become a set of handcuffs when trying to implement the actual generalization needed. It becomes an intensive analysis effort to determine what operations of the general version are critical to the current operations and which can be safely changed to allow the needed new operations.

Many generalizations never get used in future deployments. Either the specific functionality implement continues to meet the users' needs or the generalization required goes in a different direction than forecast by the developer.

Acceptance of the above, however, is going to require a major shift in practices and beliefs by developers, managers, and users. We need to get beyond the "develop once, use forever" mentality. Developers cannot expect to write a class or module and not have it modified in the future. The module should not be written to answer all possibilities, rather it should be written to be easily modified to address new possibilities. Software development needs to be viewed as an ongoing effort and not a one-time task. The former view is usually held in product houses, whereas the latter is held in contract houses. Lastly, in software development, cost and schedule are best held constant, with scope as a variable. It is better to have a few things completely done than a lot of things partially done.

Early generalization provides benefits that are largely imagined, while the costs incurred are real. The cost of the generalization likely does not increase over time, so wait until it is requested before implementing it.

by rayjeff

"I think that you where moving toward that by working with the users to understand what the database can do for them. The comments of the System Analyst was correct form a strict "develop to the requirements" point of view. Unfortunately, ther are too many failed projects that met all the requirements but were not used."

I see what you're saying, but the problem I had was that the person who was acting as the analyst had not been in the process. Because there was no one who has assess the requirements of the database, I had to do it. The database did have some broad requirements as defined by the accredidation body that reviewed my division. Basicially, we all in the division were flying blind while trying to get the database requirements together at the same time as deveolping it. We had many consultants come in and review and assess the database requirements. By the time the person on-campus came on-board, the database requirements had gone through the final ok with all of the consultants we had. So, what's that say when the person says that what the consultants said was wrong, when they were privy to any and everything dealing with the database. That's why i have a problem with the statement.

by tony hopkinson

There is no one right way to do it, there are however many wrong ones.

Development Rule Two

It's much easier to find a wrong way than a right way, if you assume the way you are doing it is is the right way.

The road to failure is paved with assumptions of success!.

by tony hopkinson

If getLastPeriodDetails comes in I was right.
If getNextPeriodDetails comes in I was right.
If GetYearDetails comes in I was right.

In fact the only way the example above could go 'wrong', is if a period was to be identified by more than one parameter.
Or someone felt it necessary to move it's position in the hierarchy.

I should hasten, to add it was a specific example, not a generalistion to be applied everywhere it was potentially possible to.

I know development managers get all iffy about us grunts changing the code, but it's nice to make your lot sweat everynow and then.

LOL

by wayne m.

I learned long ago that the only way to discuss specific code implementations is over beer; text discussions get taken way too seriously.

Any way, I am close enough to my coding days that I feel confident in giving advice, and I am far enough removed that I don't take offense when my advice is not taken. The scariest part about being a manager is letting go and trusting in your staff's instincts.

by tony hopkinson

see manager, run.
LOL

Seriously though. Too many people looking for the route map, the step by step path to success.

All we can hand out is an orienteering course.

by rayjeff

Because I can into the project not knowing what I was developing had far reaching implications, I was automatically in "instinct mode". No one in the division knew what to do or how to go about developing a database. Time constraints made it that much worse. So, I didn't have a choice but to go on instinct. Luckily it paid off.

Believe you me, I would've much preferred to have had a year or two to plan and assess and analyze everything before developing it. I know things could've gone 1000xs more smoothly.

by frankz

Good stuff! From my "nebulous" requirement (which is often how users present their requirements), creativity and experience pushes you to define and create a "star" - a feature that addresses current needs and could (should?) withstand the test of time.

by tony hopkinson

LOL
I been doing this stuff a long time. Made more than enough mistakes that even an eejit like myself can't fail to learn from.

by frankz

Yep, I reckon we all should follow the I.T. "golden rule" that you seem to be echoing: "When we stop learnin', we stop livin'."

by frankz

You make some good points. (This should teach me a lesson for hastily coming up with an example that is worthy of being blasted! :)

Like you, I am a firm believer in a clearly defined scope of work (There is a glimpse of my fanaticism on this topic in the thread "Do simple preparation before estimating work" - "The devil is in the details".) Therefore, the current needs should be described and detailed in a statement of work, as you pointed out. However, the scoping phase is also where future needs can be identified and, where possible, the apps should allow for these future needs to be included with as little modifications as possible - or, at the very least, the apps should not be developed as if they are the final solution to the user's needs (which can result from considering only current needs).

I don't completely agree that increased configurability equates to increased complexity. Having been a developer, and worked with other developers, I would say that the increased complexity is endured more by the developer than by the end-user, because incorporating configurability forces the development to be a tad more abstract, hence inherently more complex, and the code could therefore be more difficult to maintain for the developer. On the other hand, the end-user can deal with the increased complexity with sufficiently well-documented configuration guides (yes, I can almost hear the loud laughter from the audience!).

by tony hopkinson

of learning by doing.
Good point is
What you do learn gets burnt in really well, there are a set of mistakes and assumptions you just never make again.

The bad point is there still might be a 'better' way of accomplishing the goal, but you spent all your time making it work instead of making it work the best it could.

The more experience you get the more honed your instinct the less likely you are to miss the best solution.

Also I've seen many theoritically sound solutions founder on practical application through other constraints. It's those constraints that you don't learn in being trained, as they provide the most conducive environment when training you.

by rowdydave

The product is being created for the end-user, not the programmer. Programmers are very smart, highly skilled individuals, but they should never dictate the way a program should be designed. The business process of the end-user should dictate the design of the program. The program is written for the customer, not the programmer. The customer should be able to intuitively understand and effectively use the product within two or three uses. If they can't, then it cannot have been written with their job in mind, but the programmer's preference.

This certain brand of arrogance is all too common in software development. It is understandable, in a way, that this happens. Programmers are very smart, capable people. End-users are often lacking in computer skills and knowledge. This makes it easy for programmers to believe that they "know better" than the lowly, unskilled end-user. The result is a product that often pleases the sensibilities of the programmer, but fails to achieve the job for which it was commissioned.

The application should flow on a parallel course, as much as possible, with the end-user's workflow processes. As stated before, it should be intuitive enough for the person using it to become familiar and efficient with it after two or three uses, because it does what the user needs it to do, not what the programmer thinks it should do. Anticipating or, better yet, truly learning what the end-user does helps tremendously in creating applications that make life better for everyone in the long-run.

by tony hopkinson

vacancies. Users who know what they do and what they want.
Imagine :D

I know where you are coming from, I spent seven years on shifts as a data entry operator. I moved into IT because I knew I could do better than the garbage I was often served up with.

The entire point of this discussion as coping with the fact that they don't know, or even on the remote chance that they do now, but they won't soon.

Also you have to be aware of the very real danger of user solutions, they state what they want in a way that constrains your design options.

For example one guy asked me to merely allow the system wide identifier to accept alpha input instead of the originally specified integer.

That's what he asked for, not what he wanted.

What he actually wanted to do was split a large product into pieces and keep the relation between them. The request he asked for, was to put a letter suffix in the unique product ID, which in fact was a solution, and a poor one in terms of the existing design.

So even when the client is positive about what they want, don't assume they actually do.

by putchavn1

The question is not, who knows better or who should decide (between the user and programmer / developer). As rightly said, the development is for the user, not programmer. As pointed out in the suffix example, a requirement, when expressed by the user tends to be current and specific (at times misleading)but the program must work now and for some time to come.

Analysts / developers need to identify a class of uses and arrive at the essence of sample and enumerated requirements---that process is called Abstraction. Then the abstraction has to be validated jointly by the uses, programmers and consultants. A design meeting the abstracted requirement has better chance of meeting a wide variety of requirements (current and futuristic or known and yet to be discovered).

This process is often considered time consuming and unproductive but there are methods and tools to do "Abstraction" quickly and properly.

This discussion is closed to new replies.