SDLC stands for Software Development Life Cycle.

It is a process that provides a structured and

disciplined approach to developing software or information systems. The SDLC consists of
several phases, each with its own set of activities and deliverables.

THREE benefits of applying SDLC for an Information Systems (IS) project are:

1. Quality Assurance: SDLC promotes the development of high-quality software by

incorporating testing and validation activities throughout the process. This helps to
identify and resolve defects early, reducing the cost and effort required to fix them later.

2. Project Management: SDLC provides a framework for effective project management.

Each phase has clearly defined objectives, deliverables, and milestones, which help in
tracking progress, allocating resources, and managing risks.

Documentation: The SDLC emphasizes the importance of documentation at every stage. This
documentation serves as a reference for future maintenance, enhancement, and knowledge
transfer, ensuring the project's long-term sustainability.

THREE problems or challenges of applying SDLC for an IS project are:

1. Inflexibility: The traditional SDLC model can be rigid and may not adapt well to
changing requirements or rapidly evolving technologies. This can lead to delays, rework,
and increased costs.

2. Communication Gaps: SDLC emphasizes sequential phases, which can lead to

communication gaps between different teams or stakeholders involved in the project.
This can result in misunderstandings, delays, and potentially missed requirements.

3. Overhead and Bureaucracy: Following a structured SDLC process can introduce

overhead and bureaucracy, especially in large organizations with strict governance
processes. This can slow down the development process and potentially demotivate team
members.

Here is a diagram of the SDLC process, which is not found in the provided slides:
This diagram illustrates the typical phases of the SDLC:

1. Planning: Defining the project scope, objectives, and requirements.

2. Analysis: Studying the existing system or business requirements in detail.

3. Design: Developing the system architecture, user interfaces, and data models.

4. Implementation: Writing the code and creating the software components.

5. Testing: Verifying the software against requirements and fixing any defects.

6. Deployment: Installing and configuring the software in the production environment.

7. Maintenance: Providing ongoing support, bug fixes, and enhancements.

┌──────────────────────────────────────────────────────
───────────────────────┐

│ Software Development Life Cycle (SDLC) │

└──────────────────────────────────────────────────────
───────────────────────┘

1. Planning Phase
 Sub-phases:

- Feasibility Study

- Project Initiation

Involved:

- Project Manager, Business Analysts, Stakeholders

Input:

- Business Case, Project Proposal

Output:

- Project Plan, Requirements Documentation

Techniques:

- Scope Definition, Risk Assessment, Cost-Benefit Analysis

2. Analysis Phase

Sub-phases:

- Requirements Gathering

- Requirements Analysis and Specification

Involved:

- Business Analysts, Subject Matter Experts, Stakeholders

Input:

- Project Plan, Existing System Documentation

Output:

- Software Requirements Specification (SRS), Data Models

Techniques:
 - Interviews, Surveys, Prototyping, Data Modeling

3. Design Phase

Sub-phases:

- System Design

- Database Design

- User Interface Design

Involved:

- System Architects, Database Designers, UI/UX Designers

Input:

- Software Requirements Specification (SRS), Data Models

Output:

- System Architecture Document, Database Schema, UI Mockups

Techniques:

- Architectural Modeling, Data Normalization, Wireframing

4. Implementation Phase

Sub-phases:

- Coding

- Unit Testing

- Integration Testing

Involved:

- Developers, Testers
 Input:

- System Architecture Document, Database Schema, UI Mockups

Output:

- Source Code, Test Cases, Test Reports

Techniques:

- Programming, Unit Testing, Code Reviews, Continuous Integration

5. Testing Phase

Sub-phases:

- System Testing

- User Acceptance Testing (UAT)

Involved:

- Testers, End-Users

Input:

- Source Code, Test Cases, Test Reports

Output:

- System Test Reports, UAT Reports

Techniques:

- Functional Testing, Performance Testing, Usability Testing

6. Deployment Phase

Sub-phases:

- Release Management
 - Installation and Configuration

Involved:

- Release Managers, System Administrators, Support Staff

Input:

- System Test Reports, UAT Reports

Output:

- Deployed System, User Documentation

Techniques:

- Version Control, Deployment Scripting, User Training

7. Maintenance Phase

Sub-phases:

- Support and Maintenance

- Enhancements and Upgrades

Involved:

- Support Staff, Developers

Input:

- Deployed System, User Feedback, Change Requests

Output:

- Bug Fixes, Software Updates, New Features

Techniques:

- Incident Management, Change Management, Regression Testing

This diagram and summary provide an overview of the main phases of the SDLC, along with
their sub-phases, involved participants, input/output documents, and popular techniques used in
each phase. It serves as a comprehensive reference for understanding the software development
process and the activities involved in each stage.

Popular IS Development Methodologies:

1. **Agile Methodologies**:

- Scrum

- Extreme Programming (XP)

- Kanban

- Lean Software Development

- Crystal

These methodologies are widely used for projects that require flexibility, adaptability, and rapid
delivery. They are well-suited for projects with changing requirements, complex environments,
and a focus on continuous improvement.

2. **Waterfall Model**:

This traditional methodology is best suited for projects with well-defined requirements and
minimal changes during development. It is often used in large-scale projects, particularly in
industries with strict regulations or high risks, such as healthcare, finance, or government sectors.

3. **Iterative and Incremental Methodologies**:

- Rational Unified Process (RUP)

 - Spiral Model

These methodologies are suitable for projects with evolving requirements or a need for frequent
releases. They are commonly used in software development projects where requirements may
change or become more refined during the development process.

4. **V-Model**:

This structured methodology is commonly used in large-scale projects, particularly in industries

that require rigorous testing and documentation, such as aerospace, defense, and automotive
sectors.

5. **Structured Systems Analysis and Design Methodology (SSADM)**:

SSADM is a traditional methodology used for developing information systems, particularly in

government and public sector projects. It emphasizes a structured approach to analysis and
design.

Advantages of using IS Development Methodologies:

1. **Standardization**: Methodologies provide a consistent and standardized approach to

software development, ensuring that projects follow best practices and adhere to established
processes.

2. **Risk Mitigation**: By following a structured methodology, risks can be identified and

mitigated early in the project lifecycle, reducing the likelihood of costly mistakes or failures.
3. **Clear Roles and Responsibilities**: Methodologies define clear roles and responsibilities
for team members, facilitating better collaboration and accountability.

4. **Quality Assurance**: Methodologies often include quality assurance activities, such as

testing and code reviews, to ensure that the software meets the required standards and
specifications.

5. **Improved Communication**: Methodologies establish a common language and framework

for communication among stakeholders, reducing misunderstandings and facilitating effective
collaboration.

6. **Project Management**: Methodologies provide guidelines for project planning, scheduling,

and tracking, enabling better control and management of the development process.

Distinctive Disadvantages of Specific Methodologies:

1. **Waterfall Model**:

- Inflexible and rigid approach, making it difficult to accommodate changes in requirements or

technological advancements.

- Lack of early feedback or working software until late in the project lifecycle.

- Potential for overlooking important requirements or design flaws early on.

2. **SSADM (Structured Systems Analysis and Design Methodology)**:

- Heavily documentation-driven, leading to a significant overhead and potential delays.

 - Rigid and inflexible approach, making it challenging to adapt to changing requirements or
new technologies.

- Perceived as overly bureaucratic and complex, particularly for smaller projects or agile
environments.

3. **V-Model**:

- Highly structured and sequential nature, making it less suitable for projects with rapidly
changing requirements or evolving technologies.

- Potential for delays and rework if defects are discovered late in the testing phase.

- Lack of flexibility and adaptability, which can be challenging in dynamic or innovative

projects.

It's important to note that the choice of methodology depends on the project's specific
requirements, constraints, and organizational culture. Some organizations may adopt a hybrid
approach, combining elements from different methodologies to suit their needs better.

Comparison of Traditional Methodologies and Agile Methods:

Aspect Traditional Methodologies Agile Methods

Project Follows a sequential, linear Iterative and incremental approach, with

Management approach with distinct phases. frequent feedback and adaptation.

Requirements are gathered upfront

Requirements are gathered incrementally
Requirements and expected to remain relatively
and are expected to evolve over time.
stable throughout the project.

Documentation Emphasis on extensive Prioritizes working software over

documentation for each phase, comprehensive documentation, with just
Aspect Traditional Methodologies Agile Methods

which can be time-consuming and enough documentation to support the

costly. project.

Customer involvement is typically Customers or their representatives are

Customer
limited to the initial requirements actively involved throughout the project,
Involvement
gathering and final testing phases. providing feedback and guidance.

