Software Engineering-software design method-by cker (HTML Version ))

Software Engineering-by cker (HTML Version)

THE DESIGN PROCESS
(Software) Design Method

Good programmers are just like people. Think more, maybe the Stone of other mountains can attack the jade, never become a slave of code. CKER

Original:Larry BrinnTranslation:CKER

1. Introduction
2. What is (software) design?
3. (software) Design Process
4. (software) Design Basics
5. (software) Design Methodology
6. (software) Design Documents
7. Object-oriented (software) Design
8. Conclusion

Introduction
How did you start a new project? Do you want to open your favorite RAD tool and enter the code before jumping to the computer? Have you ever wondered what the program will execute or how the system will manipulate the data? Have you ever thought about writing down something to help remind you or clarify the logic Implementation of your developed code? If you answer "no" to the first question and "yes" to other questions, you can skip this document. Otherwise, please read this article carefully. You should have a plan, a blueprint, and a concise arrangement at hand for your problem solution. "You must know where you want to get everything! "Let's take a look at what is tricky to develop a program that can implement the features you have designed.

What is (software) design?
E.S. Taylor defines the design:
"... The process of applying various techniques and principles for the purpose of defining a device, a process or a system in sufficient detail to permit its physical realization."
"... Apply various technologies and principles and use them to define the physical implementation process of a device, program, or system in sufficient detail."
For any engineering product or system, the first absolute step in the development phase is to determine the target concept of the manufacturing prototype or entity to be constructed in the future. This step is jointly determined by a variety of intuition and judgment. These include the experience of building similar models, a set of principles that lead the development of models, a set of standards for initiating quality evaluations, and the process of repeatedly modifying until the final design finalized. Compared with other engineering disciplines, computer software design is still in its infancy and is constantly changing, such as newer methods, better algorithm analysis, and significant evolution of understanding. The methodology of software design has only appeared for more than 30 years. It still lacks depth, adaptability, and quantitative nature. It is usually more associated with classical engineering design disciplines. Even so, today's software technology already exists, design quality standards can also be used, design symbols can also be applied. With these opinions, let's take a look at what helps programmers find their software Nirvana ).

(Software) Design Process
Software design is a process of transforming a requirement into a software statement. This statement gives us a global view of the software. By gradually improving the system, the design statement gradually approaches the source code. There are two basic steps. The first step isPreliminary design, Focusing on how to transform requirements into data and software frameworks. Step 2:Detailed design Detail designFocuses on refining the framework into specific data structures and software algorithm expressions. In-process design behavior, Data, algorithms, and program design all need to be combined by the clear act of Interface Design required by modern programs.Interface designEstablish a program layout and Human-Computer Interaction Mechanism. The quality throughout the design process consists of a seriesFormal technical evaluation formal technical reviewsOrDesign rehearsal design impact throughs. Good design specifications must be built on the evaluation of design statements (expressions). The following guidelines are provided:
1. The design should show the hierarchy to make the control between various parts of the software more sensible.
2. The design should be modularized; that is to say, the software should be logically divided into specific functions and sub-functions.
3. The design should consist of clear and detachable data and process expressions.
4. The design should enable the module to display independent functional features.
5. The design should make the interface reduce the complexity of connecting modules and the external environment.
6. The design should be derived from the use of repetitive methods defined in the information obtained during the software requirement analysis.
It is not luck to have good design features. in the design process, the comprehensive use of the basic design principles, system methodology, and thorough evaluation review can contribute to a good design. Software design methods evolve every day. As tested and refined methods, a good design should have the following four features and be consistent among all these features.
1. Transform the expression of the information field into the expression mechanism of the software design.
2. It indicates the function component and its interface symbol.
3. A test of gradual refinement and division.
4. Guidelines for quality assessment.
No matter what design method you use when developing software, you must be proficient in using a set of basic principles about data, algorithms, and program design.

