Unit- 6
Software Process Model (SPM)
Software project Concept
A software project is the complete procedure of software development from requirement gathering to testing, and maintenance, carried out according to the execution methodologies, in a specific period to achieve intended software product.
Program:
- A program is a set of instructions, or a sequence of statements written in a programming language that performs a specific task or a set of tasks when executed by a computer.
- Programs can be created to perform various functions, such as processing data, solving problems, controlling hardware devices, and facilitating user interactions.
- They are designed to enable computers to perform specific tasks efficiently and accurately.
- Programs can be small, like a simple calculator application, or large, like an operating system.
Software
- Software refers to a collection of programs, data, and instructions that are designed to work together to perform specific functions or tasks on a computer system.
- It includes both the programs themselves (executable code) and the associated data required for their operation.
- Software can be classified into several categories, such as operating systems (e.g., Windows, macOS, Linux), application software (e.g., word processors, web browsers, games), utility software (e.g., antivirus programs, disk cleanup tools), and system software (e.g., compilers, device drivers).
- Software is the broader term that encompasses all types of computer programs.
Software project management
Software project management refers to the planning, organizing, and controlling of resources, activities, and tasks involved in developing and delivering software projects. It involves applying project management principles and techniques to ensure the successful completion of software projects within the defined scope, budget, and timeline.
SDLC (Software Development Life Cycle)
Introduction
Software project management refers to the planning, organizing, and controlling of resources, activities, and tasks involved in developing and delivering software projects. It involves applying project management principles and techniques to ensure the successful completion of software projects within the defined scope, budget, and timeline.
Importance of sdlc
- It ensures that the software meets the needs of its user.
- It supports proper analysis and design of the software.
- It ensures proper development and testing.
- It Ensure that projects are well-organized and executed in a systematic manner.
- It helps to determine the needs of the user.
- The SDLC includes risk management practices, enabling the identification and mitigation of potential risks throughout the development process.
- Deliver quality systems which meet or exceed customer expectations when promised and within cost estimates.
- Provide a framework for developing quality systems using an identifiable, measurable, and repeatable process.
Different phases of SDLC
Phase 1: Requirement collection and analysis
Phase 2: Feasibility study
Phase 3: Design
Phase 4: Coding
Phase 5: Testing
Phase 6: Installation/Deployment
Phase 7: Maintenance
Phase 1: Requirement collection and analysis
- The requirement is the first stage in the SDLC process.
- It is conducted by the senior team members with inputs from all the stakeholders and domain experts in the industry.
- Planning for the quality assurance requirements and recognition of the risks involved is also done at this stage.
- Requirements Gathering stage need teams to get detailed and precise requirements. This helps companies to finalize the necessary timeline to finish the work of that system.
Phase 2: Feasibility study
Once the requirement analysis phase is completed the next sdlc step is to define and document software needs. This process conducted with the help of ‘Software Requirement Specification’ document also known as ‘SRS’ document. It includes everything which should be designed and developed during the project life cycle.
There are mainly five types of feasibilities checks:
- Economic: Can we complete the project within the budget or not?
- Legal: Can we handle this project as cyber law and other regulatory framework/compliances.
- Operation feasibility: Can we create operations which is expected by the client?
- Technical: Need to check whether the current computer system can support the software
- Schedule: Decide that the project can be completed within the given schedule or not.
Phase 3: Design
In this third phase, the system and software design documents are prepared as per the requirement specification document. This helps define overall system architecture.
This design phase serves as input for the next phase of the model.
There are two kinds of design documents developed in this phase:
High-Level Design (HLD)
- Brief description and name of each module
- An outline about the functionality of every module
- Interface relationship and dependencies between modules
- Database tables identified along with their key elements
- Complete architecture diagrams along with technology details
Low-Level Design (LLD)
- Functional logic of the modules
- Database tables, which include type and size
- Complete detail of the interface
- Addresses all types of dependency issues
- Listing of error messages
- Complete input and outputs for every module
Phase 4: Coding
- In this phase, developers start build the entire system by writing code using the chosen programming language.
- In the coding phase, tasks are divided into units or modules and assigned to the various developers.
- It is the longest phase of the Software Development Life Cycle process.
- They need to use programming tools like compiler, interpreters, debugger to generate and implement the code.
Phase 5: Testing
- It is an iterative process that helps identify defects, errors, or bugs in the software before it is released to end-users.
- The testing team starts testing the functionality of the entire system. This is done to verify that the entire application works according to the customer requirement. It helps to identify and fix any defects or bugs.
- Different types of testing, such as unit testing, integration testing, system testing, and user acceptance testing, are performed to ensure the software functions as intended.
Phase 6: Installation/Deployment
- Once the software testing phase is over and no bugs or errors left in the system then the final deployment process starts.
- Based on the feedback given by the project manager, the final software is released and checked for deployment issues if any.
Phase 7: Maintenance
Once the system is deployed, and customers start using the developed system, following 3 activities occur
- Bug fixing – bugs are reported because of some scenarios which are not tested at all
- Upgrade – Upgrading the application to the newer versions of the Software
- Enhancement – Adding some new features into the existing software
The focus of this SDLC phase is to ensure that needs continue to be met and that the system continues to perform as per the specification mentioned in the first phase.
Feasibility study and its type
A feasibility study is a comprehensive analysis of a proposed project or business idea to determine its potential for success. It is conducted before starting the actual project to assess its viability and to identify potential issues that may arise during the implementation phase.
The feasibility study helps stakeholders to make informed decisions about whether to proceed with the project or not.
There are different types of feasibility studies, including:
Technical Feasibility Study: This type of feasibility study assesses whether the proposed project is technically feasible. It examines factors such as whether the technology required for the project is available, whether the project can be completed within the available time frame, and whether the project can be completed within the allocated budget.
Economic Feasibility Study: This type of feasibility study evaluates whether the proposed project is economically feasible. It examines factors such as the cost of the project, potential revenue streams, and the return on investment (ROI) that can be expected from the project.
Legal Feasibility Study: This type of feasibility study examines whether the proposed project is legally feasible. It examines factors such as compliance with relevant laws and regulations, potential legal challenges, and the availability of required licenses and permits.
Operational Feasibility Study: This type of feasibility study assesses whether the proposed project is operationally feasible. It examines factors such as the availability of resources, the capacity of the organization to implement the project, and the potential impact on existing operations.
Schedule Feasibility Study: This type of feasibility study evaluates whether the proposed project can be completed within the desired time frame. It examines factors such as the availability of resources, the complexity of the project, and potential delays that may arise during the implementation phase
Explain Requirement collection methods.
Requirement collection is a critical phase in software development that involves gathering and analyzing information from stakeholders to understand their needs, preferences, and expectations for the project. Here are some common methods used for requirement collection:
Interviews: This method involves conducting one-on-one or group interviews with stakeholders to gather their requirements. It provides an opportunity to ask specific questions, clarify information, and understand stakeholders' perspectives.
Surveys and Questionnaires: This method involves sending a set of standardized questions to stakeholders to collect their feedback. It can be administered online or in print, making it a cost-effective way to gather a large amount of data.
Focus Groups: This method involves bringing together a group of stakeholders to discuss their requirements and provide feedback. It is an interactive way to gather insights and perspectives from multiple stakeholders at once.
Observation: This method involves observing stakeholders in their work environment to understand their needs and behaviors. It can be helpful in identifying unspoken requirements that stakeholders may not be able to articulate verbally.
Prototyping: This method involves creating a working prototype of the system or product to gather feedback from stakeholders. It can help to identify design flaws, usability issues, and other requirements that may not be apparent in the early stages of development.
Workshops and Brainstorming Sessions: This method involves bringing together stakeholders for a facilitated session to generate ideas and requirements. It can be a collaborative way to gather input from multiple stakeholders at once and encourage creativity.
Data Flow Diagram
- A data flow diagram shows the way information flows through a process or system. It includes data inputs and outputs, data stores, and the various subprocesses the data moves through. DFDs are built using standardized symbols and notation to describe various entities and their relationships.
- Data flow diagrams visually represent systems and processes that would be hard to describe in just words. You can use these diagrams to map out an existing system and make it better or to plan out a new system for implementation.
- DFDs can be divided into different levels, which provide varying degrees of detail about the system. The following are the four levels of DFDs:
- 0-level DFD: It is also known as a context diagram. It represents the entire system as a single bubble with input and output data indicated by incoming/outgoing arrows.
1-level DFD: In 1-level DFD, the context diagram is decomposed into multiple bubbles/processes. In this level, we highlight the main functions of the system and breakdown the high-level process of 0-level DFD into subprocesses.
2-level DFD: 2-level DFD goes one step deeper into parts of 1-level DFD. It can be used to plan or record the specific/necessary detail about the system’s functioning.
DFD for library management system
Testing and its types
Testing is an integral part of software project development. It helps ensure that the software meets the desired quality standards, functions correctly, and satisfies the requirements of the end users. There are various types of testing that can be performed throughout the software development lifecycle. Here are some common types of testing:
Unit Testing: This type of testing focuses on verifying the smallest testable units of code, such as functions or methods, in isolation. It helps identify bugs or defects early in the development process.
Integration Testing: Integration testing is performed to verify the interactions between different components or modules of the software. It ensures that these components work together as expected and helps detect any issues arising from their integration.
System Testing: System testing involves testing the entire software system as a whole. It validates the system against the functional and non-functional requirements, checking if it meets the specified criteria.
Acceptance Testing: Acceptance testing is conducted to determine whether the software meets the expectations and requirements of the end users or stakeholders. It can be performed through various methods like user acceptance testing (UAT), alpha/beta testing, or customer validation.
Performance Testing: Performance testing assesses how well the software performs under specific conditions, such as high user loads or heavy data volumes. It helps identify bottlenecks, scalability issues, or any other performance-related problems.
Security Testing: Security testing evaluates the software's ability to protect data, prevent unauthorized access, and detect vulnerabilities. It includes testing for potential threats, such as penetration testing, vulnerability scanning, and security code reviews.
Usability Testing: Usability testing focuses on evaluating how user-friendly and intuitive the software is. It involves gathering feedback from end users and assessing factors like ease of use, user interface design, and overall user experience.
Different types of system testing
Black Box Testing:
- Testers focus on the inputs and outputs of the system, treating it as a "black box" where they cannot see its internal structure.
- The goal is to test the system only based on its expected behavior and requirements.
- The main objective of this testing is to check what functionality of the system under test.
- Testers design test cases based on the system's specifications, user stories, or functional requirements to validate the system's functionality, usability, and compliance.
White Box Testing:
- White box testing, also known as glass box testing or clear box testing, is an approach where testers have access to the internal code, structure, and implementation details of the system being tested.
- The main objective of White Box testing is done to check the quality of the code.
- Testers examine and test the internal components, algorithms, and control flows of the system to ensure that they function correctly.
- This type of testing requires knowledge of programming languages, code analysis, and an understanding of the system's internal design.
System analyst
A system analyst is a professional responsible for analyzing, designing, and implementing information systems that meet business needs. Here are some of the key qualities that are essential for a system analyst:
Role and responsibilities of system analyst
The role of a system analyst in software development is critical. Here are some of the key responsibilities of a system analyst:
Gathering requirements: A system analyst works with stakeholders to understand their business needs and requirements. They document these requirements and translate them into technical specifications.
Designing system solutions: A system analyst designs system solutions that meet business requirements. They work with developers to ensure that the technical specifications are properly implemented.
Developing and maintaining system documentation: A system analyst is responsible for documenting system requirements, designs, and specifications. They also ensure that this documentation is up to date and accurate.
Testing and quality assurance: A system analyst is involved in testing and quality assurance activities, including unit testing, integration testing, and user acceptance testing. They ensure that the software meets business requirements and is free of defects.
Project management: A system analyst may be involved in project management activities, such as scheduling, budgeting, and resource allocation. They ensure that the project is completed on time, within budget, and to the satisfaction of stakeholders.
Communication and collaboration: A system analyst works closely with business stakeholders, developers, and other IT professionals. They must communicate effectively, collaborate with team members, and manage stakeholder expectations.
Qualities of system analyst
Strong analytical skills: A system analyst must be able to analyze complex information and break it down into smaller, more manageable pieces. They must also be able to identify patterns and trends in data to help inform decisions.
Technical Skills: Technical skill enables system analyst to understand the potentials and limitation of information technology. A system analyst should be well trained in relevant areas of computer science. He must have knowledge of programming ideas and technique to be able to design a system which can be implemented.
Excellent communication skills: A system analyst must be able to communicate effectively with both technical and non-technical stakeholders. They must be able to listen actively, ask probing questions, and provide clear and concise explanations.
Attention to detail: A system analyst must have a keen eye for detail, as even small errors can have significant impacts on the software's performance.
Strong problem-solving skills: A system analyst must be able to identify problems and propose effective solutions. They must be able to think creatively and consider alternative approaches to problem-solving.
Knowledge of software development: A system analyst must have a solid understanding of software development processes, including programming languages, database systems, and testing methodologies.
Time management skills: A system analyst must be able to prioritize tasks and manage their time effectively. They must be able to work efficiently under pressure and meet project deadlines.
Teamwork skills: A system analyst must be able to work effectively as part of a team, collaborating with developers, business stakeholders, and other IT professionals.
Adaptability: A system analyst must be able to adapt to changing circumstances and requirements, adjusting their approach as necessary to meet project goals.
Software engineer
A software engineer is a professional who specializes in designing, developing, and maintaining software systems. They possess a strong understanding of software development principles, programming languages, algorithms, and data structures. Software engineers apply engineering principles and practices to build efficient, reliable, and scalable software solutions that meet specific requirements.
Roles and responsibilities of software engineers
- Monitoring and managing all installed systems and infrastructure.
- Establish, configure, test, and maintain OS, application software and system management tools.
- Plan and implement the system.
- Evaluate the existing systems and provide technical direction to iT support staffs
- Timely reporting on the log sheet for the rapid response of any glitches.
Differences between software analyst and software engineer.
|
Software Analyst |
Software Engineer |
|
A software analyst primarily focuses
on analyzing and understanding the software requirements and needs of the
end-users, clients, or stakeholders. |
software engineer focuses on
designing, developing, and implementing software applications based on the requirements
and specifications provided by the software analyst or other stakeholders. |
|
|
. |
|
software analysts focus on
requirements analysis, software evaluation, and creating functional
specifications |
Software engineers are responsible
for the development and implementation of software solutions. |
|
A software analyst may also not be
as technician or proficient with programming as the engineer. |
It is purely technical person. |
|
Leadership quality is needed. |
Logical, mathematical, and creative
qualities are needed. |
|
Need or prefer to have both coding
and managerial skills. |
Need skills of coding and new
programming language |
|
Software analyst does more problem research
and plan solutions. |
Works on building new software,
adding new features to already existing software. |
Concept of system design
The concept of system design refers to the process of creating a plan or blueprint for the architecture, components, and interfaces of a complex system. It involves analyzing requirements, considering various design options, and making decisions to ensure the system meets the desired functionality, performance, and quality criteria. It provides a structured approach to defining how different components and subsystems of a system will work together to achieve the intended goals.
Key aspects of system design include:
Requirements Analysis: Understanding and capturing the needs and objectives of the system's stakeholders, such as users, clients, and business owners. This involves gathering and analyzing functional and non-functional requirements, constraints, and dependencies.
Architecture Design: Defining the overall structure and organization of the system. This includes identifying major components, subsystems, and their interactions. The architecture design should address scalability, performance, security, and other relevant factors.
Component Design: Designing the individual components of the system. This involves breaking down the system into smaller modules or units and specifying their interfaces, responsibilities, and interactions. It may include designing algorithms, data structures, database schemas, user interfaces, and other relevant components.
Data Design: Designing the data model and storage mechanisms for the system. This includes defining the structure, relationships, and constraints of the data entities, as well as selecting appropriate database technologies or storage solutions.
Interface Design: Designing the interfaces between different components, subsystems, or external systems. This includes specifying communication protocols, data formats, and APIs to enable seamless interaction and integration.
Security and Performance Design: Addressing security considerations by incorporating appropriate security measures, such as access controls, encryption, and data privacy. Considering performance requirements and designing the system to achieve optimal performance, including load balancing, caching, and optimization techniques.
Error Handling and Fault Tolerance: Designing mechanisms to handle errors, exceptions, and failures. This involves defining error-handling strategies, logging mechanisms, and incorporating fault tolerance measures, such as redundancy and failover capabilities.
Documentation and Communication: Documenting the system design, including architectural diagrams, component specifications, and design decisions. Effective communication with stakeholders, developers, and other team members is crucial to ensure a shared understanding of the design.
Software and quality
Software quality refers to the degree to which a software system meets specified requirements and satisfies the needs of its users. It encompasses various attributes and characteristics that determine the software's reliability, functionality, usability, performance, maintainability, and security.
Functional Suitability: Software should fulfill the specified functional requirements accurately and completely. It should perPerformance Efficiency:form the intended tasks and operations as expected, without errors or unexpected behavior.
Reliability: Software reliability refers to its ability to perform consistently and predictably over time. Reliable software should be stable, robust, and free from failures or crashes. It should also recover gracefully from errors and handle exceptions appropriately.
Usability: Usability focuses on how easy and intuitive the software is to use for its intended users. A user-friendly interface, clear navigation, and logical workflows contribute to good usability. Software should provide a positive user experience, minimize learning curves, and support user productivity.
Software should exhibit good performance in terms of speed, responsiveness, and resource utilization. It should execute tasks efficiently, process data in a timely manner, and not consume excessive system resources, such as memory or processing power.
Maintainability: Maintainable software is easy to understand, modify, and enhance. It should have well-structured and modular code, clear documentation, and adhere to coding standards. Maintainability allows for easier bug fixing, updates, and future development, reducing costs and efforts associated with software maintenance.
Portability: Software portability refers to its ability to run on different hardware platforms, operating systems, or environments without requiring significant modifications. Portable software enables wider deployment options and increases its usefulness across various platforms.
Security: Software security involves protecting the system and data from unauthorized access, vulnerabilities, and attacks. It includes implementing appropriate authentication mechanisms, access controls, encryption, and secure coding practices to ensure data confidentiality, integrity, and availability.
Testability: Testability is the degree to which software can be effectively tested to verify its functionality and uncover defects. Software should be designed in a way that facilitates testability, with modular and independent components, clear interfaces, and the ability to isolate and simulate different scenarios.
Compliance: Compliance refers to adherence to relevant laws, regulations, standards, and industry best practices. Depending on the software's domain, it may need to comply with specific regulations such as data privacy laws or industry-specific standards like HIPAA or ISO.
Software development model
Waterfall model
The waterfall model is a sequential software development process model that follows a linear and structured approach. It consists of distinct phases, with each phase dependent on the completion of the previous one.
System Design: In this phase, the system design is created based on the requirements gathered. The design includes architectural decisions, component specifications, data models, interfaces, and other relevant design documentation. It sets the foundation for the subsequent development phase.
Coding and Implementation: The implementation phase involves coding or developing the software based on the design specifications. Developers write code, integrate components, and implement the functionality outlined in the design phase. The output of this phase is a working software system.
Testing: Once the software is developed, it undergoes testing to identify and fix defects or errors. This phase includes various testing activities such as unit testing, integration testing, system testing, and user acceptance testing. The goal is to ensure that the software functions as expected and meets the specified requirements.
Deployment of system: After successful testing and bug fixing, the software is deployed or released to the production environment. It involves activities like installation, configuration, and data migration. User training and documentation may also be part of this phase.
Maintenance: The final phase of the waterfall model is maintenance, where the software is actively supported and updated to address bugs, enhancements, or changes requested by the users. Maintenance can include bug fixing, performance optimizations, security updates, and other necessary modifications.
Prototype model
The prototype model is an iterative software development model that focuses on creating a working prototype of the software early in the development process. It involves building a simplified version of the final product to gather feedback, validate requirements, and refine the design. The prototype model consists of the following key steps:
Requirements Gathering: Initially, the requirements of the software are collected through discussions with stakeholders, end-users, and other relevant parties. These requirements are used as a basis for creating the prototype.
Prototype Design (Quick Design): In this phase, a basic design and structure for the prototype are developed. The emphasis is on creating a representation of the core functionality or features that address the primary user needs.
Build a Prototype: The prototype is built using rapid development techniques. The focus is on creating a functional prototype that demonstrates key aspects of the software's intended functionality. The development process may involve using low-fidelity or high-fidelity prototypes depending on the level of detail required.
Prototype Evaluation: The developed prototype is shared with stakeholders, including end-users and clients, to gather feedback and evaluate its usability, functionality, and design. The evaluation can involve user testing, surveys, interviews, or any other suitable methods to gather feedback.
Refinement and Iteration: Based on the feedback received during the evaluation phase, the prototype is refined and improved. Changes are made to address any shortcomings or enhancements suggested by the stakeholders. This iterative process of refinement and iteration continues until the prototype meets the desired requirements and user expectations.
Prototype Evolution: Once the prototype is refined and validated, it serves as the foundation for the development of the final software product. The insights gained from the prototype help in creating detailed specifications, architecture, and design for the actual software development.
Spiral model
The spiral model is a software development model that combines elements of both the waterfall model and iterative development. It provides a structured approach to software development while incorporating flexibility and risk management. The spiral model is particularly useful for large and complex projects where uncertainties and risks are present. It follows a series of iterative cycles known as spirals, with each spiral representing a phase in the development process. The key components of the spiral model include:
Phases: The spiral model consists of four main phases, which are repeated in each iteration:
Planning: In this phase, project objectives, requirements, and constraints are defined. Risks are identified and prioritized, and a plan is formulated to address them.
Risk Analysis: The identified risks are assessed, and strategies are developed to mitigate them. This involves analyzing alternatives, considering risk impact, and developing risk management plans.
Engineering and Development: In this phase, the software is designed, developed, and tested. Iterative prototyping, if required, can be employed to gather user feedback, and refine the design.
Evaluation: The software is evaluated based on the defined objectives and requirements. This includes user testing, feedback collection, and assessing the overall performance and quality of the software.
Advantages Of Spiral Model
1. It is good for big and complex projects
2. It can be added at the mid-level of projects.
3. It has strong controls on documentation.
4. In this phase, it has more chances to produce software in the early software life cycle.
Disadvantages Of Spiral Model
1. This model can be costly to use.
2. It should require high expertise in risk analysis.
3. The dependency on risk analysis is high due to the project’s success.
4. It is not suitable for small projects.
Uses
1. This model is useful when costs and risk evaluation required.
2. When there is a medium to the high-risk project at that time we can use this model.
3. When customers are not clear about their requirements.
4. When rapidly changes expected
5. Requirements are complex.
Agile development model
In the Agile model, the requirements are decomposed into many small parts that can be incrementally developed. The Agile model adopts Iterative development. Each incremental part is developed over an iteration. Each iteration is intended to be small and easily manageable and can be completed within a couple of weeks only. At a time one iteration is planned, developed, and deployed to the customers. Long-term plans are not made.
The agile model is a combination of iterative and incremental process models. The steps involve in agile SDLC models are:
- Requirement gathering
- Design the Requirements
- Construction / Iteration
- Testing / Quality Assurance
- Deployment
- Feedback
- Requirement Gathering:- In this step, development team must gather the requirements, by interaction with the customer. development team should plan the time and effort needed to build the project. Based on this information you can evaluate technical and economical feasibility.
- Design the Requirements:- In this step, development team will use user-flow-diagram or high level UML diagrams to show the working of the new features and show how it will apply to the existing software. Wireframing and designing user interfaces are done in this phase.
- Construction / Iteration:- In this step, development team members start working on their project, which aims to deploy a working product.
- Testing / Quality Assurance:- Testing involves unit testing, Integration testing, system testing. Brief introduction of these three testing are as follows:
- Unit Testing:- Unit testing is the process of checking small pieces of code to ensure that the individual parts of a program work properly on their own. Unit testing is used to test individual blocks (units) of code.
- Integration Testing:- Integration testing is used to identify and resolve any issues that may arise when different units of the software are combined.
- System Testing:- Goal is to ensure that the software meets the requirements of the users and that if works correctly in all possible scenarios.
5. Deployment:- In this step, development team will deploy the working project to end users.
6. Feedback:- This is the last step of Agile Model. In this, team receives feedback about the product and works on correcting bugs based on feedback provided by the customer.
Why documentation is essential in developing a system? Explain its types in brief.
Documentation is an essential part of developing a system as it helps to ensure that stakeholders have a clear understanding of the system's requirements, design, and implementation. It provides a record of the project's progress and helps to communicate important information to stakeholders, such as developers, testers, and end-users. Documentation can also be used to identify problems or potential issues in the system, and to provide a basis for future improvements or modifications. Here are some of the most common types of documentation in system development:
a) User documentation: This type of documentation is intended for end-users of the system. It provides instructions on how to use the system, including step-by-step guides, user manuals, and help files.
b) Technical documentation: This type of documentation provides technical information about the system, including specifications, design documents, and API documentation. It is intended for developers, engineers, and other technical professionals.
c) Requirements documentation: This type of documentation captures the functional and nonfunctional requirements of the system. It includes details such as user stories, use cases, and acceptance criteria to ensure that the system meets stakeholder needs.
d) Design documentation: This type of documentation describes the architecture and design of the system. It includes diagrams, flowcharts, and other technical details that provide a clear understanding of how the system works.
e) Test documentation: This type of documentation outlines the testing strategy and approach for the system. It includes details such as test cases, test scenarios, and expected results to ensure that the system meets the requirements and is free from defects.
f) Maintenance documentation: This type of documentation provides information on how to maintain the system, including details such as how to troubleshoot common issues, perform upgrades, and manage backups.