Python Application Development: Student Record Management

System

C++ Application Development: Python Application Development: Student Record Management

System

CSE PATHSHALA

A training report Bachelor of Technology

(Computer Science and Engineering) Submitted to LOVELY PROFESSIONAL UNIVERSITY

PHAGWARA, PUNJAB

From 10/06/2025 to 3/08/2025 SUBMITTED BY

Name of student: Prince Arora Registration Number: 12311936

Signature:

Student Declaration To whom so ever it may concern I, Prince Arora, Registration Number
12311936, hereby declare that the work done by me on “C++ Application Development: Student
Record Management

System” From June 2025 To August 2025, Is A Record Of Original

work for the partial fulfillment of the requirements for the award of the degree, Bachelor of
Technology (B.Tech.) in Computer Science and Engineering.

Name of student: Prince Arora Registration Number: 12311936

Signature:

Date: 8/08/2025

Certificate From The Cse Pathshala

Acknowledgement
I would like to express my sincere gratitude to CSE Pathshala for providing me with the
opportunity to undergo this training. I extend my sincere thanks to Professor Rahul Jain, my mentor
during this training program, for his continuous support, guidance, and valuable insights, which
greatly contributed to the successful completion of my project work. I am also grateful to my family
and friends for their encouragement and moral support throughout the training period.
Prince Arora

Format for list of contents S. No. Title Page 1 Cover Page 1 2

Declaration By Student
2 3 Training Certificate from Organization 3 4

Acknowledgement
4 5 List of Contents 5 6 List of Tables 6 7 List of Figures 7 8 List of Abbreviations 8 9 Chapter 1 –
Introduction 9 10 Chapter 2 – Source of Dataset 10 11 Chapter 3 – SQLite Database 11–24 12
Chapter 4 – Statistical Analysis 25–36 13 Chapter 5 – Conclusion 37 14 Chapter 6 – Future Scope
38 15

References
39-40

List of Tables

Table No. Title Page No. 1 Dataset Summary 10 2 Statistical Results of t-test 25 3 Outlier Detection
Results 30

List of Figures / Charts Figure No. Title Page No. 1

System Architecture Diagram

14 2 Data Flow Diagram (Level 0) 15 3 Marks Distribution Histogram 28

List of Abbreviations Abbreviation Full Form SRMS Python Application Development: Student
Record Management System GUI Graphical User Interface SQL Structured Query Language OOP
Object-Oriented Programming DFD Data Flow Diagram ERD Entity Relationship Diagram

Chapter 1. Introduction The rapid evolution of software development has transformed the way
academic institutions and individuals manage information. C++ remains one of the most powerful
and versatile programming languages for building high-performance, reliable, and
resource-efficient applications. Leveraging its strengths, this project, titled “C++ Application
Development: Python Application Development: Student Record Management System focuses on
designing and implementing two practical applications: 1. Python Application Development:
Student Record Management System efficiently storing, updating, retrieving, and managing student
academic records. The objective of this project is to integrate core C++ programming concepts with
real- world problem-solving. Both applications are implemented using fundamental and advanced
C++ concepts, including: • Classes and Objects • Constructors and Destructors • Inheritance and
Polymorphism • File Handling for persistent storage • Data Structures (Stacks, Queues, Linked
Lists) • Exception Handling and generics-like patterns The Python Application Development:
Student Record Management System student data, updating existing records, deleting entries,
searching for students, and

displaying all records in a structured format. The main goals of this project are: • To demonstrate
practical application of core and advanced C++ concepts. • To develop a file-based storage system
for persistent data in SRMS. • To provide an interactive, user-friendly command-line interface for
both applications. This project not only enhances programming proficiency but also bridges the gap
between theoretical concepts and their practical, real-world usage.

Chapter 2. Source of Dataset Unlike projects relying on pre-existing datasets, the C++ Application
Development: SRMS - CSE Pathshala project generates and manages its own data through user
interaction. The focus is on data design, storage, and retrieval techniques rather than external
dataset sourcing.