(Software) Design Basics
The basic principles of software design methodology have evolved over the years. Each concept has different degrees of influence, but they all experience the baptism of time. Based on these basic principles, designers can adopt more mature design methods. These basic principles help designers answer the following questions:
1. What standards will be used to separate software into independent components?
2. How to divide the principle representation of the software into functions or data structures in detail?
3. Have you defined a unified standard for the technical quality of software design?
M.A. Jackson once said: "for a computer programmer, distinguish between program execution and program execution.CorrectThe difference between them is a good start. "To" enable the programCorrect", The basic design principle provides a required framework. So let's take a brief look at these basic principles.
Abstract lateral actionAt the highest level, it refers to a solution that uses the terms described in the problem field to be resolved. The abstraction at a relatively lower level is more program-oriented languages, and the abstraction at the lowest layer is a description of the direct implementation of the solution. Every step of software design is an abstraction of corresponding levels of solutions.
RefinementThe progressive refinement refers to the strategy for developing a program system through continuous refinement of program details. The process of decomposing the program abstraction step by step until it becomes a programming language simultaneously creates a program hierarchy. At this point, we need to consider more details, which also shows that refinement is actually a painstaking process.
Modular ModularitySoftware can be divided into named and addressable components (also called modules). Combining modules can meet the needs of the problem. "Software modularization is the only property that allows intelligent management of programs. "In other words, it is easier to resolve a complex problem into small ones. It should be explained that even if a system must be implemented like a single-chip microcomputer, it can adopt modular design.
Software ArchitectureIt involves two important features of the program: 1) hierarchical structure of the module. 2) data structure. This stems from the segmentation process that associates the implicit definition of real-world problems with the elements of software solutions during demand analysis. When each part of the problem is solved by one or more software elements, the evolution of software and data structures is consistent with the definition and solution of the problem. This process represents the location between the software requirement analysis and design.
Control level Control HierarchyIt is also called the program structure, which describes the organization of the program component and represents the control level. It does not describe the program aspect of the software, such as the process sequence, the determined event/command, or the work cycle. The following hierarchical chart shows the communication flows between modules and the modules that are repeated (the blocks become black in the upper right corner ). This chart describes a readable file, computes the value of each record, and writes a report to display the record information and completed calculations.

Data structureDescribes the logical relationship between a single data. The data structure specifies the data organization, access method, correlation level, and selection and processing of information. The organization and complexity of data structures are limited by the flexibility of designers. The only limit is that the number of classic data structures hinders the emergence of more time-tested structures.
Software ProcedureFocuses on processing the details of each module and must provide a precise processing specification, including the event sequence, accurate judgment points, repeated operations, and even data structures. The program performance of the software is hierarchical, and the processing method should include the reference of all its sub-modules.
Information HidingRule recommendationsThe features of modules determined by the design should be invisible to other modules.. In other words, modules should be designed and specified to be included in the module and inaccessible to other modules, which is not required for other modules. Hiding means that effective modularity can be achieved by defining a set of independent modules. The communication between these modules only includes the information necessary to implement software functions. Using information hiding as a design standard brings the greatest benefit when you need to modify the system during testing or future maintenance.

(Software) Design Methodology
Let's traverse the four areas used to facilitate modular design during the design process:Module Modular, Data, system ArchitecturalAndProgram ProceduralDesign.
Modular designIt reduces complexity, facilitates modification, and makes it easier to support parallel development of different parts of the system. The operation features provided by the module type are presented by combining the time history, activation mechanism, and control mode. Within the program structure, modules can be classified:
1. The sequential module is referenced and executed by the application, but cannot be interrupted from the apparent perspective.
2. the incremental module can be interrupted by the application and then restarted from the breakpoint.
3. parallel module, which can be executed simultaneously with other modules in a multi-processor environment.
Independent modules are easier to develop because functions can be divided, while interfaces are only used to ensure the independence of functions. The independence of functions can be measured using two qualitative criteria:Cohesion-Correlation between the function strength of the module andCoupling-It is used to measure the dependency between modules.
Data designFirst of all, some people also believe that it is the most important design behavior. The impact of data structures and Program Complexity lead to a profound impact on software quality. This quality is implemented by the following principles:
1. system analysis principles applicable to function and behavior analysis should also apply to data.
2. All data structures and their respective operations should be determined.
3. Create a data dictionary to describe the data and program design in detail.
4. The underlying data design decision should be delayed to the later stages of the design process.
5. The data structure Statement (specific description) should only be known to those modules that directly use the data contained in this structure.
6. Useful data structures and operation libraries can be used as appropriate.
7. software design and programming languages should support the specification and implementation of abstract data types.
Architectural tural DesignThe main goal is to develop a modular program structure and express the control correlation between modules. In addition, the system design integrates the program structure and data structure, as well as the interface definition that allows data to flow in the program. This approach encourages designers to focus on the overall design of the system rather than the individual components in the system. Different methods use different approaches to approach the origin of the system, but all these methods should recognize the importance of having a global concept of software.
Program Design Procedural DesignAfter data, program structure, and detailed statement algorithm are presented in a natural language similar to English, determine the program design. The reason for using natural language statements is that when the vast majority of developers use natural language to communicate, a newbie outside the group will be more likely to understand these instructions without learning. There is a problem here: the program design must be explained in detail without ambiguity, but we all know that unambiguous natural language is not natural.

