TOPIC 1: IDENTIFY PROGRAMMING CONCEPTS AND APPROACHES

Definition of program and programming

A program is a collection of instructions written in the programming language that performs a
specific task when executed by a computer. It consists of logical steps, algorithms, and syntax
conforming to the rules of the programming language.

A program is a set of instructions written in a programming language that a computer can

execute to perform a specific task or solve a problem.

Programming is the process of designing, writing, testing, and maintaining a set of instructions
(called code) that a computer can execute to perform specific tasks. These instructions are
written in a programming language, such as C, Python, Java, or others, and follow a structured
logic to solve problems or achieve objectives.

Language translators
Language translators are programs that convert source code written in one programming
language into another form. These include compilers, interpreters, and assemblers.
1. Compiler
 A compiler translates high-level programming code (source code) into machine code
or an intermediate code in a single step.
 Example: A C++ compiler translates C++ code into machine-readable instructions.
 Compilers generate an executable file that can run independently.
 Examples: GCC (GNU Compiler Collection), Java Compiler.
2. Interpreter
 An interpreter executes the high-level source code line by line without converting it
into machine code beforehand.
 It doesn’t produce an independent executable file, so it must be run every time the
program is executed.
 Examples: Python Interpreter, JavaScript Engines like V8.
3. Editors
 Editors are tools used for writing and editing source code.
 They provide features like syntax highlighting, autocomplete, and debugging support.
 Examples: Visual Studio Code, Sublime Text, Notepad++, and Vim.
4. Linker
 The linker combines multiple object files (produced by a compiler) into a single
executable file.
 It also resolves external references between modules.
 Example: In C++, the linker combines your code with libraries to create an
executable.
 5. Loader
 The loader is a part of the operating system that loads the executable program into
memory for execution.
 It also handles memory allocation and prepares the program to run.

Types of programming approaches

There are several types of programming approaches, also referred to as programming paradigms.
These approaches provide different methodologies for designing, structuring, and writing
programs.

1. Procedural Programming
 Definition: Focuses on breaking down a program into a set of procedures or functions
that operate on data.
 Key Features:
o Step-by-step instructions (sequence, selection, and iteration).
o Emphasis on functions and procedures.
o Reusable code through function calls.
 Examples: C, Pascal, Fortran.
 Use Cases: Suitable for linear and simple tasks, such as small applications.

2. Object-Oriented Programming (OOP)

 Definition: Organizes code into objects that contain data (attributes) and methods
(functions).
 Key Features:
o Encapsulation, inheritance, and polymorphism.
o Promotes code reusability and modularity.
 Examples: Java, Python, C++, C#.
 Use Cases: Ideal for large-scale, complex systems, such as GUI-based applications and
game development.

3. Functional Programming
 Definition: Treats computation as the evaluation of mathematical functions and avoids
changing states or mutable data.
 Key Features:
o Focus on "what to solve" rather than "how to solve."
o Functions are first-class citizens (can be assigned to variables, passed as
arguments, etc.).
o Emphasizes immutability and recursion.
 Examples: Haskell, Lisp, Scala, Python (partially).
  Use Cases: AI, data analysis, and systems with high concurrency.

4. Logic Programming
 Definition: Based on formal logic, it uses rules and facts to define relationships and
derive conclusions.
 Key Features:
o Uses declarative statements (rules and facts).
o The system solves problems by searching through these rules.
 Examples: Prolog, Datalog.
 Use Cases: AI applications, such as expert systems and natural language processing.

5. Event-Driven Programming
 Definition: The program flow is determined by user or system-generated events (e.g.,
mouse clicks, key presses).
 Key Features:
o Events trigger actions or functions.
o Often used in graphical user interfaces (GUIs).
 Examples: JavaScript (browser events), VB.NET, C#.
 Use Cases: Web development, GUI-based software.

6. Declarative Programming
 Definition: Focuses on defining what the program should accomplish without specifying
how to do it.
 Key Features:
o High-level abstractions.
o Relies on the underlying system to determine execution.
 Examples: SQL (for databases), HTML (for web layouts), Prolog.
 Use Cases: Database queries, web development.

7. Parallel Programming
 Definition: Involves executing multiple computations simultaneously to improve
performance.
 Key Features:
o Divide tasks into smaller subtasks to run in parallel.
o Requires careful synchronization.
 Examples: MPI, OpenMP, CUDA.
 Use Cases: High-performance computing, simulations, and large-scale data processing.

