소프트웨어 공학의 정의와 역사
소프트웨어 공학은 과학적 원리를 적용하여 소프트웨어를 설계하고 만드는 체계적인 접근법입니다.
1950년대 후반 컴퓨팅이 시작될 때는 명확한 분야가 아니었으나, 1960년대부터 점차 발전하여 오늘날의 공학 분야로 자리 잡았습니다.
소프트웨어 위기와 해결책
1960년대 중반부터 1980년대 중반까지 소프트웨어 개발은 예산 초과, 일정 지연, 버그 많은 코드 등 문제를 겪으며 ‘소프트웨어 위기’라 불렸습니다.
이 위기를 극복하기 위해 개발 과정에 공학적 원칙과 표준화된 방법론이 도입되었고, CASE(컴퓨터 지원 소프트웨어 공학) 도구들이 개발되어 효율성을 높였습니다.
소프트웨어 엔지니어와 개발자의 차이
소프트웨어 엔지니어는 시스템 전체를 설계하고 구축하는 데 중점을 두며, 보다 넓은 지식을 바탕으로 체계적인 접근을 합니다.
반면, 소프트웨어 개발자는 특정 기능 구현에 집중하며 보다 창의적인 코딩 작업을 수행합니다.
엔지니어는 대규모 프로젝트에 주로 참여하며, 다양한 이해관계자와 협업하는 역할도 맡습니다.
소프트웨어 엔지니어의 주요 책임
소프트웨어 시스템을 설계, 구축, 유지보수하는 일
코드 작성 및 테스트
고객, 제3자 소프트웨어 공급자, 보안 전문가 등과 협의
현대 소프트웨어 개발 프로세스
소프트웨어 개발 생명주기(SDLC)를 통해 고품질 소프트웨어를 개발하는 단계별 절차를 따릅니다.
SDLC는 소프트웨어 개발의 체계적이고 과학적인 접근을 가능하게 합니다.
요약
소프트웨어 공학은 소프트웨어를 체계적이고 과학적으로 개발하는 분야입니다.
소프트웨어 엔지니어는 시스템 전체를 설계하고 다양한 이해관계자와 협력하며, 개발자는 특정 기능 구현에 집중합니다.
SDLC와 같은 표준화된 방법론과 도구들이 소프트웨어 개발의 효율성과 품질을 높이는 데 기여하고 있습니다
소프트웨어 엔지니어링이란 무엇인가?
소프트웨어 엔지니어링은 프로그래밍 언어와 공학 원칙을 활용하여 다양한 소프트웨어 제품을 만드는 과정입니다. 여기에는 웹 애플리케이션, 모바일 앱, 데스크톱 앱, 운영체제, 네트워킹 시스템 등이 포함됩니다. 현대 사회에서 기술은 필수적이며, 소프트웨어 엔지니어링은 이러한 기술 발전의 핵심 역할을 합니다.
소프트웨어 엔지니어링의 다양한 역할
소프트웨어 엔지니어링은 매우 광범위한 분야로, 프론트엔드, 백엔드, 보안, 모바일, 테스트, 풀스택, 데브옵스, 클라우드 데이터, 머신러닝 등 다양한 역할이 존재합니다.
소프트웨어 엔지니어는 설계, 아키텍처, 사용자 인터페이스 개발, 버그 수정 등 소프트웨어의 전 과정에 관여합니다.
소프트웨어 엔지니어링과 개발자의 차이
소프트웨어 엔지니어링은 단순히 코드를 작성하는 것을 넘어서, 소프트웨어의 전체 수명 주기를 고려하는 포괄적인 과정입니다.
개발자는 주로 코드 작성에 집중하는 반면, 엔지니어는 설계, 구현, 배포, 유지보수 등 전반적인 시스템을 책임집니다.
다만, 회사나 지역에 따라 소프트웨어 엔지니어와 개발자의 역할과 명칭이 다르게 사용되기도 하며, 때로는 같은 의미로 혼용되기도 합니다.
소프트웨어 엔지니어링의 창의성과 윤리적 책임
소프트웨어 엔지니어링은 창의적인 과정으로, 아이디어 구상부터 실제 구현, 유지보수까지 전 과정을 포함합니다.
특히 일부 국가에서는 소프트웨어 엔지니어가 윤리 강령을 준수해야 하는 전문직으로 인정받기도 하며, 이는 다른 공학 분야와 유사한 책임감을 요구합니다.
결론적으로, 소프트웨어 엔지니어링은 단순한 프로그래밍을 넘어선 복합적이고 체계적인 과정이며, 다양한 역할과 책임을 포함하는 중요한 분야임을 알 수 있습니다.
소프트웨어 엔지니어링에서 설계와 구현은 서로 밀접하게 연결된 단계입니다.
설계는 소프트웨어가 어떻게 동작할지, 어떤 구조와 아키텍처를 가질지 계획하는 과정입니다. 여기에는 시스템의 구성 요소, 데이터 흐름, 인터페이스, 그리고 기술적 선택들이 포함됩니다. 좋은 설계는 소프트웨어의 유지보수성, 확장성, 성능에 큰 영향을 미칩니다.
구현은 설계 단계에서 계획한 내용을 실제 코드로 작성하는 과정입니다. 설계가 청사진이라면, 구현은 그 청사진을 바탕으로 건물을 짓는 작업에 비유할 수 있습니다.
즉, 설계는 구현의 기반이 되며, 구현은 설계의 구체적인 실행입니다. 설계가 잘 되어야 구현도 효율적이고 효과적으로 이루어질 수 있습니다. 소프트웨어 엔지니어링에서는 이 두 단계를 유기적으로 연결하여 전체 소프트웨어 개발 과정의 품질을 높이는 것이 중요합니다.
소프트웨어 개발 생명주기(SDLC): 체계적인 소프트웨어 개발의 시작
소프트웨어 개발 생명주기(SDLC)는 고품질 소프트웨어를 예측 가능한 시간과 예산 내에 개발하기 위한 체계적인 프로세스입니다. 이 글에서는 SDLC의 개념, 역사, 그리고 이를 활용하는 주요 장점에 대해 살펴보겠습니다.
SDLC의 정의와 목적
SDLC는 고객의 비즈니스 요구사항을 충족하는 소프트웨어를 만드는 것을 목표로 하며, 계획, 설계, 개발의 단계를 포함하는 순환 과정입니다.
각 단계는 고유한 프로세스와 산출물을 가지며, 반복적인 접근법으로도 구현할 수 있어 변화하는 요구사항에 유연하게 대응할 수 있습니다.
SDLC의 역사적 배경
1960년대 중반, 소프트웨어 개발이 점점 복잡해지면서 보다 세밀한 관리가 필요해졌고, 이에 따라 SDLC가 형성되었습니다.
초기에는 ‘워터폴 방법’이라는 선형적 단계별 접근법이 주로 사용되었으나, 이후 고객 요구와 변화에 대응하기 위해 반복적이고 유연한 방법론으로 발전했습니다.
SDLC를 활용하는 주요 장점
개발팀에게 체계적인 프로세스를 제공하여 효율성을 높이고 위험을 줄입니다.
명확하게 정의된 단계 덕분에 팀원들은 자신의 역할과 작업 시점을 명확히 이해할 수 있습니다.
고객과 이해관계자 간의 소통이 원활해지며, 각 단계별 완료 시점을 기준으로 협업이 체계적으로 이루어집니다.
문제 해결이 초기 단계에서 이루어져, 설계 단계에서 문제를 조기에 발견하고 수정할 수 있습니다.
각 팀원의 역할이 명확히 구분되어 책임 충돌이나 중복을 줄입니다.
결론적으로, SDLC는 소프트웨어 개발을 위한 로드맵을 제공하며, 위험 감소와 효율성 향상, 그리고 팀과 이해관계자 간의 원활한 소통을 가능하게 합니다. 또한 반복적 적용이 가능해 변화하는 요구사항에도 유연하게 대응할 수 있는 중요한 개발 방법론입니다.
Welcome to the Phases of the Software Development Life Cycle. After watching this video, you will be able to name the phases involved in the SDLC, describe each phase, and identify several tasks associated with each phase. There are generally six phases in the SDLC process, planning, design, development, testing, deployment, and maintenance. Each phase is discrete meaning that tasks from a previous phase do not overlap with tasks in the next phase. The original SDLC was conceived as a traditional waterfall method where the phases are linear, but have since been adapted to introduce iteration so that shifting requirements can be accommodated. Waterfall and other approaches to software development will be discussed in another video. Note that some organizations may have different names for each stage.
For example, “planning” may be called “requirements” or “strategy” or “analysis”. Also, some organizations may have additional or fewer stages. In the first stage of the SDLC, the planning phase, requirements are gathered, analyzed, documented and prioritized. When planning a software solution, the following factors must be considered: users of the solution the overall purpose of the solution, data inputs and outputs, legal and regulatory compliance, risk identification, quality assurance requirements, allocation of human and financial resources, and project scheduling. As part of the planning process, labor and material costs are estimated and weighed against time constraints. Also, project teams are identified, and roles of each team member are proposed. If stakeholders are struggling to define requirements, often the development team may produce prototypes during the planning stage to tease out those requirements.
A prototype is a small-scale replica of the end product used to get stakeholder feedback and establish requirements. A prototype is used to test basic design ideas. Though prototyping usually occurs during the planning stage, prototyping can occur at various phases of the SDLC whenever requirements need to be reconsidered or clarified as the project develops. After requirements have been gathered, they are combined into a document called a software requirements specification, or SRS, document. The SRS needs to be clearly understood and approved by all stakeholders. The developers are also involved at this stage so they can gain a clear understanding of these requirements. Requirements and the SRS will be discussed in more detail in a later video.
In the design phase, the requirements gathered from the SRS are used to develop the software architecture. Several team members work together at this stage to design the architecture. The architecture is reviewed by the stakeholders and team. And during this phase, prototypes can be designed. A prototype is a preliminary mock-up of the system, or parts of the system, used for demonstration purposes. The document created in this phase is called a design document, and is used by developers during the next phase, which is the development phase. The development phase, sometimes called the “building" phase or the "implementation" phase, is when the developers start the coding process once the design document is completed.
The project planners use the design document to determine and assign coding tasks. This phase often requires the use of programming tools, different programming languages, and software stacks. Organizations may also have standards or guidelines that need to be followed. The testing phase is next in the process once the coding is complete. And some large projects have dedicated testing teams. Code needs to be thoroughly tested to ensure it is stable, secure, and meets the requirements outlined in the SRS. Testing can be manual, automated, or a hybrid of both.
Product bugs are reported, tracked, and fixed, and code is retested until the software is stable. Some common levels of testing include unit testing, integration testing, system testing, and acceptance testing. Each of these testing levels will be described in further detail in another video. The deployment phase is where the application is released into the production environment and made available to users. This can also happen in stages— first, it is released onto a user acceptance testing, also called UAT, platform and once the customer signs off on the functionality, it is released to production. This approach can be used for making software available on a website, mobile device app store, or a software distribution server on a corporate network. Finally, the maintenance phase happens once the code has been deployed into a production environment.
This phase helps to find any other bugs, identify user interface issues, or UI for short, and identify other requirements that may not have been listed in the SRS. Code enhancements can also be identified at this stage. If bugs are discovered in this phase that were missed during testing, these errors may need to be fixed for high-priority issues or incorporated into the requirements as part of a future software release and the process can start over again. In this video, you learned that The SDLC can be divided into six phases. Planning involves requirement gathering and development of the SRS. The architecture is developed during the design phase and the design document is created. The Development phase is when coding takes place, and then during the testing phase issues with the code are found and fixed if possible.
Deployment is when the code is released to the production environment. And finally, in the maintenance stage feedback is collected from stakeholders, other UI issues may be identified, and code enhancements suggested. And this information then can be fed into another software development cycle if necessary.
Welcome to the Phases of the Software Development Life Cycle. After watching this video, you will be able to name the phases involved in the SDLC, describe each phase, and identify several tasks associated with each phase. There are generally six phases in the SDLC process, planning, design, development, testing, deployment, and maintenance. Each phase is discrete meaning that tasks from a previous phase do not overlap with tasks in the next phase. The original SDLC was conceived as a traditional waterfall method where the phases are linear, but have since been adapted to introduce iteration so that shifting requirements can be accommodated. Waterfall and other approaches to software development will be discussed in another video. Note that some organizations may have different names for each stage. For example, “planning” may be called “requirements” or “strategy” or “analysis”. Also, some organizations may have additional or fewer stages. In the first stage of the SDLC, the planning phase, requirements are gathered, analyzed, documented and prioritized. When planning a software solution, the following factors must be considered: users of the solution the overall purpose of the solution, data inputs and outputs, legal and regulatory compliance, risk identification, quality assurance requirements, allocation of human and financial resources, and project scheduling. As part of the planning process, labor and material costs are estimated and weighed against time constraints. Also, project teams are identified, and roles of each team member are proposed. If stakeholders are struggling to define requirements, often the development team may produce prototypes during the planning stage to tease out those requirements. A prototype is a small-scale replica of the end product used to get stakeholder feedback and establish requirements. A prototype is used to test basic design ideas. Though prototyping usually occurs during the planning stage, prototyping can occur at various phases of the SDLC whenever requirements need to be reconsidered or clarified as the project develops. After requirements have been gathered, they are combined into a document called a software requirements specification, or SRS, document. The SRS needs to be clearly understood and approved by all stakeholders. The developers are also involved at this stage so they can gain a clear understanding of these requirements. Requirements and the SRS will be discussed in more detail in a later video. In the design phase, the requirements gathered from the SRS are used to develop the software architecture. Several team members work together at this stage to design the architecture. The architecture is reviewed by the stakeholders and team. And during this phase, prototypes can be designed. A prototype is a preliminary mock-up of the system, or parts of the system, used for demonstration purposes. The document created in this phase is called a design document, and is used by developers during the next phase, which is the development phase. The development phase, sometimes called the “building" phase or the "implementation" phase, is when the developers start the coding process once the design document is completed. The project planners use the design document to determine and assign coding tasks. This phase often requires the use of programming tools, different programming languages, and software stacks. Organizations may also have standards or guidelines that need to be followed. The testing phase is next in the process once the coding is complete. And some large projects have dedicated testing teams. Code needs to be thoroughly tested to ensure it is stable, secure, and meets the requirements outlined in the SRS. Testing can be manual, automated, or a hybrid of both. Product bugs are reported, tracked, and fixed, and code is retested until the software is stable. Some common levels of testing include unit testing, integration testing, system testing, and acceptance testing. Each of these testing levels will be described in further detail in another video. The deployment phase is where the application is released into the production environment and made available to users. This can also happen in stages— first, it is released onto a user acceptance testing, also called UAT, platform and once the customer signs off on the functionality, it is released to production. This approach can be used for making software available on a website, mobile device app store, or a software distribution server on a corporate network. Finally, the maintenance phase happens once the code has been deployed into a production environment. This phase helps to find any other bugs, identify user interface issues, or UI for short, and identify other requirements that may not have been listed in the SRS. Code enhancements can also be identified at this stage. If bugs are discovered in this phase that were missed during testing, these errors may need to be fixed for high-priority issues or incorporated into the requirements as part of a future software release and the process can start over again. In this video, you learned that The SDLC can be divided into six phases. Planning involves requirement gathering and development of the SRS. The architecture is developed during the design phase and the design document is created. The Development phase is when coding takes place, and then during the testing phase issues with the code are found and fixed if possible. Deployment is when the code is released to the production environment. And finally, in the maintenance stage feedback is collected from stakeholders, other UI issues may be identified, and code enhancements suggested. And this information then can be fed into another software development cycle if necessary. Welcome to the Phases of the Software Development Life Cycle. After watching this video, you will be able to name the phases involved in the SDLC, describe each phase, and identify several tasks associated with each phase. There are generally six phases in the SDLC process, planning, design, development, testing, deployment, and maintenance. Each phase is discrete meaning that tasks from a previous phase do not overlap with tasks in the next phase. The original SDLC was conceived as a traditional waterfall method where the phases are linear, but have since been adapted to introduce iteration so that shifting requirements can be accommodated. Waterfall and other approaches to software development will be discussed in another video. Note that some organizations may have different names for each stage. For example, “planning” may be called “requirements” or “strategy” or “analysis”. Also, some organizations may have additional or fewer stages. In the first stage of the SDLC, the planning phase, requirements are gathered, analyzed, documented and prioritized. When planning a software solution, the following factors must be considered: users of the solution the overall purpose of the solution, data inputs and outputs, legal and regulatory compliance, risk identification, quality assurance requirements, allocation of human and financial resources, and project scheduling. As part of the planning process, labor and material costs are estimated and weighed against time constraints. Also, project teams are identified, and roles of each team member are proposed. If stakeholders are struggling to define requirements, often the development team may produce prototypes during the planning stage to tease out those requirements. A prototype is a small-scale replica of the end product used to get stakeholder feedback and establish requirements. A prototype is used to test basic design ideas. Though prototyping usually occurs during the planning stage, prototyping can occur at various phases of the SDLC whenever requirements need to be reconsidered or clarified as the project develops. After requirements have been gathered, they are combined into a document called a software requirements specification, or SRS, document. The SRS needs to be clearly understood and approved by all stakeholders. The developers are also involved at this stage so they can gain a clear understanding of these requirements. Requirements and the SRS will be discussed in more detail in a later video. In the design phase, the requirements gathered from the SRS are used to develop the software architecture. Several team members work together at this stage to design the architecture. The architecture is reviewed by the stakeholders and team. And during this phase, prototypes can be designed. A prototype is a preliminary mock-up of the system, or parts of the system, used for demonstration purposes. The document created in this phase is called a design document, and is used by developers during the next phase, which is the development phase. The development phase, sometimes called the “building" phase or the "implementation" phase, is when the developers start the coding process once the design document is completed. The project planners use the design document to determine and assign coding tasks. This phase often requires the use of programming tools, different programming languages, and software stacks. Organizations may also have standards or guidelines that need to be followed. The testing phase is next in the process once the coding is complete. And some large projects have dedicated testing teams. Code needs to be thoroughly tested to ensure it is stable, secure, and meets the requirements outlined in the SRS. Testing can be manual, automated, or a hybrid of both. Product bugs are reported, tracked, and fixed, and code is retested until the software is stable. Some common levels of testing include unit testing, integration testing, system testing, and acceptance testing. Each of these testing levels will be described in further detail in another video. The deployment phase is where the application is released into the production environment and made available to users. This can also happen in stages— first, it is released onto a user acceptance testing, also called UAT, platform and once the customer signs off on the functionality, it is released to production. This approach can be used for making software available on a website, mobile device app store, or a software distribution server on a corporate network. Finally, the maintenance phase happens once the code has been deployed into a production environment. This phase helps to find any other bugs, identify user interface issues, or UI for short, and identify other requirements that may not have been listed in the SRS. Code enhancements can also be identified at this stage. If bugs are discovered in this phase that were missed during testing, these errors may need to be fixed for high-priority issues or incorporated into the requirements as part of a future software release and the process can start over again. In this video, you learned that The SDLC can be divided into six phases. Planning involves requirement gathering and development of the SRS. The architecture is developed during the design phase and the design document is created. The Development phase is when coding takes place, and then during the testing phase issues with the code are found and fixed if possible. Deployment is when the code is released to the production environment. And finally, in the maintenance stage feedback is collected from stakeholders, other UI issues may be identified, and code enhancements suggested. And this information then can be fed into another software development cycle if necessary.
Welcome to Building Quality Software. After watching this video, you will be able to: list common software engineering processes and describe the common software engineering processes required for building-high quality software. There are numerous processes that are common to software engineering projects. In this video we will discuss six of them: requirements gathering, design, coding for quality, testing, releases, and documenting. The software requirements specification, or SRS, encompasses the process of collecting and documenting the set of requirements that the software needs to adhere to. It may include a set of use cases that describe the business needs and user flows that the software must implement. Software requirements can be classified into four broad categories: functional, external and User Interface, or UI, system features, and non-functional.
These categories are discussed in more detail in another video. Software design is the process of transforming the requirements into a structure that is implementable using code. The software design process translates the requirements into a language the developers can use to write the code. It transforms the requirements into a software solution. The technical lead breaks down requirements into sets of related components with clearly defined behaviors, boundaries, and interactions. These components define the system architecture. The system design incorporates guidance on system functions, performance, security, and platform characteristics.
The design communicates business rules and application logic, application programming interface design, which is how apps talk to each other or communicate with the database, user interfaces, and database design. Code quality refers to the characteristics of the code including attributes such as maintainability, readability, testability, and security. Quality code must fulfill the intended requirements of the software without defects. Additionally, it should be clean and consistent, easy to read and maintain, well documented, and efficient. Coding for quality entails following a set of coding practices during development. These include: following common coding standards, conventions, patterns and styles, using automated tools, known as linters, to detect programmatic and stylistic errors, and commenting in the code itself to make it easy for others to understand and modify. Software testing is the process of verifying that the software matches established requirements and is free of bugs.
Its purpose is to identify errors, gaps, or missing requirements when compared with stated requirements. Properly tested software ensures reliability, security, performance, and efficiency. Software testing can often be automated or done manually. Levels of testing include unit, integration, system, and user acceptance. Unit testing is often done by the developer and tests the smallest component of code that can be isolated from the rest of the system. Once the components are integrated into the larger product, integration testing occurs. Then, after the larger product is deemed completed, system testing can take place.
User acceptance testing, or UAT for short and sometimes called beta testing, is when the software is tested by the intended end user. Types of testing can broadly be divided into three categories, functional, non-functional, and regression. Testing levels and types will be further explained in an upcoming video. When the newest version of the software is distributed, it is referred to as a “release.” Different types of releases are intended for different audiences. There is generally an “alpha,” a “beta,” and a “GA” release. GA stands for general availability.
The alpha release is the first functioning version of the system released to a select group of stakeholders. The alpha release likely contains errors and may not contain the full feature set but does contain most of the desired functionality. Design changes may still occur during this release stage. The beta release, also called a limited release, is given to the stakeholders outside of the developing organization. One of the intents of the beta release is to try out the software under real conditions, test the functionality, and identify any outstanding bugs or errors. The beta release should meet all the functional requirements. Then, after beta release changes are agreed upon, made, and tested, and a stable version is released.
The audience for the GA release is all users. Software documentation should be provided to both non-technical end-users and technical users. System documentation is geared towards the technical user. Technical users may be other engineers, developers, or architects. System documentation explains how the software operates or how to use it. It consists of README files, inline comments, architecture and design documents, verification information, and maintenance guides. User documentation is provided to the non-technical end-users to assist them in the use of the product. Generally, user documentation is provided in the form of user guides, instructional videos and manuals, online help, and inline help.
More details about documentation will be discussed in another video. In this video, you learned that: Requirement gathering is collecting and documenting the set of requirements that the software needs to adhere to. Designing transforms requirements into a structure that developers can use. Coding for quality entails following a set of coding practices during development. Testing is the process of verifying that the software matches established requirements and is free of bugs There are three types of releases including: alpha, beta, and general availability. And finally, documenting requires text or video that explains the software to technical and non-technical users.
Welcome to Requirements. After watching this video, you will be able to: Describe the steps of the requirement gathering process. Explain the purpose of a User Requirement Specification, or URS, document. Explain the purpose of a Software Requirement Specification, or SRS, document, and Explain the purpose of a System Requirement Specification, or SysRS, document Requirement gathering is a six-step process of defining a problem to be solved and documenting how to go about solving that problem. These steps include: identifying stakeholders, establishing goals and objectives, eliciting requirements from the stakeholders, documenting the requirements, analyzing and confirming the requirements, and prioritizing. Generally, the stakeholders work for the organization that requests the development of the software product. Key personnel from the organization may include decision-makers, end-users, system administrators, engineering, marketing, sales, and customer support personnel.
It is good to have a representative from every group that the product affects. The goals of the product should be clearly defined. Goals are broad, long-term achievable outcomes. Goals can include customer outcomes and business goals. Next, objectives should be identified. Objectives are more specific than goals and they are actionable and measurable actions that achieve the stated goals. The next three steps, eliciting, documenting, and requirement confirmation are usually completed iteratively.
Elicitation can be accomplished through surveys, questionnaires, and interviews. As the requirements emerge, they should be documented and checked to ensure they align with the goals and objectives. Documented requirements should be easily understood by stakeholders and the project team. In order to confirm the requirements, they should be analyzed to ensure consistency, clarity, and completeness. And after analysis, the requirements should be shared with and approved by the stakeholders. After confirmation, requirements should be prioritized. Labels such as “must-have,” “highly desired,” and “nice to have” are helpful. If possible, order the requirements within those categories.
Typically, there may be three documents that result from the requirements gathering process: software requirements specification, or SRS, user requirements specification, or URS, and system requirements specification, or SysRS. The most common of these is the software requirements specification. The software requirements specification, or SRS, is a document that captures the functionalities that the software should perform and also establishes benchmarks or service levels for its performance. Parts of an SRS include: A purpose statement that contains the intended use of the SRS, its audience and scope, constraints, assumptions and dependencies, and requirements, which can be sorted into four categories: Functional requirements External Interface requirements System Features and Non-functional requirements The product’s purpose describes who will have access to the SRS and how they should use it. The scope describes the benefits of the software, its goals, and objectives. The second part of the SRS should detail constraints, assumptions, and dependencies. Constraints describe how the product must operate under given conditions that may limit options in the design phase such as confirmation to standards or hardware limitations.
Assumptions may include things like a required operating system or hardware that is needed by the software to function. Dependencies on other software products should also be noted. Requirements can be classified into four categories. Functional requirements are those that cover the functionalities of the software. External requirements are the requirements that address the behavior of the software in relation to external entities such as users and interactions with other hardware or software. System features are a subset of functional requirements. These are required features for the system to function.
There are also non-functional requirements such as specifying performance, safety, security, and quality standards. User requirements describe the business need and expectations of the end-users from the software system. The user requirements are written as “user stories” or “use cases” that answer three questions: Who is the user? What is the function that needs to be performed? And why does the user want this functionality? User acceptance testing determines if these requirements have been met. Often though, the user requirements and software requirements are combined into a single SRS document. The SRS details the expectations of the software system.
The System Requirement Specification document, or SysRS, to differentiate it from the SRS, clearly outlines the requirements of an entire system. The system requirement specification is often used interchangeably with software requirement specification, but the SysRS is actually broader in scope than the SRS. Many software projects develop an SRS rather than a SysRS. The SysRS contains system capabilities, interfaces, and user characteristics. It also may include policy requirements, regulation requirements, personnel requirements, performance requirements, security requirements, and system acceptance criteria. It also outlines expectations of the hardware needed for the system in addition to software requirements. In this video you learned that: The requirement gathering process entails identifying stakeholders, establishing goals and objectives, and eliciting, documenting, confirming, and then prioritizing requirements.
The SRS documents functional, external, system, and non-functional requirements. The URS documents user stories. And finally, the SysRS documents system capabilities and acceptance criteria, and policy, regulation, personnel, performance, security, and hardware requirements.
아직 댓글이 없습니다.
로그인 후 댓글을 남길 수 있어요