Practical SE (SRS) 2

Soft
Software Engineering (3161605)
A Laboratory Manual for
SOFTWARE ENGINEERING
(3161605)
B.E. Semester 6 (Information Technology)
Directorate of Technical Education, Gandhinagar,

Gujarat.
Soft
Preface
The main motto of any laboratory/practical/field work is to enhance required skills and create ability
amongst students to solve real-time problems by developing relevant competencies in the psychomotor
domain. By keeping this in view, GTU has designed a competency-focused outcome- based curriculum
for engineering degree programs where sufficient weightage is given to practical work. It shows the
importance of enhancement of skills amongst the students, and it pays attention to utilizing every second
of time allotted for practicals amongst students, instructors, and faculty members to achieve relevant
outcomes by performing the experiments rather than merely study-type experiments. It is a must for the
effective implementation of a competency-focused outcome-based curriculum that every practical is
keenly designed to serve as a tool to develop and enhance relevant competency required by the various
industry among every student. These psychomotor skills are very difficult to develop through traditional
chalk-and-board content delivery methods in the classroom. Accordingly, this lab manual is designed
to focus on industry-defined relevant outcomes rather than the old practice of conducting practicals to
prove concepts and theories.
By using this lab manual, students can go through the relevant theory and procedure in advance before
the actual performance, which creates interest, and students can have a basic idea prior to the
performance. This, in turn, enhances pre-determined outcomes amongst students. Each experiment in
this manual begins with competency, industry-relevant skills, course outcomes as well as practical
outcomes (objectives). The students will also achieve safety and necessary precautions to be taken while
performing practical.
This manual also provides guidelines to faculty members to facilitate student-centric lab activities
through each experiment by arranging and managing necessary resources in order that the students
follow the procedures with required safety and necessary precautions to achieve the outcomes. It also
gives an idea of how students will be assessed by providing rubrics.
Software Engineering is an application of a systematic, defined, and measurable approach that begins
with requirement specification and progresses with planning, modeling, and testing, and concludes with
deployment. It is a layered paradigm that comprises processes, methods, and tools with the bedrock of
quality focus. The Software Engineering approach's main purpose is committed to developing the
software products within the stipulated time and budget with more quality. Quality product motivates
firmness, commodity, and delight.
Utmost care has been taken while preparing this lab manual; however ,there is always a chance of
improvement. Therefore, we welcome constructive suggestions for improvement and removal of
errors, if any.
Soft
Practical – Course Outcome matrix
Course Outcomes (COs):

CO-1: Prepare SRS (Software Requirement Specification) document and SPMP (Software Project
Management Plan) document.
CO-2: Apply the concept of Functional Oriented and Object-Oriented Approaches for Software Design.
CO-3. Recognize how to ensure the quality of software products, different quality standards, and
software review techniques.
CO-4. Apply various testing techniques and test plans in.
CO-5. Able to understand modern Agile Development
Sr.
Objective(s) of Experiment CO1 CO2 CO3 CO4 CO5
No.
Study of various type of Software Process models with
comparison and find out which process model will be
1. √
appropriate for your selected Project.
Discuss the Project Management: Project Planning and

2. √ √
Project Scheduling about your Project.
Prepare the Software Requirement Specification (SRS)
3. √ √
document for selected project.
4. Draw the Data Flow Diagram for your selected Project. √ √
Draw the Entity-Relationship Diagram for your selected

5. Project √ √
Draw Usecase Diagram for your selected Project.

6. √ √
Solve the problem by applying basic COCOMO model.

7. √ √
8. Modeling UML Class Diagrams and Sequence diagrams √ √

Design the various test cases to perform the testing of the
9. √ √
system and also perform the various type of testing.
Study of any two Open source tools in DevOps for
Infrastructure Automation, Configuration Management
10. √
Deployment Automation, Performance Management, Log
Management Monitoring.
Soft
Industry Relevant Skills
The following industry relevant competency is expected to be developed in the student by

undertaking the practical work of this laboratory.
1. Apply knowledge of Process Models for the development of software.

2. Understand the concept of Software requirement Specification (SRS) document for project
development.
Guidelines for Faculty members
1. Teacher should provide the guideline with demonstration of practical to the students with
all features.
2. Teacher shall explain basic concepts/theory related to the experiment to the students before
starting of each practical
3. Involve all the students in performance of each experiment.
4. Teacher is expected to share the skills and competencies to be developed in the students
and ensure that the respective skills and competencies are developed in the students after
the completion of the experimentation.
5. Teachers should give opportunity to students for hands-on experience after the
demonstration.
6. Teacher may provide additional knowledge and skills to the students even though not covered
in the manual but are expected from the students by concerned industry.
7. Give practical assignment and assess the performance of students based on task assigned to
check whether it is as per the instructions or not.
8. Teacher is expected to refer complete curriculum of the course and follow the guidelines
for implementation.
9.
Instructions for Students
1. Students are expected to carefully listen to all the theory classes delivered by the faculty members
and understand the COs, content of the course, teaching and examination scheme, skill set to be
developed etc.
2. Students shall organize the work in the group and make record of all observations.
3. Students shall develop maintenance skill as expected by industries.
4. Student shall attempt to develop related hand-on skills and build confidence. Student shall develop the
habits of evolving more ideas, innovations, skills etc. apart from those included in scope of manual.
5. Student shall refer technical magazines and data books.Student should develop a habit of submitting the
experimentation work as per the schedule andshe/he should be well prepared for the same. included in scope of
manual.
6. Student shall refer technical magazines and data books.
7. Student should develop a habit of submitting the experimentation work as per the schedule and
she/he should be well prepared for the same.
Soft
Soft
Soft
Index (Progressive Assessment Sheet)
Sr. Objective(s) of Experiment Page Date of Date of Assessmen Sign. of Remar

No. No. perform submiss t Teacher ks
ance ion Marks with date
1 Study of various type of Software Process
models with comparison and find out which
process model will be appropriate for your
selected Project.
2 Discuss the Project Management: Project
Planning and Project Scheduling about your
Project.
3 Prepare the Software Requirement
Specification (SRS) document for selected
project.
4 Draw the Data Flow Diagram for your selected
Project.
5 Draw the Entity-Relationship Diagram for your
selected Project
6 Draw Usecase Diagram for your selected
Project.
7 Solve the problem by applying basic
COCOMO model.
8 Modeling UML Class Diagrams and
Sequence diagrams
9. Design the various test cases to perform the
testing of the system and also perform the
various type of testing.
10. Study of any two Open source tools in DevOps
for Infrastructure Automation, Configuration
Management ,Deployment Automation,
Performance Management, Log
Management Monitoring.
Total
included in scope of manual.

8. Student shall refer technical magazines and data books.
9. Student should develop a habit of submitting the experimentation work as per the schedule and
she/he should be well prepared for the same.
Soft
General Guidelines for Software Engineering Laboratory Work
1. Student has to perform all the practical as described in the practical list.
2. For performing the practical list, student can able to work individually or work in a team as per
subject teacher guidelines.
3. After establishing the team, every team will have to identify the problem area / definition for
performing the laboratory work.
4. Every team has to approve their problem definition to respective faculty member within 15 days
of the beginning of the semester.
5. Once the problem definition is approved by the faculty member, every team has to perform all
the practical based on their respective problem definition.
Soft
Practical – 1
AIM: Study of various type of Software Process models with comparison and find out which process
model will be appropriate for your selected Project.
Objectives: To learn different process models and identify suitable model for the project development.
• Theory:
A software process is defined as a collection of work activities, actions, and tasks that are
performed when some work product is to be created.
List of Different Process Models
 Waterfall model.
