Page 146 - DCAP305_PRINCIPLES_OF_SOFTWARE_ENGINEERING
P. 146

Principles of Software Engineering



                   Notes         It is necessary that some decomposition and abstraction mechanism be used for such systems.
                                 DFDs can be hierarchically organized, which helps in progressively partitioning and analyzing
                                 large systems. Such DFDs together are called a leveled DFD set.
                                 A leveled DFD set has a starting DFD, which is a very abstract representation of the system,
                                 identifying the major inputs and outputs and the major processes in the system. Often, before
                                 the initial DFD, a context diagram may be drawn in which the entire system is shown as a
                                 single process.
                                 This DFD is an abstract description of the system for handling payment. It does not matter
                                 if the system is automated or manual. This diagram could very well be for a manual system
                                 where the computations are all done with calculators, and the records are physical folders and
                                 ledgers. The details and minor data paths are not represented in this DFD. For example, what
                                 happens if there are errors in the weekly timesheet is not shown in this DFD. This is done to
                                 avoid getting bogged down with details while constructing a DFD for the overall system. If more
                                 details are desired, the DFD can be further refined. It should be pointed out that a DFD is not a
                                 flowchart. A DFD Many system represents the flow of data, while a flowchart shows the flow of
                                 control. A DFD does not represent procedural information. So, while drawing a DFD, one must
                                 not get involved in procedural details, and procedural thinking must be consciously avoided.
                                 For example, considerations of loops and decisions must be ignored. In drawing the DFD, the
                                 designer has to specify the major transforms in the path of the data flowing from the input to
                                 output. How those transforms are performed is not an issue while drawing the data flow graph.

                                 All its inputs, outputs, sinks, and sources. Then each process is refined and a DFD is drawn
                                 for the process. In other words, a bubble in a DFD is expanded into a DFD during refinement.
                                 For the hierarchy to be consistent, it is important that the net inputs and outputs of a DFD for
                                 a process are the same as the inputs and outputs of the process in the high-level DFD. This
                                 refinement stops if each bubble is considered to be “atomic,” in that each bubble can be easily
                                 specified or understood. It should be pointed out that during refinement, though the net input
                                 and output are preserved, a refinement of the data might also occur. That is, a unit of data may be
                                 broken into its components for processing when the detailed DFD for a process is being drawn.
                                 So, as the processes are decomposed, data decomposition also occurs. In a DFD, data flows are
                                 identified by unique names. These names are chosen so that they convey some meaning about
                                 what the data is. However, for specifying the precise structure of data flows, a data dictionary is
                                 often used. The associated data dictionary states precisely the structure of each data flow in the
                                 DFD. To define the data structure, a regular expression type notation is used. While specifying
                                 the structure of a data item, sequence or composition is represented by “+”, selection by vertical
                                 bar “|” (means one OR the other), and repetition by “*”.
                                                Data flow diagrams were proposed by Larry Constantine, the original
                                                developer  of  structured  design,  based  on  Martin  and  Estrin’s  “data  flow
                                                graph” model of computation.

                                 6.11 Design Heuristics


                                 The design steps mentioned earlier do not reduce the design process to a series of steps that can
                                 be followed blindly. The strategy requires the designer to exercise sound judgment and common
                                 sense. The basic objective is to make the program structure reflect the problem as closely as
                                 possible. With this in mind the structure obtained by the methodology described earlier should
                                 be  treated  as  an  initial  structure,  which  may  need  to  be  modified.  Here  we  mention  some
                                 heuristics that can be used to modify the structure, if necessary. Keep in mind that these are
                                 merely pointers to help the designer decide how the structure can be modified. The designer is





        140                               LOVELY PROFESSIONAL UNIVERSITY
   141   142   143   144   145   146   147   148   149   150   151