Changes to requirements or scope Changes are expected and embraced as

Change
are generally discouraged and can part of the iterative process, allowing for
Management
be costly and disruptive. flexibility and adaptation.

Testing is typically done towards the Testing is integrated throughout the

Testing end of the project, after development project, with frequent testing and
is complete. feedback cycles.
These diagrams illustrate the high-level processes and flow of activities in the Extreme
Programming (XP), Scrum, and Rapid Application Development (RAD) methodologies. They
provide a visual representation of the iterative and incremental nature of these agile approaches,
emphasizing collaboration, frequent feedback, and rapid delivery of working software.

**Feasibility Study Report Contents:**

A typical Feasibility Study Report includes the following sections:

1. Executive Summary

2. Introduction and Background

3. Market Analysis
4. Technical Analysis

5. Financial Analysis

6. Organizational Analysis

7. Risk Assessment

8. Recommendations and Conclusions

The report aims to assess the viability of a proposed project or venture by analyzing various
factors such as market demand, technical feasibility, financial viability, organizational readiness,
and associated risks.

**Information from a Gantt Chart:**

A Gantt Chart is a graphical project management tool that provides the following information:

1. Project Tasks: It lists all the tasks involved in the project.

2. Task Duration: The length of each task is represented by horizontal bars.

3. Task Dependencies: It shows the relationships and dependencies between tasks.

4. Start and End Dates: The chart displays the scheduled start and end dates for each task.

5. Critical Path: It highlights the sequence of tasks that cannot be delayed without impacting the
overall project timeline.

6. Resource Allocation: Some advanced Gantt charts can also display resource assignments for
each task.

7. Progress Tracking: The chart can be updated to reflect the actual progress of tasks.
Gantt charts provide a visual representation of the project schedule, making it easier to
understand the timeline, task sequence, and potential bottlenecks.

**Work Breakdown Structure (WBS) for Creating a Website for APU:**

1. Project Planning

1.1. Define project scope and objectives

1.2. Gather requirements

1.3. Develop project timeline and milestones

2. Design and Development

2.1. Website wireframing and mockups

2.2. User interface (UI) design

2.3. Content creation and management

3. Technical Implementation

3.1. Front-end development (HTML, CSS, JavaScript)

3.2. Back-end development (server-side scripting, database integration)

3.3. Integration of third-party services (e.g., payment gateways, analytics)

4. Testing and Quality Assurance

4.1. Functional testing

4.2. Usability testing

 4.3. Performance testing

5. Deployment and Launch

5.1. Web server configuration

5.2. Content migration and data transfer

5.3. Site go-live and monitoring

6. Maintenance and Support

6.1. Website updates and bug fixes

6.2. Security patches and upgrades

6.3. User support and feedback management

1. Situations where the various software development methodologies can be used and not
suitable to be used:

Waterfall Model:

Can be used: For projects with well-defined and stable requirements, where the project follows a
linear sequence of phases.

Not suitable: For projects with changing requirements, as it is difficult to accommodate changes
once a phase is completed.

Iterative Model:

Can be used: For projects with evolving requirements, where the software can be developed
incrementally through multiple iterations.

Not suitable: For projects with strict deadlines, as the iterative process can be time-consuming
and may lead to delays.

Agile Model:

Can be used: For projects with rapidly changing requirements, where flexibility and
collaboration are essential.

Not suitable: For projects with strict regulatory requirements or critical systems, where a more
structured approach may be necessary.

Spiral Model:
Can be used: For large and complex projects, where risk management is crucial, and
requirements are likely to change.

Not suitable: For small projects with well-defined requirements, as the spiral model may
introduce unnecessary overhead.

2. A simple questionnaire to find out the effectiveness of Webspace-2 in APU:

1. How often do you use Webspace-2?

a. Daily b. Weekly c. Monthly d. Rarely

2. How would you rate the user-friendliness of Webspace-2?

a. Excellent b. Good c. Average d. Poor

3. Does Webspace-2 provide the necessary features and tools for your academic or professional
needs?

a. Yes b. No c. Partially

4. How satisfied are you with the performance and response time of Webspace-2?

a. Very satisfied b. Satisfied c. Neutral d. Dissatisfied e. Very dissatisfied

5. Have you encountered any technical issues or bugs while using Webspace-2?

a. Yes (please specify) _______________ b. No