Python Application Development: Student Record Management System Data for SRMS is created
through direct user input at runtime. Each student record consists of: • Roll Number – Unique
identifier for each student. • Name – Full name of the student. • Course / Branch – Academic
program enrolled in. • Semester – Current semester number. • Marks – Academic scores in relevant
subjects. • Grade – Computed or input based on marks. All data is stored in a structured format
within text or binary files using C++ file handling (fstream) to ensure persistent storage. Records
can be updated, deleted, or retrieved anytime without data loss. Duplicate entries are avoided by
validating the roll number before insertion. Preprocessing & Data Operations Before any operation,
data is validated to prevent errors (e.g., invalid roll numbers, empty URLs). In SRMS, derived data
such as total marks and percentage is calculated dynamically. In the Browser History Manager,
duplicate consecutive entries are prevented to ensure accurate navigation history. Advantages of
This Approach • Full Control over data format and storage. • High Flexibility to modify features
and fields. • No External Dependency on third-party datasets. • Real-Time Data Entry for a more
interactive learning experience.

This self-generated dataset model allowed us to implement file handling, data structures, and
object-oriented programming principles effectively, providing a realistic and engaging C++
application development experience.

Chapter 3. SQLite Database 1.1 Importing Required Libraries We import: • pandas for reading and
processing CSV files. • sqlite3 for creating and interacting with an SQLite database.

1.2 Loading the Dataset The cleaned_data.csv file is loaded into a pandas DataFrame, which
provides an easy- to-use tabular structure for the data.
1.3 Creating a Database Connection A connection to a SQLite database named
video_sales_database.db is established. If the file does not exist, SQLite automatically creates it.

1.4 Storing the Data in the Database The DataFrame is written to the database as a table named
Game_sales using df.to_sql().

• if_exists="replace" ensures any previous table with the same name is replaced. • index=False
prevents pandas from adding a separate index column.

1.5 Closing the Connection The connection is closed to finalize database creation and free
resources.

1.6 Retrieving Data for Verification A new connection is made to the database, and a cursor is used
to execute an SQL query.

Outcome The process successfully: 1. Loaded a cleaned CSV file into pandas. 2. Created an SQLite
database. 3. Stored the CSV data as a structured table. 4. Verified that the data was correctly
inserted. This makes the dataset much easier to query, analyze, and integrate into further analysis
workflows.

2. Data Handling and Processing Approach In this project, there is no pre-existing dataset. Both
applications — Student Record Management System (SRMS)— generate and manage their data
dynamically through user input. This eliminates the need for dataset loading and focuses on
real-time data creation, storage, and retrieval. 2.1 Data Entry and Storage • SRMS: Records are
entered manually, including roll number, name, course/branch, semester, marks, and grade. Data is
stored in arrays or written to text/binary files using fstream for persistent storage. Example from the
addStudent() function:

2.2 Data Validation Before storing, the program validates inputs: • SRMS: Prevents duplicate roll
numbers and ensures marks are within valid limits.

2.3 Data Retrieval and Search • SRMS: Supports searching by roll number, displaying all stored
records, and modifying or deleting data.

2.4 Processing and Derived Values • SRMS: Can compute derived fields like total marks,
percentage, and grade dynamically. 2.5 Advantages of This Approach • Real-time data generation
ensures full control over format and content. • No dependency on third-party datasets. •
Demonstrates Object-Oriented Programming, file handling, and data structure usage in C++. •
Simple to extend with additional features like data sorting or export to external files. This approach
aligns with practical C++ application development, allowing both beginner-friendly functionality
and scope for advanced enhancements.

3. Analysis on Dataset 3.1 Python Application Development: Student Record Management System
I. Introduction The purpose of this project is to develop a Python Application Development:
Student Record Management System C++. This system allows efficient management of student
information, including roll numbers, names, and marks. The application provides functionalities to
add, display, and search student records, offering a structured approach to manage academic data.
The system aims to simplify data handling for educational institutions by maintaining a centralized
repository of student information and enabling quick access and retrieval. II. General Description

Methodology:
• A struct named Student is used to store student details such as roll number, name, and marks. • An
array students[MAX_STUDENTS] is used to store up to 100 student records. • Key functionalities
implemented include: 1. Add Student: Allows adding a new student record if the maximum limit is
not reached. 2. Display Students: Displays the list of all student records in a readable format. 3.
Search Student: Searches for a student by roll number and displays the details if found. Operational
Flow: • The program displays a menu with options to add, display, or search student records. •
Users interact through console input to perform the desired operations. • Validation ensures that
operations respect the limits and provide appropriate feedback. III. Specific Requirements,
Functions, and Formulas (C++

Implementation)
• Data Structure: struct Student with rollNo, name, marks. • Array Storage:
students[MAX_STUDENTS] • Core Functions:

o addStudent() – Adds a student record. o displayStudents() – Displays all records. o

searchStudent() – Searches for a student by roll number. • Menu-driven interface for user
interaction. IV. Analysis Results Example Data Insights (Hypothetical): Metric Value Notes Total
Students Added 25 Successfully added records without exceeding max limit Highest Marks 98.5
Achieved by student Roll No 12 Lowest Marks 45.0 Achieved by student Roll No 7 Average Marks
72.4 Indicates overall class performance

Observations: • The system efficiently stores and retrieves student records. • Adding a student
beyond the MAX_STUDENTS limit is prevented. • Searching allows instant access to individual
student performance. V. Visualization Menu Example:

Sample Record Display:

VI. Summary The Python Application Development: Student Record Management System
academic data using C++. Key takeaways: • Provides structured data storage and retrieval. •
Simple, menu-driven interface ensures ease of use. • Efficient handling of student records with
validation for data limits. • Can be extended to include additional features like updating or deleting
records, calculating statistics, and exporting data. 3.2 Python Application Development: Student
Record Management System i. Introduction The objective of this project is to develop a Python
Application Development: Student Record Management System the C++ programming language.
This system allows users to manage basic student information, including roll numbers, names, and
marks. Key features include adding new students, viewing all student records, and searching for a
student by roll number. This console-based application demonstrates foundational programming
concepts in C++, making it suitable for beginners in software development. ii. General Description
The system performs the following operations: 1. Add Student – Allows entry of roll number,
name, and marks for each student. 2. Display Students – Displays a list of all students currently
stored.

3. Search Student – Searches for a student using the roll number and displays their name and marks.
4. Exit – Closes the application. • The system can store up to 100 students. • Data is stored using an
array of structures. • Input is handled using standard C++ I/O streams (cin, cout).

iii. Specific Requirements, Functions, and Formulas Code Snippet: Structure and Storage

Code Snippet: Add Student Function

Code Snippet: Display & Search

iv. Analysis Results Key observations and functionality validation: 1. Successful Student Addition
The system correctly stores multiple student records and increments the counter with each entry.

2. Display Accuracy All stored records are listed accurately, showing roll number, name, and
marks. 3. Search Feature Efficiently locates a student using roll number, returning associated details
or a "not found" message. 4. Limitations o No duplicate roll number validation. o No persistent
storage (data lost on exit). o No deletion or update functionality. v. Summary The Python
Application Development: Student Record Management System to managing student data using
core C++ features. The system: • Implements arrays, structures, conditionals, and loops. • Supports
adding, viewing, and searching records. • Uses modular functions for clean and maintainable code.
Opportunities for enhancement: • Add file handling (to save data permanently). • Implement record
update/delete options. • Validate duplicate roll numbers. • Add GUI using frameworks like Qt
(optional).

3.3 Outlier Detection in Student Marks i. Introduction Outliers are unusual data points that differ
significantly from other values in a dataset. In a student record system, identifying students with
exceptionally high or very low marks can provide useful insights. These outliers might represent
top performers, students in need of support, or data entry errors. This section outlines how such
outliers can be detected using a logical approach within the C++ system.

ii. General Description Outlier detection is based on statistical methods using: • Minimum and
Maximum Marks in the dataset • Average Marks (Mean) • Standard Deviation (to measure how
spread out marks are) We consider marks outside the normal range as outliers. This can be
approximated in C++ using the rule: Outlier if: marks < (mean - 2 × std_dev) or marks > (mean + 2
× std_dev) This helps detect both underperforming students and top scorers in the system. iii.
Implementation in C++ (Pseudo + Real Logic)

iv. Analysis Results • Consistency: Most student marks lie within a reasonable range. • Outliers
Detected: A few students with either very low or very high marks stand out. • These values help
identify: o Top performers for rewards or scholarships.

o Struggling students for academic support or intervention. v. Summary Outlier analysis provides
critical insights into the academic performance distribution among students. The majority have
marks clustered near the average, while a few outliers reveal either high-achieving or
low-performing students. This enhances decision-making in academic planning and student support
strategies.

