Software Design - Revision history

User at 21:01, 14 April 2023

2023-04-14T21:01:15Z

User at 17:46, 23 November 2022

2022-11-23T17:46:58Z

User: The LinkTitles extension automatically added links to existing pages (https://github.com/bovender/LinkTitles).

2021-02-06T18:26:08Z

The LinkTitles extension automatically added links to existing pages (https://github.com/bovender/LinkTitles).

User at 20:19, 17 April 2020

2020-04-17T20:19:09Z

User at 20:11, 17 April 2020

2020-04-17T20:11:08Z

User at 20:06, 17 April 2020

2020-04-17T20:06:00Z

User at 20:04, 17 April 2020

2020-04-17T20:04:23Z

User: Created page with "'''Content Coming Soon'''"

2019-01-07T06:34:59Z

Created page with "'''Content Coming Soon'''"

New page

'''Content Coming Soon'''

@@ Line 1: / Line 1: @@
-'''Software [[Design]]''' is a [[process]] to transform user requirements into some suitable form, which helps the programmer in [[Software|software]] coding and implementation. For assessing user requirements, an SRS (Software [[Requirement]] Specification) document is created whereas for coding and implementation, there is a need of more specific and detailed requirements in software terms. The [[output]] of this process can directly be used into implementation in programming languages. Software design is the first step in [[Software Development Life Cycle (SDLC)|SDLC (Software Design Life Cycle)]], which moves the concentration from problem domain to solution domain. It tries to specify how to fulfill the requirements mentioned in SRS.<ref>Definition - What does Software Design Mean? [https://www.slideshare.net/HimanshuAwasthi14/software-design-75545764 Himanshu Awasthi]</ref>
+'''Software Design''' is a process to transform user requirements into some suitable form, which helps the programmer in software coding and implementation. For assessing user requirements, an SRS (Software Requirement Specification) document is created, whereas for coding and implementation, there is a need for more specific and detailed requirements in software terms. The output of this process can directly be used in implementation in programming languages. Software design is the first step in SDLC (Software Design Life Cycle), which moves the concentration from the problem domain to the solution domain. It tries to specify how to fulfill the requirements mentioned in SRS.<ref>[https://www.slideshare.net/HimanshuAwasthi14/software-design-75545764 Definition - What does Software Design Mean?]</ref>
@@ Line 6: / Line 6: @@
+== Software Design Process<ref>[https://en.wikipedia.org/wiki/Software_design Software Design Process]</ref> ==
-'''Software [[Design Process]]<ref>Software Design Process [https://en.wikipedia.org/wiki/Software_design Wikipedia]</ref>'''<br />
+Software design is both a process and a model. The design process is a sequence of steps that enables the designer to describe all aspects of the software for building. Creative skill, past experience, a sense of what makes "good" software, and an overall commitment to quality are examples of critical success factors for a competent design. It is important to note, however, that the design process is not always a straightforward procedure; the design model can be compared to an architect's plans for a house. It begins by representing the totality of the thing to be built (e.g., a three-dimensional rendering of the house); slowly, the thing is refined to provide guidance for constructing each detail (e.g., the plumbing lay). Similarly, the design model that is created for software provides a variety of different views of the computer software. Basic design principles enable the software engineer to navigate the design process. Davis suggests a set of principles for software design, which have been adapted and extended in the following list:
-Software design is both a process and a [[model]]. The design process is a sequence of steps that enables the designer to describe all aspects of the software for building. Creative skill, past experience, a sense of what makes "good" software, and an overall commitment to [[quality]] are examples of critical success factors for a competent design. It is important to note, however, that the design process is not always a straightforward procedure; the design model can be compared to an architect's plans for a house. It begins by representing the totality of the thing that is to be built (e.g., a three-dimensional rendering of the house); slowly, the thing is refined to provide guidance for constructing each detail (e.g., the plumbing lay). Similarly, the design model that is created for software provides a variety of different views of the [[computer]] software. Basic design principles enable the software engineer to navigate the design process. Davis[3] suggests a set of principles for software design, which have been adapted and extended in the following list:
+*The design process should not suffer from "tunnel vision." A good designer should consider alternative approaches, judging each based on the requirements of the problem, and the resources available to do the job.
 *The design should be traceable to the analysis model. Because a single element of the design model can often be traced back to multiple requirements, it is necessary to have a means for tracking how requirements have been satisfied by the design model.
-*The design should not reinvent the wheel. Systems are constructed using a set of design patterns, many of which have likely been encountered before. These patterns should always be chosen as an alternative to reinvention. Time is short and resources are limited; design time should be invested in representing (truly new) ideas by integrating patterns that already exist (when applicable).
+*The design should not reinvent the wheel. Systems are constructed using a set of design patterns, many of which have likely been encountered before. These patterns should always be chosen as an alternative to reinvention. Time is short, and resources are limited; design time should be invested in representing (truly new) ideas by integrating patterns that already exist (when applicable).
 *The design should "minimize the intellectual distance" between the software and the problem as it exists in the real world. That is, the structure of the software design should, whenever possible, mimic the structure of the problem domain.
-*The design should exhibit uniformity and integration. A design is uniform if it appears fully coherent. In order to achieve this [[outcome]], rules of style and format should be defined for a design team before design work begins. A design is integrated if care is taken in defining interfaces between design components.
+*The design should exhibit uniformity and integration. A design is uniform if it appears fully coherent. In order to achieve this outcome, rules of style and format should be defined for a design team before design work begins. A design is integrated if care is taken in defining interfaces between design components.
-*The design should be structured to accommodate change. The design concepts discussed in the next section enable a design to achieve this [[principle]].
+*The design should be structured to accommodate change. The design concepts discussed in the next section enable a design to achieve this principle.
-*The design should be structured to degrade gently, even when aberrant [[data]], events, or operating conditions are encountered. Well-designed software should never "bomb"; it should be designed to accommodate unusual circumstances, and if it must terminate processing, it should do so in a graceful manner.
+*The design should be structured to degrade gently, even when aberrant data, events, or operating conditions are encountered. Well-designed software should never "bomb"; it should be designed to accommodate unusual circumstances, and if it must terminate processing, it should do so gracefully.
-*Design is not coding, coding is not design. Even when detailed procedural designs are created for program components, the level of abstraction of the design model is higher than the source code. The only design decisions made at the coding level should address the small implementation details that enable the procedural design to be coded.
+*Design is not coding; coding is not design. Even when detailed procedural designs are created for program components, the level of abstraction of the design model is higher than the source code. The only design decisions made at the coding level should address the small implementation details that enable the procedural design to be coded.
 *The design should be assessed for quality as it is being created, not after the fact. A variety of design concepts and design measures are available to assist the designer in assessing quality throughout the development process.
 *The design should be reviewed to minimize conceptual (semantic) errors. There is sometimes a tendency to focus on minutiae when the design is reviewed, missing the forest for the trees. A design team should ensure that major conceptual elements of the design (omissions, ambiguity, inconsistency) have been addressed before worrying about the syntax of the design model.
-'''Software Design Levels<ref>Software Design Levels [https://www.tutorialspoint.com/software_engineering/software_design_basics.htm Tutorials Point]</ref>'''<br />
+== Software Design Levels<ref>[https://www.tutorialspoint.com/software_engineering/software_design_basics.htm Software Design Levels]</ref> ==
 Software design yields three levels of results:
-*Architectural Design - The architectural design is the highest abstract version of the [[system]]. It identifies the software as a system with many components interacting with each other. At this level, the designers get the idea of proposed solution domain.
+*Architectural Design - The architectural design is the highest abstract version of the system. It identifies the software as a system with many components interacting with each other. At this level, the designers get an idea of the proposed solution domain.
-*High-level Design- The high-level design breaks the ‘single entity-multiple component’ concept of architectural design into less-abstracted view of sub-systems and modules and depicts their interaction with each other. High-level design focuses on how the system along with all of its components can be implemented in forms of modules. It recognizes modular structure of each sub-system and their relation and interaction among each other.
+*High-level Design- The high-level design breaks the ‘single entity-multiple component’ concept of architectural design into a less-abstracted view of sub-systems and modules and depicts their interaction with each other. The high-level design focuses on how the system, along with all of its components, can be implemented in form of modules. It recognizes the modular structure of each sub-system and their relation and interaction with each other.
-*Detailed Design- Detailed design deals with the implementation part of what is seen as a system and its sub-systems in the previous two designs. It is more detailed towards modules and their implementations. It defines logical structure of each module and their interfaces to communicate with other modules.
+*Detailed Design- Detailed design deals with the implementation part of what is seen as a system and its sub-systems in the previous two designs. It is more detailed towards modules and their implementations. It defines the logical structure of each module and its interfaces to communicate with other modules.
@@ Line 39: / Line 38: @@
 === References ===

@@ Line 29: / Line 29: @@
 === See Also ===
-[[Software]]<br />
+*[[Software Architecture]]
-[[Software Architecture]]<br />
+*[[Enterprise Architecture]]
-[[Enterprise Architecture]]<br />
+*[[Client Server Architecture]]
-[[Client Server Architecture]]<br />
+*[[Software Development Life Cycle (SDLC)]]
-[[Software Development Life Cycle (SDLC)]]<br />
+*[[Software Design]]
-[[Software Architecture Analysis Method (SAAM)]]<br />
+*[[Software-Defined WAN (SD-WAN)]]
-[[Software-Defined WAN (SD-WAN)]]<br />
+*[[Software Project Management]]
 === References ===

@@ Line 1: / Line 1: @@
-'''Software Design''' is a process to transform user requirements into some suitable form, which helps the programmer in [[Software|software]] coding and implementation. For assessing user requirements, an SRS (Software Requirement Specification) document is created whereas for coding and implementation, there is a need of more specific and detailed requirements in software terms. The output of this process can directly be used into implementation in programming languages. Software design is the first step in [[Software Development Life Cycle (SDLC)|SDLC (Software Design Life Cycle)]], which moves the concentration from problem domain to solution domain. It tries to specify how to fulfill the requirements mentioned in SRS.<ref>Definition - What does Software Design Mean? [https://www.slideshare.net/HimanshuAwasthi14/software-design-75545764 Himanshu Awasthi]</ref>
+'''Software [[Design]]''' is a [[process]] to transform user requirements into some suitable form, which helps the programmer in [[Software|software]] coding and implementation. For assessing user requirements, an SRS (Software [[Requirement]] Specification) document is created whereas for coding and implementation, there is a need of more specific and detailed requirements in software terms. The [[output]] of this process can directly be used into implementation in programming languages. Software design is the first step in [[Software Development Life Cycle (SDLC)|SDLC (Software Design Life Cycle)]], which moves the concentration from problem domain to solution domain. It tries to specify how to fulfill the requirements mentioned in SRS.<ref>Definition - What does Software Design Mean? [https://www.slideshare.net/HimanshuAwasthi14/software-design-75545764 Himanshu Awasthi]</ref>
@@ Line 7: / Line 7: @@
-'''Software Design Process<ref>Software Design Process [https://en.wikipedia.org/wiki/Software_design Wikipedia]</ref>'''<br />
+'''Software [[Design Process]]<ref>Software Design Process [https://en.wikipedia.org/wiki/Software_design Wikipedia]</ref>'''<br />
-Software design is both a process and a model. The design process is a sequence of steps that enables the designer to describe all aspects of the software for building. Creative skill, past experience, a sense of what makes "good" software, and an overall commitment to quality are examples of critical success factors for a competent design. It is important to note, however, that the design process is not always a straightforward procedure; the design model can be compared to an architect's plans for a house. It begins by representing the totality of the thing that is to be built (e.g., a three-dimensional rendering of the house); slowly, the thing is refined to provide guidance for constructing each detail (e.g., the plumbing lay). Similarly, the design model that is created for software provides a variety of different views of the computer software. Basic design principles enable the software engineer to navigate the design process. Davis[3] suggests a set of principles for software design, which have been adapted and extended in the following list:
+Software design is both a process and a [[model]]. The design process is a sequence of steps that enables the designer to describe all aspects of the software for building. Creative skill, past experience, a sense of what makes "good" software, and an overall commitment to [[quality]] are examples of critical success factors for a competent design. It is important to note, however, that the design process is not always a straightforward procedure; the design model can be compared to an architect's plans for a house. It begins by representing the totality of the thing that is to be built (e.g., a three-dimensional rendering of the house); slowly, the thing is refined to provide guidance for constructing each detail (e.g., the plumbing lay). Similarly, the design model that is created for software provides a variety of different views of the [[computer]] software. Basic design principles enable the software engineer to navigate the design process. Davis[3] suggests a set of principles for software design, which have been adapted and extended in the following list:
-*The design process should not suffer from "tunnel vision." A good designer should consider alternative approaches, judging each based on the requirements of the problem, the resources available to do the job.
+*The design process should not suffer from "tunnel [[vision]]." A good designer should consider alternative approaches, judging each based on the requirements of the problem, the resources available to do the job.
 *The design should be traceable to the analysis model. Because a single element of the design model can often be traced back to multiple requirements, it is necessary to have a means for tracking how requirements have been satisfied by the design model.
 *The design should not reinvent the wheel. Systems are constructed using a set of design patterns, many of which have likely been encountered before. These patterns should always be chosen as an alternative to reinvention. Time is short and resources are limited; design time should be invested in representing (truly new) ideas by integrating patterns that already exist (when applicable).
 *The design should "minimize the intellectual distance" between the software and the problem as it exists in the real world. That is, the structure of the software design should, whenever possible, mimic the structure of the problem domain.
-*The design should exhibit uniformity and integration. A design is uniform if it appears fully coherent. In order to achieve this outcome, rules of style and format should be defined for a design team before design work begins. A design is integrated if care is taken in defining interfaces between design components.
+*The design should exhibit uniformity and integration. A design is uniform if it appears fully coherent. In order to achieve this [[outcome]], rules of style and format should be defined for a design team before design work begins. A design is integrated if care is taken in defining interfaces between design components.
-*The design should be structured to accommodate change. The design concepts discussed in the next section enable a design to achieve this principle.
+*The design should be structured to accommodate change. The design concepts discussed in the next section enable a design to achieve this [[principle]].
-*The design should be structured to degrade gently, even when aberrant data, events, or operating conditions are encountered. Well-designed software should never "bomb"; it should be designed to accommodate unusual circumstances, and if it must terminate processing, it should do so in a graceful manner.
+*The design should be structured to degrade gently, even when aberrant [[data]], events, or operating conditions are encountered. Well-designed software should never "bomb"; it should be designed to accommodate unusual circumstances, and if it must terminate processing, it should do so in a graceful manner.
 *Design is not coding, coding is not design. Even when detailed procedural designs are created for program components, the level of abstraction of the design model is higher than the source code. The only design decisions made at the coding level should address the small implementation details that enable the procedural design to be coded.
 *The design should be assessed for quality as it is being created, not after the fact. A variety of design concepts and design measures are available to assist the designer in assessing quality throughout the development process.
@@ Line 23: / Line 23: @@
 '''Software Design Levels<ref>Software Design Levels [https://www.tutorialspoint.com/software_engineering/software_design_basics.htm Tutorials Point]</ref>'''<br />
 Software design yields three levels of results:
-*Architectural Design - The architectural design is the highest abstract version of the system. It identifies the software as a system with many components interacting with each other. At this level, the designers get the idea of proposed solution domain.
+*Architectural Design - The architectural design is the highest abstract version of the [[system]]. It identifies the software as a system with many components interacting with each other. At this level, the designers get the idea of proposed solution domain.
 *High-level Design- The high-level design breaks the ‘single entity-multiple component’ concept of architectural design into less-abstracted view of sub-systems and modules and depicts their interaction with each other. High-level design focuses on how the system along with all of its components can be implemented in forms of modules. It recognizes modular structure of each sub-system and their relation and interaction among each other.
 *Detailed Design- Detailed design deals with the implementation part of what is seen as a system and its sub-systems in the previous two designs. It is more detailed towards modules and their implementations. It defines logical structure of each module and their interfaces to communicate with other modules.

@@ Line 1: / Line 1: @@
 '''Software Design''' is a process to transform user requirements into some suitable form, which helps the programmer in [[Software|software]] coding and implementation. For assessing user requirements, an SRS (Software Requirement Specification) document is created whereas for coding and implementation, there is a need of more specific and detailed requirements in software terms. The output of this process can directly be used into implementation in programming languages. Software design is the first step in [[Software Development Life Cycle (SDLC)|SDLC (Software Design Life Cycle)]], which moves the concentration from problem domain to solution domain. It tries to specify how to fulfill the requirements mentioned in SRS.<ref>Definition - What does Software Design Mean? [https://www.slideshare.net/HimanshuAwasthi14/software-design-75545764 Himanshu Awasthi]</ref>
 '''Software Design Process<ref>Software Design Process [https://en.wikipedia.org/wiki/Software_design Wikipedia]</ref>'''<br />
@@ Line 20: / Line 26: @@
 *High-level Design- The high-level design breaks the ‘single entity-multiple component’ concept of architectural design into less-abstracted view of sub-systems and modules and depicts their interaction with each other. High-level design focuses on how the system along with all of its components can be implemented in forms of modules. It recognizes modular structure of each sub-system and their relation and interaction among each other.
 *Detailed Design- Detailed design deals with the implementation part of what is seen as a system and its sub-systems in the previous two designs. It is more detailed towards modules and their implementations. It defines logical structure of each module and their interfaces to communicate with other modules.

← Older revision		Revision as of 20:11, 17 April 2020
Line 1:		Line 1:
		+	'''Software Design''' is a process to transform user requirements into some suitable form, which helps the programmer in [[Software\|software]] coding and implementation. For assessing user requirements, an SRS (Software Requirement Specification) document is created whereas for coding and implementation, there is a need of more specific and detailed requirements in software terms. The output of this process can directly be used into implementation in programming languages. Software design is the first step in [[Software Development Life Cycle (SDLC)\|SDLC (Software Design Life Cycle)]], which moves the concentration from problem domain to solution domain. It tries to specify how to fulfill the requirements mentioned in SRS.<ref>Definition - What does Software Design Mean? [https://www.slideshare.net/HimanshuAwasthi14/software-design-75545764 Himanshu Awasthi]</ref>
		+
	'''Software Design Process<ref>Software Design Process [https://en.wikipedia.org/wiki/Software_design Wikipedia]</ref>'''<br />		'''Software Design Process<ref>Software Design Process [https://en.wikipedia.org/wiki/Software_design Wikipedia]</ref>'''<br />
	Software design is both a process and a model. The design process is a sequence of steps that enables the designer to describe all aspects of the software for building. Creative skill, past experience, a sense of what makes "good" software, and an overall commitment to quality are examples of critical success factors for a competent design. It is important to note, however, that the design process is not always a straightforward procedure; the design model can be compared to an architect's plans for a house. It begins by representing the totality of the thing that is to be built (e.g., a three-dimensional rendering of the house); slowly, the thing is refined to provide guidance for constructing each detail (e.g., the plumbing lay). Similarly, the design model that is created for software provides a variety of different views of the computer software. Basic design principles enable the software engineer to navigate the design process. Davis[3] suggests a set of principles for software design, which have been adapted and extended in the following list:		Software design is both a process and a model. The design process is a sequence of steps that enables the designer to describe all aspects of the software for building. Creative skill, past experience, a sense of what makes "good" software, and an overall commitment to quality are examples of critical success factors for a competent design. It is important to note, however, that the design process is not always a straightforward procedure; the design model can be compared to an architect's plans for a house. It begins by representing the totality of the thing that is to be built (e.g., a three-dimensional rendering of the house); slowly, the thing is refined to provide guidance for constructing each detail (e.g., the plumbing lay). Similarly, the design model that is created for software provides a variety of different views of the computer software. Basic design principles enable the software engineer to navigate the design process. Davis[3] suggests a set of principles for software design, which have been adapted and extended in the following list:

← Older revision		Revision as of 20:06, 17 April 2020
Line 11:		Line 11:
	*The design should be assessed for quality as it is being created, not after the fact. A variety of design concepts and design measures are available to assist the designer in assessing quality throughout the development process.		*The design should be assessed for quality as it is being created, not after the fact. A variety of design concepts and design measures are available to assist the designer in assessing quality throughout the development process.
	*The design should be reviewed to minimize conceptual (semantic) errors. There is sometimes a tendency to focus on minutiae when the design is reviewed, missing the forest for the trees. A design team should ensure that major conceptual elements of the design (omissions, ambiguity, inconsistency) have been addressed before worrying about the syntax of the design model.		*The design should be reviewed to minimize conceptual (semantic) errors. There is sometimes a tendency to focus on minutiae when the design is reviewed, missing the forest for the trees. A design team should ensure that major conceptual elements of the design (omissions, ambiguity, inconsistency) have been addressed before worrying about the syntax of the design model.
		+
		+
		+	'''Software Design Levels<ref>Software Design Levels [https://www.tutorialspoint.com/software_engineering/software_design_basics.htm Tutorials Point]</ref>'''<br />
		+	Software design yields three levels of results:
		+	*Architectural Design - The architectural design is the highest abstract version of the system. It identifies the software as a system with many components interacting with each other. At this level, the designers get the idea of proposed solution domain.
		+	*High-level Design- The high-level design breaks the ‘single entity-multiple component’ concept of architectural design into less-abstracted view of sub-systems and modules and depicts their interaction with each other. High-level design focuses on how the system along with all of its components can be implemented in forms of modules. It recognizes modular structure of each sub-system and their relation and interaction among each other.
		+	*Detailed Design- Detailed design deals with the implementation part of what is seen as a system and its sub-systems in the previous two designs. It is more detailed towards modules and their implementations. It defines logical structure of each module and their interfaces to communicate with other modules.

← Older revision		Revision as of 20:04, 17 April 2020
Line 1:		Line 1:
−	'''~~Content Coming Soon~~'''	+	'''Software Design Process<ref>Software Design Process [https://en.wikipedia.org/wiki/Software_design Wikipedia]</ref>'''<br />
		+	Software design is both a process and a model. The design process is a sequence of steps that enables the designer to describe all aspects of the software for building. Creative skill, past experience, a sense of what makes "good" software, and an overall commitment to quality are examples of critical success factors for a competent design. It is important to note, however, that the design process is not always a straightforward procedure; the design model can be compared to an architect's plans for a house. It begins by representing the totality of the thing that is to be built (e.g., a three-dimensional rendering of the house); slowly, the thing is refined to provide guidance for constructing each detail (e.g., the plumbing lay). Similarly, the design model that is created for software provides a variety of different views of the computer software. Basic design principles enable the software engineer to navigate the design process. Davis[3] suggests a set of principles for software design, which have been adapted and extended in the following list:
		+	*The design process should not suffer from "tunnel vision." A good designer should consider alternative approaches, judging each based on the requirements of the problem, the resources available to do the job.
		+	*The design should be traceable to the analysis model. Because a single element of the design model can often be traced back to multiple requirements, it is necessary to have a means for tracking how requirements have been satisfied by the design model.
		+	*The design should not reinvent the wheel. Systems are constructed using a set of design patterns, many of which have likely been encountered before. These patterns should always be chosen as an alternative to reinvention. Time is short and resources are limited; design time should be invested in representing (truly new) ideas by integrating patterns that already exist (when applicable).
		+	*The design should "minimize the intellectual distance" between the software and the problem as it exists in the real world. That is, the structure of the software design should, whenever possible, mimic the structure of the problem domain.
		+	*The design should exhibit uniformity and integration. A design is uniform if it appears fully coherent. In order to achieve this outcome, rules of style and format should be defined for a design team before design work begins. A design is integrated if care is taken in defining interfaces between design components.
		+	*The design should be structured to accommodate change. The design concepts discussed in the next section enable a design to achieve this principle.
		+	*The design should be structured to degrade gently, even when aberrant data, events, or operating conditions are encountered. Well-designed software should never "bomb"; it should be designed to accommodate unusual circumstances, and if it must terminate processing, it should do so in a graceful manner.
		+	*Design is not coding, coding is not design. Even when detailed procedural designs are created for program components, the level of abstraction of the design model is higher than the source code. The only design decisions made at the coding level should address the small implementation details that enable the procedural design to be coded.
		+	*The design should be assessed for quality as it is being created, not after the fact. A variety of design concepts and design measures are available to assist the designer in assessing quality throughout the development process.
		+	*The design should be reviewed to minimize conceptual (semantic) errors. There is sometimes a tendency to focus on minutiae when the design is reviewed, missing the forest for the trees. A design team should ensure that major conceptual elements of the design (omissions, ambiguity, inconsistency) have been addressed before worrying about the syntax of the design model.