LESSON 3 SOFTWARE DEVELOPMENT LIFES CYCLE

APPLICATION
DEVLOPMENT
EMERGING
TECHNOLOGIES
ITCC
AND

Module 1:
Overview of Application
Development and Emerging
Technologies

Lesson 3:
The Software Development
Life Cycle (SDLC)

Requirement Management
What is Requirement Management?
Requirements exist within all organizations; all
organizations exist to delivery products and/or services to
customers, which are always delivered through business
processes that are decomposed into individual requirements.
Requirements are simply a capability needed by a stakeholder
(person) to deliver a product and/or service.
Software Development Life Cycle

A requirement is a very simply a stated desire or need: For
example, in a fictitious library system, a requirement could be
that "the library system allows people to check-in and check-
out books". Requirements management is the process of
capturing and managing all of the different ‘needs’ that
different stakeholders have in a system. Sometimes the needs
relate to the functionality (the system needs to do X), other
times it may be technical need (the system needs to run on
specific web browsers, database servers, etc.)

In addition, requirements management is the process of
collecting, analyzing, refining, and prioritizing product
requirements and then planning for their delivery. The
purpose of requirements management is to ensure that the
organization validates and meets the needs of its customers
and external and internal stakeholders.

Why Manage Requirements?
Studies have shown that requirements management
improves all major aspects of organizational strategy
(portfolio, programs, and projects) or operations management
(day-to-day business) by:
• Reducing cost
• Improving quality
• Decreasing time taken
• Decreasing risks

However here are some common features that should be part
of any requirements management tool:
• Ability to enter requirements, use cases and user stories in an easy-
to-use web interface
• Derive detailed technical tasks from the requirements for building
the project development schedule.
• Ability to associate acceptance tests to the requirements so that
features can be adequately tested before development is complete.

• Use visual tools such as planning boards, GANTT charts to help plan
the requirements development.
• Integrated version control and history tracking of requirements
• Support for real-time collaboration and feedback during
requirements validation
• Drill down from requirements to tests and incidents
• Personalized dashboards and customizable reporting
• Fully customizable workflows and support for custom fields.

Design and Prototyping
• User Interface (UI) Design
User Interface Design is the process designers use to build interfaces
in software or computerized devices, focusing on looks or style.
Designers aim to create interfaces which users find easy to use and
pleasurable. UI design refers to graphical user interfaces and other
forms — e.g., voice-controlled interfaces.

UI Design focuses on anticipating what users might need to do and
ensuring that the interface has elements that are easy to access,
understand, and use to facilitate those actions. UI brings together
concepts from interaction design, visual design, and information
architecture.
Choosing Interface Elements
Users have become familiar with interface elements acting in a
certain way, so try to be consistent and predictable in your choices and
their layout. Doing so will help with task completion, efficiency, and

Interface elements include but are not limited to:
• Input Controls: buttons, text fields, checkboxes, radio buttons,
dropdown list, list boxes, toggles, date field
• Navigational Components: breadcrumb, slider, search field,
pagination, tags, icons
• Informational Components: tooltips, icons, progress bar,
notifications, message boxes, modal windows
• Containers: accordion

Best Practices for Designing an Interface
Everything stems from knowing your users, including
understanding their goals, skills, preferences, and tendencies.
Once you know about your user, make sure to consider the following
when designing your interface:
• Keep the interface simple. The best interfaces are almost invisible
to the user. Avoid unnecessary elements and use clear language on
labels and in messaging

• Create consistency and use common UI elements. Use common
elements in your UI, users feel more comfortable and are able to get
things done more quickly. Create patterns in language, layout and
design throughout the site to help facilitate efficiency to be able to
transfer that skill to other parts of the site easily.
• Be purposeful in page layout. Consider the spatial relationships
between items on the page and structure the page based on
importance. Careful placement of items can help draw attention to
the most important pieces of information and can aid scanning and

• Strategically use color and texture. You can direct attention
toward or redirect attention away from items using color, light,
contrast, and texture to your advantage.
• Use typography to create hierarchy and clarity. Consider how
you use typeface. Different sizes, fonts, and arrangement of the text
to help increase scanability, legibility and readability.

• Make sure that the system communicates what’s happening.
Always inform your users of location, actions, changes in state, or
errors. The use of various UI elements to communicate status and, if
necessary, next steps can reduce frustration for your user.
• Think about the defaults. By carefully thinking about and
anticipating the goals people bring to your site, you can create
defaults that reduce the burden on the user. This becomes
particularly important when it comes to form design where you
might have an opportunity to have some fields pre-chosen or filled