6. How would you rate the overall effectiveness of Webspace-2 in supporting your academic or
professional activities?

a. Highly effective b. Effective c. Moderately effective d. Ineffective

7. Please provide any additional comments or suggestions for improving Webspace-2.

_______________________________________________________________

3. Group work:

Requirement statements for Webspace-2:

Functional Requirements:

1. The system should allow users to create, edit, and delete files and folders within their allocated
storage space.

2. The system should provide a secure file upload and download mechanism to ensure data
integrity and confidentiality.

Non-Functional Requirements:

1. The system should be highly available, ensuring minimal downtime and reliable access for
users.

2. The system should have a user-friendly interface that is intuitive and easy to navigate.

Performance Requirements:
1. The system should be able to handle a large number of concurrent users without significant
performance degradation.

2. The system should provide fast file transfer speeds to enable efficient data exchange.

Security Requirements:

1. The system should implement robust authentication and authorization mechanisms to protect
user data and prevent unauthorized access.

2. The system should encrypt all data during transmission and storage to maintain data
confidentiality.
 Tutorial 5

Data Analysis Methods:

1. Data Mining:

Advantages:

- Ability to discover hidden patterns and relationships within large datasets.

- Can handle structured and unstructured data from various sources.

- Useful for predictive modeling and forecasting.

- Automated process, reducing human effort and time.

Disadvantages:

- Requires large amounts of data for accurate results.

- Potential for overfitting or finding spurious correlations.

- Complexity of algorithms and techniques can be challenging to understand.

- Privacy and ethical concerns regarding the use of personal data.

2. Statistical Analysis:

Advantages:

- Provides quantitative and objective insights into data.

- Well-established mathematical foundations and proven methods.

- Allows for hypothesis testing and significance analysis.

 - Suitable for smaller datasets and specific research questions.

Disadvantages:

- Relies on assumptions about data distribution and relationships.

- Limited ability to handle large, unstructured datasets.

- May require extensive domain knowledge and expertise.

- Results can be influenced by data quality and sampling methods.

Functional and Non-Functional Requirements for Webspace3 (upgrade of Webspace2):

Functional Requirements:

1. The system should provide a file versioning feature, allowing users to track changes and revert
to previous versions of their files.

2. The system should support collaboration and sharing capabilities, enabling users to share files
and folders with others and work on projects together.

Non-Functional Requirements:

1. The system should have a scalable architecture to accommodate growing user demand and
data storage needs.

2. The system should implement regular data backups and disaster recovery mechanisms to
ensure data integrity and availability in case of system failures or data loss incidents.
 Tutorial 6
A Short History of UML (Unified Modeling Language):

UML (Unified Modeling Language) is a standardized general-purpose modeling language in the

field of software engineering. It was developed in the early 1990s by Grady Booch, Ivar
Jacobson, and James Rumbaugh, who were leading methodologists in the software engineering
community at the time.

In 1994, Booch and Rumbaugh joined forces with Jacobson to create a unified approach to
software design modeling. They combined the best elements of their individual methodologies,
known as the Booch method, the Object-Modeling Technique (OMT), and the Objectory
process, respectively.

The first version of UML, version 0.9, was released in 1996, and it quickly gained popularity
among software developers and architects. In 1997, the Object Management Group (OMG), a
non-profit technology standards consortium, adopted UML as a standard for modeling software
systems.

Over the years, UML has undergone several revisions and updates, with the latest version being
UML 2.5.1, released in 2017. Each new version has introduced new features, improved existing
ones, and addressed various shortcomings to better meet the evolving needs of the software
industry.

UML has become an essential tool in the software development lifecycle, providing a visual way
to capture and communicate the structure, behavior, and architecture of software systems. It is
widely used in various domains, including enterprise applications, real-time systems, and
embedded systems.

Popular UML Diagrams:

1. Class Diagram

2. Use Case Diagram

3. Sequence Diagram

4. Activity Diagram

5. State Machine Diagram

6. Component Diagram

7. Deployment Diagram

Advantages of UML:

1. Standardization: UML provides a common language and notation for modeling software
systems, facilitating communication and understanding among stakeholders.

2. Visual Representation: UML diagrams offer a visual representation of the system, making it
easier to understand and communicate complex concepts.

3. Platform Independence: UML is independent of programming languages and development

platforms, making it useful across various technologies.

