CSC 335: SOFTWARE ENGINEERING ASSIGNMENT​

Name: Oyedele Philemon Oluwakoyejo

Matric Number: 230924
Level: 300

A)​
A DETAILED REPORT ON THE MAJOR PHASES OF SOFTWARE
DEVELOPMENT LIFE CYCLE (SDLC)

Source: javatpoint.com
PHASE 1: Requirement Analysis and Planning

Source: geeksforgeeks.org

Software development, like any major undertaking, requires thorough

planning as its foundation. During this first phase, developers conduct
detailed requirement analysis by gathering information from multiple
sources, including direct customer feedback and market research
conducted by sales teams. These gathered requirements serve as the
cornerstone for the project's foundation. The overall quality of the final
product is directly tied to how well this planning phase is executed. At this
stage, developers use all the collected information to create the project's
preliminary design. [1]

The project begins with a crucial meeting between the business analyst,
project organizer, and the client. During this meeting, they gather
essential information about the desired product, including its intended
users, core purpose, and overall objectives. Having a deep understanding
of the product is essential before beginning development.

Consider a financial transaction application as an example. The

requirements must be extremely specific - detailing the types of
transactions supported, the processing methods, currency options, and
other critical operational details.

After defining the core functionality, the team evaluates the product's
growth potential and overall feasibility. If any aspects remain unclear, they
flag these items for additional discussion and clarification. [2]
Phase 2: Defining the Requirements

The requirements definition phase begins after initial planning. During

this stage, the team formally documents all software requirements in the
SRS (Software Requirement Specification), which must be approved by
customers, market analysts, and stakeholders. This document serves as
the blueprint for the entire project lifecycle. [3]

Source: geeksforgeeks.org
Phase 3: Architectural Design

Once requirements are finalized, the architectural design phase begins.

Software designers use the SRS as their foundation to develop potential
architectural approaches, which are documented in the Design Document
Specification (DDS). These design proposals undergo thorough evaluation
by market analysts and stakeholders before selecting the most practical
and efficient architecture for implementation. [4]

Tools like Figma can also be used this stage to give a prototype of the
intended software before the actual coding starts.

Source: geeksforgeeks.org
Phase 4: Implementation/Product Development

Source: geeksforgeeks.org

The development phase marks the beginning of actual product

construction. Developers write code following the approved design
specifications in the DDS, adhering to organizational coding standards
and practices. They utilize standard development tools like compilers,
debuggers, and interpreters, working with appropriate programming
languages such as Python, Java, or C++ based on project requirements. [5]

At this phase, we also have system documentation implemented in parallel

with the product development.
Phase 5: Testing and Integration
Testing and integration follows development. While testing occurs
throughout the SDLC, this phase involves comprehensive testing to
identify and resolve any issues. The team verifies that the product meets
all quality requirements specified in the SRS. This phase is complemented
by thorough documentation, which serves as a knowledge repository for
the software's functionality, processes, and maintenance procedures.
Additionally, training programs are implemented to ensure employees can
effectively utilize and maintain the software. [6]

Source: geeksforgeeks.org
Phase 6: Deployment and Maintenance
The final stage involves deployment and maintenance. The product is
released in phases, starting with testing in real-world environments to
ensure optimal performance. Based on user feedback, the organization
may release the product as-is or implement improvements. Ongoing
maintenance and supervision ensure the product continues to meet user
needs and perform effectively over time. [7]

Source: geeksforgeeks.org
 B)
FOUR POPULAR SOFTWARE MODELS

1.​ THE WATERFALL MODEL

The Waterfall Model represents the original, sequential approach to
software development. It can be thought of as water flowing down
steps - each phase must be completed before moving to the next,
with no going back. While its straightforward nature makes it easy to
understand and manage, its rigidity is its main drawback. Once a
phase is completed, revisiting or modifying it becomes extremely
difficult. For example, if requirements change after the design phase
has begun, accommodating these changes becomes problematic.
Despite no longer being widely used in modern software
development, it laid the groundwork for all subsequent SDLC
models. [8]

Source: geeksforgeeks.org
2.​ THE AGILE MODEL
The Agile Model revolutionized software development by
emphasizing flexibility and rapid adaptation to change. Unlike
Waterfall, Agile breaks development into small, manageable
increments called sprints, typically lasting 2-4 weeks. Each sprint
delivers a working piece of software, allowing for continuous
feedback and adjustment. This model is particularly valuable when
requirements are likely to evolve or when quick delivery is essential.
For instance, a startup developing a mobile app might use Agile to
release basic features quickly and then iterate based on user
feedback. [9]

Source: geeksforgeeks.org
3.​ THE ITERATIVE MODEL
The Iterative Model takes a different approach by developing
software through repeated cycles (iterations). Each iteration adds
new functionality while maintaining a working version of the
software. Consider building a house room by room, where each room
is fully functional before moving to the next. The first iteration might
deliver core features, the second adds additional capabilities, and
so on until the complete product emerges. This approach allows for
more flexibility than Waterfall while maintaining more structure than
Agile. [10]

Source: geeksforgeeks.org
4.​ THE SPIRAL MODEL
The Spiral Model is unique in its emphasis on risk management. It
combines elements of both iterative development and systematic
planning. Imagine a spiral where each loop represents a complete
phase of development, with four key activities: planning, risk
analysis, engineering, and evaluation. For example, in developing a
financial system, the first spiral might focus on core banking
functions while assessing security risks, the second spiral might add
investment features while evaluating performance risks, and so on.
This makes it particularly suitable for large, high-risk projects where
careful risk assessment is crucial. [11]