8. Scripting Programming
  Definition: Focuses on automating tasks and controlling other software applications.
 Key Features:
o Interpreted languages.
o Used for lightweight programming tasks.
 Examples: Python, JavaScript, Perl, Ruby.
 Use Cases: Web development, task automation, and server scripting.

9. Aspect-Oriented Programming (AOP)

 Definition: Focuses on separating cross-cutting concerns (e.g., logging, security) from
the main program logic.
 Key Features:
o Introduces aspects to modularize concerns.
o Enhances modularity beyond OOP.
 Examples: AspectJ (extension of Java).
 Use Cases: Systems requiring clean separation of concerns like auditing, logging.

TOPIC 2: IDENTIFY PROGRAM DEVELOPMENT METHODOLOGIES

Program specifications
Program specifications are detailed documents or descriptions that outline the requirements,
features, and constraints of a program or system. They serve as a blueprint for developers,
designers, and other stakeholders to understand what is being built and how it should function.
Program specifications typically include:

1. General Overview
 Purpose: Why the program is being developed and the problem it solves.
 Scope: The boundaries of the program, including what it will and won’t do.
 Target Audience: The end-users or customers who will use the program.

2. Functional Requirements
 Features: Specific functions the program must perform (e.g., user authentication, data
processing).
 Input/Output: Expected inputs the system will handle and the outputs it will produce.
 User Interactions: How users will interact with the program (e.g., through a web
interface, mobile app, or command-line tool).

3. Non-Functional Requirements
 Performance: Response time, throughput, and other performance metrics.
 Scalability: How the program will handle growth in users or data.
 Reliability: Expected uptime, error tolerance, and recovery mechanisms.
  Security: Measures to protect the program from threats, like encryption or authentication
protocols.
 Usability: Design considerations to make the program user-friendly.

4. Technical Specifications
 Programming Language: The language(s) to be used (e.g., Python, Java).
 Frameworks/Libraries: Tools or frameworks required for development (e.g., Django,
React).
 Hardware Requirements: Minimum hardware for running the program (e.g., processor,
memory, storage).
 Operating Systems: Platforms the program must support (e.g., Windows, Linux,
macOS).

5. Data Specifications
 Database Requirements: Type of database (SQL or NoSQL), structure, and storage
needs.
 Data Flow: How data moves through the system.
 Integration: Any external systems or APIs the program needs to communicate with.

6. Constraints
 Budget: Financial limitations for the project.
 Timeline: Deadlines and key milestones.
 Regulations/Standards: Compliance with laws or industry standards (e.g., GDPR,
HIPAA).

7. Testing and Validation

 Testing Criteria: How the program will be tested (e.g., unit testing, integration testing).
 Success Metrics: Criteria to determine if the program meets the requirements.

8. Maintenance and Support

 Updates: How updates will be delivered.
 Documentation: Instructions and manuals for users and developers.
 Support Plan: Processes for addressing bugs and user issues post-launch.

Benefits of Program Specifications

 Provides clarity for developers and stakeholders.
 Helps ensure that the project meets user needs.
 Reduces risks of miscommunication and costly rework.
 Serves as a reference document throughout the project lifecycle.

Program development cycle

The Program Development Cycle (also known as the Software Development Life Cycle, or
SDLC) is a structured approach to software development that outlines the stages and processes
involved in creating and maintaining a software application or system. The cycle helps ensure
that the software is developed efficiently, meets requirements, and is delivered on time and
within budget. Below is an overview of the typical stages in the program development cycle:

1. Requirement Phase
This is the most crucial phase of the software development life cycle for the developing team as
well as for the project manager. During this phase, the client states requirements, specifications,
expectations, and any other special requirement related to the product or software. All these are
gathered by the business manager or project manager or analyst of the service providing
company.
The requirement includes how the product will be used and who will use the product to
determine the load of operations. All information gathered from this phase is critical to
developing the product as per the customer requirements.

Activities:
 Identify project requirements (e.g., business needs, user requirements).
 Conduct feasibility studies (technical, operational, financial).
 Set goals, budgets, and timelines.
 Define the team and resources needed.
Deliverables: Feasibility report, project plan, resource allocation.

2. Design Phase
The design phase includes a detailed analysis of new software according to the requirement
phase. This is the high priority phase in the development life cycle of a system because the
logical designing of the system is converted into physical designing. The output of the
requirement phase is a collection of things that are required, and the design phase gives the way
to accomplish these requirements.