4. Design Documentation: UML diagrams serve as documentation for the design of the software
system, aiding in maintenance and future development.
5. Reusability: UML models can be reused across different projects, promoting code reuse and
consistency.

Disadvantages of UML:

1. Complexity: UML has a steep learning curve, and mastering all its diagrams and notations can
be challenging, especially for beginners.

2. Over-engineering: UML can lead to over-engineering if not used judiciously, resulting in

excessive documentation and diagrams that may not be necessary for all projects.

3. Subjectivity: The interpretation and application of UML can be subjective, leading to

inconsistencies and misunderstandings among team members.

4. Tooling Limitations: While UML tools are available, they may have limitations or
compatibility issues, hindering seamless collaboration and sharing of models.

5. Maintenance Overhead: As software systems evolve, keeping UML diagrams up-to-date can
become a significant maintenance overhead.

Despite these disadvantages, UML remains a widely adopted and valuable tool in the software
engineering industry, providing a standardized way to model and document software systems.
 Tutorial 7

This state diagram illustrates the different states and transitions involved in the ATM withdrawal
process. It starts with inserting the card, followed by entering the PIN number. If the PIN is
incorrect, the user is allowed to re-enter it up to three times. If the PIN is correct, the user can
choose the account type and enter the withdrawal amount. If the balance is insufficient, a
message is displayed. Otherwise, the cash is dispensed, a receipt is printed, and the process ends
with the user exiting the ATM.
 Tutorial 8
If you don't adhere to good programming practices, you may face the following major problems:

1. **Code Maintainability**: Poor coding practices can make your code difficult to understand,
modify, and maintain over time. As the codebase grows, it becomes increasingly harder to make
changes or add new features without introducing bugs or breaking existing functionality.

2. **Code Readability**: Poorly written code with inconsistent naming conventions, lack of
comments, and unclear structure can make it challenging for other developers (or even your
future self) to comprehend and work with the codebase.

3. **Performance Issues**: Disregarding best practices for efficiency, such as optimizing

algorithms, managing memory, and utilizing appropriate data structures, can lead to performance
bottlenecks and slower application execution.

4. **Security Vulnerabilities**: Failing to follow secure coding practices, such as input

validation, proper error handling, and encryption techniques, can expose your application to
security risks and potential attacks.

5. **Debugging Difficulties**: Neglecting practices like proper error handling, logging, and
testing can make it extremely difficult to identify and fix bugs, especially in larger and more
complex codebases.

Good programming practices when building an application for mobile phones:

1. **Responsive Design**: Ensure your application follows responsive design principles to
adapt to different screen sizes and resolutions, providing a seamless user experience across
various mobile devices.

2. **Performance Optimization**: Optimize your code for mobile devices, which often have
limited processing power and memory. This includes efficient algorithms, lightweight data
structures, and minimizing unnecessary computations or network requests.

3. **Battery Optimization**: Implement techniques to minimize battery consumption, such as

efficiently managing background processes, optimizing network usage, and minimizing
resource-intensive operations.

4. **Offline Functionality**: Consider implementing offline capabilities, allowing users to

access and interact with the application even when an internet connection is not available.

5. **Gesture and Sensor Integration**: Leverage mobile-specific features like gestures (swipe,
pinch, etc.), accelerometer, GPS, and camera to provide a more intuitive and engaging user
experience.

6. **Modular Design**: Adopt a modular design approach, separating concerns and

functionality into reusable components, making it easier to maintain and update the application.

7. **Testing and Debugging**: Implement comprehensive testing strategies, including unit

testing, integration testing, and user acceptance testing, to ensure the application functions
correctly across various devices and scenarios. Utilize mobile-specific debugging tools and
techniques.
8. **Security and Data Protection**: Implement secure coding practices, such as data
encryption, secure authentication, and protection against common mobile threats like data
leakage and unauthorized access.

9. **Accessibility**: Ensure your application is accessible to users with disabilities by following

accessibility guidelines and best practices for mobile platforms.

10. **Adherence to Platform Guidelines**: Follow the platform-specific guidelines and design
patterns provided by mobile operating systems (e.g., Android Material Design, iOS Human
Interface Guidelines) to ensure a consistent and familiar user experience.

• Advantages of Software Testing:

1. **Quality Assurance**: Software testing helps identify defects, bugs, and issues in the
software, ensuring that the final product meets the desired quality standards and user
requirements.