The Waterfall model progresses through several distinct phases:
1. Requirement Gathering and

Analysis: In this initial phase, all the
necessary requirements for the
system are identified and documented
in a specification requirement
document.
2. System Design: Building upon the
requirements gathered, this phase
Involves creating a detailed system
design. This design specifies the
hardware and system requirements
and defines the overall system
architecture. Figure 1:Waterfall Model
3. Implementation: Based on the system design, the actual system is developed in small units or
programs. Each unit is developed and tested individually in a process known as Unit Testing.
4. Integration and Testing: Once all the individual units are developed and tested, they are integrated into
a complete system. The integrated system is then tested thoroughly for any faults or failures.
5. Deployment of the System: After successful testing, the product is deployed in the customer environment
or released into the market.
6. Maintenance: As the system is used in the client environment, issues may arise. To address these, patches
are released. Additionally, new versions of the product may be released to enhance its features.
Maintenance ensures that these changes are delivered to the customer environment.
Soft
2. V model.
• Verification: This phase

includes a static analysis method,
such as a review which is conducted
without executing the code. It
evaluates the product development
process to determine if specified
requirements are met.
• Validation: This phase involves a
dynamic analysis method, including
functional and non-functional
testing, which is performed by
executing the code. Validation
classifies the software after the
development process to ascertain if
it meets customer expectations and Figure 2:V Model
requirements.
• The V-Model incorporates
Verification phases on one side and Validation phases on the other side. The Verification and Validation
processes are connected by the coding phase in a V-shape, hence its name. Here are the various phases
of the Verification Phase in the V-model:
1. Business Requirement Analysis: This initial step involves understanding the product requirements from
the customer's perspective. It requires detailed communication to grasp the customer's expectations and
exact requirements.
2. System Design: In this stage, system engineers analyze and interpret the business aspects of the proposed
system by studying the user requirements document.
3. Architecture Design: The architecture design phase involves selecting a baseline architecture that
comprehensively addresses all requirements. This typically includes a list of modules, brief functionality
of each module, interface relationships, dependencies, database tables, architecture diagrams, technology
details, etc. Integration testing is also carried out in this phase.
4. Module Design: During this phase, the system is broken down into small modules. Detailed designs of
these modules are specified, which is known as Low-Level Design.
5. Coding Phase: After the design phase, the coding phase begins. Based on the requirements, a suitable
programming language is chosen. Coding is done following specific guidelines and standards. Before
checking in the repository, the final build is optimized for better performance. The code also undergoes
many code reviews to ensure its performance.
Soft
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.
• Incremental model.
The Incremental Model of software development

Progress through several phases:
1. Requirement Analysis: In this initial phase,
the product analysis experts identify the
requirements. The requirement analysis
team understands the system's functional
requirements, which plays a crucial
role in developing software under the
incremental model.
2. Design & Development: This phase completes the design of the system functionality and the development
of the method. The incremental model uses the design and development phase when developing new
functionality.
3. Testing: The testing phase in the incremental model checks the performance of each existing function and
any additional functionality. Various methods are used to test the behavior of each task.
4. Implementation: The implementation phase enables the coding phase of the development system. It
involves the final coding designed in the design and development phase and tests the functionality from the
testing phase. After this phase, the product's working functionality is enhanced and upgraded to the final
system product.
The Incremental Model is used in the following scenarios:
• When requirements are complex: Breaking them down into smaller chunks makes them easier to handle.
• For lengthy development schedules: Incremental development allows for regular releases, keeping
stakeholders engaged.
• With less experienced teams: It allows for learning and improvement over successive iterations.
Soft
• When quick product releases are required: Incremental development enables rapid, iterative
improvements.
• For prioritized requirements: Allows development of high-priority features first, ensuring essential
functionality is delivered early.
• RAD model.
Figure 4: RAD Model
The various phases of RAD are as follows:
1. Business Modelling: This phase defines the flow of information among business functions. It answers
questions like what data drives the business process, who generates it, where does it go, who processes it,
and so on.
2. Data Modelling: The data collected from business modeling is refined into a set of data objects (entities)
needed to support the business. Attributes (characteristics of each entity) are identified, and the
relationships between these data objects (entities) are defined.
3. Process Modelling: Information objects 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: This phase involves using automated tools to facilitate the construction of the
software.
5. Testing & Turnover: Many of the programming components have already been tested since RAD
emphasizes reuse. This reduces overall testing time. However, the new parts must be tested, and all
interfaces must be fully exercised
 Agile model.
Soft
Figure 5: Agile Model
Phases of Agile Model:

1. Requirements gathering: In this phase, the requirements are defined. It involves explaining business
opportunities and planning the time and effort needed to build the project. Based on this information,
technical and economic feasibility can be evaluated.
2. Designing: Once the project is identified, stakeholders work together to define requirements. User flow
diagrams or high-level UML diagrams can be used to illustrate the workflow of new features and how they
will integrate with the existing system.
3. Construction/ iteration: After the requirements are defined, the work begins. Designers and developers
start working on the project, aiming to deploy a working product. The product undergoes various stages of
improvement, including the inclusion of simple, minimal functionality.
4. Testing: In this phase, the Quality Assurance team examines the product's performance and looks for bugs.
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:

1. Scrum
2. Crystal
3. Dynamic Software Development Method (DSDM)
4. Feature Driven Development (FDD)
5. Lean Software Development
6. extreme Programming (XP)
When to use the Agile Model?

• When frequent changes are required.
• When a highly qualified and experienced team is available.
• When a customer is ready to have a meeting with a software team all the time.
Soft
• Iterative model.
Figure 6:Iterative Model
The various phases of Iterative model are as follows:

1. Requirement gathering & analysis: In this phase, requirements are gathered from customers and
analyzed by an analyst to ensure they can be fulfilled within budget. Once this is done, the software team
moves on to the next phase.
2. Design: During the design phase, the team creates the software using various diagrams such as Data Flow
diagrams, activity diagrams, class diagrams, and state transition diagrams When project size is small.
3. Implementation: In the implementation phase, the requirements are translated into code and transformed
into computer programs, which form the software.
4. Testing: After the coding phase is completed, software testing begins using different methods such as
white box, black box, and grey box testing.
5. Deployment: Once all the phases are completed, the software is deployed to its working environment.
6. Review: After the software is deployed, a review phase is conducted to check the behavior and validity of
the product. If any errors are found, the process starts again from the requirement gathering phase.
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.
Soft
 Spiral model.
Figure 7:Spiral Model
Each cycle in the spiral is divided into four parts:
1. 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.
2. 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.
3. 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.
4. 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.
Soft
• 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
• Requirement Gathering and Analyst

• Quick Decision
• Build a Prototype
• Assessment or User Evaluation
• Prototype Refinement
• Engineer Product
1. Which process model will be appropriate for your selected Project?

