Software Design - Essay Example

USABILITY AND SOFTWARE ARCHITECTURE: “THE FORGOTTEN PROBLEMS” The “forgotten problems”. What are they? These are the emerging issues in software development that focus on the usability aspects of the system. They emerge from the interactions between usability design principles and software development principles. The “forgotten problems” could follow these directions. Changes required in functionality. Changes in the user interface that focus on positioning aspects, “screen-deep changes”, and changes that go beyond positioning aspects, “non-screen deep changes”.

These emerging issues will either be easier to implement, or harder to achieve. The software architecture in place will determine the easiness of change. In as much these “forgotten problems” are crucial to be addressed, the software development principles have other factors that also need to be addressed. These are the performance, availability, maintainability, security, costs, benefits and schedule. Thus, it is more valuable to achieve a balance rather than focus on only one aspect which in the “forgotten problems” is the usability factor.

The Software architecture is the representation of the software development. It lists all the key modules, their responsibilities, and interactions. It has various representations. It is essential as a good architecture would reduce development time, maintenance costs and improve the quality of product.How does software architecture interact with usability? This can be understood via enumerating all the phases in software development. These are; system formulation, requirement definition, architecture design, detailed design, implementation, system test and deployment.

Each of these chapters is critical, and there exist a high level of interactions. The development cycle in place will dictate the level of interactions between these phases. These methodologies are; waterfall cycle, spiral circle, extreme programming and HCI cycle. The feedback mechanisms in these methodologies will show how effective a method is. (Smith & Williams, 2003).The idea is to come up with an architectural pattern that best achieves usability factors. Various patterns can be applied.

The Model view controller displays the module responsibilities and their interactions. A good model view controller shows productive interactions. It hides the unwanted aspects of the user interface from the remainder of the application. It provides a means of buffering changes in the user interface from the remainder of the application. It localizes the “screen-deep” changes to either the view or the controller. With regards to interactive design, it supports color change of text and order of dialogs.

Appearance features are frequent changes that occur in systems. However, deeper changes such as cancellation or addition features may require modification of the various modules. They are complex. These issues can be addressed in a number of ways. To achieve efficient usability requirements, then it calls for early planning in software design decision making. Usability requirements should be determined especially for those impacting software architecture. A relationship should be created between usability requirements and software architecture.

Finally, we need to incorporate these relations in the software design principles. This calls for a meeting between the usability specialists and the software engineers. It is also crucial for the changes pointed to come up with their mechanisms of implementation. The early models only focused on what is to be done. They do not say how it should be done. (Nielsen & Mack, 1994). This will enable achievement of a rudimentary system. This has been the assumption in many usability development teams.

Not all “forgotten problems” can be solved. However, in order to obtain a good system, we can identify those critical aspects of usability features that are essential architecturally. That is it becomes difficult to sustain patterns that only separate the user interface from the application. For instance, changing color of text may not be architectural significant. However, a cancel command modification presents an architectural significance. We can provide a checklist of vital software responsibilities, user benefits and possible architectural patterns to meet the various scenarios.

Then we integrate these details into the software architecture design and evaluation methods.Once we have understood and formulated the architectural significant scenarios, we come up with a Usability-supporting architectural pattern. (R. Molich, & J. Nielsen, 1990). It has three components. The scenario, for example, change in color of text. In scenario stating, the cost of implementation and comprehensive benefits should be given to justify the scenario. A manual to the development team for implementing the solution is necessary.

The second component is the general responsibilities. We acquire them from the user and other environmental factors. We consider each function individually to understand its relevance to the designed system. Not all responsibilities will be appropriate or implementable by the software development team. The third component is the sample solution. Here, we assign responsibilities using the model view controller pattern to different modules. At this stage, we can consider issuing sequence outline of activities.

Indeed, this pattern provides a systematic way of implementing the changes. Its reason for success is from the fact that when we use usability supporting architectural patterns, we get fewer usability changes that impact the model. It gives a valuable system for end users. The software developers, managers, researchers and other agencies, need to be convinced that these patterns work. Otherwise, they will not consider them. The assessment strategy could focus on surveys on friends and experts.

Carrying out controlled experiments. Doing usability tests and doing documented case studies. This will present evidence of their success or ineffectiveness.In summary, the “forgotten problems” are the usability issues emerging in software development. These are common issues that will appear in most software development projects. We can beat them with a well - structured pattern that emphasizes on relationships between usability specialists and the software engineers. Handling these issues is a guarantee of a quality product.

End-users will appreciate this. Thus, it is necessary to understand and solve these emerging issues.REFERENCESNielsen J., & Mack R. L. (1994). 10 Heuristics for User Interface Design. New York, NY.Molich R., & Nielsen J. (March, 1990). Improving a human-computer dialogue: Communications of ACM. 338 – 348.Smith C. U. & Williams L. G. (2003). Best Practices for software performance Engineering. MA, Addison Wesley.