SET-1

Que.-1:- What is SDLC? Explain different phases of SDLC.

Ans.:- The Software Development Life Cycle (SDLC) is a methodical process that is employed
to efficiently and effectively develop, deploy, and maintain software applications. It offers a
structured framework that enables teams to produce high-quality software while adhering to
schedule and cost constraints. The SDLC is composed of a number of phases, each of which
serves a distinct purpose in the development process. The primary phases are as follows:
1. Planning: This is the initial phase of the project, during which the project's objectives are
established, feasibility studies are conducted, and resource allocation is determined. The
planning phase is responsible for determining the project's scope and establishing
achievable objectives that are consistent with the business's requirements.
2. Analysis of Requirements: This phase involves the collection and documentation of
detailed requirements by stakeholders. These encompass technical, non-functional, and
functional requirements. Analysts and developers work together to comprehend the
software's objectives, guaranteeing their clarity and comprehensiveness.
3. Design: The software architecture is developed in accordance with the requirements
during the design phase. The system's overall structure is defined by high-level design
(HLD), whereas low-level design (LLD) concentrates on the specific modules and
components. The development team is guided by technical documentation and design
blueprints that are the outcome of this phase.
4. Development: The actual coding occurs during the development phase. The software is
constructed by developers utilizing the design specifications. This phase typically entails
the development, testing, and integration of code using programming languages and
tools. In order to guarantee consistency, development teams frequently implement
version control systems and adhere to coding standards.
5. Testing: The software is subjected to rigorous testing after it has been developed in order
to detect and rectify any flaws or defects. Testing encompasses user acceptance testing
(UAT), system testing, integration testing, and unit testing. This phase guarantees that the
software satisfies user requirements and adheres to quality standards.
6. Deployment: The software is deployed to the production environment following effective
testing. The deployment process can be conducted in phases, such as pilot releases, or as
a full-scale implementation. A seamless transition for end users is guaranteed by
appropriate deployment strategies and support.
7. Maintenance: The final phase entails the ongoing maintenance and updating of the
software to guarantee that it remains compatible with user needs and adjusts to evolving
technologies or requirements. Bug corrections, updates, and enhancements comprise
maintenance.
The SDLC is structured to ensure that software development is conducted in a controlled and
methodical manner, with each phase having its own deliverables and milestones. Teams are able
to deliver reliable software, enhance productivity, and mitigate risks by adhering to the SDLC
framework. SDLC can be executed through a variety of methodologies, including Waterfall,
Agile, or DevOps, each of which provides distinct advantages that are customized to the unique
requirements of the project.

Que.-2:- Explain the prototyping model in detail with the help of a diagram. State its
advantages and disadvantages

Ans.:- The Prototyping Model is a software development methodology that emphasizes the
creation of a functional software prototype at the outset of the development process. Developers
and stakeholders can gather feedback for enhancement by visualizing the final product using this
model. The prototype is refined until it satisfies the intended specifications through an iterative
process.

The Prototyping Model follows several stages, as illustrated in the provided diagram:
1. Requirement Gathering: This phase entails the acquisition of preliminary requirements
from the client. These requirements may not be exhaustive, as the primary objective is to
establish a foundation for the prototype's construction.
2. Rapid Design: The system's fundamental design is developed, with an emphasis on
functionality and user interfaces. Rather than a finished design, this is a framework that
will be used to construct the prototype.
3. Prototyping: A functional software prototype is created by employing the rapid design
process. The final product's main features are replicated in the prototype; however, it may
not possess the same level of robustness or functionality.
 4. Customer Evaluation: The prototype is presented to the client or end-users for
assessment. In order to ascertain whether the prototype fulfills their expectations and
requirements, feedback is solicited.
5. Prototype Improvement: The prototype is enhanced and refined in accordance with the
feedback. This iterative process persists until the prototype transforms into a system that
meets the stakeholders' needs.
6. Engineer Product: The actual system is engineered after the prototype is finalized,
ensuring that all features are implemented and the product is prepared for deployment.

The advantages of the Prototyping Model include:

● Enhanced Communication: The prototype enables clients and developers to early
visualize the system, thereby promoting a more comprehensive comprehension of the
requirements and improved communication.
● Lowered Risks: The identification of potential issues through early feedback reduces the
probability of significant changes in the later phases.
● Increased User Engagement: Clients are actively engaged, resulting in a product that
closely correlates with their expectations.
● Flexibility: This paradigm is designed to adapt to variations in requirements that may
arise during the development process.

Despite its benefits, the Prototyping Model has certain disadvantages:

● Time-Intensive: The iterative refinement process can be time-consuming, particularly
when clients request frequent changes.
● Expensive: The development costs may be elevated by the construction of numerous
prototypes and the integration of feedback.
● Insufficient Documentation: The emphasis on prototyping may result in inadequate
documentation, which can pose a challenge for future maintenance.
● Scope Creep: The uncontrolled expansion of scope may result from frequent changes and
evolving requirements.

Que.-3:- Write short note on following: -

a. Close -ended and Open-ended prototyping
b. Requirement Management

Ans.:- a) Close-ended and Open-ended Prototyping:

Closed-ended prototyping is characterized by the creation of a prototype that has a well-defined
and unambiguous scope, and which functions as a preliminary version of the final system. The
objective is to develop a functional model that embodies the software's primary capabilities and
facilitates comprehension of user needs. The prototype is discarded after it has been evaluated
and approved, and the actual development process commences with the finalized requirements.
This method is especially advantageous when the requirements are relatively well comprehended
but necessitate validation through a functional or visual representation. The primary benefit of
close-ended prototyping is that it offers a structured approach to final development, thereby
reducing the likelihood of deviation. Nevertheless, it may not be able to effectively adapt to
changing requirements.

On the other hand, open-ended prototyping is a flexible and iterative method in which the
prototype is perpetually modified in response to user feedback. Initially, an initial prototype is
developed, which is subsequently refined until it satisfies user expectations. This prototyping
method is most appropriate for projects that are anticipated to undergo changes in requirements
over time. Active collaboration with stakeholders is fostered by open-ended prototyping, which
enables dynamic modifications and enhancements. Although this method has the potential to
improve user satisfaction and adaptability, it can also result in increased costs and scope
expansion if not managed carefully.

Both forms of prototyping are selected based on the level of ambiguity in defining system
demands and the project requirements. They serve distinct purposes.

b) Requirement Management:
Requirement Management is a methodical process that involves the collection, analysis,
documentation, and maintenance of requirements throughout the software development lifecycle
(SDLC). It guarantees that the system's requirements are effectively implemented in the final
product and that all stakeholders have a comprehensive comprehension of them. The process
commences with requirement elicitation, which involves the collection of inputs from
stakeholders through methods such as interviews, surveys, and ideation. These requirements are
subsequently analyzed to determine feasibility, prioritize needs, and resolve ambiguities.

The subsequent phase entails the development of comprehensive documentation, including a

Software Requirements Specification (SRS), which serves as a reference for project managers,
testers, and developers. It is also necessary to trace requirements to ensure that they are
addressed at every stage of development and to confirm that the final product satisfies these
requirements during testing. This is known as requirement management.

Effective requirement management is essential for the success of a project, as it mitigates the
likelihood of misunderstandings, scope expansion, and rework. It allows teams to remain in
alignment with project objectives while adapting to changes. Tools such as Jira, IBM DOORS,
and Microsoft Azure DevOps are frequently employed to optimize requirement management by
monitoring, organizing, and updating requirements in real-time.

Ensuring that the product is delivered in accordance with the business objectives and
expectations, requirement management serves as a bridge between stakeholders and developers.
 SET-2

Que.-4:- Explain various code verification techniques and write short notes on coding tools.

Ans.:- Code verification is the process of verifying that the written code complies with the
specified requirements, standards, and anticipated behavior. Early detection and correction of
errors are essential components of software development, as they guarantee maintainability and
reliability. Code verification employs a variety of methodologies, including:
1. Code Reviews: This process entails the systematic review of the source code by senior
developers or colleagues. Code evaluations are instrumental in the identification of
logical errors, potential issues with maintainability, and adherence to coding standards.
GitHub, Bitbucket, and Gerrit are among the tools that facilitate collaborative code
evaluations.
2. Static Code Analysis: This method evaluates the source code without executing it.
SonarQube, PMD, and Coverity are automated tools that scan the code to identify
potential issues, including coding violations, vulnerabilities, and inefficient code patterns.
3. Dynamic Code Analysis: In contrast to static analysis, this method evaluates the code
during execution. It assists in the identification of security vulnerabilities, performance
obstacles, and memory leakage. Dynamic analysis is facilitated by tools like Valgrind and
Purify.
4. Unit Testing: This process entails the isolation of individual components or modules of
the code to verify their accuracy. Unit tests are automated and consistent testing practices
are guaranteed by frameworks such as PyTest (for Python) and JUnit (for Java).
5. Code Walkthroughs and Inspections: These manual methods engage a team of developers
and stakeholders in a line-by-line examination of the code to spot errors. Walkthroughs
are informal and exploratory, whereas inspections are more formal and structured.
6. Debugging: The process of debugging entails the identification and correction of errors in
the code through the execution of it under controlled conditions. Visual Studio and
Eclipse are examples of Integrated Development Environments (IDEs) that provide
diagnostic tools for the purpose of detecting errors in real time.

Coding Tools:-
Coding tools are software applications and utilities that aid developers in the authoring, testing,
troubleshooting, and management of code. They improve code quality, expedite workflows, and
increase productivity. Coding instruments that are frequently employed include:
1. IntelliJ IDEA, Visual Studio Code, and Eclipse are examples of Integrated Development
Environments (IDEs) that offer exhaustive features such as syntax highlighting, code
completion, debugging, and version control integration.
 2. Version Control Systems (VCS): Developers utilize tools such as Git, SVN, and
Mercurial to monitor changes, collaborate on code, and manage multiple versions of a
project.
3. Maven, Gradle, and Ant are build tools that automate the process of building,
distributing, and deploying software, thereby ensuring consistency across environments.
4. Static Analysis Tools: SonarQube and ESLint are examples of tools that evaluate code
for potential errors, security vulnerabilities, and compliance with coding standards.
5. Testing Frameworks: Selenium, JUnit, and Cypress are among the tools that assist in the
automation of testing processes, thereby guaranteeing the software's comprehensive
validation.

Que.-5:- Write short notes on the following: a) Black box testing b) White box testing c)
Validation testing.

Ans.:- a) Black Box Testing:-

Black box testing is a software testing method that involves the tester assessing the functionality
of an application without any knowledge of its internal code structure. The primary objective of
this approach is to confirm that the software functions as anticipated from the user's perspective.
The evaluator is focused on the overall system behavior, functionality, and input-output
behavior, rather than the implementation of the code. The design of test cases in black box
testing is determined by the software specifications and requirements. It is especially beneficial
in the context of system testing, integration testing, and functional testing. One of the primary
benefits is that it replicates the real-world user experience, thereby identifying issues related to
functionality, usability, and user interfaces. Nevertheless, black box testing may not reveal
specific types of internal code issues or vulnerabilities due to the fact that the tester is unaware of
the internal workings.

b) White Box Testing:-

White box testing, referred to as clear-box testing or structural testing, is a software testing
methodology that allows the tester to examine the internal mechanisms of the program. This
testing focuses on validating the functionality and accuracy of the code. Testers analyze the
system's core logic, code pathways, algorithms, and data flow inside the program. This technique
is often used for unit and integration testing, aiming to verify that each component of the system
functions as expected. Test cases in white box testing are generated based on an understanding of
the code architecture and may include assessments of code coverage, control flow, data flow, and
route coverage. It facilitates the identification of logical mistakes, security vulnerabilities, and
segments of the code that are not used in standard operations. Nonetheless, it requires expertise
in the programming language and system architecture and might be labor-intensive.

c) Validation Testing:-
Validation testing is the procedure of confirming that a software product fulfills the defined
criteria and addresses the demands of the end-users. It is performed subsequent to verification
testing, which assesses the software's adherence to technical standards and design. The main
objective of validation testing is to verify that the program functions as anticipated in a practical
setting. This kind of testing addresses the inquiry, “Are we developing the correct product?” and
verifies that the software aligns with company objectives and user anticipations. Validation
testing is often conducted via user acceptance testing (UAT) or beta testing, whereby actual users
evaluate the system. The objective is to identify any inconsistencies between the product's
intended use and its actual performance. Effective validation testing guarantees that the program
provides value to its stakeholders and operates as intended, making it an essential phase prior to
software deployment. Nonetheless, it may not consistently reveal technical problems like flaws
or system inefficiencies that may be detected during verification or other testing stages.

Que.-6:- What is software quality assurance? Explain the activities that are carried
throughout the project lifecycle.

Ans.:- Software Quality Assurance (SQA) is a systematic method designed to ensure software
quality throughout its development lifetime. It includes several tasks aimed at establishing
quality standards, preventing flaws, and facilitating continual improvement to guarantee the
software meets or beyond the requisite standards and customer expectations. The primary
objective of SQA is to enhance the development and maintenance processes, hence facilitating
the delivery of superior quality software. Software Quality Assurance (SQA) encompasses more
than just testing; it incorporates methodologies from several phases of the Software Development
Lifecycle (SDLC) to guarantee that the software product is resilient, dependable, and devoid of
flaws. It is a continuous process including planning, monitoring, assessment, and enhancement
from project inception to conclusion.

Activities Throughout the Project Lifecycle:-

1. The SQA process starts with meticulous planning and the establishment of quality
standards. At this juncture, SQA experts engage with stakeholders to establish quality
objectives, define key performance indicators (KPIs), and set expectations for software
quality. They guarantee that the software requirements are explicit, attainable, and
quantifiable. The objective is to develop a quality assurance roadmap that is congruent
with the overarching project objectives.
2. Design and Development: In the design and development phase, SQA guarantees
adherence to best practices, coding standards, and recommendations to mitigate faults.
This includes code reviews, design evaluations, and audits to verify the integrity of the
design and assure adherence to appropriate coding standards by the development team.
Automated technologies may be used to assess code quality and detect possible errors at
an early stage.
3. Testing and Validation: A fundamental aspect of Software Quality Assurance (SQA) is
software testing. Testing occurs at several levels, including unit testing, integration
 testing, system testing, and user acceptability testing. The objective is to ascertain if the
program operates as intended and fulfills the established criteria. Test planning, test case
formulation, execution, and defect monitoring are essential tasks in this context. Software
Quality Assurance guarantees that testing occurs at every phase, with flaws found and
rectified expeditiously.
4. Deployment and Maintenance: Following testing and validation, the program proceeds to
deployment. Software Quality Assurance (SQA) persists in overseeing the software after
deployment to verify its effective performance in the actual environment. In the
maintenance phase, the SQA team monitors issues, does regression testing, and verifies
that upgrades or additions do not adversely impact the current system functioning.
5. Continuous Improvement: Software Quality Assurance is an iterative method that
incorporates insights gained from each project phase. Following each release, SQA
personnel evaluate the procedures to identify potential areas for improvement. Feedback
loops are established via testing results, user input, and performance measurements,
resulting in enhanced procedures and more efficient methods for subsequent projects.