Our project is "Stock trend prediction website", the focus of this project is to forecast the future prices of
stocks based on historical data, news articles, Social media sentiments, and other factors. The main goal
of this website project is to provide investors and traders with useful insights and guidance for making
informed decision in the stock market.
In this project the “Agile Model” is used as the arguable is most popular software developing life cycle
model because :-
Soft
(a) Flexibility and Adaptability: Agile methodologies, like Scrum and Kanban, prioritize responding to
change over following a rigid plan. This flexibility allows teams to adapt quickly to evolving
requirements, market conditions, or stakeholder feedback, enabling them to deliver valuable software
increments more effectively.
(b) Customer Collaboration: Agile places a strong emphasis on customer collaboration throughout the
development process. By involving customers or stakeholders in regular feedback sessions, Agile teams
ensure that the delivered software meets their expectations and addresses their needs more accurately,
resulting in higher customer satisfaction.
(c) Faster Time-to-Market: Agile methodologies promote iterative development and incremental delivery
of working software. This approach allows for faster delivery of usable features or products, enabling
businesses to respond to market demands more swiftly and gain a competitive edge.
(d) Improved Quality: Agile practices, such as continuous integration, automated testing, and frequent code
reviews, contribute to higher software quality. By testing and validating software increments regularly,
Agile teams can identify and address issues early in the development process, leading to fewer defects
and higher overall product quality.
(e) Enhanced Team Collaboration: Agile fosters a collaborative and cross-functional team environment.
Team members work closely together, share knowledge and responsibilities, and collectively work
towards achieving project goals. This collaborative approach promotes innovation, creativity, and
shared ownership of the project, resulting in higher team morale and productivity.
(f) Better Risk Management: Agile methodologies, particularly the iterative nature of development, allow
teams to identify and mitigate risks early in the project lifecycle. By breaking down the project into
smaller iterations and focusing on delivering value incrementally, Agile teams can address risks
proactively, making the project more resilient to potential challenges or uncertainties.
2. Give reasons why all other life cycle models are not selected for this project.
The Agile model is chosen for "Stock Trend Prediction" due to its adaptability and responsiveness, key
for a project evolving with user feedback and market trends. Other models were considered but deemed
less suitable:
• Waterfall Model:
This model is linear and sequential, which means each phase depends on the deliverables of the
previous one. Changes are difficult to implement once the project is underway. In a field like stock
trend prediction, where market conditions can change rapidly, this inflexibility can be a significant
drawback.
• V Model:
Similar to the Waterfall model, the V-Model is also a sequential path of execution of processes. Any
changes in midway or any error that is encountered in the life cycle can be corrected only after the
completion of the entire process. This lack of flexibility can be problematic in a dynamic field like
stock trend prediction.
Soft
• Incremental Model:
For a stock trend prediction website, this model might not be ideal because it requires a clear
understanding of all requirements from the beginning, which might not be possible given the
dynamic nature of stock markets.
• RAD Model (Rapid Application Development):

RAD requires a high degree of customer interaction and the product is developed in a series of
incremental releases. While suitable for projects with a well-defined set of requirements, it might
not be ideal for a stock trend prediction website where requirements could change rapidly with
market conditions.
• Spiral Model:
While the Spiral model allows for early prototyping and constant improvements, it can be complex
and costly. It’s designed for large and complicated projects. A stock trend prediction website might
not require this level of complexity.
• Prototype Model:
Excluded due to concerns about limited scalability, as prototyping emphasizes quickly building and
refining a model, which could become challenging for " stock trend prediction website ".
• Iterative Model:
The Iterative model could be a viable option as it develops the system through repeated cycles and
in smaller portions at a time. However, it may require more resources than Agile as it involves
repeating phases multiple times until the final system is achieved.
In summary, the Agile model is selected for "Travelling Mate" due to its adaptability and responsiveness,
aligning well with the project's dynamic nature and goals of providing an engaging virtual tourism
experience.
Soft
Quiz:
1. Compare waterfall model and incremental model.
2. State weather the following statements are true or false. Justify your answer.
a) Software development organizations which follow the iterative waterfall model forproduct
development provide maximum customer satisfaction.
Soft
b) The loops for spiral model are fixed.
Suggested Reference:
1. Ian Sommerville, Software engineering, Pearson education Asia
2. Roger S.Pressman, Software Engineering- A practitioner‟s Approach, McGraw-Hill International Editions
References used by the students:

https://www.tutorialspoint.com/sdlc/index.htm
https://www.javatpoint.com/software-engineering-prototype-model
Soft
Rubric wise marks obtained:
Rubrics 1 2 3 4 5 Total
Marks Complete Complete Complete Complete Complete

implementation as implementation as implementation as implementation as implementation as
asked asked asked asked asked
Problem analysis Problem analysis Problem analysis Problem analysis
Development of the Development of the Development of the

Solution Solution Solution
Concept Clarity & Concept Clarity &

understanding understanding
Correct answer to all

questions
Signature of Faculty:
Soft
Practical – 2
AIM: Discuss the Project Management: Project Planning and Project Scheduling about your Project.
Objectives:
1. To represent the plan to deliver the project scope over time.
Theory:
Once a project is found to be feasible, software project managers undertake project planning. Project
planning is undertaken and completed even before any development activity starts. Project planning
consists of the following essential activities:
Project-task scheduling is an important project planning activity. It involves deciding which tasks
would be taken up when. In order to schedule the project activities, a software project manager needs to
do the following:
1. Identify all the tasks needed to complete the project.
1. Project Initiation Phase

• Define project scope and objectives.
• Identify stakeholders.
• Formulate project team.
2. Research and Planning
• Research stock market data sources.
• Research existing prediction algorithms and models.
• Define the prediction model's requirements and specifications.
• Plan data acquisition strategy.
• Plan the project schedule and budget.
3. Data Collection:
• Gather historical stock market data.
• Collect relevant financial indicators (e.g., price, volume, volatility).
• Obtain any supplementary data required for analysis (e.g., economic indicators, news
sentiment).
4. Data Preprocessing
• Cleanse and preprocess raw data.
• Handle missing values and outliers.
• Normalize or scale data for consistency.
5. Algorithm Development:
• Select appropriate machine learning or statistical models for prediction.
• Develop and train prediction algorithms.
• Optimize algorithms for accuracy and efficiency.
• Validate algorithms using historical data.
6. Website Design and Development
• Design user interface mockups and wireframes.
• Develop frontend components for the website.
Soft
7. Backend Development:
• Set up server infrastructure.
• Develop backend logic for data processing and prediction.
• Implement APIs for communication between frontend and backend.
• Integrate data storage solutions for managing user data and preferences.
8. Testing and Validation:

• Perform unit testing for individual components.
• Conduct integration testing to ensure proper functioning of the entire system.
• Validate prediction accuracy against test datasets.
• Identify and debug any errors or discrepancies.
9. Deployment:
• Prepare for deployment to production environment.
• Configure servers and databases.
• Deploy the website and prediction model.
• Monitor system performance and stability post-deployment.
10. Documentation and Training:

• Document project processes, algorithms, and system architecture.
• Create user guides and tutorials for using the website.
• Provide training for administrators and users as necessary.
11. Maintenance and Updates:

• Monitor data quality and update data sources as needed.
• Address user feedback and bug reports.
• Implement enhancements or new features based on market trends or user demand.
2. Break down large tasks into small activities.