4. Statistical Analysis on Student Marks This section applies statistical techniques to the student
data collected in the C++

System. These Techniques Help Uncover Patterns, Compare

Performance Against
benchmarks, and explore relationships within the dataset. 4.1 One-Sample t-test on Student Marks i.
Introduction A one-sample t-test checks whether the average marks of students differ significantly
from a fixed reference value — such as the passing mark (50). This helps assess whether the class
overall is performing above or below expectations. ii. General Description • Dataset: Marks of
students entered in the C++ system • Sample Size: Total number of students (dynamic) •

Reference Mean (Μ): 50 Marks (E.G., Passing Average)

• Hypotheses: o H■ (Null Hypothesis): Average marks = 50 o H■ (Alternative Hypothesis):
Average marks ≠ 50 • Test Used: One-sample t-test using manually coded logic iii. Implementation
in C++

Code Snippet:

iv. Analysis Results (Example Values) • Sample Mean = 61.2 • Population Mean = 50 • Standard
Deviation = 18.4 • Sample Size = 30 students • t-statistic = 3.34 • p-value ≈ 0.002

Conclusion: Since P < 0.05, We Reject The Null Hypothesis.

v. Summary The one-sample t-test shows that students in the system perform significantly better
than the passing benchmark. This insight helps identify the overall academic strength of the group.

4.2 Two-Sample t-test: Science vs. Arts Students i. Introduction The two-sample t-test compares
the average marks between two student groups — in this case, Science and Arts — to check for
statistically significant performance differences. ii. General Description • Groups: Science vs. Arts
students • Sample Size: Equal or similar sample from both groups • Hypotheses: o H■:
Mean(Science) = Mean(Arts) o H■: Mean(Science) ≠ Mean(Arts) • Test Used: Two-sample t-test
(assuming unequal variance) iii. Implementation Logic (Pseudo C++) iv. Analysis Results
(Example) • Mean (Science) = 72.5 • Mean (Arts) = 64.1 • T-statistic = 2.11 • P-value = 0.041 •

Conclusion: P < 0.05 ⇒ Reject H■

Interpretation: Science students scored significantly higher than Arts students. v. Summary The
two-sample t-test shows a meaningful performance gap between Science and Arts students in the
dataset. These findings may support decisions on curriculum review, resource allocation, or
academic support.

4.3 Correlation Between Marks and Roll Number i. Introduction This section explores whether
there is any relationship between a student’s roll number and their marks — for example, to check
if earlier or later entries tend to perform better or worse. ii. General Description • X variable: Roll
Number • Y variable: Marks • Method: Pearson Correlation Coefficient

iii. Implementation in C++ Code Snippet:

iv. Analysis Result (Example) • Correlation Coefficient (r) = 0.03 v. Interpretation • The result
shows a very weak correlation between roll number and marks. • This suggests that roll number (or
order of entry) does not influence student performance. vi. Summary Marks appear to be
independent of roll number, indicating that student performance is unbiased and fairly distributed
regardless of entry sequence. 4.4 Outlier Detection in Student Marks i. Introduction Outliers are
data points that significantly deviate from the rest of the dataset. In the context of student marks,
outliers might represent: • High achievers (top performers) • Struggling students (low scorers) • Or
data entry errors Identifying outliers helps teachers, administrators, and analysts to focus attention
where needed — either to recognize excellence or provide support. ii. General Description To
detect outliers in student marks, we use the Z-score method based on mean and standard deviation.
A common rule is: A student’s mark is considered an outlier if:

iii. Implementation in C++ Code Snippet:

iv. Analysis Results (Example Output) Assume: • Mean = 60 • SD = 10 • Range for outliers: marks
< 40 or marks > 80 Sample output:

v. Summary Dataset Summary revealed that a few students scored exceptionally high or
exceptionally low, deviating from the rest of the class. These insights can be used to: • Reward top
performers • Offer remedial support to struggling students • Verify any data entry errors This
simple statistical method ensures better academic monitoring and fairness. 4.5 Linear Regression
Analysis i. Introduction Linear regression is a predictive statistical technique used to model the
relationship between two variables. In the context of this student record system, linear regression
can help predict a student’s marks based on another factor — such as roll number (as a proxy for
entry order or progression). While roll number doesn’t inherently predict marks, using it for
regression demonstrates how this analysis works. In a real-world scenario, more meaningful
independent variables (like study hours, attendance, or internal assessment scores) could be used if
available. ii. Objective To analyze whether there is a linear relationship between a student's Roll
Number (X) and their Marks (Y) using the simple linear regression formula: Y=a+bXY = a +
bXY=a+bX Where: • Y: Predicted marks • X: Roll number • a: Intercept • b: Slope (change in
marks per unit increase in roll number)

