|
|||
|
|||
Essential Design Tips
Posted October 15, 2003 Many project managers place good coding skills at the top of their priority list for employee experience. I would argue that design skills are far more important, because software design has the most prominent lifecycle implications. The ability to develop robust software designs differs vastly from the ability to program proficiently. Software design is difficult, in part because designs can be tested only to an extent. The future of every software development project includes evolving requirements. Ideally, today's design will adapt to meet the changing needs of tomorrow. Here are several design tips that, when kept at the forefront, will advance software designs toward adaptable, robust software architectures. Use Lightweight Components Consider designing an enterprise application that integrates data (such as a data warehouse) from multiple, disparate sources. I worked this task with several colleagues recently. In considering a design, it was first suggested that we take an approach like that illustrated in Figure 1. There are several problems with combining discrete functionality within a single software component—Extract, Translate, and Load (ETL) in this case. First, pieces of functionality will certainly be duplicated among the ETL components. If and when a change is required, it must be made and managed in multiple places. This is a maintenance nightmare. Second, think about reuse. Software components are rarely reusable when built to "do it all." The goal is to decompose functionality and create many lightweight components vs. a smaller number of heavyweight components. Figure 2 depicts a far better solution where the E, T, and L functionality is decomposed into separate components. Leverage Abstractions Consider the ETL application (see Figure 2). Say, for example, that the data provided by System A changes from a database dump format to XML. Ideally, you would like the ability to "swap out" the current translator and add a new XML translator without any impact to the existing system. You can accomplish this by leveraging abstractions based on the Strategy design pattern (see Figure 3 and Gamma, et al. in Resources). In the requisite text on object-oriented design patterns (see Gamma, et al. in Resources), abstraction is the common thread among the most popular patterns (Composite, Strategy, Observer, and so on). Design software component relationships based on concepts rather than implementations. For a thorough discussion of interface design leveraging abstraction and design patterns, see "The Philosophy of Interface-Driven Design" in Resources. Enforce Encapsulation Recently I gave my Java students a homework assignment to implement an interface exposing methods that dealt with a collection of data. I was surprised by the fact that, although each solution yielded the correct output, no two implementations were the same—most were not even similar. The important point is that the implementation details for each student's solution were transparent to the test driver (client) program. This enabled seamless testing without changing any code. This is a classic example of the ease with which different implementations can be "plugged in" when the implementation details are hidden. Minimize Dependencies
Work toward adaptable, reusable, simplified software designs by reducing relationships among software components to the extent possible. Developing good, sound software designs is difficult, yet it is the challenge that makes it fun. To this end, the first step is being aware of various design strategies. The second step is understanding the benefits of a good design and the potential pitfalls when sound design techniques are not used. Keep these design tips at the forefront, and unleash your design skills on new software challenges.
About the Author |