i. Data Collection
ii. Data Preprocessing
iii. Algorithm Development
iv. Website Design and Development
v. Backend Development
3. Determine the dependency among different activities.
1. Data Collection:
• Dependencies:
• Dependent on: Availability of data sources, access permissions, and data fetching tools.
• Precedes: Data preprocessing, algorithm development.
• Predecessor to:
• Data preprocessing: Requires raw data for cleansing and transformation.
• Algorithm development: Needs historical data for training and validation.
2. Data Preprocessing:
• Dependencies:
• Dependent on: Completion of data collection phase.
• Precedes: Algorithm development, model training.
Soft
• Predecessor to:
• Algorithm development: Cleaned and preprocessed data are inputs for building predictive
models.
• Model training: Preprocessed data is used to train and validate prediction algorithms.
• Dependencies:
• Dependent on: Availability of preprocessed data, selection of appropriate algorithms.
• Precedes: Model validation, website development.
• Predecessor to:
• Model validation: Developed algorithms are tested and evaluated for performance.
• Website development: Prediction models are integrated into the website for user
interaction.
4. Website Design and Development:

• Dependencies:
• Dependent on: Finalization of website requirements, availability of frontend and backend
developers.
• Precedes: Deployment, user testing.
• Predecessor to:
• Deployment: Completed website is deployed to production servers for public access.
• User testing: Users interact with the website to identify any usability issues or bugs.
• Dependencies:
• Dependent on: Finalization of backend requirements, availability of backend developers.
• Precedes: Integration with frontend, deployment.
• Predecessor to:
• Integration with frontend: Backend services are connected to the frontend for data
exchange.
• Deployment: Backend infrastructure is set up and configured before deploying the
website.
4. Establish the most likely estimates for the time durations necessary to complete the activities.
1. Data Collection:
• Estimated Duration: 2-3 weeks
• Explanation: Gathering historical stock market data and obtaining necessary permissions may take some
time. Depending on the complexity of data sources and the availability of APIs, it could take 2-3 weeks
to collect a sufficient amount of data.
• Explanation: Cleaning and preprocessing raw data, handling missing values, and performing exploratory
data analysis can be time-consuming. It may take 1-2 weeks to preprocess the data adequately for further
analysis.
Soft
• Explanation: Developing and optimizing prediction algorithms involves experimenting with various
machine learning models, feature engineering techniques, and hyperparameter tuning. It typically
requires iterative testing and refinement, which can span 4-6 weeks.

• Explanation: Designing the website layout, creating wireframes and mockups, and developing frontend
components may take 3-4 weeks. This includes implementing interactive features, ensuring
responsiveness across different devices, and refining the user interface.
• Explanation: Setting up server infrastructure, developing backend logic, and implementing APIs can take
2-3 weeks. This includes integrating with databases, implementing authentication mechanisms, and
testing backend services.

• Explanation: Testing the website for functionality, performance, and compatibility, as well as validating
prediction algorithms against test datasets, may require 1-2 weeks. This involves conducting unit tests,
integration tests, and user acceptance testing.
7. Deployment:
• Estimated Duration: 1 week
• Explanation: Deploying the website to production servers, configuring server infrastructure, and ensuring
proper setup may take around 1 week. This includes finalizing security measures, monitoring tools, and
deployment pipelines.

• Estimated Duration: Ongoing throughout the project
• Explanation: Documentation and training activities should be carried out continuously throughout the
project. This includes documenting processes, algorithms, and system architecture, as well as creating
user guides and tutorials. Ongoing maintenance and updates should also be accounted for in the project
timeline.
5. Allocate resources to activities.
1. Data Collection:
• Resources:
• Data scientists or analysts to research and gather historical stock market data.
• Access to financial APIs or data providers.
• Computing resources for data storage and processing.
• Resources:
• Data scientists or analysts skilled in data cleaning and preprocessing techniques.
• Computing resources for data manipulation and transformation.
Soft
• Resources:
• Data scientists or machine learning engineers to develop prediction algorithms.
• Software developers proficient in machine learning frameworks (e.g., scikit-learn, TensorFlow).
• Access to computing resources for model training and experimentation.

• Resources:
• Frontend developers to design and implement the website interface.
• UI/UX designers to create wireframes and mockups.
• Graphic designers for creating visual assets.
• Tools for frontend development (e.g., HTML/CSS, JavaScript frameworks).
• Collaboration platforms for design reviews and feedback.
• Resources:
• Backend developers to build server infrastructure and implement backend logic.
• Database administrators for database setup and management.
• DevOps engineers for server configuration and deployment automation.
• Tools for backend development (e.g., backend frameworks like Django or Flask, database
management systems like PostgreSQL or MongoDB).
6. Testing and Validation:s

• Resources:
• Quality assurance (QA) engineers to conduct testing and validation.
• Test environments and tools for automated testing (e.g., Selenium, JUnit).
• Access to testing datasets and simulation environments.
• Collaboration platforms for reporting and tracking bugs.
7. Deployment:
• Resources:
• DevOps engineers to handle deployment to production servers.
• System administrators for server configuration and maintenance.
• Continuous integration/continuous deployment (CI/CD) pipelines for automated deployment.
• Monitoring tools for tracking system performance post-deployment.

• Resources:
• Technical writers to document project processes, algorithms, and system architecture.
• Trainers or subject matter experts to create user guides and tutorials.
• Collaboration platforms for knowledge sharing and documentation management.
6. Plan the starting and ending dates for various activities.
1. Data Collection:
• Starting Date: Month 1, Day 1
• Ending Date: Month 1, Day 21
Soft


7. Deployment:

• Ongoing throughout the project, with completion by Month 6, Day 15
7. Determine the critical path.
A critical path is the chain of activities that determines the duration of the project. The first step in
scheduling a software project involves identifying all the tasks necessary to complete the project. A
good knowledge of the intricacies of the project and the development process helps the managers to
effectively identify the important tasks of the project. Next, the large tasks are broken down into a
logical set of small activities which would be assigned to different engineers. The work breakdown
structure formalism helps the manager to breakdown the tasks systematically after the project manager
has broken down the tasks and created the work breakdown structure, he has to find the dependency among
the activities.
Dependency among the different activities determines the order in which the different activities would
be carried out. If an activity A requires the results of another activity B, then activity A must be scheduled
after activity B. In general, the task dependencies define a partial ordering among tasks, i.e. each tasks
may precede a subset of other tasks, but some tasks might not have any precedence ordering defined
between them (called concurrent task). The dependency among the activities is represented inthe form
of an activity network. Once the activity network representation has been worked out, resources are
allocated to each activity.
Resource allocation is typically done using a Gantt chart. After resource allocation is done, a PERT chart
representation is developed. The PERT chart representation is suitable for program monitoring andcontrol.
For task scheduling, the project manager needs to decompose the project tasks into a set of activities. The
time frame when each activity is to be performed is to be determined. The end of each activity is called
milestone. The project manager tracks the progress of a project by monitoring thetimely completion
of the milestones. If he observes that the milestones start getting delayed, then he has to carefully control
the activities, so that the overall deadline can still be met.
Soft
A Gantt chart (Time line chart) is a special type of bar chart where each bar represents an activity. The
bars are drawn along a time line. The length of each bar is proportional to the duration of time planned for
the corresponding activity. Gantt charts are used in software project management are actually an enhanced.
Soft
START
ACTIVITY STATUS ASSIGNED TO - DURETION
DATE
PHASE 1: Requirements Gathering Done Aakash & Rajendra 28-01-2024 08-02-2024 11
Basic Structure Done Aakash & Rajendra 28-01-2024 30-01-2024 2
Basic UI Done Aakash 31-01-2024 02-02-2024 2
Functional Requirements Done Rajendra 03-02-2024 05-02-2024 2
Non-Functional Requirements Done Rajendra 06-02-2024 07-02-2024 1
Security Requirements Done Aakash 08-02-2024 08-02-2024 0
PHASE 2: Design the Architecture Almost Done Aakash & Rajendra 09-02-2024 18-02-2024 9
UI with HTML and CSS Done Rajendra 09-02-2024 12-02-2024 3
Chatting Interface Done Akash 13-02-2024 14-02-2024 1
Responsive UI Done Akash 15-02-2024 18-02-2024 3
PHASE 3: Backend In Progress Aakash & Rajendra 19-02-2024 26-02-2024 7
Adding logic Done Rajendra 09-02-2024 12-02-2024 3
Requirements Done Rajendra 22-02-2024 24-02-2024 2
Backend Done Akash 25-02-2024 26-02-2024 1
Gantt Chart
01-02-2024 02-02-2024 03-02-2024 04-02-2024 05-02-2024 06-02-2024 07-02-2024 08-02-2024 09-02-2024
PHASE 1: Requirements Gathering
Basic Structure
Basic UI
Tasks
Functional Requirements
Non-Functional Requirements
Security Requirements
PHASE 1:
Security Non-Functional Functional
Basic UI Basic Structure Requirements
Requirements Requirements Requirements
Gathering
START DATE 08-02-2024 06-02-2024 03-02-2024 31-01-2024 28-01-2024 28-01-2024
Duretion 0 1 2 2 2 11
Phase 1 Gantt Chart