A good UI Design presents a seamless blend of visual design,
interaction design, and information architecture:
• Visual Design
Visual design improves a site’s ornamental value by strategically
implementing elements such as fonts, colors, and images among
other things. When professionally done, visual design makes a page
elegant without compromising on its function or content.

• Interactive design
The interactive design looks at how users interact with technology. It
then uses the understanding of such interactions to create an
interface with behaviors that are well thought-out. Excellent interactive
design not only anticipates how a person interacts with a system but
also antedates and fixes problems in good time. It may also invent
new ways through which a system interacts and responds to users.

• Information Architecture
Information architecture is designed to help users find the info they
need to complete various tasks. It involves labelling, structuring, and
organizing the web content in a manner that makes it easily accessible
and sustainable. Also, UI is the very important part of the mobile app
design.

Multiple elements constitute a functional UI. These may include:
• Input controls such as buttons, toggles, and checkboxes among
many others.
• Navigation components e.g. breadcrumb, sliders, search fields,
icons etc.
• Information components for example tooltips, notifications,
message boxes and progress bars among others.
• Call to Action elements (see how to create perfect Call to Action
button).
**When choosing what element to include in a User Interface Design, it’s
always wise to consider your tradeoffs. An element may, for instance, save you
some space but end up unnecessarily burdening the user and break the user

UI Design Best Practices
Designing the perfect user interface comes from knowing the
users as well as understanding their tendencies, preferences, skills,
and goals.
Remember the following practices of a good User Interface Design.
1) Simple Interfaces are best- use a clear language and avoid
inessential elements.
2) Maintain Consistency by using common UI elements. Use elements
that users are familiar with. This ensures things get done fast. It
also guarantees user comfort and gratification.

3) Use smart, purposeful page layouts. Try to draw attention to the
most important aspects of the website.
4) Colors and textures should be appropriately used to draw the
attention of the user to a particular or given component. See F5
Studio’s post about web design for ordinary business
5) Use the typeface to increase readability and legibility of the content
6) Use defaults to reduce the burden of the user where appropriate.

Prototyping
Prototyping defines layout, content, and type of controls and their
behavior. It defines how functionality is spread across the screens.
Graphic design, on the other hand, defines the grid, the colors, the
fonts and the backgrounds.
The prototype gives the customer a complete idea of how the site
will look like in the final result. Prototyping allows you to streamline
the design development process, focusing on important interface
elements. Having a prototype in hand, the designer and customer

In addition, prototyping is the process of building a model of a
system. In terms of an information system, prototypes are employed
to help system designers build an information system that intuitive
and easy to manipulate for end users. Prototyping is an iterative
process that is part of the analysis phase of the systems development
life cycle.
A prototype can be anything from paper drawings (low-fidelity) to
something that allows click-through of a few pieces of content to a
fully functioning site (high-fidelity).

Advantages of Prototyping:
• Reduces development time.
• Reduces development costs.
• Requires user involvement.
• Developers receive quantifiable user feedback.
• Facilitates system implementation since users know what to expect.
• Results in higher user satisfaction.
• Exposes developers to potential future system enhancements.

Disadvantages of Prototyping:
• Can lead to insufficient analysis.
• Users expect the performance of the ultimate system to be the same
as the prototype.
• Developers can become too attached to their prototypes
• Can cause systems to be left unfinished and/or implemented before
they are ready.
• Sometimes leads to incomplete documentation.
• If sophisticated software prototypes (4th GL or CASE Tools) are
employed, the time saving benefit of prototyping can be lost.

High-Fidelity and Low-Fidelity Prototyping
Low-Fidelity Prototypes are often paper-based and do not allow user
interactions. They range from a series of hand-drawn mock-ups to
printouts. In theory, low-fidelity sketches are quicker to create. Low-
fidelity prototypes are helpful in enabling early visualization of
alternative design solutions, which helps provoke innovation and
improvement. An additional advantage to this approach is that when
using rough sketches, users may feel more comfortable suggesting
changes.

High-Fidelity Prototypes are computer-based, and usually allow
realistic (mouse-keyboard) user interactions. High-fidelity prototypes
take you as close as possible to a true representation of the user
interface. High-fidelity prototypes are assumed to be much more
effective in collecting true human performance data (e.g., time to
complete a task), and in demonstrating actual products to clients,
management, and others.

