Module-1 Introduction To Software Development
Module-1 Introduction To Software Development
Software itself is the set of instructions or programs that tell a computer what to
do. It is independent of hardware and makes computers programmable. There
are three basic types:
Software developers have a less formal role than engineers and can be closely
involved with specific project areas — including writing code. At the same
time, they drive the overall software development lifecycle — including
working across functional teams to transform requirements into features,
managing development teams and processes, and conducting software testing
and maintenance.3
The work of software development isn’t confined to coders or development teams. Professionals
such as scientists, device fabricators and hardware makers also create software code even though
they are not primarily software developers. Nor is it confined to traditional information technology
industries such as software or semiconductor businesses. In fact, according to the Brookings Institute
(link resides outside of ibm.com), those businesses “account for less than half of the companies
performing software development.”
The steps of the software development process fit into application lifecycle
management (ALM). The IBM Engineering Management solution is a superset
of ALM that enables the management of parallel mechanical, electrical and
software development.
A few examples:
• Soul Machines (link resides outside of ibm.com) uses software to create
artificial online advisors that improve customer service and efficiency.
The advisors have human faces, expressions and voices that react
intelligently, empathetically and efficiently to customer questions and
needs. They can answer over 40 percent of customer inquiries without
human intervention — and they learn from their interactions to improve
over time. Using IBM Watson Assistant to incorporate artificial
intelligence (AI) capabilities into the development process, Soul
Machines can create and roll out an artificial advisor in about 8 to 12
weeks.
• “This is a race,” says Erik Bak-Mikkelsen. “We have to keep up with
what’s happening in the market.” Bak-Mikkelsen is head of cloud
operations at car2go (link resides outside of ibm.com). He understands
that delivering new features and functions to car2go’s ride-sharing apps
and vehicles is key to getting and staying ahead. To do so, car2go moved
its development operations to a managed-services cloud and adopted a
DevOps development model. The result is accelerated development
cycles, faster time to market and the capability to scale for future growth.
• Working with electrical power lines can be deadly. To stay safe engineers
set electrical “lockouts” using physical tags and padlocks to divert power
from work locations. French energy company Enedis (link resides outside
of ibm.com) worked with IBM Garage for Cloud to develop software
that instruments these locks and tags and ties them into a shared network.
Tags and locks detect each time they are removed from an engineer’s van
and communicate the time and geo-location. As the engineer attaches the
locks, their location is recorded on a digital map. All stakeholders share a
view of the map to ensure safety, reduce downtime and facilitate repairs.
The IBM Cloud Garage collaborative development approach enabled
Enedis to develop field-ready prototypes in three months.
Key features of effective software development
A quick glossary
• Agile development breaks requirements into consumable functions and
delivers rapidly on those functions through incremental development. A
feedback loop helps find and fix defects as functionality continues to
deploy.
• Capability Maturity Model (CMM) assesses the proficiency of
software development processes. It tracks progress from ad hoc actions to
defined steps to measured results and optimized processes.
• DevOps, a combination of development and operations, is an agile-based
approach that brings software development and IT operations together in
the design, development, deployment and support of software.
Why SDLC?
Some of the reasons why SDLC is important in Software Development are as
follows.
What are the 7 Phases of SDLC (Software Development Life Cycle Phases)
Seven Phases of Software Development Life Cycle (SDLC Phases) are as
following:
Requirement Phase
Requirement gathering and analysis is the most important phase in the software
development lifecycle. Requirement phase is the first step of the SDLC.
Business Analyst collects the requirement from the Customer/Client as per the
clients business needs and documents the requirements in the Business
Requirement Specification (document name varies depends upon the
Organization. Some examples are Customer Requirement Specification (CRS),
Business Specification (BS), etc., and provides the same to Development Team.
Analysis Phase
Once the requirement gathering and analysis is done the next step is to define
and document the product requirements and get them approved by the customer.
This is done through the SRS (Software Requirement Specification) document.
SRS consists of all the product requirements to be designed and developed
during the project life cycle. Key people involved in this phase are Project
Manager, Business Analyst and Senior members of the Team. The outcome of
this phase is the Software Requirement Specification.
Design Phase
It has two steps:
HLD – High-Level Design – It gives the architecture of the software product to
be developed and is done by architects and senior developers
LLD – Low-Level Design – It is done by senior developers. It describes how
each and every feature in the product should work and how every component
should work. Here, only the design will be there and not the code
The outcome from this phase is High-Level Document and Low-Level
Document which works as an input to the next phase
Development Phase
Developers of all levels (seniors, juniors, freshers) involved in this phase. This
is the phase where we start building the software and start writing the code for
the product. The outcome from this phase is Source Code Document (SCD) and
the developed product.
Testing Phase
When the software is ready, it is sent to the testing department where Test team
tests it thoroughly for different defects. They either test the software manually
or using automated testing tools depends on the process defined in STLC
(Software Testing Life Cycle) and ensure that each and every component of the
software works fine. Once the QA makes sure that the software is error-free, it
goes to the next stage, which is Implementation. The outcome of this phase is
the Quality Product and the Testing Artifacts.
Waterfall
The V-model is another linear model with each stage having a corresponding
testing activity. Such workflow organization implies exceptional quality control,
but at the same time, it makes the V-model one of the most expensive and time-
consuming models. Moreover, even though mistakes in requirements
specifications, code and architecture errors can be detected early, changes
during development are still expensive and difficult to implement. As in the
Waterfall case, all requirements are gathered at the start and cannot be changed.
Use cases:
The development process based on the Incremental model is split into several
iterations (“Lego-style” modular software design is required!). New software
modules are added in each iteration with no or little change in earlier added
modules. The development process can go either sequentially or in parallel.
Parallel development adds to the speed of delivery, while many repeated cycles
of sequential development can make the project long and costly.
With Iterative development software changes on each iteration, evolves and
grows. As each iteration builds on the previous one, software design remains
consistent.
As software is delivered in parts, there is no need for a full specification from
the project’s start and small changes to requirements are possible in the course
of the development process. However, the requirements can’t change radically –
major ones must be defined in the beginning, especially those for system design
in case of Incremental development as further integration of the delivered
software parts can become an issue.
This SDLC model typically entails some customer involvement because of the
possible need in small requirements amendments during the development
process.
Use cases:
Spiral model
The Spiral model puts focus on thorough risk assessment. Thus, to reap the
benefits of the model to the fullest, you’ll need to engage people with a strong
background in risk evaluation. A typical Spiral iteration lasts around 6 months
and starts with 4 important activities - thorough planning, risk analysis,
prototypes creation, and evaluation of the previously delivered part. Repeated
spiral cycles seriously extend project timeframes.
This is the model where intensive customer involvement appears. They can be
involved in the exploration and review stages of each cycle. At the development
stage, the customer’s amendments are not acceptable.
Use cases:
The Rational Unified Process (RUP) is also a combination of linear and iterative
frameworks. The model divides the software development process into 4 phases
– inception, elaboration, construction, and transition. Each phase but Inception
is usually done in several iterations. All basic activities (requirements, design,
etc.) of the development process are done in parallel across these 4 RUP phases,
though with different intensity.
RUP helps to build stable and, at the same time, flexible solutions, but still, this
model is not as quick and adaptable as the pure Agile group (Scrum, Kanban,
XP, etc.). The degree of customer involvement, documentation intensity, and
iteration length may vary depending on the project needs.
Use cases:
Scrum
Scrum is probably the most popular Agile model. The iterations (‘sprints’) are
usually 2-4 weeks long, and they are preceded with thorough planning and
previous sprint assessment. No changes are allowed after the sprint activities
have been defined.
Extreme Programming (XP)
With Extreme Programming (XP), a typical iteration lasts 1-2 weeks. The
model allows changes to be introduced even after the iteration’s launch if the
team hasn’t started to work with the relevant software piece yet. Such flexibility
significantly complicates the delivery of quality software. To mitigate the
problem, XP requires the use of pair programming, test-driven development and
test automation, continuous integration (CI), small releases, simple software
design and prescribes to follow the coding standards.
Kanban