(Software) Design Documents
Development documents are valuable in any system. There are already many different developed document plans available for you to choose when creating a system. A pretty good model is the so-called design specification (Translator's note: The original hyperlink has expired, so the original template cannot be obtained. But there is also a set of document templates called APM by CKER, which seems good. We may look at it later ...... ^_^ ). When you look at the outline of this document, please pay attention to the details at all levels. The first section shows the overall scope of the design results derived from system instructions and other definition documents. The second part shows detailed descriptions of the support documentation. The third part is also called the design description, which is completed in the preliminary design stage. Part 4 and 5 develop the content of the preliminary design stage to the detailed design stage. The sixth part shows the cross reference matrix to ensure the following two principles:
1. Use software design to meet all requirements.
2. Identify the key modules to meet specific requirements.
Part 7: it is necessary to test the system's functionality and correctness in the first step of developing a test program (STEP. This section can be deleted if detailed test program specifications have been developed concurrently while the design specifications are being developed. The eighth part describes in detail the considerations and requirements for the system package to the user site. Part 9 and 10 of the remaining sections of the document cover algorithm descriptions, selection programs, list data, flowcharts, pseudocode, data flow charts, and all relevant information used in design specification development. it can be placed here.

Object-oriented (software) Design
So far, everything we have described in detail is the cornerstone of a widely used design methodology in the IT field. Object-oriented design (OOD) connects Data Objects and processing operations through modular information and its processing methods instead of simply processing methods. This process relies on three extremely important design concepts: abstraction, information hiding, and modularity. All design methods strive to present these features, but only the good mechanism enables designers to acquire all three features without adding complexity or compromise. In OOD, we haveObjects (object), operations (Operation), AndMessages (Message).Objects (Object), Also known as class, can be people, machines, commands, files, cars, houses, and so on.Operations)Contains a private data structure and a processing method for transforming the data structure.Messages (Message)It is used to activate call operation control and object program construction. This means that the shared part of an object is its interface, and the message moves between interfaces and specifies the operation of the object to be used, but does not know how the operation is implemented. The object determines how to execute the message after receiving the message. Now let's take a look at how some tools in the object-oriented system are used:
1.Pseudocode-Commands that are similar to computer programming languages, but use languages that are similar to English, rather than real programming languages, to facilitate viewing program logic. The following is an example of a record in a processing file:
Start)
Initialize program (initialization program)
Read a record (Read a record)
Process record)
Move record to print area (Move record to print area)
Write a line (Write a row)
End job)
Stop run. (Stop running)
2.Prototype-Steps for testing a software package's first version or model, or when the computer hardware is ready for production. You can usually use your favorite RAD tool to create.
3.TOE chart-(Task tasks, Object objects, Event charts) are used to display tasks or jobs to be completed, objects to be executed, and events or actions to complete the process. See the following TOE chart that adds two numbers:
Task object event
Main Form OnStartup
Enter the first number of EdtFirstNumber User types in
Enter the second number EdtSecondNumber User types in
Sum EdtResult OnClick
Program exit BtnExit OnClick
As you have seen in the previous example, this correctly shows what to execute, who to execute, and when to execute.

Conclusion
As you said at the beginning, "you must know where you want to get everything" and follow a specific path or method to give you the confidence you need to implement the system you are trying to develop. There are many ways to follow. here you just want to say a few words: You should adopt a method that can be accepted by the Group and yourself. The method you choose should make everyone you may use in your plan feel simple, clear, and easy to understand. Remember the meaning of this abbreviation in your mind: KISS (Keep It Short and Simple) <Keep your code Short and Simple>.

References during design:
"Software Engineering, A practitioner's approach 3rd edition", by Roger s. Pressman.
"Object-Oriented Design", by Peter Coad and Edward Yourdon

Copyright description:
There seems to be a lot of content about C ++ Builder on Chinese websites, but most of them are software and components. Most forums are not very satisfactory and very empty. Books are expensive, but the content is too expensive. I do not care enough for beginners and scholars who lack money, so I want to do my best. All the documents in this article are collected from foreign websites. Because E is inconvenient, it is translated into Chinese. Because E and computers are not very good, errors in the text are inevitable. If you find it useful, I plan to constantly collect and translate some useful things. You can copy, distribute, and download this document at will. You cannot intercept, modify, or use this article to seek any form of interest without your consent.
Please write to: cker@sina.com if you have any comments and suggestions