Jerry Yoakum's thoughts on software engineering and architecture from experience working with code, computer science, python, java, APIs, NASA, data mining, math, etc.
Monday, June 11, 2018
Build Software So That It Needs a Short Users' Manual
One way to measure the quality of a software system is to look at the size of its users' manual. The shorter the manual, the better the software. The use of well-designed software should be mostly self-evident. Unfortunately, too many software designers fashion themselves as experts in human interface design as well. The voluminous manuals that result are sufficient evidence that most interface designers are not as great as they proclaim.
Use standard interfaces. Use industry experts to design self-evident icons, commands, protocols, and user scenarios. And remember: Just because software developers "like" an interface, it doesn't mean that your customers will have any idea of how to use it. Many software developers like interfaces with built-in short-cuts. Usually, customers want simple, clean, clear interfaces - they don't want to learn tricks to enable short-cuts.
Reference:
Hoare, C.A.R., "Programming: Sorcery or Science?", IEEE Software, April 1984.
Wednesday, May 30, 2018
If Possible, Buy Instead of Build
Off-the-shelf software may address only some of your feature needs. But consider that building your own software may result in going over budget, being late, and still only addressing only some of your feature needs.
"As a developer, you should reuse as much software as possible. Reuse is 'buying instead of building' on a less grand scale."
Reference:
Brooks, F., "No Silver Bullet: Essence and Accidents of Software Engineering," IEEE Computer, April 1987.
"As a developer, you should reuse as much software as possible. Reuse is 'buying instead of building' on a less grand scale."
Reference:
Brooks, F., "No Silver Bullet: Essence and Accidents of Software Engineering," IEEE Computer, April 1987.
Friday, May 25, 2018
Change During Development Is Inevitable
Prepare yourself for changes by making sure:
- that all software development is appropriately cross-referenced,
- that change management procedures are in place, and
- Establish SCM Procedures Early*
- Give Every Intermediate Product a Name and Version*
- Rank and Schedule Change Requests*
- that budgets and schedules have enough leeway so that you are not tempted to ignore necessary changes just to meet budgets and schedules.
- Don't Set Unrealistic Deadlines*
- Avoid the Impossible*
- Avoid Standing Waves*
Reference:
Bersoff, E., V. Henderson, and S. Siegel, Software Configuration Management, Englewood Cliffs, N.J.: Prentice Hall, 1980, Section 2.2.
Labels:
Chicago,
product-management,
software-engineering
Location:
Chicago, IL, USA
Thursday, May 24, 2018
The More Seen, the More Needed
"The more functionality (or performance) that is provided to a user, the more functionality (or performance) that the user will want."Which supports:
- Give Products to Customers Early
- Grow Systems Incrementally
- Software Will Continue to Change
- The System's Existence Promotes Evolution
More importantly, you must be prepared for the inevitable requests for more.
- Documentation should be organized in such a way that it is easy to update and add to.
- Establish SCM (Software Configuration Management) Procedures Early.
- Systems and processes in place to handle the users' requests.
- Design so that configuration is quick and easy.
Reference:
Curtis, B., H. Krasner, and N. Iscoe, "A Field Study of the Software Design Process for Large Systems," Communications of the ACM, 31, 11 (November 1988), pp. 1268--1287.
Labels:
product-management,
software-engineering
Location:
Springfield, MO, USA
Monday, May 14, 2018
Grow Systems Incrementally
- Build the Right Kind of Prototype
- Build the Right Features into a Prototype
- Build Throwaway Prototypes Quickly
Reference:
Ruskin, R., Debugging Techniques in Large Systems. Prentice Hall. Englewood Cliffs, NJ, USA, 1971.
Sunday, May 13, 2018
Plan to Throw One Away
A highly critical factor in the success of a project is whether the project is entirely new. New software treads in new territory and rarely works on the first try.
In 1970, Winston Royce said one should plan for the first fully deployed system to be the second one created. The first is a prototype that flushes out the critical design issues and proves the concept. You should expect to spend 25% of your time and effort in making the prototype. Fred Brooks reiterates Royce's advice in the Mythical Man Month saying, "Plan to throw one away; you will anyway."
When developing a new software application:
- Plan to build a series of throwaway prototypes before starting the final product.
- Build the Right Kind of Prototype
- Build the Right Features into a Prototype
- Build Throwaway Prototypes Quickly
- Expect a software application to be modifiable for a certain period of years, after which it will need to be fully replaced.
- Software Will Continue to Change*
- Software's Entropy Increases*
- Fix Problems, Not Symptoms*
- The System's Existence Promotes Evolution*
- You can only fiddle with an application just so much before it becomes unstable and must be replaced.
- Software's Entropy Increases*
- The Older a Program, the More Difficult It Is to Maintain*
- Maintenance Causes More Errors Than Development*
- Belief That a Change Is Easy Makes It Likely It Will Be Made Incorrectly*
Friday, May 11, 2018
Align Incentives for Developer and Customer
Align developer and customer goals for project success. To align everyone's goals:
- Prioritize requirements.
- Reward the developer based on the relative priorities.
- Define reasonable penalties for late delivery.
Friday, May 04, 2018
Give Products to Customers Early
The most effective way to learn users' needs is to give them a prototype and gather feedback from the experience. This goes perfectly with the Agile Methodology to always deliver after each sprint. Which allows for faster feedback and the product continuously moving toward the customer's desired product.
Reference:
H. Gomaa and D. Scott. 1981. "Prototyping as a Tool in the Specification of User Requirements". Fifth International Conference on Software Engineering. IEEE Computer Society Press., Washington, DC, USA.
Thursday, May 03, 2018
Poor Reliability Is Worse Than Poor Efficiency
Poor Reliability |
Poor Efficiency |
Reference:
I. Sommerville. 1992. Software Engineering, Section 20.0. Addison-Wesley., Reading, MA, USA.
Tuesday, May 01, 2018
Don't Try to Retrofit Quality
It is difficult enough to build quality software from the start of a project. It is much harder to take an existing application and improve it's quality (reliability, testability, adaptability, etc).
This additional difficulty to add quality after the fact is why you must not try to convert a throwaway prototype into a product. Make sure you Build the Right Kind of Prototype.
Subscribe to:
Posts (Atom)