Assignment No.

3 – Agile Software Development

Questions:

A. What is the difference between agile and plan driven development?

The plan driven development is a style of development that attempts to plan for and anticipate
up front all of the features a user might want in the end product and to determine how best to
build those features. The work plan is based on execution of a sequential set of work-specific
phases.

Agile approaches to software development consider design and implementation to be the

central activities in the software process. They incorporate other activities, such as requirements
elicitation and testing, into design and implementation. By contrast, a plan-driven approach to
software engineering identifies separate stages in the software process with outputs associated
with each stage. The outputs from one stage are used as a basis for planning the following
process activity.

In a plan-driven approach, iteration occurs within activities with formal documents used to
communicate between stages of the process. In an agile approach, iteration occurs across
activities. Therefore, the requirements and the design are developed together, rather than
separately.

When it comes to using these developments, software engineers need to use plan-driven
approach when developing large systems, for this kind of development requires a lot of analysis
before implementation. Software engineers should use agile software development when the
team relies on good tools to keep track of an evolving design or to support system development.

The aim of plan driven development is to foresee and prepare for every functionality
that a user could require in the final product and to decide how to effectively implement those
functionalities. The execution of a sequential group of task-specific stages forms the basis of the
work plan. Design and implementation are viewed as the primary tasks in the software process
in agile methods to software development. They combine testing and requirements elicitation
into design and execution, among other things. A plan-driven approach to software engineering,
in comparison, distinguishes distinct stages in the development process and associates results
with each stage. The results of one stage serve as the foundation for the subsequent process
activity's planning. In a plan-driven approach, iteration takes place inside activities and formal
documentation are utilized to communicate between process phases. Iteration happens across
activities when using an agile method. As a result, rather of being developed independently, the
requirements and the design are produced simultaneously. Software engineers should employ a
plan-driven approach when creating big systems in order to utilize these developments, as they
need extensive study prior to implementation. When a team depends on effective tools to
 monitor a developing design or to assist system development, software engineers should utilize
agile software development.

B. Suggest four reasons why the productivity rate of programmers working as a pair might be more
than half that of two programmers working individually.

It is essential to have more productivity in programming. With pair programming, it is a

practice where two people look at one machine when in a process of writing or producing the
code so the code will be less defective. At this rate, they have different roles at different times,
they alternate the role of programming and strategizing, where in strategizing, the programmer
looks at the code that has been written and thinking whether that would work or what other
tests that are there that might not work, given the way the code is being written, or maybe
looking at the code from a detached perspective and trying to figure out whether the code can
be made simpler, more maintainable, more efficient. With pair programming, especially with big
projects, you can leverage each other’s knowledge and ask questions especially if one
programmer is an expert at a particular thing, that is a very beneficial on pursuing a successful
program or system that you two are building and getting it done quickly. With pair
programming, it can be done face-to-face, or remotely with people in other countries. And
talking through your ideas and communicating with another person can bring up a much better
code in the end. Using pair programming, it’s a great way learning opportunity, an opportunity
to transfer knowledge to each other, and when it comes to code reviews, every piece of code is
looked at by more than one person.

C. Suppose you were the software manager in a company that develops mobile applications and
web-based applications for online shopping. Present a draft on how you will create a new online
shopping app for a newly opened grocery store using the agile software development. (Draft
only, list only the important things your team will do to create the app).

Suppose I’m a software manager in a company that develops mobile applications and web-
based applications for online shopping, when creating a new online shopping app for a newly
opened grocery store using agile software development, I and my team will do the following:

For every iteration, the team should work simultaneously on areas like planning, requirement
analysis, design, coding, unit testing, and acceptance testing.

The app that will be created should have an adaptability, wherein it can adapt to what the
customer wants or needs.

The app should be flexible or adjustable or has flexibility so that the customer can give their own
inputs to fill their satisfaction.
There should have a rapid delivery, meaning fast development
The iterative approach is being done to build the whole system and to deliver it in every
repetition, so there should be results in every multiple iterations.

Then the system that has been built on the process of iteration, should be used on another
incremental phase until it reaches the final build that the customer wants.

Before starting, we should initiate a project, and define requirements whether requires high-
level or low-level requirements. This should be done to have the integration of those
requirements, of those projects and to test the functionality

After those testing, then there should be customer visibility of the system. It can be viewed by
the user and can be viewed by clients and developers on the things that are happening in the
system. Then if the client wants to add something, we can develop and act on it as soon as
possible. This results in the system becoming an adjustable system, and because of the
development, there are improvements.

After the development process, on its release, we can wait for the feedback and review from the
client and from the users that used the system.