The difference between outline design and detailed design
The outline design is to design the structure of the software, including the constituent modules, the hierarchical structure of the modules, the calling relationship of the modules, the function of each module, and so on. At the same time, it is also necessary to design the overall data structure and database structure of the application system of the project, that is, what data should the application system store, what kind of structure these data are, and what is the relationship between them.
The detailed design phase is to describe the functions completed by each module in detail, and transform the function description into an accurate and structured process description.
In the general design stage, the software structure diagram is usually obtained.
The common description methods in the detailed design stage are: flow chart, NS diagram, PAD diagram, pseudo code, etc.
Outline Design and Detailed Design
In software design, a question that everyone often asks is: what should be a general method for general design, and what should be a detailed method for detailed design?
This question is often asked within the company. State it now.
Our company's R&D process is waterfall-type, and the analysis and design phases in this model are based on classical structured methods.
The basic idea of the structured design method is: according to the problem domain, the software is refined step by step, and decomposed into modules that do not need to be decomposed. Each module completes a certain function and serves one or more parent modules (that is, accepts calls). , which also accepts services from one or more submodules (i.e. calls submodules). The concept of a module corresponds to a subroutine or function in a programming language.
In this way, the design can be clearly divided into two stages:
the outline (structure) design stage: the software is decomposed into module levels according to certain principles, each module is assigned certain tasks, and the calling relationship and interface between modules are determined.
Detailed design stage: According to the decomposition of the outline design stage, design the algorithms , processes, etc. in each module.
High-level design phase:
During this phase, the designer will roughly consider and take care of the internal implementation of the module, but not get too involved in it. It mainly focuses on dividing modules, assigning tasks, and defining calling relationships. The interface and parameter transfer between modules should be very detailed and clear at this stage, and a rigorous data dictionary should be written to avoid confusion or misunderstanding in subsequent design. The outline design is generally not done once, but iteratively adjusts the structure. A typical adjustment is to merge modules with duplicate functions, or to further decompose modules that can be reused. In the outline design stage, reusable modules should be extracted to the maximum extent, and a reasonable structural system should be established to save the workload of subsequent links.
The most important part of the outline design document is the hierarchical data flow diagram, structure diagram, data dictionary and corresponding text description. Based on the outline design document, the detailed design of each module can be carried out in parallel.
Detailed design phase:
In this phase, each module can be assigned to different people to design in parallel. In the detailed design stage, the designer's work object is a module. According to the local tasks and external interfaces given by the outline design, the module's algorithm, process, state transition and other contents are designed and expressed. It should be noted here that if it is found necessary to adjust the structure (such as decomposing sub-modules, etc.), you must return to the outline design stage and reflect the adjustment in the outline design document, instead of solving it on the spot without saying hello. The most important part of the detailed design document is the flow chart, state diagram, local variables and corresponding text description of the module. One module is one detailed design document.
概要设计文档相当于机械设计中的装配图，而详细设计文档相当于机械设计中的零件图。文档的编排、装订方式也可以参考机械图纸的方法。
我们公司对模块的认识和传统定义有所不同，认为是较大的软件功能单元才可以称作模块。这种认识使大家对概要设计和详细设计的分工产生了混乱的理解，降低了文档的可用性，应该予以纠正。
概要设计中较顶层的部分便是所谓的方案。方案文档的作用是在宏观的角度上保持设计的合理性。
有的项目采用面向对象的分析、设计方法。可能在概要设计、详细设计的分工上疑问更多。其实，面向对象的分析、设计方法并没有强调结构化方法那样的阶段性， 因此一般不引入概要、详细设计的概念。如果按照公司的文档体系，非要有这种分工的话，可以将包的划分、类及对象间的关系、类的对外属性、方法及协作设计看 做 概要设计；类属性、方法的内部实现看做详细设计。
1.需求分析--产生软件功能规格说明书,需要确定用户对软件的需求,要作到明确、无歧义。不涉及具体实现方法。用户能看得明白，开发人员也可据此进行下面的工作（概要设计）。
2.概要设计--产生软件概要设计说明书，说明系统模块划分、选择的技术路线等，整体说明软件的实现思路。并且需要指出关键技术难点等。
3.详细设计--产生软件详细设计说明书，对概要设计的进一步细化，一般由各部分的担当人员依据概要设计分别完成，然后在集成，是具体的实现细节。理论上要求可以照此编码。
概要设计和详细设计的区别与联系
软件设计采用自顶向下、逐次功能展开的设计方法，首先完成总体设计，然后完成各有机组成部分的设计。
根据工作性质和内容的不同，软件设计分为概要设计和详细设计。概要设计实现软件的总体设计、模块划分、用户界面设计、数据库设计等等；详细设计则根据概要设计所做的模块划分，实现各模块的算法设计，实现用户界面设计、数据结构设计的细化，等等。
概要设计是详细设计的基础，必须在详细设计之前完成，概要设计经复查确认后才可以开始详细设计。概要设计，必须完成概要设计文档，包括系统的总体设计文档、以及各个模块的概要设计文档。每个模块的设计文档都应该独立成册。
详细设计必须遵循概要设计来进行。详细设计方案的更改，不得影响到概要设计方案；如果需要更改概要设计，必须经过项目经理的同意。详细设计，应该完成详细设计文档，主要是模块的详细设计方案说明。和概要设计一样，每个模块的详细设计文档都应该独立成册。
概要设计里面的数据库设计应该重点在描述数据关系上，说明数据的来龙去脉，在这里应该结合我们的一下结果数据，说明这些结果数据的源点，我们这样设计的目 的和原因。详细设计里的数据库设计就应该是一份完善的数据结构文档，就是一个包括类型、命名、精度、字段说明、表说明等内容的数据字典。
概要设计里的功能应该是重点在功能描述，对需求的解释和整合，整体划分功能模块，并对各功能模块进行详细的图文描述，应该让读者大致了解系统作完后大体的 结构和操作模式。详细设计则是重点在描述系统的实现方式，各模块详细说明实现功能所需的类及具体的方法函数，包括涉及到的sql语句等。
概要设计，详细设计之间的关系是什么？
Q:
我的看法：
概要设计只说明系统有多少个模块，各模块之间的接口和个模块本身的功能
详细设计说明某个具体模块如何实现，粒度应该比程序略高一些
But here comes the problem. There is a hierarchical relationship between each module, and there is also a logical relationship. This shows that in the outline design, the implementation details of the module must also be considered. Otherwise, how do you know that this module should be divided into sub-modules? How do you know the order in which the submodules are called?
This shows that the general design and the detailed design are overlapped, and the software engineering book says that it is carried out sequentially. I don't know if there is a problem with my understanding.
For example, a sorting program, if you design 2 modules:
a main module is used to sort the sub-module to exchange 2 variables, the main module calls the sub-module, but how is the sub-module designed? You must have first thought of the need to exchange data when sorting methods such as bubbling. This has considered enough details of the main module, and it seems to belong to the "detailed design", but the current design is the outline design, which produced me Said overlapping situation.
A:
Take a look at the above posts, most of them are interesting.
There are also friends who mentioned using the example of architecture as a metaphor.
The general design of the software is mainly to establish the overall structure of the software system , that is, when we build a house, we need to build the entire shelf of the house first.
The detailed design of the software is mainly to express the specific design method, logic and function of each part of the software system in words. In this way, in the implementation process, Coding personnel can implement the code strictly according to this principle.
One of the simplest examples of this: we can hand over the code to a third party to do it. Verification and tracking take design to.
I see that a friend above said: do code quickly. This in itself is nothing to criticize. But just think about it, the code you write doesn't have any design ideas or documentation left, how will it be maintained once you leave? Redesign? Or spend several times the manpower to study the thousands/thousands or even hundreds of thousands of lines of code you wrote? If that's the case, you're right, the point is that your boss is so right that money is nothing.
Another question is: the Chinese are so smart, but why haven't there been giant software products in China? Personal heroism is still very serious, and the boss's short-sighted interests are prevalent.