Soft
Gantt Chart
04-02-2024 06-02-2024 08-02-2024 10-02-2024 12-02-2024 14-02-2024 16-02-2024 18-02-2024 20-02-2024
PHASE 2: Design the Architecture
UI with HTML and CSS

Tasks
Chatting Interface
Responsive UI
PHASE 2: Design the

Responsive UI Chatting Interface UI with HTML and CSS
Architecture
START DATE 15-02-2024 13-02-2024 09-02-2024 09-02-2024
Duretion 3 1 3 9
Phase 2 Gantt Chart
Gantt Chart
29-01-2024 03-02-2024 08-02-2024 13-02-2024 18-02-2024 23-02-2024 28-02-2024
PHASE 3: Backend
Adding logic
Tasks
Requirements
Backend
Backend Requirements Adding logic PHASE 3: Backend

START DATE 25-02-2024 22-02-2024 09-02-2024 19-02-2024
Duretion 1 2 3 7
Phase 3 Gantt Chart

Soft
Critical Path Method (CPM)
Task Duration Start Date End Date

(Days)
Requirements Gathering 11 Days 28-01-2024 08-02-2024
Design the Architecture 9 Days 09/02/024 18-02-2024
Backend 7 Days 19-02-2024 26-02-2024
Connectivity 1 Day 27-02-2024 28-02-2024
Demo Testing 1 Day 28-02-2024 29-02-2024
Deployment Not Done Yet - -
Maintenance & Support On Going 01-02-2024 TBD
Task Duration ES EF LS LF
(Days)
Requirements Gathering 11 Days 0 3 0 3
Design the Architecture 9 Days 3 7 3 7
Backend 7 Days 7 13 7 13
Connectivity 1 Day 13 21 13 21
Demo Testing 1 Day 25 26 28 29
Deployment Not Done Yet - - - -
Maintenance & Support On Going 0 NA 13 NA
Requirements Gathering -> Design the Architecture-> Backend -> Connectivity -> Demo Testing
->Deployment -> Maintenance & Support
Soft
PERT (Path Evaluation and Review Technique)
Quiz:
1) Explain project scheduling process.
Soft
2) Explain Software metrics used for software cost estimation
Soft

2. Roger S.Pressman, Software Engineering- A practitioner‟s Approach, McGraw-Hill International
Editions

implementation implementation implementation implementation implementation
as asked as asked as asked as asked as asked
Development of Development of Development of

the Solution the Solution the Solution
Concept Clarity Concept Clarity

& understanding & understanding
Correct answer to
all questions
Soft
SOFTWARE
REQUIREMNT
SPECIFICATION FOR
“Stock Trend Prediction Website”
Authors
Jha Rajendra
Aakash Makwana
Department of Information and Technology, Government
Engineering College, Modasa
Guided by,
Prof Nainesh Nagekar,
Assistant Professor,
Department of Computer Engineering, Government Engineering
College, Modasa
Date:
Version: 1.0
Soft
AIM: Prepare the Software Requirement Specification (SRS) document for selected project.
Objectives:
1. Learn how to provide a detailed overview of our software product, its parameters and goals.
2. Describes the project's target audience and its user interface, hardware and software requirements.
Theory:
A software requirements specification (SRS) is a document that is created when a detailed description of
all aspects of the software to be built must be specified before the project is to commence. It is important
to note that a formal SRS is not always written. In fact, there are many instances in which effort expended
on an SRS might be better spent in other software engineering activities. However, when software is to be
developed by a third party, when a lack of specification would create severe business issues, or when a
system is extremely complex or business critical, an SRS may be justified.
Procedure to develop SRS:

Every team has to identify the requirements of their projects and arrange as per the requirement
engineering document.
In order to form a good SRS, here you will see some points which can be used and should be considered to
form a structure of good SRS. These are as follows:
1. Introduction
• Purpose of this document
• Scope of this document
• Overview
2. General description
3. Functional Requirements
4. Interface Requirements
5. Performance Requirements
6. Design Constraints
7. Non-Functional Attributes
8. Preliminary Schedule and Budget
9. Appendices
Soft
1. Introduction…………………………………………………………………..
• Overview
2. General description…………………………………………………………..
3. Functional Requirements…………………………………………………….
4. Interface Requirements………………………………………………………
5. Performance Requirements…………………………………………………..
6. Design Constraints……………………………………………………………
7. Non-Functional Attributes………………………………................................
Soft
Soft
1) INTRODUCTION

The purpose of this document is to outline the software requirements for the
development of a stock trend prediction website. This document serves as a guide for
stakeholders, developers, and testers involved in the project.

The scope of this document is to provide essential and detailed information about the
Stock Trend Prediction Website project to the reader. It will discuss the prediction
algorithms, data sourcing and management, user interface design, trend visualization,
portfolio management, and providing special features like real-time updates and
alerts. This document aims to give a comprehensive overview of the project, its
functionalities, and its implementation.
• Overview
There are already various Stock Trend Prediction Websites available but as we
observe, there are some areas that have not been adequately addressed. We are taking
those points into consideration and working on them to develop a more
comprehensive and user-friendly Stock Trend Prediction Website. Our focus is on
improving the accuracy of predictions, enhancing the user interface, and providing
real-time updates and alerts to give users a better experience and more valuable
insights into stock trends.
2) General Description
In today’s rapidly evolving financial market, effective management of stock trend

prediction is crucial to ensure a seamless and satisfying experience for users. The Stock
Trend Prediction Website project is designed to address the various challenges faced
by users who want to make informed investment decisions. Our project aims to provide
accurate predictions, real-time updates, and user-friendly interfaces to help users
navigate the complexities of the stock market with ease.
Key Features:
• In our project, users get a unique facility for predicting stock trends. They can choose
their preferred stocks and get predictions at their fingertips.
• We also provide an option for users to manage their portfolio, keeping track of their
investments and returns.
Project Function:
1. Stock Trend Prediction: Predict future trends of stocks using historical data and
machine learning algorithms.
2. Stock Information: Provide detailed information about various stocks, including
current price, historical trends, market cap, etc.
3. Portfolio Management: Allow users to create and manage their portfolio of stocks.
4. Real-time Updates: Provide real-time updates on stock trends.
Soft
3) INTRODUCTION
R.1: Predict Stock Trends Description:

