Many problems take place at internal and external system interfaces. Here are some suggestions to minimize them.
Image by freepik
Internal and external interfaces are common sources of problems in software-containing products. An interface describes how two architectural elements intersect, either between two components of a multicomponent system (internal) or between the system and its environment (external).
Any sizable software system has many modules and numerous internal interfaces, as one component invokes another to provide some service. A system could present external interfaces to human users, other software systems, hardware devices, networks, and possibly the computer’s operating system, as illustrated in Figure 1. Products that contain both hardware and software components introduce additional interface complexities.
Figure1. Software systems have internal interfaces between components and external interfaces to other entities.
Business analysts must identify external interfaces and the constraints they impose on architecture and detailed designs. Conscientious designers will ensure that all the pieces of a complex system fit together correctly across their mutual interfaces. New components that developers integrate into an existing system must also conform to established interface conventions.
Interface Hassles
An interface defines a contract or agreement regarding how two architectural elements—one a requestor and the other a provider—connect to exchange data, services, or both. Each of these elements has a clearly defined boundary and a set of responsibilities or services it provides. The design must handle errors that occur at interfaces. If an interface implementation can’t perform its responsibilities for some reason, it should provide an appropriate notification to assist in recovery efforts.
Here’s an example of an interface failure. I recently began reading an e-book that I borrowed from the library in my iPad’s web browser. I repeatedly tried to download the file for offline access, using the button provided for that function. The download would begin, but then I’d see this uninformative error message:
Figure 2. This message didn’t help me correct an interface error between my iPad and the e-book server.
Apparently, there was some reproducible failure with the interface between my iPad and the server that hosted the e-book, which the software duly reported to me. But I have no clue from this message where the problem lies or what to do about it. I never could download that e-book or others that I tried to access in the same way. Designers should thoroughly plan and study the system’s internal and external interfaces to prevent such user annoyances.
When designing an interface, it’s common to start with everything the designer thinks a user—whether a human or another system—might need. This approach can result in bloated interfaces loaded with functionality that the interface’s users won’t ever employ. Understanding the tasks that users will want to perform with the product helps designers build a streamlined, efficient user interface.
Complex systems that have many interconnected components are challenging to modify. Changing one of the interface definitions can launch a cascade of changes in the other connected components. Unless the system is architected with clearly defined component interfaces, technical debt can accrue as the team adds new capabilities that require interface changes. Problems can also arise if new functionality doesn’t respect the existing interfaces.
Try to anticipate likely changes that developers will make in the system over time and consider how they might affect the interfaces. This anticipation is particularly important when growing an application in iterative and incremental development life cycles. The priority of planned incremental enhancements will inform developers about those portions of the system that are more likely to change and those that should remain more stable. Designing the architecture well from the outset facilitates sustained product growth and frequent releases.
Input Data Validation
Each component involved in an interaction should validate the inputs it receives across the interface before processing them. Many security exploits occur because bad actors inject malicious code across an interface that doesn’t reject it as invalid input. Microsoft recommends some practices for validating user input to thwart these types of malware attacks.
Figure 3 provides a heuristic to guide your assessment of interface behavior. Following a proper design-by-contract interface strategy will ensure that your components lie in the two quadrants within the heavy dashed line.
Figure 3. Looking at valid and invalid inputs and outputs lets you assess proper interface behavior.
A well-designed system will properly handle exceptions that take place at both internal and external interfaces. I recently tried to print a document from my Windows PC to a printer on my home Wi-Fi network. The printer was powered on and connected to the network, but my PC insisted the printer was offline. I had to restart my PC, which then correctly discovered the printer as being online and sent the print job. Some unhandled interface problem between the PC and the printer had broken the connection between them, with no way for me to repair it other than the drastic action of a computer reboot. This type of error occurs way too often.
User Interface Issues
Users aren’t concerned with a system’s internal architecture but with its user interface. User interface shortcomings result in products that users regard as being thoughtlessly designed. Inconsistent UI behavior confuses and frustrates users. Poorly designed user interfaces lead to products that aren’t easy or obvious to use, waste the user’s time, make it too easy to make a mistake, and don’t work well in realistic usage scenarios.
Defining UI standards helps provide a consistent user experience both throughout an application and across multiple related applications. When I managed a small software group, we adopted UI guidelines for the applications we developed for internal company use. These guidelines helped all of our applications look and behave similarly. Our users could recognize from the UI that an app they used came out of our group, but they couldn’t tell which team member designed the UI because of its appearance or conventions.
Well-designed user interfaces should require little support documentation in the form of help screens, user guides, and tip sheets. They make it easier for users to get up to speed on a new application, and users will make fewer errors when they use it. There’s a vast body of literature on software UX design. Any designer will benefit from usability expert Jakob Nielsen’s usability heuristics for UI design. Keeping the design focused on usage rather than on product features can help avoid many of the UX problems that drive users nuts.
Author: Karl Wiegers
This is Lesson #2 of 60 in Software Development Pearls by Karl Wiegers. Karl is the author of numerous other books, including Software Requirements Essentials (with Candase Hokanson), Software Requirements (with Joy Beatty), The Thoughtless Design of Everyday Things, and Successful Business Analysis Consulting.
#design #productdesign #softwaredesign #productmanagement #requirements #businessanalysis #softwaredevelopment #architecture #productowner #businessanalyst