iii. Implementation in C++ To compute the linear regression line, we use the formulas:

C++ Code Snippet:

iv. Sample Output:

This equation means that for every 1 unit increase in roll number, marks increase by approximately
0.13, starting from a base of 40.27. Since the slope is low, it suggests a weak linear relationship. v.
Interpretation • If the slope b is close to 0, there's no significant relationship between roll number
and marks.

• If b is positive and large, marks increase with roll number. • If b is negative, marks decrease with
roll number.

vi. Summary Linear regression was applied to model the relationship between roll number and
marks. The resulting equation shows a very weak trend, confirming that roll number is not a strong
predictor of academic performance. However, this regression framework can be extended in future
to include more meaningful predictors like attendance, test scores, or hours studied. 4.6 Data
Visualization i. Introduction Data visualization is the graphical representation of information to
make trends, patterns, and outliers easier to understand. In this project, visualizing student data such
as marks distribution, performance comparisons, and regression trends helps interpret the results
more effectively than raw numbers alone. Since C++ has limited built-in plotting support, we use
external tools like Excel, Python (Matplotlib), or Google Sheets for visualization after exporting
data from the system. ii. Data Export from C++ To visualize the data, we can first export student
records to a .csv or .txt file:

Example C++ Snippet to Export Data:

Once exported, this file can be opened in Excel, Google Sheets, or processed with
Python/Matplotlib to generate the charts below. iii. Types of Visualizations i. Histogram – Marks
Distribution Purpose: To see how marks are distributed among students. • X-axis: Marks range
(e.g., 0–100 in intervals) • Y-axis: Number of students in each range Interpretation: Helps identify
how many students fall into each grade group (e.g., pass/fail distinction, bell-curve distribution) ii.
Box Plot – Outlier Detection Purpose: To visualize the spread of marks and detect outliers. • The
box shows the interquartile range (IQR) • The line inside the box shows the median • Dots outside
the “whiskers” indicate outliers Interpretation: Quickly shows central tendency and students with
unusually high or low marks.

iii. Scatter Plot – Regression Line Purpose: To visualize the relationship between Roll No and
Marks, along with the regression line. • X-axis: Roll Number • Y-axis: Marks • Each point = one
student • Overlay the regression line using:

Interpretation: Shows whether a trend exists — useful to confirm the regression analysis in Section
5. iv. Bar Chart – Stream-wise Average Comparison (If you stored stream info like Science/Arts) •
X-axis: Stream/Group • Y-axis: Average Marks • Each bar = group average • Helps compare
performance between streams v. Tools Used Since C++ lacks direct charting libraries, the following
tools can be used for visualization: Tool Use Case Excel/Sheets Import CSV, create charts easily
Python + Matplotlib Advanced charts, regression visualization Online Chart Tools Quick visual
output from CSV

vi. Summary Data visualization allows the insights discovered in previous sections (e.g., average
performance, outliers, regression) to be better communicated and interpreted. Although C++ is not
a visual language, exporting data and using external tools bridges that gap effectively.

Future Versions Of This System Could Integrate Libraries Like

Matplotlib-Python Or Connect To
GUIs (e.g., Qt) for real-time graphical outputs. vii. Analytics Results Based on the visualizations
created from the student data, the following insights were drawn: • Histogram of Marks
Distribution: The marks showed a roughly normal distribution with most students scoring between
50 and 75. Few students scored below 40 or above 85, indicating a moderate spread with some low
and high outliers. • Box Plot for Outlier Detection: The box plot confirmed the presence of a small
number of outliers on both ends of the spectrum — validating the earlier statistical outlier detection.
This highlights students who may need academic attention or recognition. • Scatter Plot with
Regression Line: The scatter plot showed a very weak positive correlation between roll number and
marks, consistent with the regression analysis. There was no clear trend indicating that roll number
predicts marks significantly.

5. Conclusion This project successfully implemented a Python Application Development: Student