Description The predict stock trends function first determines the type of stock that the user has
selected. It fetches the historical data for the selected stock and uses a machine
learning model to predict the future trend of the stock. If the prediction is successful, it
displays the predicted trend, otherwise, it generates an error message.
R.1.1: Select Predict Stock Trend Option
Input “Predict Stock Trend” option
Output User prompted to enter the stock symbol
R.1.2: Select Stock
Input User-selected stock symbol
Output Prompt to confirm prediction
R.1.2: Select Stock

Input Confirmation from the user to proceed with the prediction
Output The predicted stock trend and a graph visualizing the trend Processing: The system
fetches the historical data for the selected stock, applies the prediction model, and if
the prediction is successful, displays the predicted trend. If there’s an issue with the
prediction, an error message is displayed.
R.2: Time Selection

Description User can select time interval for Stock data
R.2.1: Portfolio Management
Input User-selected stocks to add or remove from their portfolio
Output Updated portfolio with selected stocks Processing: The system allows users to manage
their portfolio of stocks. They can add new stocks to their portfolio or remove existing
ones. The system keeps track of all the stocks in the user’s portfolio and displays them
in a user-friendly format.
R.2.2: Real-time Updates and Alerts
Input User’s preference for receiving updates and alerts
Output Real-time updates and alerts based on user’s preference Processing: The system
provides real-time updates on the stock trends in the user’s portfolio. It also sends alerts
when significant events occur, such as drastic changes in stock trends. Users can
customize their preferences for receiving these updates and alerts.
R.2.3: Historical Data Visualization
Input User-selected stock and time period.
Output Output: A graph visualizing the historical trend of the selected stock Processing: The
system fetches the historical data for the selected stock and time period, and visualizes it
in a graph. This helps users understand the past performance of the stock.
Soft
4) Interface Requirements:
User Interfaces
The user interface should be intuitive and easy to navigate. It should include features like
login/registration, a dashboard for viewing stock trends, a search function for finding
specific stocks, and a user profile section. The interface should be responsive, meaning it
should provide a consistent experience across different devices and screen sizes.
Hardware Interfaces
As a web-based application, the stock trend prediction website doesn’t directly interact
with hardware. It should be accessible from any device with a web browser and internet
connection. However, the server hosting the website will have hardware requirements,
such as sufficient storage to hold the website data and enough processing power to
handle user requests.
Software Interfaces
The website will need to interface with various software components. This includes the
web server software (like Apache or Nginx), the database management system (like
MySQL or PostgreSQL), and potentially other services for things like user authentication
or email notifications. Additionally, the website will likely use APIs to fetch real-time
and historical stock data.
Communication Interfaces
The website will communicate with users primarily over the HTTP/HTTPS protocols. It
may also use WebSocket for real-time updates of stock trends. If the website includes
features like email notifications, it will also need to use SMTP for sending emails.
5) Performance Requirements
Response Time:
The system should respond to user interactions within a specified time frame, such as: 95%
of requests must be processed within 2 seconds.
System Availability:
The Stock Trend Prediction Website should be available 24/7, with minimal downtime for
maintenance or upgrades. Define an acceptable uptime percentage (e.g., 99.9%
availability) for the system.
Soft
Scalability:
The system should be able to handle increased load during peak trading periods. Define
how many concurrent users or transactions the system should support without performance
degradation. Implement load balancing and auto-scaling mechanisms to distribute traffic
efficiently.
Resource Utilization:
Monitor and optimize CPU, memory, and storage utilization to ensure efficient resource
management. Set limits on resource usage to prevent resource exhaustion.
Database Performance:
Database queries, especially those related to stock trend prediction and portfolio
management, should execute quickly. Implement database indexing and caching
mechanisms for faster data retrieval. Define acceptable database response times for various
operations (e.g., stock search, portfolio retrieval).
Network Performance:
Ensure fast and reliable communication between the Stock Trend Prediction Website and
external systems (e.g., real-time stock data providers, third-party integrations). Define
acceptable network latency and bandwidth requirements.
6) Design Constraints:
Technology Constraints:
Legacy Systems: Integration with existing legacy systems may impose constraints on the
choice of technology and architecture.
Platform: The Stock Trend Prediction Website may need to be developed for specific platforms
or operating systems (e.g., Windows, iOS, Android).
Budget Constraints:
Cost Limitations: There may be budget limitations that affect the choice of technologies,
hardware, and software licenses.
Resource Availability: Constraints on the availability of financial and human resources can
impact system development.
Localization and Globalization Constraints:

Multilingual Support: The system may need to support multiple languages, which can affect
user interface design and database structure.
Security Constraints:
Security Policies: Compliance with security policies and standards, which may affect system
design and access control.
Data Constraints:
Data Volume: Constraints related to the volume of data to be stored and processed, which can
affect database design and storage solutions.
Soft
7) Non-Functional Attributes
Performance:
Response Time: The website should load within 2 seconds to ensure a smooth user experience.
Throughput: The system should be able to handle thousands of concurrent users or transactions
per second, especially during peak trading hours.
Documentation and Training:

Comprehensive Documentation: Detailed documentation should be available for users to
understand how to use the website effectively and for administrators to manage the system.
Training Materials: User guides and tutorials should be provided to help users understand how
to interpret the stock trends and make informed decisions.
Security:
Data Security: All sensitive data, including user information and transaction details, should be
encrypted. Access control mechanisms should be in place to prevent unauthorized access.
Compliance: The website should comply with all relevant data protection regulations (e.g.,
GDPR) and industry security standards.
Availability:
Uptime: The website should be available 24/7, with minimal downtime for maintenance. This
is crucial as stock markets operate round the clock across different time zones.
Fault Tolerance: The system should be designed to continue operating even in the event of
hardware or software failures.
Reliability:
The website should consistently provide accurate and up-to-date stock trend predictions
without errors or failures.
MTBF (Mean Time Between Failures) and MTTR (Mean Time to Repair) should be optimized
to ensure high system reliability and minimal disruption to users.
Soft
Quiz:
1. Which are properties of good SRS?
2. What is functional and non-functional requirement?

Soft

2. Roger S.Pressman, Software Engineering- A practitioner‟s Approach,
McGraw-Hill InternationalEditions



Correct answer to
all questions
Soft
Practical – 4
AIM: Draw the Data Flow Diagram for your selected Project.
1. Data Flow Diagrams
• Data flow diagram is graphical representation of flow of data in an information

system. It can depict incoming data flow, outgoing data flow and stored data. The
DFD does not mention anything about how data flows through the system.
• There is a prominent difference between DFD and Flowchart. The flowchart depicts
flow of control in program modules. DFDs depict flow of data in the system at
various levels. DFD does not contain any control or branch elements.
1.1) DFD Level 0
• Level 0- Highest abstraction level DFD is known as Level 0 DFD, which depicts the
entire information system as one diagram concealing all the underlying details. Level
0 DFDs are also known as context level DFDs.
1.2) DFD Level 1
• The Level 0 DFD is broken down into more specific, Level 1 DFD. Level 1 DFD
depicts basic modules in the system and flow of data among various modules. Level 1
DFD also mentions basic processes and sources of information.
Soft
1.3) DFD Level 2
• At this level. DFD shows how data flows inside the modules mentioned in Level 1.
Higher level DFDS can be transformed into more specific lower level DFDs with
deeper level of understanding unless the desired level of specification is achieved.
Quiz:
1. In a data flow diagram, does an arrow represent a flow of control or

