1) A statement that is to be broken down may be regarded as what we call?
Answer: Paragraph Subroutine
2.)The Language That is use to Express the Solution is Called what?
3.)How Good is This method?
Answer: Considerable Skills
4.)Consider a Program That is to input of how Many Characters in lines of text?
Answer : 80 Characters
5.)Good for Large Scale Design ?
Answer: Yes !!!
-refers broadly to the process of resolving a functional relationship into its constituent parts in such a way that the original function can be reconstructed (i.e., recomposed) from those parts by function composition.
Functional Decomposition-is the process of taking a complex process and breaking it down into its smaller, simpler parts.
For instance, think about using an ATM. You could decompose the process into:
Walk up to the ATM
Insert your bank card
Enter your pin
well...you get the point.
You can think of programming the same way. Think of the software running that ATM:
Code for reading the card
Each of which can be broken down further. Once you've reached the most decomposed pieces of a subsystem, you can think about how to start coding those pieces. You then compose those small parts into the greater whole.
Guideline Role- to supplement the design methods in providing guidance during the process of design.
-enable us to make judgement on the quality of piece of software that has been designed.
-largely independent of particular design methods.
Modularity-of the key essues in program design.
-the unobtainable holy grail. It is to do all the structure of the software.
Structure-the end product of all the major current design methods such as FUNCTION DECOMPOSITION,OBJECT-OMENTED DESIGN,DATA STRUCTURE DESIGN.
Module-is a fairly independent piece of a program that typically has a name and some instruction and some data of its own.
-invoked, or called, from some other module, similarly, uses other modules.
*Modules in Various Programming Languages*
PASCAL-procedure on function
ADA-procedure or package
-the design for modularity is about trying to construct software from piece that are as independent of each other as possible
-each module, should be self-contained, and has as few reference as possible to other modules.
The aim has the ff. consequences for nearly all stages of SOFTWARE DEVELOPMENT:
1. ARCHITECTURE DESIGN-the step during w/c the large scale structure of software is determined.
2. MODULE DESIGN-if the architectural design is modular, then the design off individual modules will be easy.
3. DEBUGGING-it is during debugging that modularity come into its own
-if structure is modular, it should be easier to identify w/c particular module is responsible in the observed fault.
4. TESTING- testing a large system made up of a large number of module is a difficult and time – consuming task
-it is virtually impossible to test the system as a complete whole and usually it is carried out in a piecemeal fashion.
5. MAINTENANCE-means fixing bugs and enhancing a system to meet change user needs.
TWO OTHER IMPORTANT ASPECT OF MODULARITY
1. INDEPENDENT DEVELOPMENT- most pieces of software are implemented by a team of people, often own months or year. Normally, each module is developed by a single person.
2. SOFTWARE REUSE- major current trend is to reuse software from an earlier project. This avoids re-inventing the wheel, and can, particularly, some enormous effort.
However, a module cannot easily be reused if it is connected in some complex way to other modules in previous system.
SHARMAINE S. VILLANUEVA
CHERYL S. VILLARUEL