2. **Cost Savings**: Detecting and fixing issues during the testing phase is typically less
expensive than addressing them after the software is released and deployed in a production
environment.

3. **User Satisfaction**: Thorough testing helps ensure that the software functions as expected,
leading to improved user satisfaction and a better overall experience.
4. **Risk Mitigation**: Testing helps identify potential risks and vulnerabilities, allowing
developers to address them before the software is released, reducing the likelihood of security
breaches, data loss, or system failures.

5. **Compliance and Regulatory Requirements**: Software testing is often a mandatory step in

industries with strict regulatory requirements, such as finance, healthcare, and aviation, to ensure
compliance with industry standards and regulations.

• Disadvantages of Software Testing:

1. **Time and Cost**: Software testing can be a time-consuming and resource-intensive process,
especially for large and complex software systems, which can increase development costs and
delay product releases.

2. **Exhaustive Testing is Impossible**: Testing every possible scenario, input, and

combination of conditions is practically impossible, especially for complex software systems,
which means that some defects may still go undetected.

3. **Skill and Experience Requirements**: Effective software testing requires skilled and
experienced testers who understand the software, testing methodologies, and tools, which can be
challenging to find and retain.

4. **Test Environment Setup**: Setting up realistic test environments that accurately mimic
production environments can be complex and costly, especially for distributed or cloud-based
systems.
5. **Maintenance Overhead**: Test cases, scripts, and automation tools need to be maintained
and updated as the software evolves, adding to the overall maintenance overhead.

• 3 Testing Tools (software) that can be used to test other software:

1. **Selenium**: An open-source suite of tools for automating web browser interactions,

primarily used for web application testing.

2. **JUnit**: A unit testing framework for Java programming language, widely used for writing
and executing unit tests.

3. **Katalon Studio**: A comprehensive test automation solution that supports web, mobile, and
API testing, with built-in integration with various tools and frameworks.

• Simple Test Plan to test 3 functions of Webspace-2:

**Function 1: File Upload**

Test Case 1: Verify that a user can upload a file successfully.

Test Case 2: Verify that an error message is displayed when attempting to upload a file with an
invalid format or extension.

Test Case 3: Verify that the uploaded file is accessible and can be downloaded correctly.

**Function 2: Folder Creation**

Test Case 4: Verify that a user can create a new folder successfully.
Test Case 5: Verify that an error message is displayed when attempting to create a folder with an
invalid name or in an invalid location.

Test Case 6: Verify that the created folder can be accessed, and files can be added to it.

**Function 3: File Sharing**

Test Case 7: Verify that a user can share a file or folder with another user successfully.

Test Case 8: Verify that the shared file or folder is accessible to the recipient with the correct
permissions.

Test Case 9: Verify that the file or folder sharing can be revoked, and the recipient can no longer
access the shared content.

For each test case, include the following details:

- Test Case ID

- Test Case Description

- Prerequisites

- Test Steps

- Expected Results

- Actual Results

- Pass/Fail Status

Additionally, include sections for test environment setup, test data requirements, and any
assumptions or constraints related to the testing process.

• Common problems faced during System Deployment:

1. **Compatibility Issues**: Ensuring that the new system is compatible with existing hardware,
software, operating systems, and network infrastructure can be challenging, leading to potential
conflicts and issues during deployment.

2. **Data Migration**: Transferring data from the old system to the new system can be a
complex and error-prone process, especially when dealing with large datasets, different data
formats, or legacy systems.

3. **Environmental Differences**: Differences between the development, testing, and

production environments can lead to unforeseen issues, such as configuration mismatches,
dependencies, or performance discrepancies.

4. **User Resistance**: End-users may resist adopting the new system due to a lack of training,
fear of change, or perceived disruptions to their existing workflows, leading to user adoption
challenges.

5. **Downtime**: Deploying a new system often requires taking the old system offline,
resulting in downtime and potential disruptions to business operations, which can be costly and
impact productivity.

6. **Security Risks**: Deploying a new system can introduce potential security vulnerabilities if
proper security measures, access controls, and hardening practices are not followed.

7. **Resource Constraints**: Deploying a new system may require additional hardware,

software, or personnel resources, which can be limited or constrained by budgets or availability.
• Deploying Websites and Web Applications - Differences:

Deploying websites and web applications share some similarities, but there are distinct
differences:

1. **Scalability**: Web applications often require more scalability considerations, such as load
balancing, clustering, and autoscaling, to handle varying user loads and traffic spikes effectively.

2. **Data Persistence**: Web applications typically require persistent data storage, such as
databases, which introduces additional complexities in deployment, migration, and backup
processes compared to static websites.

3. **Server-side Processing**: Web applications involve server-side processing and logic, which
may require additional configurations, dependencies, and compatibility checks during
deployment.

4. **Session Management**: Web applications often require session management and state
handling mechanisms, which can introduce additional deployment considerations related to
session persistence and clustering.

5. **Security**: Web applications typically handle sensitive data and user interactions,
necessitating more robust security measures, such as authentication, authorization, and input
validation, which need to be properly configured during deployment.
6. **Continuous Integration and Deployment**: Web applications often benefit from continuous
integration and deployment pipelines, allowing for more frequent and automated deployments,
whereas websites may have less frequent and manual deployment processes.

• Deploying Webspace-3 to replace Webspace-2 using different changeover methods:

1. **Direct Changeover**:

- This method involves directly replacing Webspace-2 with Webspace-3 in a single

step.
- Webspace-2 would be taken offline, and Webspace-3 would be deployed and
made available to users.
- Advantages: Simple and straightforward process, no need for parallel
environments.
- Disadvantages: Potential for significant downtime, increased risk of disruptions,
and limited rollback options if issues arise.

2. **Parallel Changeover**:

- Both Webspace-2 and Webspace-3 would be running in parallel for a period of

time.
- Users would be gradually migrated from Webspace-2 to Webspace-3, allowing
for testing and validation.
- Advantages: Reduced downtime, ability to roll back changes if issues arise, and
easier data migration.
- Disadvantages: Increased complexity, potential for data inconsistencies, and
higher resource requirements (hardware, personnel) during the parallel phase.

3. **Pilot Changeover**:
 - Webspace-3 would be deployed initially to a subset of users or a specific
department/faculty for pilot testing and evaluation.
- Based on feedback and testing results, adjustments can be made before a wider
rollout.
- Advantages: Allows for controlled testing and feedback, reduces overall risk, and
enables gradual adoption.
- Disadvantages: Increased complexity, potential for data inconsistencies between
pilot and non-pilot users, and extended deployment timeline.

4. **Phased Changeover**:

- Webspace-3 would be deployed in phases, gradually replacing Webspace-2 for

different user groups, departments, or functionalities.
- Each phase would involve deploying, testing, and stabilizing Webspace-3 for a
specific set of users or features.
- Advantages: Reduced risk, ability to address issues in a controlled manner, and
gradual adoption for users.
- Disadvantages: Increased complexity, potential for data inconsistencies between
phases, and extended deployment timeline.

The choice of the changeover method would depend on factors such as the complexity of the
new system, potential risks, available resources, user impact, and the criticality of the service.
Careful planning, testing, and communication with stakeholders are essential for a successful
deployment, regardless of the method chosen.
Here are 5 good practices specifically for System Development Methodologies (SDMs):

1. Choose the Right SDM:

- Evaluate the project requirements, team skills, and constraints

- Select an SDM that aligns with the project's needs (e.g., Waterfall for well-defined
requirements, Agile for rapidly changing requirements)

- Consider hybrid approaches if a single SDM doesn't fit all your needs

2. Stakeholder Involvement:

- Involve stakeholders (users, clients, subject matter experts) throughout the development
process

- Gather requirements, feedback, and buy-in from stakeholders regularly

- Conduct user acceptance testing (UAT) with stakeholders before final delivery

3. Iterative and Incremental Development:

- Break down the project into smaller, manageable iterations or increments

- Deliver working software at the end of each iteration/increment

- Incorporate feedback and changes in subsequent iterations/increments

4. Continuous Integration and Testing:

- Set up a continuous integration (CI) pipeline for automated builds and testing
 - Implement unit tests, integration tests, and end-to-end tests

- Automate testing as much as possible to catch issues early

5. Documentation and Knowledge Sharing:

- Document the system requirements, design decisions, and architecture

- Maintain up-to-date project documentation throughout the development lifecycle

- Encourage knowledge sharing among team members through code reviews, pair
programming, or knowledge transfer sessions

By following these practices, you can increase the chances of successful system development,
adaptability to changes, and stakeholder satisfaction while adhering to the principles and
practices of the chosen SDM.