something else?
Soft
2. What is “information flow continuity” and how is it applied

as a data flow diagram isrefined?
3. What are the advantages of DFD?

Soft




Correct answer to
all questions
Soft
Practical – 5
AIM: Draw the Entity-Relationship Diagram for your selected Project.
• Objectives:
1. Identify entity sets, their attributes, and various relationships
2. Represent the data model through ER diagram
• Theory:
Entity-Relationship model is used to represent a logical design of a database to be
created. In ERmodel, real world objects (or concepts) are abstracted as entities, and
different possible associations among them are modeled as relationships.
1. Identify entity sets, their attributes, and various relationships
2. Represent the data model through ER diagram

Soft
Quiz:
1. what is weak entityset?
2. what is mapping cardinality?

Soft




Correct answer to
all questions
Soft
Practical – 6
AIM: Draw Usecase Diagram for your selected Project .
• Objectives:
1. To write different scenarios of the system‟s execution.
2. To explore various UML use case diagram components to draw USECASE
diagram.
• Theory:
• A use case diagram is used to represent the dynamic behavior of a system. It
encapsulatesthe system's functionality by incorporating use cases, actors, and
their relationships. It models the tasks, services, and functions required by a
system/subsystem of an application. It depicts the high-level functionality of
a system and also tells how the user handles a system.
Purpose of Use Case Diagrams

• The main purpose of a use case diagram is to portray the dynamic
aspect of a system. It accumulates the system's requirement, which
includes both internal as well as external influences. It invokes
persons, use cases, and several things that invoke the actors and
elements accountable for the implementation of use case diagrams. It
represents how an entity from the external environment can interact
with a part of the system.
Following are the purposes of a use case diagram given below:
1. It gathers the system's needs.
2. It depicts the external view of the system.
3. It recognizes the internal as well as external factors that influence the
system.
4. It represents the interaction between the actors.
• In a use-case diagram, an actor is a user of the system (i.e.
Something external to thesystem; can be human or non-human)
acting in a particular role.
• A use-case is a task which the actor needs to perform with the
help of the system,e.g., find details of a book or print a copy of a
receipt in a bookshop.
• We can draw a box (with a label) around a set of use cases to
denote the systemboundary, as on the previous slide (“library
system”).
Inheritance can be used between actors to show that all use cases of one actor
are available to the other:
If several use cases include, as part of their functionality, another use case, we
have a special way to show this in a use-case diagram with an <<include>>
relation.
Soft
If a use-case has two or more significantly different outcomes, we can show

this by extending the use case to a main use case and one or more subsidiary cases.
Use Case Diagram:
STOCK TREND PREDICTION WEBSITE
Quiz:
1. What are the four main components of a use case diagram?

Soft
2. List relationship used in use case.
3. What Tests Can Help Find Useful Use Cases?

Soft




Correct answer to
all questions
Soft
Practical – 7
AIM: Solve the problem by applying basic COCOMO model.
• Objectives:
1. Categorize projects using COCOMO, and estimate effort and
development time requiredfor a project.
• Theory
A software project is not just about writing a few hundred lines of source code
to achieve a particular objective. The scope of a software project is
comparatively quite large, and such a project could take several years to
complete. However, the phrase "quite large" could only give some (possibly
vague) qualitative information. As in any other science and engineering
discipline, one would be interested to measure how complex a project is. One
of the major activities of the project planning phase, therefore, is to estimate
various project parameters in order to take proper decisions. Some important
project parameters that are estimated include:
Project size: What would be the size of the code written say, in number of
lines, files,modules?
Cost: How much would it cost to develop a software? A software may be
just pieces ofcode, but one has to pay to the managers, developers, and other
project personnel.
Duration: How long would it be before the software is delivered to the clients?
Effort: How much effort from the team members would be required to
create thesoftware?
In this experiment we will focus on two methods for estimating project
metrics:COCOMO
COCOMO (Constructive Cost Model) was proposed by Boehm. According to

him, there could be three categories of software projects: organic,
semidetached, and embedded. The classification is done considering the
characteristics of the software, the development team and environment. These
product classes typically correspond to application, utility and system
programs, respectively. Data processing programs could be considered as
application programs. Compilers, linkers, are examples of utility programs.
Operating systems, real-time system programs are examples of system
programs. One could easily apprehend that it would take much more time and
effort to develop an OS than an attendance management system.
The concept of organic, semidetached, and embedded systems are described

below.
Soft
Organic: A development project is said to be of organic type, if The project

deals with developing a well understood application The development team is
small The teammembers have prior experience in working with similar types
of projects
Semidetached: A development project can be categorized as semidetached
type, if The team consists of some experienced as well as inexperienced staff
Team members may have some experience on the type of system to be
developed
Embedded: Embedded type of development project are those, which Aims to
develop a software strongly related to machine hardware Team size is usually
large Boehm suggested that estimation of project parameters should be done
through three stages: Basic COCOMO, Intermediate COCOMO, and
Complete COCOMO.
Basic COCOMO Model

The basic COCOMO model helps to obtain a rough estimate of the project
parameters. It estimates effort and time required for development in the
following way:
Effort = a * (KDSI)b
PMTdev= 2.5 * (Effort)c Months
where
▪ KDSI is the estimated size of the software expressed in Kilo Delivered

SourceInstructions
▪ a, b, c are constants determined by the category of software project
▪ Effort denotes the total effort required for the software development, expressed
inperson months (PMs)
▪ Tdev denotes the estimated time required to develop the software (expressed
inmonths)
The value of the constants a, b, c are given below:
Software project a b c
Organic 2.0 1.2 0.8
Semi-detached 2.8 1.5 1.1
Embedded 3.3 1.8 1.3
Assumptions:
• Size estimation: Estimated size of the project is 2000 lines of code (LOC).
• Mode selection: Organic mode is chosen as the project is relatively small and
straightforward.
• Productivity: Assume a productivity factor of 20 person-months per KLOC (thousand
lines of code).
• Team Size: Assume a team size of 2 developers.
• Scheduling: Assume a standard schedule with no specific constraints.
Soft
• Solution:
1. Determine Size
Estimated size of the project = 2000 LOC
2. Select Mode
Since the size of the project is relatively small and the requirements are
clear, we’ll choose the Organic mode.
3. Calculate Effort
Effort = 2.4 * (LOC)^1.05 for Organic mode (where LOC is in KLOC)
Since 1 KLOC = 1000 LOC, for your project LOC = 2000 LOC = 2 KLOC
So, Effort = 2.4 * (2)^1.05 = 5.07 person-months
4. Calculate Duration
Duration = Effort / Team Size
Duration = 5.07 person-months / 2 developers = 2.54 months.
COCOMO divides effort and time as follows

35% Requirements Analysis
20% Design
25% Coding and Unit Testing
20% Integration and Testing
If it is adapted to Airline Reservation System the following table occurs;
• Estimation Plan
In this part of the Initial Plan, the cost and schedule for conducting the project as well
as methods, tools and techniques used to estimate project cost, schedule and resource
requirements are specified.
Since it is a convenient method to use in the early phases of project development, the
size of the Online Airline Reservation System is estimated according to the function-
point (FP) method [8]. In counting function points, external inputs, external outputs,
external enquiries, internal files and external interfaces of the software are identified.
Each instance for each separate class is multiplied with the associated weight factor.
The overall sum is calculated to find the function points. Weights for simple, average
and complex inputs, outputs, enquires, files and external interfaces, which are used in
calculations, are depicted below:
Simple Average Complex