The decision of all required essential tools such as programming language like Java, .NET,
PHP, a database like Oracle, MySQL, a combination of hardware and software to provide a
platform on which software can run without any problem is taken in this phase.
There are several techniques and tools, such as data flow diagrams, flowcharts, decision tables,
and decision trees, Data dictionary, and the structured dictionary are used for describing the
system design.
Activities:
 High-Level Design: Define system architecture, technologies, and data flow.
 Low-Level Design: Break down the system into detailed components (e.g., database
schema, UI design, and algorithms).
 Choose the programming languages, tools, and frameworks.
Deliverables: System architecture diagrams, detailed design documents, wireframes.

3. Implementation/Development Phase
After the successful completion of the requirement and design phase, the next step is to
implement the design into the development of a software system. In this phase, work is divided
into small units, and coding starts by the team of developers according to the design discussed in
the previous phase and according to the requirements of the client discussed in requirement
phase to produce the desired result.

Front-end developers develop easy and attractive GUI and necessary interfaces to interact with
back-end operations and back-end developers do back-end coding according to the required
operations. All is done according to the procedure and guidelines demonstrated by the project
manager.
Since this is the coding phase, it takes the longest time and more focused approach for the
developer in the software development life cycle.

Activities:
 Write the actual code based on the design documents.
 Adhere to coding standards and best practices.
 Perform unit testing to validate individual components.
Deliverables: Source code, unit tests, and initial documentation.

4. Testing Phase
Testing is the last step of completing a software system. In this phase, after getting the developed
GUI and back-end combination, it is tested against the requirements stated in the requirement
phase.

Testing determines whether the software is actually giving the result as per the requirements
addressed in the requirement phase or not. The Development team makes a test plan to start the
test. This test plan includes all types of essential testing such as integration testing, unit testing,
acceptance testing, and system testing. Non-functional testing is also done in this phase.

If there are any defects in the software or it is not working as per expectations, then the testing
team gives information to the development team in detail about the issue. If it is a valid defect or
worth to sort out, it will be fixed, and the development team replaces it with the new one, and it
also needs to be verified.
Activities:
 Conduct different types of testing:
o Unit Testing: Test individual components for functionality.
o Integration Testing: Ensure that components work together as expected.
o System Testing: Validate the complete system for overall functionality.
o Acceptance Testing: Ensure the system meets business and user requirements.
 Track bugs and fix issues identified during testing.
Deliverables: Test cases, test results, bug reports, fixes.

5. Deployment/ Deliver Phase

When software testing is completed with a satisfying result, and there are no remaining issues in
the working of the software, it is delivered to the customer for their use.
As soon as customers receive the product, they are recommended first to do the beta testing. In
beta testing, customer can require any changes which are not present in the software but
mentioned in the requirement document or any other GUI changes to make it more user-friendly.

Besides this, if any type of defect is encountered while a customer using the software; it will be
informed to the development team of that particular software to sort out the problem. If it is a
severe issue, then the development team solves it in a short time; otherwise, if it is less severe,
then it will wait for the next version.
After the solution of all types of bugs and changes, the software finally deployed to the end-user.

Activities:
 Install and configure the software in the live environment.
 Conduct a final round of testing (e.g., user acceptance testing).
 Provide training or support for end-users.
Deliverables: Deployed system, user manuals, and training materials.

6. Maintenance
The maintenance phase is the last and long-lasting phase of SDLC because it is the process
which continues until the software's life cycle comes to an end. When a customer starts using
software, then actual problems start to occur, and at that time there's a need to solve these
problems. This phase also includes making changes in hardware and software to maintain its
operational effectiveness like to improve its performance, enhance security features and
according to customer's requirements with upcoming time. This process to take care of product
time to time is called maintenance.

Activities:
 Monitor the system for performance issues, bugs, and security vulnerabilities.
  Provide updates, patches, and new features based on user feedback or evolving
requirements.
 Perform regular maintenance tasks such as backups, database tuning, etc.
Deliverables: System updates, patches, performance reports.

Benefits of the Program Development Cycle

 Provides structure and clarity throughout the development process.
 Enhances collaboration between development teams and stakeholders.
 Helps track progress and identify potential issues early.
 Ensures high-quality software that meets user requirements and expectations.

Types of development methodologies