Development
On receiving system design documents, the work is divided in
modules/units and actual coding is started. Since, in this phase the
code is produced so it is the main focus for the developer. This is the
longest phase of the software development life cycle. The purpose of
the Development Phase is to convert the system design prototyped in
the Design Phase into a working information system that addresses all
documented system requirements. At the end of this phase, the
working system will enter the Test Phase.
Development

Testing
Software testing is the process of evaluating and verifying that a
software product or application does what it is supposed to do. The
benefits of testing include preventing bugs, reducing development
costs and improving performance.
Different Types of Tests:
- Unit Tests - End-to-end Tests - Smoke Tests - Usability
Tests
- Integration Tests - Acceptance Tests - Regression Tests
Testing

 Unit Tests are very low level, close to the source of your application.
They consist in testing individual methods and functions of the
classes, components or modules used by your software. Unit tests
are in general quite cheap to automate and can be run very quickly
by a continuous integration server. Validating that each software
unit performs as expected. A unit is the smallest testable
component of an application.
 Integration Tests verify that different modules or services used by
your application work well together. These types of tests are more
expensive to run as they require multiple parts of the application to
Testing

 Functional Tests focus on the business requirements of an
application. They only verify the output of an action and do not
check the intermediate states of the system when performing that
action.
*There is sometimes a confusion between integration tests and
functional tests as they both require multiple components to interact
with each other. The difference is that an integration test may simply
verify that you can query the database while a functional test would
expect to get a specific value from the database as defined by the
product requirements.
Testing

 End-to-end Tests replicates a user behavior with the software in a
complete application environment. It verifies that various user flows
work as expected and can be as simple as loading a web page or
logging in or much more complex scenarios verifying email
notifications, online payments, etc.
*End-to-end tests are very useful, but they're expensive to perform
and can be hard to maintain when they're automated. It is
recommended to have a few key end-to-end tests and rely more on
lower-level types of testing (unit and integration tests) to be able to
quickly identify breaking changes.
Testing

 Acceptance Tests are formal tests executed to verify if a system
satisfies its business requirements. They require the entire
application to be up and running and focus on replicating user
behaviors. But they can also go further and measure the
performance of the system and reject changes if certain goals are
not met. It verifies whether the whole system works as intended.
Testing

 Performance Tests check the behaviors of the system when it is
under significant load. These tests are non-functional and can have
the various form to understand the reliability, stability, and
availability of the platform. For instance, it can be observing
response times when executing a high number of requests, or
seeing how the system behaves with a significant of data.
*Performance tests are by their nature quite costly to implement
and run, but they can help you understand if new changes are going
to degrade your system. Testing how the software performs under
different workloads.
Testing

 Smoke Tests are basic tests that check basic functionality of the
application. They are meant to be quick to execute, and their goal is
to give you the assurance that the major features of your system are
working as expected.
*Smoke tests can be useful right after a new build is made to
decide whether or not you can run more expensive tests, or right after
a deployment to make sure that they application is running properly in
the newly deployed environment.
Testing

 Regression Testing Checking whether new features break or
degrade functionality. Sanity testing can be used to verify menus,
functions and commands at the surface level, when there is no time
for a full regression test.
 Stress Testing How much strain the system can take before it fails.
Considered to be a type of non-functional testing.
 Usability Testing Validating how well a customer can use a system
or web application to complete a task.
Testing

Deployment
Software deployment is the process of delivering completed
software to the client who ordered it or rolling out the software to
consumers. Software deployment should only take place after
thorough testing to ensure that all the flaws and bugs have been
identified and fixed.
Deployment and Maintenance
Maintenance
Maintenance is the final step of the life cycle, and this is when
remaining fixes will be delivered. It is also when additional features or
functions might be

Software Deployment Best Practices
General Best Practices for Deployment:
• Allow your end users to install software themselves using the self-
service portal.
• Check out the 'Templates' section before deploying any software.
• Configure a software repository so that you can reuse the packages
to install or uninstall a software.
• Keep your software and applications up-to-date with the Auto-
update Templates option

Pre-deployment checklist before installation/uninstallation:
• Checking if software already exists
• Ensuring minimum free disk space
• Checking registry key/value
• Specifying the file/folder name
• Configuring processes such as executing custom scripts, creating or
deleting a shortcut, etc.
• Changing registry values in workstations
• Configuring applications to run on Windows service

LESSON 3 SOFTWARE DEVELOPMENT LIFES CYCLE

More Related Content

Similar to LESSON 3 SOFTWARE DEVELOPMENT LIFES CYCLE (20)

Recently uploaded (20)

LESSON 3 SOFTWARE DEVELOPMENT LIFES CYCLE

Editor's Notes