Source: geeksforgeeks.org
C) Detailed analysis using the above (a & b) for an e-commerce application
E-commerce Application Development Plan
Using Agile Methodology

Phase 1: Planning and Requirement Analysis

Initial Planning
- Stakeholder interviews and requirements gathering
- Market analysis of existing e-commerce platforms
- Identification of target users and their needs
- Resource allocation and team formation
- Technology stack evaluation and selection
- Initial project timeline and budget estimation

Business Analysis
- Competitor analysis
- Market opportunity assessment
- Risk assessment
- Cost-benefit analysis
- Stakeholder identification and management plan

Phase 2: Defining Requirements

Functional Requirements
1. User Management
- User registration and authentication
- Profile management
- Role-based access control
- Password recovery system

2. Product Management
- Product catalog management
- Inventory tracking
- Category and subcategory organization
- Product search and filtering

3. Shopping Features
- Shopping cart functionality
- Wishlist management
- Order processing
- Payment integration

4. Admin Features
- Dashboard analytics
 - Order management
- Inventory control
- Customer support system

Non-Functional Requirements
- Performance metrics
- Security standards
- Scalability requirements
- Accessibility standards
- Browser compatibility
- Mobile responsiveness

Phase 3: Designing Architecture

System Architecture
- Database design
- Entity-relationship diagrams
- Data flow diagrams
- Database schema
- Data dictionary

- Technical Architecture
- System components
- Integration points
- APIs and services
- Security architecture

User Interface Design

- Wireframes
- User flow diagrams
- Responsive design specifications
- Style guide and brand elements

Phase 4: Developing Product

Sprint-based Development
- Sprint 1-2: Core System Setup
- Database implementation
- Basic authentication
- Project structure

- Sprint 3-4: User Management

- Registration system
- Login system
 - Profile management

- Sprint 5-6: Product Management

- Product catalog
- Search functionality
- Category management

- Sprint 7-8: Shopping Features

- Shopping cart
- Checkout process
- Order management

- Sprint 9-10: Admin Features

- Admin dashboard
- Reporting systems
- Inventory management

- Sprint 11-12: Integration

- Payment gateway
- Email system
- Analytics integration

Phase 5: Product Testing and Integration

Testing Levels
1. Unit Testing
- Individual component testing
- Function-level testing
- Module testing

2. Integration Testing
- Component integration
- API testing
- Database integration

3. System Testing
- End-to-end testing
- Performance testing
- Security testing

4. User Acceptance Testing

- Stakeholder testing
- Beta testing
 - Usability testing

Quality Assurance
- Code review processes
- Performance optimization
- Security audit
- Compliance checking
- Bug tracking and resolution

Phase 6: Deployment and Maintenance

Deployment Strategy
- Environment setup
- Data migration plan
- Rollout strategy
- Backup procedures
- Monitoring setup

Maintenance Plan
1. Regular Maintenance
- Security updates
- Performance monitoring
- Database optimization
- Backup verification

2. Enhancement Management
- Feature updates
- User feedback implementation
- Performance improvements
- Security enhancements

3. Support System
- Technical support
- User support
- Documentation
- Training materials

Long-term Management
- System monitoring
- Performance tracking
- User feedback collection
- Regular security audits
- Continuous improvement process
D) Justification for choosing the model for the above (c) project.

1. Requirement Characteristics
- The e-commerce platform has evolving requirements based on:
- Customer shopping behavior changes
- New payment methods and security standards
- Market competition and trends
- User feedback during development
- Agile's iterative nature allows us to adapt to these changing needs
efficiently

2. Project Complexity and Size

- Our e-commerce application is complex, involving:
- Multiple integrated systems (payment, inventory, user management)
- Various stakeholders (users, administrators, support staff)
- Different security levels and user roles
- Complex database relationships
- Agile's sprint-based approach helps break this complexity into
manageable chunks

3. Delivery Timeline
- The application requires:
- Quick initial market presence with core features
- Regular feature updates and enhancements
- Rapid response to user feedback
- Continuous security updates
- The two-week sprint structure in our plan supports these rapid delivery
needs

4. Stakeholder Involvement
- Our project needs continuous input from:
- Business owners for feature prioritization
- Users for interface feedback
- Security teams for compliance
- Marketing teams for promotional features
- Agile's regular sprint reviews and demos facilitate this ongoing
collaboration

5. Risk Management
- Critical risks in e-commerce include:
- Payment security
- Data protection
 - System performance
- User acceptance
- Agile's frequent testing and iterative development help identify and
address these risks early

6. Maintenance Requirements
- The e-commerce platform needs:
- Regular security updates
- Feature enhancements
- Performance optimization
- Bug fixes
- Agile's continuous improvement approach aligns perfectly with these
ongoing maintenance needs

This justification shows why Agile was the most suitable choice for our
e-commerce project, as it best addresses the key challenges and
requirements while providing the flexibility and structure needed for
successful delivery.
 REFERENCES

1 —-https://www.geeksforgeeks.org/software-development-life-cycle-sdlc/

2—-https://www.javatpoint.com/software-engineering-software-developmen
t-life-cycle

3—https://www.geeksforgeeks.org/software-development-life-cycle-sdlc/

4—Ibid

5—Ibid

6—Ibid

7—Ibid

8—Ibid

9—Ibid

10—Ibid

11—Ibid