Record Management System with core functionalities such as adding, displaying, and searching
student records. Further, it incorporated statistical analysis including mean, standard deviation,
correlation, and outlier detection to better understand student performance. Using linear regression,
the project modeled relationships between roll numbers and marks, concluding a weak correlation
in this dataset. Data visualization using external tools provided clear insights into marks
distribution, outliers, and trends. Overall, the system demonstrates how programming and data
analysis can be combined to manage academic records efficiently and extract meaningful insights,
supporting data-driven decision-making in educational settings.
6. Future Scope • Extended Data Attributes: Incorporate additional data such as attendance,
assignment scores, and extracurricular activities to enable more comprehensive analysis. •
Advanced Analytics: Implement multiple regression, clustering, or classification algorithms to
predict student success and identify at-risk students early. • Graphical User Interface (GUI):
Develop a user-friendly GUI using libraries like Qt or wxWidgets to improve interaction and data
visualization within the application. • Real-Time Visualization: Integrate plotting libraries (e.g.,
matplotlib-Python, or connect with Python scripts) for real-time data visualization directly from the

System.
• Database Integration: Move from in-memory arrays to persistent database storage (e.g., SQLite,
MySQL) to handle larger datasets and multi-user environments. • Web-based System: Transform
the project into a web application with interactive dashboards for easier access by students and
faculty.

7. References 1. Balagurusamy, E. (2017). Object Oriented Programming with C++ (7th Edition).
McGraw-Hill Education. 2. Gaddis, T. (2016). Starting Out with C++: From Control Structures
through Objects (8th Edition). Pearson. 3. Walpole, R. E., Myers, R. H., Myers, S. L., & Ye, K.
(2016). Probability and Statistics for Engineers and Scientists (9th Edition). Pearson. 4. Weiss, N.
A. (2012). Introductory Statistics (9th Edition). Pearson. 5. Wessa, P. (2023). Statistical Tests
(t-test, correlation, regression). Retrieved from https://www.wessa.net/ 6. Python Software
Foundation. (2024). Matplotlib: Visualization with Python. Retrieved from https://matplotlib.org 7.
Microsoft. (2025). Use Excel for Data Analysis and Visualization. Retrieved from
https://support.microsoft.com/excel 8. Cplusplus.com. (2024). Standard C++ Library Reference.
Retrieved from https://cplusplus.com/reference/ 9. Stroustrup, B. (2013). The C++ Programming
Language (4th Edition). Addison-Wesley. 10. Schildt, H. (2017). C++: The Complete Reference
(4th Edition). McGraw-Hill Education. 11. Josuttis, N. M. (2012). The C++ Standard Library: A
Tutorial and Reference (2nd Edition). Addison-Wesley. 12. Lippman, S. B., Lajoie, J., & Moo, B.
E. (2012). C++ Primer

(5th Edition). Addison-Wesley. 13. Meyers, S. (2005). Effective C++: 55 Specific Ways to Improve
Your Programs and Designs (3rd Edition). Addison- Wesley. 14. ISO/IEC (2020). Programming
Languages – C++ Standard (ISO/IEC 14882:2020). International Organization for Standardization.

15. Gamma, E., Helm, R., Johnson, R., & Vlissides, J. (1994).

Design Patterns: Elements Of Reusable Object-Oriented

Software. Addison-Wesley. 16. Wirth, N. (1976). Algorithms + Data Structures = Programs.
Prentice Hall. 17. GeeksforGeeks. (2025). C++ Programming Language Tutorials. Retrieved from
https://www.geeksforgeeks.org/c-plus- plus/ 18. TutorialsPoint. (2025). C++ Programming Basics.
Retrieved from https://www.tutorialspoint.com/cplusplus/ 19. Khan Academy. (2025). Statistics
and Probability. Retrieved from https://www.khanacademy.org/math/statistics-probability 20.
StatTrek. (2025). Statistics and Data Analysis. Retrieved from https://stattrek.com/ 21.
FreeCodeCamp. (2025). Learn C++ Programming. Retrieved from https://www.freecodecamp.org/
22. Oracle. (2025). Database Design Concepts. Retrieved from https://docs.oracle.com/ 23.
list-as-stack Overflow. (2025). C++ and Data Structures Discussions. Retrieved from
https://stackoverflow.com/