Softawre Engieering Assigmnet
Softawre Engieering Assigmnet
Softawre Engieering Assigmnet
“Software Crisis” is a term used in the field of Computer Science. In addition, the term
“Software Engineering” suggested at the conferences organized by NATO in 1968 and
1969 to discuss the “Software Crisis”.
During the period of 1960’s and 1970’s, due to the rapid increment in Software
demand, Complexity of software and Software challenges. There were many
difficulties of writing useful and efficient Software’s within the required time. Due to that,
so many difficulties regarding the development of large software systems arisen.
Many project failures resulted from the inability to apply the techniques used to develop
small Software Systems to the development of larger and more complex systems. This
failure leads to : Frequent cost overruns, Late or Never delivered projects, Incomplete
system functionality, Lower quality inefficient Software with errors, Software often did
not meet requirements, Projects were unmanageable and Codes difficult to maintain.
The negative consequences of failures in software range from simple user
inconvenience to huge economic losses like incorrectly recorded transactions.
Ultimately, software errors pose dangers to human lives and cause mission failures.
Correction of errors were expensive and often results in skyrocketing software
costs. Hardware costs got low while the software costs were skyrocketed
rapidly. New techniques and methods needed to control the complexity in large
software systems.
Therefore , “Software Crisis” was the name given to the difficulties encountered in
developing large, complex systems in the 1960s. The Conference organized by
NATO proposed that the adoption of an engineering approach to software development
would reduce the costs of software development and lead to software that is more
reliable.
3
If you are managing the development of new software, and you want to know
how to organize everything effectively and evaluate the quality of the product
before release, software quality metrics are vital tools that can help you
understand and improve many different aspects of a project.
Metrics themselves do not improve development, but managers use them to get
a better picture of the production process. Presenting all elements of the process
with data, metrics describe what is happening throughout the project. Without
this information, managers struggle to discover issues and make improvements.
However, with the valuable information software quality metrics provide, you can
more effectively:
Predict defects
Discover and resolve bugs
Efficiently organize development
Increase productivity
In this article, I will go over a variety of common metrics and provide examples of
how you can use them to interpret, quantify, and, most importantly, improve the
quality of software and the productivity of a team.
Testing is the process of identifying defects, where a defect is any variance between actual and
expected results. “A mistake in coding is called Error, error found by tester is called Defect,
defect accepted by development team then it is called Bug, build does not meet the
requirements then it Is Failure.”
The Fault is a state that causes the software to fail to accomplish its essential function. If
the software has lots of defects, it leads to failure or causes failure. Raised by. The Test
Engineers submit the bug. The Testers identify the defect.
5
Requirement Gathering:
If the feasibility report is positive towards undertaking the project, next phase starts with gathering
requirements from the user. Analysts and engineers communicate with the client and end-users to know
their ideas on what the software should provide and which features they want the software to include.
SRS is a document created by system analyst after the requirements are collected from various
stakeholders.
SRS defines how the intended software will interact with hardware, external interfaces, speed of
operation, response time of system, portability of software across various platforms, maintainability,
speed of recovery after crashing, Security, Quality, Limitations etc.
The requirements received from client are written in natural language. It is the responsibility of system
analyst to document the requirements in technical language so that they can be comprehended and
useful by the software development team.
• Technical requirements are expressed in structured language, which is used inside the
organization.
• After requirement specifications are developed, the requirements mentioned in this document
are validated. User might ask for illegal, impractical solution or experts may interpret the
requirements incorrectly. This results in huge increase in cost if not nipped in the bud.
Requirements can be checked against following conditions -
Requirements Elicitation is the process to find out the requirements for an intended software system by
communicating with client, end users, system users and others who have a stake in the software system
development.
Interviews:
Interviews are strong medium to collect requirements. Organization may conduct several types of
interviews such as:
• Structured (closed) interviews, where every single information to gather is decided in advance,
they follow pattern and matter of discussion firmly.
• Non-structured (open) interviews, where information to gather is not decided in advance, more
flexible and less biased.
• Oral interviews
• Written interviews
• One-to-one interviews which are held between two persons across the table.
• Group interviews which are held between groups of participants. They help to uncover any
missing requirement as numerous people are involved.
• Surveys
• Organization may conduct surveys among various stakeholders by querying about their
expectation and requirements from the upcoming system.
• Questionnaires
• A document with pre-defined set of objective questions and respective options is handed over
to all stakeholders to answer, which are collected and compiled.
• A shortcoming of this technique is, if an option for some issue is not mentioned in the
questionnaire, the issue might be left unattended.
• Task analysis
• Team of engineers and developers may analyze the operation for which the new system is
required. If the client already has some software to perform certain operation, it is studied and
requirements of proposed system are collected.
• Domain Analysis
• Every software falls into some domain category. The expert people in the domain can be a great
help to analyze general and specific requirements.
• Brainstorming
• An informal debate is held among various stakeholders and all their inputs are recorded for
further requirements analysis.
• Prototyping
• Prototyping is building user interface without adding detail functionality for user to interpret the
features of intended software product. It helps giving better idea of requirements. If there is no
software installed at client’s end for developer’s reference and the client is not aware of its own
requirements, the developer creates a prototype based on initially mentioned requirements.
The prototype is shown to the client and the feedback is noted. The client feedback serves as an
input for requirement gathering.
• Observation
• Team of experts visit the client’s organization or workplace. They observe the actual working of
the existing installed systems. They observe the workflow at client’s end and how execution
problems are dealt. The team itself draws some conclusions which aid to form requirements
expected from the software.
Gathering software requirements is the foundation of the entire software development project. Hence
they must be clear, correct and well-defined.
• Clear
• Correct
• Consistent
• Coherent
• Comprehensible
• Modifiable
• Verifiable
• Prioritized
• Unambiguous
• Traceable
• Credible source