External input 3 4 6
External output 4 5 7
External enquiry 3 4 6
Internal file 7 10 6
External interface 3 2 3
Table 4: Complexity Factors Used in Function Point Calculation

Soft
In order to systematically find complexity levels, references to file accesses, record type accesses and
data elements are counted and complexity scores are determined accordingly. The table below depicts
the factors used for complexity calculation. For example, an external input that reference four files and
nine data types (3 + 2) is considered ‘complex’. (2 - 3 simple -denoted by the letter ‘S’, 4 average -
denoted by the letter ‘A’, 5- 6 complex -denoted by the letter ‘C’)
EXTERNAL INPUTS Files Rec. Data Elements Comp. Score

Types
Stock Search Input None Stock Stock symbol, Search S 3

symbol, criteria
Search
criteria
Stock Data Table Input Entered input file Stock Stock data S 3
data
table
Stock Graph Input Entered input file Stock Stock graph data S 3
graph
Future Price Graph Input Entered input file Future Future price graph data S 3
price
graph
Closing Price v/s Time Graph Entered input file Closing Closing Price v/s Time S 3
Input Price Graph Data
v/s
Time
Graph
Input 100MA Price Graph Input 100MA
v/s Data
Time
Graph
100MA
Input 200MA Price Graph Input 200MA
v/s Data
Time
Graph
200MA
Soft
Closing Price vs Time chart Entered input file Closing Closing Price vs Time S 4
With 100 MA and 200 MA Price vs chart With 100 MA and
Time 200 MA Data
chart
With
100 MA
and 200
MA
Graph
EXTERNAL OUTPUTS
Stock Data Table Outpu None - Stock data table S 4

Stock Graph Output None - Stock graph S 4
Future Price Graph Output None - Future price graph S 4
Closing Price v/s Time Graph None - Closing Price v/s Time S 4
Output Graph
100MA Output 100MA Graph
200MA Output 200MA Graph
Closing Price vs Time chart None - Closing Price vs Time c S 4

With 100 MA and 200 MA With 100 MA and 200
Output MA Graph
INTERNAL FILES
None - None None - -
EXTERNAL ENQUIRIES
EXTERNAL INTERFACES
TOTAL UNADJUSTED FUNCTION POINTS 54
Table 5: Details of the Function Point Calculation

Soft
Influence Factors Degree of Comment

Influence-DI
Data Quality and Availability 4 No special requirements
Algorithm Selection and

Performance 2 Client-server architecture
User Interface and Experience 4 No special requirements
Feature Set and Functionality 2 No special requirements
Data Visualization 3 No special requirements
Security and Compliance 4 GDPR or SEC guidelines
Integration with External APIs 2 No special requirements
Machine Learning Model

Interpretability 3 Transparency and interpretability
Customer Support and

Engagement 1 No special requirements
Reusability Function 5 No special requirements
Installation Ease Function 4 No special requirements
Sum of Degree of Influence = 34
Table 6: Influence Factors of Stock trend prediction website

Soft
Phase Month-1 Month-2 Month-3 TOTAL

Requirements
75% 25% 0% 100%
Analysis
Design 25% 50% 25% 100%
Coding & Unit Testing
0% 50% 50% 100%
Integration & Testing

0% 25% 75% 100%
Table 7: Effort and Time Division

Effort Month-1 Month-2 Month-3
Phase (staff * months) (staff * months) (staff * months) (staff * months)
Requirements
0.35 * 2.54 = 0.889 0.8 * 0.75 = 0.6 0.8 * 0.25 = 0.2 0.8 * 0 = 0
Analysis (35%)
1.18 * 0.50 = 0.58 1.18 * 0 25 = 0.295
Design (20%) 0.20 * 2.54 = 0.508 1.18 * 0 25 = 0.29
Coding & Unit 1.18 * 0.50 = 0.58 1.18 * 0 50 = 0.50
0.25 * 2.54 = 0.635 1.18 * 0 = 0
Testing (25%)
Integration & Testing 1.55 * 0.25 = 1.55 * 0.75 =1.16
0.20 * 2.54 = 0.508 1.55* 0 = 0
(20%) 0.38
TOTAL EFFORT 2.54 0.89 1.77 1.995
(staff * months) Month-1 Month-2 Month-3 TOTAL
Cost of the staff ($) 0.89* 2000 = 1780 1.77 * 2000 = 3540 1.995 * 2000 = 3990 9310
Cost of the
subcontracted processes 64 * 10 = 640 64 * 10 = 640 64 * 10 = 640 1920
($)
Cost of the
electricity consumed 30 30 30 90
($)
TOTAL
2450 4210 4660 11320
COST ($)
Soft
Quiz:
1. Assume that the size of an organic type software product has been estimated to be
32,000 lines of source code. Assume that the average salary of software engineers be
Rs. 15,000/- per month. Determine the effort required to develop the software product
and the nominal development time.
Soft




Correct answer to
all questions

Practical SE (SRS) 2

Uploaded by

Copyright:

Available Formats

You might also like

Practical SE (SRS) 2

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Practical SE (SRS) 2

Uploaded by

Copyright:

Available Formats

Soft

Software Engineering (3161605)

A Laboratory Manual for

B.E. Semester 6 (Information Technology)

Directorate of Technical Education, Gandhinagar,

Practical – Course Outcome matrix

Course Outcomes (COs):

Discuss the Project Management: Project Planning and

4. Draw the Data Flow Diagram for your selected Project. √ √

Draw the Entity-Relationship Diagram for your selected

Draw Usecase Diagram for your selected Project.

Solve the problem by applying basic COCOMO model.

8. Modeling UML Class Diagrams and Sequence diagrams √ √

Industry Relevant Skills

The following industry relevant competency is expected to be developed in the student by

1. Apply knowledge of Process Models for the development of software.

Guidelines for Faculty members

Sr. Objective(s) of Experiment Page Date of Date of Assessmen Sign. of Remar

included in scope of manual.

General Guidelines for Software Engineering Laboratory Work

List of Different Process Models

1. Requirement Gathering and

• Verification: This phase

The Incremental Model of software development

The Incremental Model is used in the following scenarios:

Figure 4: RAD Model

The various phases of RAD are as follows:

Figure 5: Agile Model

Phases of Agile Model:

Agile Testing Methods:

When to use the Agile Model?

Figure 6:Iterative Model

The various phases of Iterative model are as follows:

Figure 7:Spiral Model

Each cycle in the spiral is divided into four parts:

Steps of Prototype Model

• Requirement Gathering and Analyst

1. Which process model will be appropriate for your selected Project?

• RAD Model (Rapid Application Development):

1. Compare waterfall model and incremental model.

b) The loops for spiral model are fixed.

References used by the students:

Marks Complete Complete Complete Complete Complete

Problem analysis Problem analysis Problem analysis Problem analysis

Development of the Development of the Development of the

Concept Clarity & Concept Clarity &

Correct answer to all

1. To represent the plan to deliver the project scope over time.

1. Identify all the tasks needed to complete the project.

1. Project Initiation Phase

8. Testing and Validation:

10. Documentation and Training:

11. Maintenance and Updates:

2. Break down large tasks into small activities.

3. Determine the dependency among different activities.

4. Website Design and Development:

4. Website Design and Development: