Reg.

# _______________Section _ ___ Name _________________________

Department: Computer Engineering Program: B.S (CE)

Assignment 3
CE-202 Software Engineering

Announced date: Due Date: 20-06-2023 Total Marks = 3

13-06-2023
Marks Obtained =
Teacher Name: Maheen Danish

Sr. No Course Learning Outcomes PLOs Blooms

Taxonomy
CLO_ Analyze design methods with an emphasis on UML modeling, web PLO_2 C2
3 application

(CLO_2): (Cognitive Level C2, i.e., Analyze) (PLO_2: Problem Analysis)

Q1: Compute FP for the system if a system has 10 external inputs, 20 external outputs, fields
25 different queries, manages 4 internal logical files, and interfaces with 4 different legacy
systems (4EIF). All of these data are of average complexity.
To compute the Function Points (FP) for the system, we need to calculate the
Unadjusted Function Points (UFP) and then apply complexity weights to determine
the Adjusted Function Points (AFP).
1. Count the External Inputs (EI): 10 external inputs.
2. Count the External Outputs (EO): 20 external outputs.
3. Count the External Inquiries (EQ): 25 external inquiries.
4. Count the Internal Logical Files (ILF): 4 internal logical files.
5. Count the External Interface Files (EIF): 4 external interface files.
Now, let's calculate the Unadjusted Function Points (UFP):
UFP = EI + EO + EQ + ILF + EIF = 10 + 20 + 25 + 4 + 4 = 63
Next, we need to apply complexity weights to calculate the Adjusted Function Points
(AFP). Since you mentioned that all the data is of average complexity, we'll use the
following weights:
Complexity Weights:
 External Inputs (EI): 3
 External Outputs (EO): 4
 External Inquiries (EQ): 3
 Internal Logical Files (ILF): 7
 External Interface Files (EIF): 5
AFP = UFP * (EI_weight + EO_weight + EQ_weight + ILF_weight + EIF_weight) = 63 *
(3 + 4 + 3 + 7 + 5) = 63 * 22 = 1386

1
 Therefore, the Adjusted Function Points (AFP) for the system would be 1386.

Q2: Illustrate using appropriate software process and team structure if you have been
appointed as a project manager within an information systems organization. Your job is to
build an application that is quite similar to others your team has built, although this one is
larger and more complex. Requirements have been thoroughly documented by the customer.

As a project manager within an information systems organization, I would adopt the following
software process and team structure to successfully build the application:

1. Software Process: Agile Development Methodology (Scrum)

 Agile methodologies are ideal for handling projects with changing requirements and a need for
flexibility. Scrum, in particular, allows for iterative development and regular feedback from the
customer.
 The process involves breaking the project into smaller, manageable units called sprints, each
lasting 1-4 weeks. Each sprint involves planning, development, testing, and review.
 The requirements documentation provided by the customer will be used as a starting point, but
the team will remain open to adjustments and collaboration with the customer throughout the
development process.
2. Team Structure:
 Product Owner: The customer or a representative who understands the business requirements
and can provide clear and prioritized user stories.
 Scrum Master: The project manager responsible for facilitating the Scrum process, removing
obstacles, and ensuring the team adheres to Scrum principles.
 Development Team: Cross-functional team members with expertise in software development,
design, testing, and other relevant skills. The team will be self-organizing and responsible for
delivering increments of the application.
 Business Analyst: Works closely with the customer and the development team to elicit, analyze,
and clarify requirements, ensuring they are documented and communicated effectively.
 Quality Assurance (QA) Team: Responsible for conducting comprehensive testing and ensuring
the application meets quality standards.
 UX/UI Designers: Develop intuitive and user-friendly interfaces in collaboration with the customer
and development team.
 DevOps Engineer: Handles the deployment, infrastructure setup, and continuous integration and
delivery aspects of the project.
 Stakeholders: Individuals or groups with an interest in the project's outcome, such as managers,
executives, or end-users. They provide feedback and guidance throughout the development
process.
3. Project Execution:
 Sprint Planning: The team, including the product owner, will identify and prioritize user stories
from the requirements documentation and create a sprint backlog.
 Daily Stand-up Meetings: The team gathers daily to share progress, discuss any obstacles, and
plan the day's tasks.
 Sprint Review: At the end of each sprint, the team demonstrates the completed functionality to
the customer, receives feedback, and incorporates it into the next sprint's planning.

2
 Sprint Retrospective: The team reflects on the completed sprint, discusses what went well and
areas for improvement, and adjusts their processes accordingly.
 Continuous Integration and Delivery: The DevOps engineer ensures a smooth integration of code
changes and automates the deployment process.
 Ongoing Communication: Regular communication with stakeholders, including the customer,
ensures that expectations are managed, feedback is collected, and progress is transparent.

By adopting an Agile methodology like Scrum and implementing an effective team structure, we
can efficiently manage the larger and more complex application project while maintaining
customer collaboration, flexibility, and quality throughout the development process.

Q3: Make the statement of scope of the given scenario. You have been asked to develop a
small application that analyzes each course offered by a university and reports the average
grade obtained in the course (for a given term).

Statement of Scope:
The scope of the project is to develop a small application that analyzes each course offered by
a university and generates a report on the average grade obtained in each course for a given
term. The application will provide insights and statistical information about the academic
performance of students in different courses.
Key Features and Functionality:
1. Course Data Analysis: The application will collect and analyze data related to each
course offered by the university, including the course code, course name, term, and
grades obtained by students.
2. Average Grade Calculation: The application will calculate the average grade obtained
in each course for a given term based on the collected data. It will consider the grades
of all students who took the course during the specified term.
3. Term Selection: The application will allow the user to select a specific term for which
they want to generate the average grade report. This will enable the user to analyze
the performance of courses in different terms.
4. Report Generation: The application will generate a comprehensive report that presents
the average grade obtained in each course for the selected term. The report may
include charts, tables, or other visual representations to present the data effectively.
5. User Interface: The application will have a user-friendly interface that allows users to
interact with the system easily. It should provide intuitive controls for selecting the
term and generating the report.
6. Data Management: The application will handle the storage and retrieval of course data
efficiently. It should provide mechanisms to update the data as new grades are
recorded and retrieve the necessary information for analysis and reporting.
Assumptions and Constraints:
1. The application will focus on analyzing courses offered by a specific university.
2. The data required for analysis, including course codes, names, terms, and grades, will
be available and accessible.
3. The application will operate within the given university's data management system or
utilize a compatible data source.
4. The application will not handle personal student data or individual student
performance analysis; it will focus on aggregate statistics.

3
 5. The application will be developed for desktop or web-based platforms, with
considerations for compatibility and usability across different devices and browsers.
The scope of the project does not include:
1. Enrollment tracking or managing student information.
2. Prediction or forecasting of future grades or course performance.
3. Integration with external systems or third-party APIs.
4. Advanced data visualization or data mining techniques.
5. Authentication and user management functionalities.
The successful completion of the project will result in a functional application that provides
accurate and insightful reports on the average grade obtained in each course for a given term
at the university, helping stakeholders to monitor and evaluate course performance.

Q4: Compute the value of function point metric for a software project with the following
information domain characteristic:

Number of external inputs (I) = 30

Number of external output (O) = 60
Number of external inquiries (E) = 23
Number of files (F) = 08
Number of external interfaces (N) = 02

It is given that the complexity weighting factors for I, O, E, F and N are 4, 5, 4, 10 and 7,
respectively. It is also given that, out of fourteen value adjustment factors that influence the
development effort, four factors are not applicable, each of the other four factors have value
3, and each of the remaining factors have value 4. What will be computed value of function
point metric?

To compute the value of the Function Point (FP) metric for the software project, we need to
multiply the domain characteristic values by their corresponding complexity weighting
factors and then adjust the result using the value adjustment factors. Let's calculate it step by
step:

Step 1: Calculate the Unadjusted Function Points (UFP):

UFP = (I * I_weight) + (O * O_weight) + (E * E_weight) + (F * F_weight) + (N * N_weight)

= (30 * 4) + (60 * 5) + (23 * 4) + (8 * 10) + (2 * 7) = 120 + 300 + 92 + 80 + 14 = 606

Step 2: Calculate the Value Adjustment Factor (VAF):

VAF = [0.65 + (0.01 * sum of value adjustment factors)] = [0.65 + (0.01 * (4 * 3 + 4 * 3 + 4

* 3 + 4 * 3 + 4 * 4))] = [0.65 + (0.01 * (12 + 12 + 12 + 12 + 16))] = [0.65 + (0.01 * 64)] =
[0.65 + 0.64] = 1.29

Step 3: Calculate the Adjusted Function Points (AFP):

AFP = UFP * VAF = 606 * 1.29 = 781.74 (rounded to the nearest whole number)

Therefore, the computed value of the Function Point metric for the software project is 782

4
Q5: Calculate the effort in terms of LOC/programmer-day and in terms of function
points/programmer day. The function point estimate was 50 unadjusted function points. The
finished project included 950 lines of code.

Effort during phases mentioned in the following table:

Phase Programmer days

Requirements 20
Design 10
Implementation 10
Testing 15
Documentation 10

To calculate the effort in terms of Lines of Code (LOC)/programmer-day, we need to divide

the total lines of code by the total programmer days.
Total Programmer Days = Sum of programmer days for each phase = 20 + 10 + 10 + 15 + 10
= 65
Effort (LOC/Programmer-day) = Total Lines of Code / Total Programmer Days = 950 / 65 ≈
14.62 LOC/programmer-day
To calculate the effort in terms of Function Points (FP)/programmer-day, we need to divide
the total function points by the total programmer days.
Total Function Points = 50 (Unadjusted Function Points)
Effort (FP/Programmer-day) = Total Function Points / Total Programmer Days = 50 / 65 ≈
0.77 FP/programmer-day
Therefore, the effort in terms of LOC/programmer-day is approximately 14.62
LOC/programmer-day, and the effort in terms of FP/programmer-day is approximately 0.77
FP/programmer-day.