1.

the nature of Software,

Software is often spoken of as being invisible or intangible, and hence is thought of as being
different from physical artefacts, which can be measured, touched, broken, and so on. This
invisibility can lead to nrealistic expectations concerning the capabilities of software, which in
turn may contribute to some of the myths that surround software and its development,
[Link]. Software is easy to change (programmers are often tempted to tweak their
code). This malleability creates a constant pressure for software to be changed rather than
replaced. Every change introduces the possibility of new errors.2. Complexity. Software is
often complex. Complexity can usually be recognised, but it is less easy to define. One item of
software can be considered more complex than another if it requires more explanation
[Link]. It is likely that there will be more errors in a large piece of software than in a small one.
You have already encountered an aspect of the intangible nature of software if you have
programmed in, for example, Java..
[Link] engineering-A layered technology,
Software engineering is a fully layered technology, to develop software we need to go from
one layer to another. All the layers are connected and each layer demands the fulfillment of
the previous layer. Layered technology is divided into four parts:
1. A quality focus: It defines the continuous process improvement principles of software. It
provides integrity that means providing security to the software no outsider can access the
data 2. Process: It is the foundation or base layer of software engineering. It is key that
binds all the layers together enables the development of software before the deadline or on
time Process activities are listed below:- Communication: It is the first and foremost
thing for the development of software. Planning: It basically means drawing a map for
reduced the complication of development. Modeling: In this process, a model is created
according to the client for better nderstanding. Construction: It includes the coding and
testing of the problem. Deployment:- It includes the delivery of software to the client for
evaluation and feedback. 3. Method: During the process of software development the
answers to all “how-to-do” questions are given by method. 4. Tools: Software engineering
tools provide a self-operating system for processes and methods. Tools are integrated whic
information created by one tool can be used by another.
[Link] principles of software engineering practice,
In software engineering, foundational principles guide the development process to create
robust, maintainable, and efficient software systems. While various frameworks and
methodologies outline different sets of principles, one widely recognized set consists of
four core principles:
1. Modularity - Definition: Modularity refers to designing a software system as a collection
of distinct, interchangeable components or modules, each responsible for a specific
functionality. 2. Abstraction - Definition: Abstraction involves simplifying complex systems
by modeling classes appropriate to the problem, and working at the most relevant level of
inheritance for a particular aspect of the problem3. Encapsulation - Definition:
Encapsulation is the bundling of data with the methods that operate on that data, restricting
direct access to some of the object's components. 4. Separation of Concerns -Definition:
Separation of Concerns (SoC) is the principle of organizing a system into distinct sections,
each addressing a separate concern or aspect of the system's functionality
.
[Link] myths,
Software Myths: Most, experienced experts have seen myths or superstitions (false beliefs
or interpretations) or misleading attitudes (naked users) which creates major problems for
management and technical people. The types of software-related myths are listed below.
`Types of Software Myths
(i) Management Myths: : We have all the standards and procedures available for software
development. Fact: Software experts do not know all the requirements for the software
development. And all existing processes are incomplete as new software development is
based on new and different problem. (ii)Customer Myths: The customer can be the direct
users of the software, the technical team, marketing / sales department, or other company.
Customer has myths leading to false expectations (customer) & that’s why you create
dissatisfaction with the developer. (iii)Practitioner’s Myths: They believe that their work
has been completed with the writing of the plan. Fact: It is true that every 60-80% effort
goes into the maintenance phase (as of the latter software release
[Link] development:
Agile Software Development is a software development methodology that values flexibility,
collaboration, and customer satisfaction. It is based on the Agile Manifesto, a set of
principles for software development that prioritize individuals and interactions, working
software, customer collaboration, and responding to change.
[Link] Tangible Value: Agile places a high priority on creating tangible value as soon
as possible in a [Link] on Value-Added Work: Agile methodology promotes
teams to concentrate on producing functional and value-added product increments [Link]
as a Mindset: Agile represents a shift in culture that values adaptability, collaboration, and
client happiness. It gives team members more authority and promotes a cooperative and
upbeat work atmosphere. [Link] Response to Change: Agile fosters a culture that allows
teams to respond swiftly to constantly shifting priorities and requirements. [Link]
Demonstrations: Agile techniques place a strong emphasis on regular demonstrations of
project progress

[Link] is an Agile Process,

Requirements Gathering:- The customer’s requirements for the software are gathered and
prioritized. Planning:- The development team creates a plan for delivering the software,
including the features that will be delivered in each iteration. Development: -The develop
ment team works to build the software, using frequent and rapid iterations. Testing: -The
software is thoroughly tested to ensure that it meets the customer’s requirements and is of
high quality. Deployment: -The software is deployed and put into use. Maintenance: -The
software is maintained to ensure that it continues to meet the customer’s Agile software
development cycle Step 1: In the first step, concept, and business opportunities in each
possible project are identified and the amount of time and work needed to complete the
project is estimated. Step 2: In the second phase, known as inception, the customer is
consulted regarding the initial requirements, team members are selected, and funding is
secured Step 3: Teams begin building functional software in the third step,
iteration/construction, based on requirements and ongoing feedback

[Link] Maturity Model Integration (CMMI).

Capability Maturity Model Integration (CMMI) is a successor of CMM and is a more evolved
model that incorporates best components of individual disciplines of CMM like Software
CMM, Systems Engineering CMM, People CMM, etc
Objectives of CMMI [Link] customer needs and expectations. 2. Value creation for
investors/stockholders. [Link] growth is increased. 4. Improved quality of products and
services. Enhanced reputation in Industry. CMMI Representation – Staged and
Continuous A representation allows an organization to pursue a different set of
improvement objectives. There are two representations for CMMI Staged Representation
: uses a pre-defined set of process areas to define improvement path. provides a sequence
of improvements, where each part in the sequence serves as a foundation for the next
Continuous Representation : allows selection of specific process areas. uses capability
levels that measures improvement of an individual process area.
8.A Generic process model (framework),
Generic Process Model is a definitive description of processes. Generic Processes are
designed to run outside a normal component or on an application processor. These processes
are not specific to any particular component, can be used in any number of applications.
Generic Process Model consists of 5 activities which will be discussed in this article Generic
Process model includes the below five framework activities, Communication: This is
the first step in the software development process which starts with the communication
between the customer and the developer. Planning: This step consists of a complete
estimation of the project, scheduling for development of the project, and tracking.
Modeling: This step consists of complete requirement analysis and project design like
algorithm, flowchart, etc. The algorithm is a step-by-step process of the problem and the
flowchart will show the flow of the program. Construction: This step consists of code
generation and its testing. Coding will implement the design details using appropriate
programming languages. Deployment: This step consists of delivering the final product to the
customer and take feedback.
[Link] Process Maturity Assessment:
The scope of Software Process Assessment includes many components like it should cover
all the processes in the organisation, a selected subset of the software process or a specific
project. The idea of process maturity serves as the foundation for the majority of standard-
based process evaluation methodologies. Though an organisation is the assessment
objective, even when the same approach is applied again, the outcomes of a process
evaluation may vary. The different results are mainly due to two reasons. The reasons are
that the organization that is being investigated must be determined. Generally there are six
different steps in the complete cycle: Selecting a team: The first step is to select all the team
members. Everyone must be software professionals with sound knowledge in software
engineering. SCAMPI; SCAMPI stands for Standard CMMI Assessment Method for
Process Improvement. To fulfil the demands of the CMMI paradigm, the Standard CMMI
Assessment Method for Process Improvement (SCAMPI) was created (Software
Engineering Institute, 2000). Moreover, it is based on the CBA IPI. The CBA IPI and
SCAMPI both have three steps. Plan and become ready Carry out the evaluation on-site
Report findings

[Link] process models: The waterfall model,

The Waterfall Model was the first Process Model to be introduced. It is also referred to as
a linear-sequential life cycle model. It is very simple to understand and use. In a waterfall
model, each phase must be completed before the next phase can begin and there is no
overlapping in the phases Waterfall Model – Design Waterfall approach was first SDLC
Model to be used widely in Software Engineering to ensure success of the project.
Requirement Gathering and analysis − All possible requirements of the system to be
developed are captured in this phase and documented in a requirement specification
document. System Design − The requirement specifications from first phase are studied in
this phase and the system design is prepared.. Implementation − With inputs from the
system design, the system is first developed in small programs called units, which are
integrated in the next phase. Integration and Testing − All the units developed in the
implementation phase are integrated into a system after testing of each unit. Deployment of
system − Once the functional and non-functional testing is done; the product is deployed in
the customer environment or released into the market. Maintenance − There are some
issues which come up in the client environment. To fix those issues, patches are released.

[Link] process models,

First, a simple working system implementing only a few basic features is built and then that
is delivered to the customer. Then thereafter many successive iterations/ versions are
implemented and delivered to the customer until the desired system is released. A, B, and
C are modules of Software Products that are incrementally developed and delivered.
Phases of incremental model Requirements of Software are first broken down into several
modules that can be incrementally constructed and delivered. Requirement analysis: In
Requirement Analysis At any time, the plan is made just for the next increment and not for
any kind of long-term plan. Design & Development: At any time, the plan is made just for
the next increment and not for any kind of long-term plan. Deployment and Testing: After
Requirements gathering and specification, requirements are then split into several different
versions starting with version 1. Implementation: In implementation After the last version
(version n), it is now deployed at the client site.
12. Evolutionary process models,
The Evolutionary development model divides the development cycle into smaller,
incremental waterfall models in which users can get access to the product at the end of each
cycle. Feedback is provided by the users on the product for the planning stage of the next
cycle and the development team responds, often by changing the product, plan, or process.
All the models have the disadvantage that the duration of time from the start of the project to
the delivery time of a solution is very high. Application of Evolutionary Model It is used
in large projects where you can easily find modules for incremental mplementation.
Evolutionary model is commonly used when the customer wants to start using the core
features instead of waiting for the full software. Necessary Conditions for Implementing this
Model Customer needs are clear and been explained in deep to the developer team. There
might be small changes required in separate parts but not a major change. As it requires
time, so there must be some time left for the market constraints.
13. The Unified process,
The Unified Process (UP) is a software development framework used for object-oriented
modeling. The framework is also known as Rational Unified Process (RUP) and the Open
Unified Process (Open UP). Some of the key features of this process include: It defines the
order of phases. It is component-based, meaning a software system is built as a set of
software components. The case-driven approach Use a case-driven approach that follows
a set of actions performed by one or more entities. A use case refers to the process of the
team performing the development work from the functional requirements. The phases of the
unified process Inception The main goal of this phase involves delimiting the project scope.
This is where we define why we are making this product in the first place Construction This
phase is where the development, integration, and testing take place. We build the complete
architecture in this phase and hand the final documentation to the client. Transition This
phase involves the deployment, multiple iterations, beta releases, and improvements of the
software. The users will test the software
14. Understanding the Requirement,
A systematic and strict approach to the definition, creation, and verification of requirements
for a software system is known as requirements engineering. To guarantee the effective
creation of a software product, the requirements engineering process entails several tasks
that help in understanding, recording, and managing the demands of stakeholders.
1. Feasibility Study The feasibility study mainly concentrates on below five mentioned
areas below. Among these Economic Feasibility Study is the most important part of the
feasibility analysis and the Legal Feasibility Study is less considered feasibility analysis.
2. Requirements Elicitation It is related to the various ways used to gain knowledge about
the project domain and requirements. The various sources of domain knowledge include
customers, business manuals, the existing software of the same type, standards, 3.
Requirements Specification This activity is used to produce formal software requirement
models. All the requirements including the functional as well as the non-functional
requirements and the constraints are specified by these models in totality
4. Requirements Verification and Validation ---
Verification: It refers to the set of tasks that ensures that the software correctly implements
a specific function. Validation: It refers to a different set of tasks that ensures that the
software that has been built is traceable to customer requirements
5. Requirements Management Requirement management is the process of analyzing,
documenting, tracking, prioritizing, and agreeing on the requirement and controlling the
communication with relevant stakeholders.
15. Requirement Modeling, Requirements for a computer-based system can be
seen in many different ways. Some software people argue that it’s worth using a number of
different modes of representation while others believe that it’s best to select one mode of
representation. The specific elements of the requirements model are dedicated to the
analysis modeling method that is to be used. Scenario-based elements : Using a
scenario-based approach, system is described from user’s point of view. Class-based
elements : A collection of things that have similar attributes and common behaviors i.e.,
objects are categorized into classes. Behavioral elements : Effect of behavior of computer-
based system can be seen on design that is chosen and implementation approach that is
applied. Modeling elements that depict behavior must be provided by requirements model.

16 Requirement Specification (SRS),

Software Requirement Specification (SRS) Format as the name suggests, is a complete
specification and description of requirements of the software that need to be fulfilled for the
successful development of the software system. These requirements can be functional as
well as non-functional depending upon the type of requirement. The interaction between
different customers and contractors is done because it is necessary to fully understand the
needs of customers.. Purpose of this Document – At first, main aim of why this document
is necessary and what’s purpose of document is explained and described. Scope of this
document – In this, overall working and main objective of document and what value it will
provide to customer is described and explained. It also includes a description of evelopment
cost and time required. Overview – In this, description of product is explained. It’s simply
summary or overall review of product. General description - In this, general functions of
product which includes objective of user, a user characteristic, features, benefits, about why
its importance is mentioned. It also describes features of user community.

17. Requirement Analysis Software requirement means requirement that is needed

by software to increase quality of software product. These requirements are generally a type
of expectation of user from software product that is important and need to be fulfilled by
software..Problem Recognition : The main aim of requirement analysis is to fully
understand main objective of requirement that includes why it is needed, does it add value
to product, will it be beneficial, does it increase quality of the project, does it will have any
other effect.. Evaluation and Synthesis : Evaluation means judgement about something
whether it is worth or not and synthesis means to create or form something. Here are some
tasks are given that is important in the evaluation and synthesis of software requirement
: Modeling : After complete gathering of information from above tasks, functional and
behavioral models are established after checking function and behavior of system using a
domain model that also known as the conceptual model. Specification : The software
requirement specification (SRS) which means to specify the requirement whether it is
functional or non-functional should be developed. Review : After developing the SRS, it
must be reviewed to check whether it can be improved or not and must be refined to make it
better and increase
18 Requirement Elicitation,
The process of investigating and learning about a system’s requirements from users, clients,
and other stakeholders is known as requirements elicitation. Requirements elicitation
in software engineering is perhaps the most difficult, most error-prone, and most
communication-intensive software development. Importance of Requirements Elicitation -----
--Compliance with Business Objectives: The process of elicitation guarantees that the
software development endeavors are in harmony with the wider company aims and
objectives. User Satisfaction: It is easier to create software that fulfills end users’ needs
and expectations when they are involved in the requirements elicitation process. Time and
Money Savings: Having precise and well-defined specifications aids in preventing
miscommunication and rework during the development phase. Compliance and Regulation
Requirements: Requirements elicitation is crucial for projects in regulated industries to
guarantee that the software conforms with applicable laws and norms.

[Link] Engineering.
A systematic and strict approach to the definition, creation, and verification of requirements
for a software system is known as requirements engineering. To guarantee the effective
creation of a software product, the requirements engineering process entails several tasks
that help in understanding, recording, and managing the demands of stakeholders.
Requirements Engineering Process 1. Feasibility Study The feasibility study mainly
concentrates on below five mentioned areas below. Among these Economic Feasibility
Study is the most important part of the feasibility analysis and the Legal Feasibility Study is
less considered feasibility analysis 2. Requirements Elicitation It is related to the various
ways used to gain knowledge about the project domain and requirements. The various
sources of domain knowledge include customers, business manuals, the existing software of
the same type, standards, and other stakeholders of the project. 3. Requirements
Specification - This activity is used to produce formal software requirement models. All the
requirements including the functional as well as the non-functional requirements and the
constraints are specified by these models in totality

21. Design Concepts

Concepts are defined as a principal idea or invention that comes into our mind or in thought
to understand something. The software design concept simply means the idea or principle
behind the design. It describes how you plan to solve the problem of designing software,
and the logic, or thinking behind how you will design software [Link] (Hide
Irrelevant data): Abstraction simply means to hide the details to reduce complexity and
increase efficiency or quality. Different levels of Abstraction are necessary and must be
applied at each stage of the design process so that any error that is present can be removed
to increase the efficiency of the software 2. Modularity (subdivide the system): Modularity
simply means dividing the system or project into smaller parts to reduce the complexity of
the system or project. [Link] (design a structure of something): Architecture
simply means a technique to design a structure of something. Architecture in designing
software is a concept that focuses on various elements and the data of the structure
[Link] (removes impurities): Refinement simply means to refine something to
remove any impurities if present and increase the quality.
22. Web Application Design
will delve into the fundamental principles of web application design, highlighting key elements
such as user-centricity, intuitive navigation, and aesthetically pleasing interfaces. By
understanding these principles, you will gain valuable insights into how to create a web
application that delights your customers and enhances their [Link], we will
guide you through the step-by-step process of designing a web application. From defining
your objectives and target audience to wireframing, prototyping, and user testing, we’ll provide
a comprehensive roadmap to ensure a successful web application development What is UI
in Web Application Design? It is the part with which users interact when using a web
application. The primary purpose of the designers is to create a user-friendly & attractive
interface. For the same, they look after the fonts, buttons, colors, navigation, etc. What is UX
in Web Application Design? User experience is how a user feels when interacting with the
web application.

[Link] Principal,
Software Design is also a process to plan or convert the software requirements into a step
that are needed to be carried out to develop a software system. There are several principles
that are used to organize and arrange the structural components of Software design.
Software Designs in which these principles are applied affect the content and the working
process of the software from the beginning.
Principles Of Software Design :
Should not suffer from “Tunnel Vision” – While designing the process, it should not
suffer from “tunnel vision” which means that is should not only focus on completing or
achieving the aim but on other effects also. Traceable to analysis model – The design
process should be traceable to the analysis model which means it should satisfy all the
requirements that software requires to develop a high-quality product. Should not
“Reinvent The Wheel” – The design process should not reinvent the wheel that means it
should not waste time or effort in creating things that already exist. Due to this, the overall
development will get increased. Minimize Intellectual distance – The design process
should reduce the gap between real-world problems and software solutions for that problem
meaning it should simply minimize intellectual distance. Exhibit uniformity and
integration – The design should display uniformity which means it should be uniform
throughout the process without any change. Integration means it should mix or combine all
parts of software i.e.
[Link] Level Design,
Component level design is the definition and design of components and modules after the
architectural design phase. Component-level design defines the data structures, algorithms,
interface characteristics, and communication mechanisms allocated to each component for
the system development. A complete set of software components is defined during
architectural design. Component Views • OO View – A component is a set of collaborating
classes. • Conventional View – A component is a functional element of a program that
incorporates processing logic CLASS ELABORATION Class elaboration focuses on
providing a detailed description of attributes, interfaces and methods before the development
of the system activities. The following example provides a elaboration design class for
“PrintJob
DESIGN PRINCIPLES The design principles for component level design comprises of the
following: 1Open-Closed Principle The following module depicts a sensor module which
performs the operations – read (), enable(), disable(), test(). This module can be extended for
sensing smoke, motion, heat, CO2 etc. 2Substitutability The subclasses derived from the
base class should extend the functionalities of the base class without replacing the
functionalities of the derived class. 3Dependency Inversion It depends abstractions and not
on concretions. Abstraction should not depend on details, as details should depend on
abstraction. Interface Segregation Many client-specific interfaces are better than one general
purpose interface. For consistency purpose, interfaces should flow from the left-hand side of
the component box

25. Function Oriented Design,

Function Oriented design is a method to software design where the model is decomposed into
a set of interacting units or modules where each unit or module has a clearly defined function.
Thus, the system is designed from a functional viewpoint.
[Link] Notations Design Notations are primarily meant to be used during the process of
design and are used to represent design or design decisions. For a function-oriented design,
the design can be represented graphically or mathematically by the following:
[Link] Flow Diagram Data-flow design is concerned with designing a series of functional
transformations that convert system inputs into the required outputs. The design is described
as data-flow diagrams. These diagrams show how data flows through a system and how the
output is derived from the input through a series of functional transformations.
[Link] Dictionaries A data dictionary lists all data elements appearing in the DFD model of
a system. The data items listed contain all data flows and the contents of all data stores
looking on the DFDs in the DFD model of a system. grossPay = regularPay + overtimePay
[Link] Charts It partitions a system into block boxes. A Black box system that
functionality is known to the user without the knowledge of internal design.
[Link]-code Pseudo-code notations can be used in both the preliminary and detailed
design phases. Using pseudo-code, the designer describes system characteristics using
short, concise, English Language phases that are structured by keywords such as If-Then-
Else, While-Do, and End.
26. Software Testing ,
Software testing is the process of checking if software satisfies its expectations. To test a
software, testers execute it under controlled conditions, across a wide range of scenarios,
environments, and user interactions to see if there are any defects arise during the process.
Benefits of Software [Link] Detect bugs: the primary goal of software testing is to identify
bugs before they impact users. Since modern apps rely on interconnected components, a
single issue can trigger a chain reaction. Early detection minimizes the impact. [Link]
and improve software quality: testing ensures the software is stable, secure, and user-
friendly. It also identifies areas for improvement and optimization. [Link] trust and
satisfaction: consistent testing creates a stable and dependable product that delivers positive
user experience, which translates into user trust and satisfaction. [Link] Vulnerabilities to
[Link] Risks: in high-stakes industries like finance, healthcare, and law, testing prevents
costly errors that could harm users or expose companies to legal risks. It acts as a safety net,
ensuring critical systems remain secure and functional.
Types of Software Testing
[Link]-functional testing checks if the software's non-functional aspects (e.g., stability,
security, and usability) satisfy expectations. [Link] testing checks an individual unit in
isolation from the rest of the application. A unit is the smallest testable part of any software.
[Link] testing checks the interaction between several individual units. These units
usually have already passed unit testing. [Link]-to-end testing checks the entire end-to-end
workflow in the software [Link] testing checks the entire system, including its functional
and non-functional aspects

[Link] Testing fundamentals,

Software testing is the evaluation of a system with the intention of finding an error or fault or a
bug. It also checks for the functionalities of the system so that it meets the specified
requirements. Objective • To execute a program with the intent of finding an error. • To check
if the system meets the requirements and be executed successfully in the intended • To
check if the system is “Fit for purpose”. • To check if the system does what it is expected to
do. Good Testing Practices Some of the good testing practices include: As the number of
detected defects in a piece of software increases, the probability of the existence of more
undetected defects also increases. AUTOMATION TOOLS The number of times a developer
has written code and then sat in front of the keyboard running through test cases has
happened quite often. Automation tools helps to run test cases efficiently to save resources
and the time consumed Scripting Imagine you have a bunch of executable that tests various
parts of your program. Imagine you’ve written a shell script to run them, one at a time. How do
you know when one fails? You can check the exit code of a program running from a shell
script: if [$? –ne 0]; then … else … if.
[Link] case design ,
To begin a software project, engineers should plan and document tests within the project’s
scope. This is part of a test case design. More specifically, a test case design is a document
that includes the test’s scope, the test strategy, the test environment, the software pieces for
testing, the intended test actions within the project, the resources, and a schedule. Thus,
developing test case designs aims to define the test strategy within the project; plan resource
allocation; and clarify responsibilities, risks, and priorities. Test data generators—This
software produces the test input data necessary to execute test cases. Debugger—This
software enables errors encountered during the tests to be found on the source code.
Emulators and simulators—These software types imitate the real hardware that the
software needs; they provide the hardware data necessary for the tests. Stubs and drivers—
These small pieces of software replace nonfunctional system components required for
[Link] Test Case Design After a software project’s requirements are approved, the
test case design phase begins. While system analysts, system engineers, and software
engineers prepare the system requirements and software requirements,

29 Control structure testing, The structural testing is done to verify the internal designs,
and implementations of the software. It is mostly carried out by the developers themselves. It
validates the various parameters of the software based on its types. Its functionalities are just the
opposite of behavioral testing. Types of Software Structural Testing 1. Control Flow Testing It is a
kind of structural testing of the code. The testers performing this type of testing should be aware of
the internal code, design, logic, algorithm, architecture etc 2. Data Flow Testing It is another kind of
structural testing of the code. It uses the control flow graph to identify the paths where the variables
are defined, and later used. It is performed with the objective to identify problems such as incorrect
definitions, unused variables etc 3. Slice Based Testing This type of testing was introduced by Weiser,
and Gallagher for the better maintenance of the software. It helps to debug, maintain, and
understand the code4. Mutation Testing It is also referred to as code mutation testing. It is an
important concept under the structural testing technique.

30. Unit testing,

Unit testing involves the testing of each unit or an individual component of the software
application. It is the first level of functional testing. The aim behind unit testing is to validate
unit components with its performance . A unit is a single testable part of a software system
and tested during the development phase of the application software. The purpose of unit
testing is to test the correctness of isolated code. A unit component is an individual
function or code of the application. White box testing approach used for unit testing and
usually done by the developers. Whenever the application is ready and given to the Test
engineer, he/she will start checking every component of the module or module of the
application independently or one by one, and this process is known as Unit
testing or components testing. Why Unit Testing? In a testing level hierarchy, unit
testing is the first level of testing done before integration and other remaining levels of the
testing

[Link] Testing,
 System Testing is a type of software testing that is performed on a completely
integrated system to evaluate the compliance of the system with the corresponding
requirements. In system testing, integration testing passed components are taken as
input. The goal of integration testing is to detect any irregularity between the units that
are integrated. System testing detects defects within both the integrated units and the
whole system. The result of system testing is the observed behavior of a component or a
system when it is tested. System Testing System Testing Process
System Testing is performed in the following steps:
Test Environment Setup: Create testing environment for the better quality testing.
Create Test Case: Generate test case for the testing process.
Create Test Data: Generate the data that is to be tested.
Execute Test Case: After the generation of the test case and the test data, test cases
Defect Reporting: Defects in the system are detected.
Regression Testing: It is carried out to test the side effects of the testing process.
Log Defects: Defects are fixed in this step.
Retest: If the test is not successful then again test is performed.
32 black box testing,
Black box testing is a technique of software testing which examines the functionality of software
without peering into its internal structure or coding. The primary source of black box testing is a
specification of requirements that is stated by the customer. In this method, tester selects a
function and gives input value to examine its functionality, and checks whether the function is
giving expected output or not. If the function produces correct output, then it is passed in testing,
otherwise failed.. Generic steps of black box testing
The black box test is based on the specification of requirements, so it is examined in the beginning.
In the second step, the tester creates a positive test scenario and an adverse test scenario by selecting
valid and invalid input values to check that the software is processing them correctly or incorrectly.
In the third step, the tester develops various test cases such as decision table, all pairs test, equivalent
division, error estimation, cause-effect graph, etc. The fourth phase includes the execution of all test cases.
In the fifth step, the tester compares the expected output against the actual output.
In the sixth and final step, if there is any flaw in the software, then it is cured and tested again.

[Link] for specialized Environments,

As we know for the development of a software application/product the development
team follows a set of steps that are performed in different phases of the Software
Development Life Cycle (SDLC). In SDLC Software testing is one of the important
phases as it ensures the quality of the product. So, for that different types of software
testing are performed to check different parameters or test cases. During the testing
phase depending upon the type of testing different members are involved like the
developer, the tester, and sometimes the customer/client also. But the basic thing to
perform testing is a test environment
 What is a Test Environment? The test environment is the hardware and software set
up for the testing teams to run test cases. This test environment setup varies from
product to product and its configuration completely depends on the application under
test requirement. The easiest way to organize a test environment is through
automation. The test environment is used by the testing teams to test the software,
identify the bugs, and find a possible fix for the bugs.
A test environment is used to check the quality of the software and the impact of the
application before release. It enables the tester to check the different parts of the
application using different configurations and data setups. Test Bed is very similar to
Test Environment with a small difference. The test bed is also a type of test
environment that consists of test data to verify the functionalities of the software
applications.
[Link] box testing,
The box testing approach of software testing consists of black box testing and white box
testing. We are discussing here white box testing which also known as glass box
is testing, structural testing, clear box testing, open box testing and transparent box
testing. It tests internal coding and infrastructure of a software focus on checking of
predefined inputs against expected and desired outputs. It is based on inner workings of
an application and revolves around internal structure testing. In this type of testing
programming skills are required to design test cases. The primary goal of white box testing
is to focus on the flow of inputs and outputs through the software and strengthening the
security of the software.

Developers do white box testing. In this, the developer will test every line of the code of the
program. The developers perform the White-box testing and then send the application or
the software to the testing team, where they will perform the black box testing and verify
the application along with the requirements and identify the bugs and sends it to the
developer.

The developer fixes the bugs and does one round of white box testing and sends it to the
testing team. Here, fixing the bugs implies that the bug is deleted, and the particular
feature is working fine on the application.