ise_questionsanswers
ise_questionsanswers
ise_questionsanswers
Unit-1
1) Define Software Engineering. Tell why there is a need for Software Engineering.
Definition:
Software engineering is the application of a systematic, disciplined and quantifiable approach to the
development, operation and maintenance of software.
Need of Software Engineering:
To help developers to obtain high quality software product.
To develop the product in appropriate manner using life cycle models.
To acquire skills to develop large programs.
To acquire skills to be a better programmer.
To provide a software product in a timely manner.
To provide a quality software product.
To provide a software product at a agreed cost.
To develop ability to solve complex programming problems.
Software is the “collection of computer programs, procedures, rules, associated documents and
concerned data with the operation of data processing system”.
tools
methods
process model
a “quality” focus
A Quality Focus Layer
Software engineering mainly focuses on quality product.
It checks whether the output meets with its requirement specification or not.
Every organization should maintain its total quality management.
Process Layer
It is the heart of software engineering.
It is also work as foundation layer.
Software process is a set of activities together if ordered and performed properly, then the
desired result would be produced.
It defines framework activities.
The main objective of this layer is to deliver software in time.
Method Layer
It describes ‘how-to’ build software product.
It creates software engineering environment to software product using CASE tools
Tools Layer
It provides support to below layers.
Due to this layer, process is executed in proper manner.
4) Explain Umbrella Activities.
started here.
Reusability Management
This includes the backing up of each part of the software project they can be corrected or any
kind of support can be given to them later to update or upgrade the software at user/time
demand.
Software configuration management:
It manages the impact of changes throughout the software development process.
Documentation
All the project planning and other activities should be hard copied and the production gets
started here.
Reusability Management
This includes the backing up of each part of the software project they can be corrected or any
kind of support can be given to them later to update or upgrade the software at user/time
demand.
Measurement(estimation)
This will include all the measurement of every aspects of the software project, like time
estimation, cost estimation.
Risk Management
Prepared By: Department of Computer Engineering Page 4
Subject Name: Introduction to Software Engineering Subject Code: 4340702
Risk management is a series of steps that help a software team to understand and manage
uncertainty.
It identifies problems and deal with it.
5) Explain Waterfall Model with diagram.
Feasibility Study:
Aim of this phase is to determine whether the system would be financially and technically
feasible to develop the product.
General maintenance is needed due to change in the environment or the requirement of the
system.
Waterfall Model – Advantages
It is simple and easy to understand and use.
Each phase has well defined input and output.
Waterfall model works well for smaller projects where requirements are very well understood.
In divides complex tasks into smaller, more manageable works.
Waterfall Model – Disadvantages
It is a theoretical model, as it is very difficult to strictly follow all the phases in all types of
projects.
It may happen that the error may be generated at any phase and encountered in later phase. So,
it is not possible to go back and solve the error in this model.
High amount of risk.
It is a document driven process that requires formal documents at the end of each phase.
Waterfall Model – When to use?
Requirements are very well known and fixed.
Product definition is stable.
Technology is understood.
When the project is short.
6) Explain the incremental process model for software development.
The incremental model is also referred as the successive version of waterfall model using
incremental approach.
In this model, the system is broken down into several modules which can be incrementally
implemented and delivered.
First develop the core product of the system.
The core product is used by customers to evaluate the system.
The initial product skeleton is refined into increasing levels of capability: by adding new
functionality in successive version.
Low reliability
Inefficient performance
Prototype model is very useful in developing GUI part of system.
In working of the prototype model, product development starts with initial requirements gathering
phase.
Then, quick design is carried out and prototype is built.
The developed prototype is then submitted to the customer for his evaluation.
Based on customer feedback, the requirements are refined and prototype is modified.
This cycle of obtaining customer feedback and modifying the prototype continues till the
customers approve the prototype.
The actual system is developed using different phases of iterative waterfall model.
Prototype Model – Advantages
A partial product is built at initial stage, so customers can get a chance to have a look of the
product.
New requirements can be accommodate easily.
Quicker user feedback is available for better solution.
As the partial product is evaluated by the end users, more chance of user satisfaction.
Prototype Model – Disadvantages
The code for prototype model is usually thrown way. So wasting of time is there.
The construction cost of developing the prototype is very high.
If the end user is not satisfied with the initial prototype, then he/she may lose interest in the
final product.
Prototype Model – When to Use?
This model is used when the desired system needs to have a lot of interactions with end users.
This type of model generally used in GUI type of development.
8) Explain Spiral models with diagram.
This model is proposed by Boehm in 1986.
In application development, spiral model uses fourth generation (4GL) languages and
development tools.
In pictorial view, this model appears like a spiral with many loops.
Each loop of the spiral represents a phase of the software process.
The innermost loop might be concerned with system feasibility
The next loop with system requirement definition.
The next one with system design and so on.
Each loop in the spiral split into four sectors. (quadrants)
Advantages:
Project scope and requirements are Project scope and requirements are more
less flexible. flexible.
Better for Large projects Better for Small and medium projects
Unit-2
1) List characteristics of good software.
Complete
Consistent
Structured
Black-Box View
Verifiable
Adaptable
Maintainable
Portable
Unambiguous
Traceable
Requirement gathering is the first activity performed during the software development.
The goal of requirement gathering activity is to collect all relevant information from the customer
regarding the product to be developed.
In this phase, meeting with customers, analyzing market demand and features of the product are
mainly focused.
Requirement gathering activities are
Studying the existing documents
Interview with end users
Task analysis
Scenario analysis
Brainstorming
Questionnaires
System Analysis produces the requirements System Design produces the design
Output
document that describes the desired system. document that describes the
Security
Scalability
Usability
Performance
Inter operability
Availability
i. Coincidental(Low)
ii. Logical
iii. Temporal
iv. Procedural
v. Communicational
vi. Sequential
vii. Functional(High)
I. Coincidental cohesion
It is lowest cohesion.
It occurs when there is no meaningful relationship between the elements.
A module is said to have coincidental cohesion if it perform a set of task that relate
each other very loosely.
II. Logical Cohesion
A module is said to be logically cohesive if there is some logical relationship between
the element of module and element perform functions that fall into same logical class.
Coupling between two modules is a measure of the degree of interaction between two modules.
Coupling refers to the no of connections between „calling‟ and a „called‟ module.
Classification of coupling
I. Data Coupling
Two modules are data coupled, if they communicate using an elementary data item that
is passed as a parameter between the two.
Ex: an int, a char etc
It is a lowest coupling and best for software development.
V. Content Coupling
Content coupling exists between two modules, if they share code.
Ex:- a branch from one module into another module.
It is a highest coupling and creates more problems in S/W development.
7) Explain the Data Flow Diagram with its primitive symbols and example.
Process (Function)
External Entity
i. Entity is represented by rectangle.
ii. Entities are external to the system which interacts by inputting data to the
system or by consuming data produced by the system.
iii. It can also define source or destination of the system.
Data Flow
i. Data flow is represented by an arc or by an arrow.
ii. It is used to describe the movement of the data.
iii. It represents the data flow occurring between two processes or between an
external entity and a process.
iv. It passes data from one part of the system to another part.
v. Data flow arrows usually annotated with the corresponding data names.
Data Store
i. Data store is represented by two parallel lines.
ii. Generally it is a logical file or database.
iii. It can be either a data structure or a physical file on the disk.
Output
i. Output is used when a hardcopy is produced.
ii. It is graphically represented by a rectangle cut either a side.
Use Case
i. Each use case is represented by ellipse with the name of the use case written
inside the ellipse.
ii. All the use cases are enclosed with a rectangle representing system boundary.
iii. Rectangle contains the name of the system.
Actor
i. An actor is anything outside the system that interacts with it.
ii. Actors in the use case diagram are represented by using the stick person icon.
iii. An actor may be a person, machine or any external system.
iv. In use case diagrams, actors are connected to use cases by drawing a simple line
connected to it.
v. Actor triggers use case.
vi. Each actor must be linked to a use case, while some use cases may not be linked
to actors.
Relationship
i. Actors are connected to the use cases through relationship.
ii. An actor may have relationship with more than one use case and one use case
may relate to more than one actor.
iii. Types of relationship
1. Association
2. Include Relationship
3. Extend Relationship.
Association
i. This relationship is the interface between an actor and a use case.
ii. It is represented by joining a line from actor to use case.
Include Relationship
i. It involves one use case including the behavior of another use case.
ii. The “include” relationship occurs when a chunk of behavior that is similar
across a number of use cases.
Extend Relationship
i. It allows you to show optional behavior of the system.
ii. This relationship among use cases is represented as a stereotype <<extend>>.
iii. Extend relationship exists when one use case calls another use case under
certain condition.
Unit-3
1) List out responsibilities of Project manager and skills required in project manager.
Software project managers take the overall responsibility of project to success.
The job responsibility of a project manager ranges from invisible activities like building up team
morale to highly visible customer presentations.
Most managers take responsibility for project proposal writing, project cost estimation,
scheduling, project staffing, deciding software process, project monitoring and control, software
configuration management, risk management, interfacing with clients, and presentations.
These activities can be classified into project planning, and project monitoring and control
activities.
Skills necessary for software project manager
A theoretical knowledge of different project management techniques is certainly necessary to
become a successful project manager.
In addition to having a good understand of the latest software project management techniques
such as cost estimation, risk management, configuration management, project managers need
good communication skills.
However, some skills such as tracking and controlling the progress of the project, customer
interaction, managerial presentations, and team building are largely acquired through experience.
Development Environment: use of the automation (CASE) tools used for software development.
Complete COCOMO model
A major shortcoming of both the basic and intermediate COCOMO models is that they consider
a software product as a single entity.
However, most large systems are made up several smaller sub-systems. These subsystems may
have widely different characteristics.
For example, some subsystems may be considered as organic type, some semidetached, and some
embedded. Not only that the development complexity of the subsystems may be different, but also
for some subsystems the reliability requirements may be high, for some the development team
might have no previous experience of similar development, and so on.
The complete COCOMO model considers these differences in characteristics of the subsystems
and estimates the effort and development time as the sum of the estimates for the individual
subsystems.
LOC metric is very popular because it is the simplest to use. Using this metric, the project size is
estimated by counting the number of source instructions in the developed program.
Lines used for commenting the code and the header lines should be ignored.
Determining the LOC count at the end of a project is a very simple job.
To estimate the LOC count at the beginning of a project, project managers usually divide the
problem into modules and each module into sub modules and so on, until the sizes of the different
leaf-level modules can be approximately predicted.
Disadvantages of Lines of Code (LOC) metric
A good problem size measure should consider the overall complexity of the problem and the effort
needed to solve it. That is, it should consider the effort needed to specify, design, code, test, etc.
and not just the coding effort.
LOC focuses on the coding activity alone; it only computes the number of source lines in final
program.
6) Draw Gantt chart and flow chart for Online shopping system.
Gantt chart
Flowchart
Unit - 4
1) Define code review. List code review techniques. Explain them in detail.
Code review for a model is carried out after all the syntax errors have been eliminated.
This is the cost-effective strategies for reduction in coding errors and to produce high quality code.
Two types code review techniques are code inspection and code walkthrough.
Code Inspection:
The aim of code inspection is to discover common types of errors caused due to improper
programming.
During code inspection the code is examined for the presence of certain kinds of errors.
Error will be discovered by looking for these kinds of mistakes in the code.
Coding standards is also checked during code inspection
Good software development companies collect different types of errors commonly committed
by their engineers and identify the type of errors most frequently committed.
List of commonly committed errors can be used during code inspection to look out for possible
errors.
Following is a list of some errors which can be checked during code inspection:
Use of uninitialized variables
No terminating loops
Incompatible assignments
Array indices out of bounds
Improper storage allocation and deallocation
Mismatches between actual and formal parameter in procedure calls
Use of incorrect logical operators or incorrect precedence among operators
Code walkthrough:
Code walk through is a code analysis technique.
In this technique carried out after a module has been coded, successfully compiled and all
syntax errors eliminated.
A few members of the development team are given the code few days before the walkthrough
meeting to read and understand code.
Prepared By: Department of Computer Engineering Page 30
Subject Name: Introduction to Software Engineering Subject Code: 4340702
Each member selects some test cases and simulates execution of the code by hand (i.e. trace
execution through each statement and function execution).
The main objectives of the walk through are to find the algorithmic and logical errors in the
code.
The members note down their findings to discuss these in a walk through meeting where the
coder of the module is present.
Some of the guidelines for this technique:
It should consist of between three to seven members.
Discussion should focus on find the errors and not on how to fix the errors.
Managers should not attend the walk through meetings
2) Describe white box testing.
In this method of testing the test cases are calculated based on analysis internal structure of the
system based on Code coverage, branches coverage, paths coverage, condition Coverage etc.
White box testing involves the testing by looking at the internal structure of the code & when you
completely aware of the internal structure of the code then you can run your test cases & check
whether the system meet requirements mentioned in the specification document.
Based on derived test cases the user exercised the test cases by giving the input to the system and
checking for expected outputs with actual output.
Statement coverage
The statement coverage strategy aims to design test cases so that every statement in a program
is executed at least once.
The principal idea governing the statement coverage strategy is that unless a statement is
executed, it is very hard to determine if an error exists in that statement.
Unless a statement is executed, it is very difficult to observe whether it causes failure due to
some illegal memory access, wrong result computation, etc.
For ex.
If(a>b)
printf(“a is greater”)
else
max=a;
else if (b>c)
max=b;
else
max=c;
}
Test cases for above example: {a=5,b=10,c=15}, {a=5,b=15,c=10}, {a=15, b=5, c=10}
Condition coverage
In this structural testing, test cases are designed to make each component of a composite
conditional expression to assume both true and false values.
For example, in the conditional expression ((c1.and.c2).or.c3), the components c1, c2 and c3
are each made to assume both true and false values.
Branch testing is probably the simplest condition testing strategy where only the compound
conditions appearing in the different branch statements are made to assume the true and false
values.
Thus, condition testing is a stronger testing strategy than branch testing and branch testing is
stronger testing strategy than the statement coverage-based testing.
For a composite conditional expression of n components, for condition coverage, 2ⁿ test cases
are required. Thus, for condition coverage, the number of test cases increases exponentially
with the number of component conditions.
Therefore, a condition coverage-based testing technique is practical only if n (the number of
conditions) is small.
Path coverage
The path coverage-based testing strategy requires us to design test cases such that all linearly
independent paths in the program are executed at least once.
A linearly independent path can be defined in terms of the control flow graph (CFG) of a
program.
Path testing is used for module or unit testing.
It requires complete knowledge of the program structure.
Unit testing
Unit testing is undertaken after a module has been coded and successfully reviewed.
Unit testing (or module testing) is the testing of different units (or modules) of a system in
separately.
When developer is coding the software it may happen that the dependent modules are not
completed for testing, in such cases developers use stubs and drivers to simulate the called
(stub) and caller (driver) units.
Unit testing requires stubs and drivers, stub represent the called unit and driver represent the
calling unit.
Integration Testing
Integration testing is the second level of the software testing process comes after unit testing.
In this testing, units or individual components of the software are tested in a group.
The focus of the integration testing level is to expose defects at the time of interaction between
integrated components or units.
4) Differentiate Unit testing and Integration testing.
In unit testing, each module of the software In integration testing, all modules of the
is tested separately. software are tested combined.
In unit testing tester knows the internal Integration testing doesn’t know the internal
design of the software. design of the software.
Unit testing is performed first of all testing Integration testing is performed after unit
processes. testing and before system testing.
Unit testing is white box testing. Integration testing is black box testing.
Unit testing is performed by the developer. Integration testing is performed by the tester.
Unit testing is responsible to observe only the Error detection takes place when modules are
functionality of the individual units. integrated to create an overall system.
The proper working of your code with the The proper working of your code with the
external dependencies is not ensured by unit external dependencies is ensured by
testing. integration testing.
Fast execution as compared to integration Its speed is slow because of the integration of
testing. modules.
Unit testing results in in-depth exposure Integration testing results in the integration
to the code. structure’s detailed visibility.
Alpha testing involves both the white box Beta testing commonly uses black-box
and black box testing. testing.
Alpha testing is performed by testers who are
Beta testing is performed by clients who are
usually internal employees of the
not part of the organization.
organization.
Alpha testing is performed at the developer’s Beta testing is performed at the end-user of
site. the product.
Reliability and security testing are not Reliability, security and robustness are
checked in alpha testing. checked during beta testing.
Beta testing also concentrates on the quality
Alpha testing ensures the quality of the of the product but collects users input on the
product before forwarding to beta testing. product and ensures that the product is ready
for real time users.
Alpha testing requires a testing environment Beta testing doesn’t require a testing
or a lab. environment or lab.
Alpha testing may require a long execution Beta testing requires only a few weeks of
cycle. execution.
User Registration:
Test case 1: Verify that a new user can successfully register with valid credentials.
Test case 2: Verify that registration fails if the user provides invalid or incomplete information.
Test case 3: Verify that registration fails if the user tries to register with an existing email
address.
User Login:
Test case 4: Verify that a registered user can log in with correct credentials.
Test case 5: Verify that login fails with incorrect credentials.
Test case 6: Verify that login fails if the user provides invalid input.
Browsing Products:
Test case 7: Verify that the user can browse products without logging in.
Test case 8: Verify that the user can search for products using the search functionality.
Test case 9: Verify that the user can filter products based on different criteria (e.g., price,
category).
Test case 10: Verify that the user can view detailed information about a product.
Adding Items to Cart:
Test case 11: Verify that the user can add items to the cart.
Test case 12: Verify that the user cannot add more items to the cart than the available stock.
Test case 13: Verify that the user can update the quantity of items in the cart.
Checkout Process:
Test case 14: Verify that the user can proceed to checkout from the cart.
Test case 15: Verify that the user can select a shipping address during checkout.
Test case 16: Verify that the user can select a payment method during checkout.
Test case 17: Verify that the user can place an order successfully.
Order Management:
Test case 18: Verify that the user can view their order history.
Test case 19: Verify that the user can track the status of an order.
Test case 20: Verify that the user can cancel an order before it is shipped.
Account Management:
Test case 21: Verify that the user can update their account information (e.g., name, address).
Test case 22: Verify that the user can change their password.
Test case 23: Verify that the user can delete their account.
Security:
Test case 24: Verify that sensitive information (e.g., passwords, payment details) is encrypted
and securely stored.
Test case 25: Verify that the system prevents unauthorized access to user accounts.
Performance:
Test case 26: Verify that the system can handle a large number of simultaneous users.
Test case 27: Verify that the response time for critical actions (e.g., adding items to cart,
checkout) is acceptable under normal load conditions.
Compatibility:
Test case 28: Verify that the website is compatible with different web browsers (e.g., Chrome,
Firefox, Safari).
Test case 29: Verify that the website is responsive and works well on different devices (e.g.,
desktops, tablets, smartphones).
==== XXX====