Waterfall model
Winston Royce introduced the Waterfall Model in 1970.This model has five phases:
Requirements analysis and specification, design, implementation, and unit testing, integration
and system testing, and operation and maintenance. The steps always follow in this order and do
not overlap. The developer must complete every phase before the next phase begins. This model
is named "Waterfall Model", because its diagrammatic representation resembles a cascade of
waterfalls.

1. Requirements analysis and specification phase: The aim of this phase is to understand the
exact requirements of the customer and to document them properly. Both the customer and the
software developer work together so as to document all the functions, performance, and
interfacing requirement of the software. It describes the "what" of the system to be produced and
not "how."In this phase, a large document called Software Requirement Specification
(SRS) document is created which contained a detailed description of what the system will do in
the common language.
2. Design Phase: This phase aims to transform the requirements gathered in the SRS into a
suitable form which permits further coding in a programming language. It defines the overall
software architecture together with high level and detailed design. All this work is documented
as a Software Design Document (SDD).

3. Implementation and unit testing: During this phase, design is implemented. If the SDD is
complete, the implementation or coding phase proceeds smoothly, because all the information
needed by software developers is contained in the SDD.
During testing, the code is thoroughly examined and modified. Small modules are tested in
isolation initially. After that these modules are tested by writing some overhead code to check
the interaction between these modules and the flow of intermediate output.

4. Integration and System Testing: This phase is highly crucial as the quality of the end
product is determined by the effectiveness of the testing carried out. The better output will lead
to satisfied customers, lower maintenance costs, and accurate results. Unit testing determines the
efficiency of individual modules. However, in this phase, the modules are tested for their
interactions with each other and with the system.

5. Operation and maintenance phase: Maintenance is the task performed by every user once
the software has been delivered to the customer, installed, and operational.

When to use SDLC Waterfall Model?

Some Circumstances where the use of the Waterfall model is most suited are:
o When the requirements are constant and not changed regularly.
o A project is short
o The situation is calm
o Where the tools and technology used is consistent and is not changing
o When resources are well prepared and are available to use.
Advantages of Waterfall model
o This model is simple to implement also the number of resources that are required for it is
minimal.
o The requirements are simple and explicitly declared; they remain unchanged during the
entire project development.
o The start and end points for each phase is fixed, which makes it easy to cover progress.
o The release date for the complete product, as well as its final cost, can be determined
before development.
o It gives easy to control and clarity for the customer due to a strict reporting system.
Disadvantages of Waterfall model
o In this model, the risk factor is higher, so this model is not suitable for more significant
and complex projects.
o This model cannot accept the changes in requirements during development.
o It becomes tough to go back to the phase. For example, if the application has now shifted
to the coding phase, and there is a change in requirement, It becomes tough to go back
and change it.
o Since the testing done at a later stage, it does not allow identifying the challenges and
risks in the earlier phase, so the risk reduction strategy is difficult to prepare.

RAD (Rapid Application Development) Model

RAD is a linear sequential software development process model that emphasizes a concise
development cycle using an element based construction approach. If the requirements are well
understood and described, and the project scope is a constraint, the RAD process enables a
development team to create a fully functional system within a concise time period.
RAD (Rapid Application Development) is a concept that products can be developed faster and of
higher quality through:
o Gathering requirements using workshops or focus groups
 o Prototyping and early, reiterative user testing of designs
o The re-use of software components
o A rigidly paced schedule that refers design improvements to the next product version
o Less formality in reviews and other team communication

The various phases of RAD are as follows:

1.Business Modelling: The information flow among business functions is defined by answering
questions like what data drives the business process, what data is generated, who generates it,
where does the information go, who process it and so on.

2. Data Modelling: The data collected from business modeling is refined into a set of data
objects (entities) that are needed to support the business. The attributes (character of each entity)
are identified, and the relation between these data objects (entities) is defined.

3. Process Modelling: The information object defined in the data modeling phase are
transformed to achieve the data flow necessary to implement a business function. Processing
descriptions are created for adding, modifying, deleting, or retrieving a data object.

4. Application Generation: Automated tools are used to facilitate construction of the software;
even they use the 4th GL techniques.
5. Testing & Turnover: Many of the programming components have already been tested since
RAD emphasis reuse. This reduces the overall testing time. But the new part must be tested, and
all interfaces must be fully exercised.
When to use RAD Model?
o When the system should need to create the project that modularizes in a short span time
(2-3 months).
o When the requirements are well-known.
o When the technical risk is limited.
o When there's a necessity to make a system, which modularized in 2-3 months of period.
o It should be used only if the budget allows the use of automatic code generating tools.
Advantage of RAD Model
o This model is flexible for change.
o In this model, changes are adoptable.
o Each phase in RAD brings highest priority functionality to the customer.
o It reduced development time.
o It increases the reusability of features.
Disadvantage of RAD Model
o It required highly skilled designers.
o All application is not compatible with RAD.
o For smaller projects, we cannot use the RAD model.
o On the high technical risk, it's not suitable.
o Required user involvement.

Spiral Model
The spiral model, initially proposed by Boehm, is an evolutionary software process model that
couples the iterative feature of prototyping with the controlled and systematic aspects of the
linear sequential model. It implements the potential for rapid development of new versions of the
software. Using the spiral model, the software is developed in a series of incremental releases.
During the early iterations, the additional release may be a paper model or prototype. During
later iterations, more and more complete versions of the engineered system are produced.
The Spiral Model is shown in fig:

Each cycle in the spiral is divided into four parts:

Objective setting: Each cycle in the spiral starts with the identification of purpose for that cycle,
the various alternatives that are possible for achieving the targets, and the constraints that exists.

Risk Assessment and reduction: The next phase in the cycle is to calculate these various
alternatives based on the goals and constraints. The focus of evaluation in this stage is located on
the risk perception for the project.

Development and validation: The next phase is to develop strategies that resolve uncertainties
and risks. This process may include activities such as benchmarking, simulation, and
prototyping.

Planning: Finally, the next step is planned. The project is reviewed, and a choice made whether
to continue with a further period of the spiral. If it is determined to keep, plans are drawn up for
the next step of the project.
The development phase depends on the remaining risks. For example, if performance or user-
interface risks are treated more essential than the program development risks, the next phase may
be an evolutionary development that includes developing a more detailed prototype for solving
the risks.

The risk-driven feature of the spiral model allows it to accommodate any mixture of a
specification-oriented, prototype-oriented, simulation-oriented, or another type of approach. An
essential element of the model is that each period of the spiral is completed by a review that
includes all the products developed during that cycle, including plans for the next cycle. The
spiral model works for development as well as enhancement projects.
When to use Spiral Model?
o When deliverance is required to be frequent.
o When the project is large
o When requirements are unclear and complex
o When changes may require at any time
o Large and high budget projects
Advantages
o High amount of risk analysis
o Useful for large and mission-critical projects.
Disadvantages
o Can be a costly model to use.
o Risk analysis needed highly particular expertise
o Doesn't work well for smaller projects.

V-Model
V-Model also referred to as the Verification and Validation Model. In this, each phase of SDLC
must complete before the next phase starts. It follows a sequential design process same as the
waterfall model. Testing of the device is planned in parallel with a corresponding stage of
development.
Verification: It involves a static analysis method (review) done without executing code. It is the
process of evaluation of the product development process to find whether specified requirements
meet.

Validation: It involves dynamic analysis method (functional, non-functional), testing is done by

executing code. Validation is the process to classify the software after the completion of the
development process to determine whether the software meets the customer expectations and
requirements.
So V-Model contains Verification phases on one side of the Validation phases on the other side.
Verification and Validation process is joined by coding phase in V-shape. Thus it is known as V-
Model.

There are the various phases of Verification Phase of V-model:

1. Business requirement analysis: This is the first step where product requirements
understood from the customer's side. This phase contains detailed communication to
understand customer's expectations and exact requirements.
2. System Design: In this stage system engineers analyze and interpret the business of the
proposed system by studying the user requirements document.
3. Architecture Design: The baseline in selecting the architecture is that it should
understand all which typically consists of the list of modules, brief functionality of each
module, their interface relationships, dependencies, database tables, architecture
 diagrams, technology detail, etc. The integration testing model is carried out in a
particular phase.
4. Module Design: In the module design phase, the system breaks down into small
modules. The detailed design of the modules is specified, which is known as Low-Level
Design
5. Coding Phase: After designing, the coding phase is started. Based on the requirements, a
suitable programming language is decided. There are some guidelines and standards for
coding. Before checking in the repository, the final build is optimized for better
performance, and the code goes through many code reviews to check the performance.
There are the various phases of Validation Phase of V-model:
1. Unit Testing: In the V-Model, Unit Test Plans (UTPs) are developed during the module
design phase. These UTPs are executed to eliminate errors at code level or unit level. A
unit is the smallest entity which can independently exist, e.g., a program module. Unit
testing verifies that the smallest entity can function correctly when isolated from the rest
of the codes/ units.
2. Integration Testing: Integration Test Plans are developed during the Architectural
Design Phase. These tests verify that groups created and tested independently can coexist
and communicate among themselves.
3. System Testing: System Tests Plans are developed during System Design Phase. Unlike
Unit and Integration Test Plans, System Tests Plans are composed by the client?s
business team. System Test ensures that expectations from an application developer are
met.
4. Acceptance Testing: Acceptance testing is related to the business requirement analysis
part. It includes testing the software product in user atmosphere. Acceptance tests reveal
the compatibility problems with the different systems, which is available within the user
atmosphere. It conjointly discovers the non-functional problems like load and
performance defects within the real user atmosphere.
When to use V-Model?
o When the requirement is well defined and not ambiguous.
o The V-shaped model should be used for small to medium-sized projects where
requirements are clearly defined and fixed.
o The V-shaped model should be chosen when sample technical resources are available
with essential technical expertise.
Advantage (Pros) of V-Model:
1. Easy to Understand.
2. Testing Methods like planning, test designing happens well before coding.
3. This saves a lot of time. Hence a higher chance of success over the waterfall model.
4. Avoids the downward flow of the defects.
5. Works well for small plans where requirements are easily understood.
Disadvantage (Cons) of V-Model:
1. Very rigid and least flexible.
2. Not a good for a complex project.
3. Software is developed during the implementation stage, so no early prototypes of the
software are produced.
4. If any changes happen in the midway, then the test documents along with the required
documents, has to be updated.

Incremental Model
Incremental Model is a process of software development where requirements divided into
multiple standalone modules of the software development cycle. In this model, each module goes
through the requirements, design, implementation and testing phases. Every subsequent release
of the module adds function to the previous release. The process continues until the complete
system achieved.

The various phases of incremental model are as follows:

1. Requirement analysis: In the first phase of the incremental model, the product analysis
expertise identifies the requirements. And the system functional requirements are understood by
the requirement analysis team. To develop the software under the incremental model, this phase
performs a crucial role.
2. Design & Development: In this phase of the Incremental model of SDLC, the design of the
system functionality and the development method are finished with success. When software
develops new practicality, the incremental model uses style and development phase.

3. Testing: In the incremental model, the testing phase checks the performance of each existing
function as well as additional functionality. In the testing phase, the various methods are used to
test the behavior of each task.

4. Implementation: Implementation phase enables the coding phase of the development system.
It involves the final coding that design in the designing and development phase and tests the
functionality in the testing phase. After completion of this phase, the number of the product
working is enhanced and upgraded up to the final system product
When we use the Incremental Model?
o When the requirements are superior.
o A project has a lengthy development schedule.
o When Software team are not very well skilled or trained.
o When the customer demands a quick release of the product.
o You can develop prioritized requirements first.
Advantage of Incremental Model
o Errors are easy to be recognized.
o Easier to test and debug
o More flexible.
o Simple to manage risk because it handled during its iteration.
o The Client gets important functionality early.
Disadvantage of Incremental Model
o Need for good planning
o Total Cost is high.
o Well defined module interfaces are needed.

Agile Model
The meaning of Agile is swift or versatile."Agile process model" refers to a software
development approach based on iterative development. Agile methods break tasks into smaller
iterations, or parts do not directly involve long term planning.

The project scope and requirements are laid down at the beginning of the development process.
Plans regarding the number of iterations, the duration and the scope of each iteration are clearly
defined in advance.

Each iteration is considered as a short time "frame" in the Agile process model, which typically
lasts from one to four weeks. The division of the entire project into smaller parts helps to
minimize the project risk and to reduce the overall project delivery time requirements. Each
iteration involves a team working through a full software development life cycle including
planning, requirements analysis, design, coding, and testing before a working product is
demonstrated to the client.

Phases of Agile Model:

Following are the phases in the Agile model are as follows:
1. Requirements gathering
2. Design the requirements
3. Construction/ iteration
4. Testing/ Quality assurance
5. Deployment
6. Feedback
1. Requirements gathering: In this phase, you must define the requirements. You should
explain business opportunities and plan the time and effort needed to build the project. Based on
this information, you can evaluate technical and economic feasibility.

2. Design the requirements: When you have identified the project, work with stakeholders to
define requirements. You can use the user flow diagram or the high-level UML diagram to show
the work of new features and show how it will apply to your existing system.
3. Construction/ iteration: When the team defines the requirements, the work begins. Designers
and developers start working on their project, which aims to deploy a working product. The
product will undergo various stages of improvement, so it includes simple, minimal
functionality.

4. Testing: In this phase, the Quality Assurance team examines the product's performance and
looks for the bug.

5. Deployment: In this phase, the team issues a product for the user's work environment.

6. Feedback: After releasing the product, the last step is feedback. In this, the team receives
feedback about the product and works through the feedback.
Agile Testing Methods:
o Scrum
o Crystal
o Dynamic Software Development Method(DSDM)
o Feature Driven Development(FDD)
o Lean Software Development
o eXtreme Programming(XP)

Scrum
SCRUM is an agile development process focused primarily on ways to manage tasks in team-
based development conditions.
There are three roles in it, and their responsibilities are:
o Scrum Master: The scrum can set up the master team, arrange the meeting and remove
obstacles for the process
o Product owner: The product owner makes the product backlog, prioritizes the delay and
is responsible for the distribution of functionality on each repetition.
o Scrum Team: The team manages its work and organizes the work to complete the sprint
or cycle.
eXtreme Programming(XP)
This type of methodology is used when customers are constantly changing demands or
requirements, or when they are not sure about the system's performance.

Crystal
Crystal is a family of agile methodologies that prioritize individuals and interactions over
processes and tools.

It acknowledges that every project is unique and, therefore, its approach should be tailored. It
focuses on delivering high-quality software while minimizing bureaucracy.
There are three concepts of this method-
1. Chartering: Multi activities are involved in this phase such as making a development
team, performing feasibility analysis, developing plans, etc.
2. Cyclic delivery: under this, two more cycles consist, these are:
o Team updates the release plan.
o Integrated product delivers to the users.
3. Wrap up: According to the user environment, this phase performs deployment, post-
deployment.
Key Features:
 Lightweight and adaptable
 Emphasizes communication and collaboration
 Frequent delivery of small increments
 Project size and criticality influence the methodology (e.g., Crystal Clear for smaller
teams, Crystal Red for more complex projects)

Dynamic Software Development Method(DSDM):

DSDM is a rapid application development strategy for software development and gives an agile
project distribution structure. The essential features of DSDM are that users must be actively
connected, and teams have been given the right to make decisions. The techniques used in
DSDM are:
1. Time Boxing
2. MoSCoW Rules
3. Prototyping
The DSDM project contains seven stages:
1. Pre-project
2. Feasibility Study
3. Business Study
4. Functional Model Iteration
5. Design and build Iteration
6. Implementation
7. Post-project

Feature Driven Development (FDD):

This method focuses on "Designing and Building" features. In contrast to other smart methods,
FDD describes the small steps of the work that should be obtained separately per function.

Lean Software Development:

Lean software development methodology follows the principle "just in time production." The
lean method indicates the increasing speed of software development and reducing costs. Lean
development can be summarized in seven phases.
 1. Eliminating Waste
2. Amplifying learning
3. Defer commitment (deciding as late as possible)
4. Early delivery
5. Empowering the team
6. Building Integrity
7. Optimize the whole
When to use the Agile Model?
o When frequent changes are required.
o When a highly qualified and experienced team is available.
o When a customer is ready to have a meeting with a software team all the time.
o When project size is small.
Advantage (Pros) of Agile Method:
1. Frequent Delivery
2. Face-to-Face Communication with clients.
3. Efficient design and fulfils the business requirement.
4. Anytime changes are acceptable.
5. It reduces total development time.
Disadvantages (Cons) of Agile Model:
1. Due to the shortage of formal documents, it creates confusion and crucial decisions taken
throughout various phases can be misinterpreted at any time by different team members.
2. Due to the lack of proper documentation, once the project completes and the developers
allotted to another project, maintenance of the finished project can become a difficulty.

Iterative Model
In this Model, you can start with some of the software specifications and develop the first
version of the software.

After the first version if there is a need to change the software, then a new version of the
software is created with a new iteration. Every release of the Iterative Model finishes in an exact
and fixed period that is called iteration.

The Iterative Model allows the accessing earlier phases, in which the variations made
respectively. The final output of the project renewed at the end of the Software Development
Life Cycle (SDLC) process.
The various phases of Iterative model are as follows:
1. Requirement gathering & analysis: In this phase, requirements are gathered from customers
and check by an analyst whether requirements will fulfil or not. Analyst checks that need will
achieve within budget or not. After all of this, the software team skips to the next phase.

2. Design: In the design phase, team design the software by the different diagrams like Data
Flow diagram, activity diagram, class diagram, state transition diagram, etc.

3. Implementation: In the implementation, requirements are written in the coding language and
transformed into computer programmes which are called Software.

4. Testing: After completing the coding phase, software testing starts using different test
methods. There are many test methods, but the most common are white box, black box, and grey
box test methods.

5. Deployment: After completing all the phases, software is deployed to its work environment.

6. Review: In this phase, after the product deployment, review phase is performed to check the
behaviour and validity of the developed product. And if there are any error found then the
process starts again from the requirement gathering.

7. Maintenance: In the maintenance phase, after deployment of the software in the working
environment there may be some bugs, some errors or new updates are required. Maintenance
involves debugging and new addition options.
When to use the Iterative Model?
1. When requirements are defined clearly and easy to understand.
2. When the software application is large.
3. When there is a requirement of changes in future.
Advantage (Pros) of Iterative Model:
1. Testing and debugging during smaller iteration is easy.
2. A Parallel development can plan.
3. It is easily acceptable to ever-changing needs of the project.
4. Risks are identified and resolved during iteration.
5. Limited time spent on documentation and extra time on designing.
Disadvantage (Cons) of Iterative Model:
1. It is not suitable for smaller projects.
2. More Resources may be required.
3. Design can be changed again and again because of imperfect requirements.
4. Requirement changes can cause over budget.
5. Project completion date not confirmed because of changing requirements.

Prototype Model
The prototype model requires that before carrying out the development of actual software, a
working prototype of the system should be built. A prototype is a toy implementation of the
system.

A prototype usually turns out to be a very crude version of the actual system, possible exhibiting
limited functional capabilities, low reliability, and inefficient performance as compared to actual
software.

In many instances, the client only has a general view of what is expected from the software
product. In such a scenario where there is an absence of detailed information regarding the input
to the system, the processing needs, and the output requirement, the prototyping model may be
employed.
Steps of Prototype Model
1. Requirement Gathering and Analyst
2. Quick Decision
3. Build a Prototype
4. Assessment or User Evaluation
5. Prototype Refinement
6. Engineer Product

Advantage of Prototype Model

1. Reduce the risk of incorrect user requirement
2. Good where requirement are changing/uncommitted
3. Regular visible process aids management
 4. Support early product marketing
5. Reduce Maintenance cost.
6. Errors can be detected much earlier as the system is made side by side.

Disadvantage of Prototype Model

1. An unstable/badly implemented prototype often becomes the final product.
2. Require extensive customer collaboration
o Costs customer money
o Needs committed customer
o Difficult to finish if customer withdraw
o May be too customer specific, no broad market
3. Difficult to know how long the project will last.
4. Easy to fall back into the code and fix without proper requirement analysis, design,
customer evaluation, and feedback.
5. Prototyping tools are expensive.
6. Special tools & techniques are required to build a prototype.
7. It is a time-consuming process.

STYLES OF PROGRAMMING
 Functional
 Modular
 Object oriented
1. Functional Programming (FP)
 Based on mathematical functions and avoids changing state or mutable data.
 Focuses on pure functions (functions that always produce the same output for the same
input).
 Uses concepts like higher-order functions, recursion, and immutability.
 Avoids side effects (modifying variables outside the function).
 Common languages: Haskell, Lisp, Clojure, Scala, Python (partially), JavaScript
(functional libraries like Ramda, Lodash).

2. Modular Programming
 Organizes code into independent modules that can be reused and maintained separately.
 Each module is a self-contained unit that performs a specific function.
 Helps in code reusability, readability, and maintainability.
 Common in most programming languages, including Python, Java, C, JavaScript.

3. Object-Oriented Programming (OOP)

 Organizes code into objects that represent real-world entities.
 Uses classes to define objects with attributes (data) and methods (functions).
 Follows principles like Encapsulation, Inheritance, Polymorphism, and Abstraction.
 Common languages: Java, C++, Python, C#, JavaScript (with ES6 classes).