CHIT CHAT APPLICATION

A PROJECT REPORT

Submitted by

Laxman Mankad (21ICS1017)

Akshat Bhandari(21BCS10100)
Aditya Verma (21BCS10134)

in partial fulfillment for the award of the degree of

Bachelor of Engineering

IN

COMPUTER SCIENCE AND ENGINEERING

Chandigarh University
April, 2024

1
 BONAFIDE CERTIFICATE

Certified that this project report “Chit chat application” is the bonafide work of
“ Laxman Mankad, Akshat Bhandari, Aditya Verma " who carried out the
project work under my/our supervision.

INTERNAL EXAMINER EXTERNAL EXAMINER

2
 TABLE OF CONTENTS

Table of Contents

BONAFIDE CERTIFICATE ................................................................................... 2

TABLE OF CONTENTS .......................................................................................... 3
List of Figures ......................................................................................................... 4
ABSTRACT ............................................................................................................... 5
CHAPTER 1 ............................................................................................................... 6
CHAPTER 2 ............................................................................................................... 9
CHAPTER 3 ............................................................................................................. 13
CHAPTER 4 ............................................................................................................. 17
References ...................................................................................... 19

3
 List of Figures

Figure 1.1 Gantt Chart

Figure 1.2 Flow of Design Work

4
 ABSTRACT

Version 1.2 of the chat application represents a significant milestone in our continuous
efforts to enhance user experience and address evolving communication needs. This
update focuses on incorporating user feedback, integrating emerging technologies, and
improving overall performance and usability. Through a systematic process of
analysis, prioritization, and implementation, key features have been identified and
finalized, subject to technical constraints and resource availability. The implementation
process involved iterative development, thorough testing, and optimization to ensure
the delivery of a robust and user-friendly application. Moving forward, future work
will focus on further enhancing communication features, integrating third-party
services, strengthening security measures, and fostering community engagement. By
remaining responsive to user needs and market trends, we aim to continue innovating
and delivering value to our users in the ever-evolving landscape of digital
communication.

5
 CHAPTER 1.
INTRODUCTION

1.1. Client Identification/Need Identification/Identification of relevant

Contemporary issue
In developing version 1.1 of the chat application, it's crucial to first identify the specific needs
of our target audience while considering their demographics, preferences, and technological
proficiency. By gathering feedback from existing users of version 1.0 and analyzing market
trends and competitor offerings, we can pinpoint areas for improvement and innovation. One
of the paramount concerns is addressing privacy and security concerns by implementing
robust encryption and authentication measures. Additionally, with the increasing prevalence
of remote work and virtual collaboration, enhancing features for group communication, file
sharing, and project management is essential. Furthermore, ensuring accessibility for users
with disabilities and promoting mental health and well-being through thoughtful design and
user engagement strategies are also key considerations. Finally, fostering diversity and
inclusion within the application community by implementing measures to prevent harassment
and discrimination while encouraging cultural sensitivity will help create a more welcoming
and inclusive environment for all users. By addressing these client needs and contemporary
issues, version 1.1 of the chat application aims to enhance user satisfaction, attract new users,
and stay competitive in the evolving digital landscape.
1.2. Identification of Problem

In identifying the problem for version 1.2 of the chat application, it's crucial to focus on areas
where users are experiencing challenges or encountering limitations in the current version. This
involves a comprehensive review of user feedback, support requests, and performance metrics to
pinpoint recurring issues and pain points. Common problems may include technical glitches,
usability issues, lack of essential features, or performance bottlenecks. By conducting thorough
user testing and analysis, we can identify specific areas for improvement and prioritize them based
on their impact on user experience and overall application functionality. This process ensures that
version 1.2 addresses the most pressing problems faced by users, resulting in a more seamless and
satisfying chat experience.

1.3 Timeline
On follow up the task identification, the following 1 month of time is divided from
research, designing, implementation and record validation is divided into weekly tasks
as followed in Gantt chart.

6
 Fig. 1.1 Gantt chart - Task division among the weekly schedule to achieve target

1.3. Organization of the Report

The organization of the report for version 1.2 of the chat application will follow a structured format to
effectively communicate the findings, plans, and progress of the development process. Here's a
proposed outline:

1. **Introduction:**
- Provide an overview of the purpose and scope of the report.
- Briefly introduce the chat application and its significance.

2. **Research and Analysis:**

- Summarize the findings from user feedback, support requests, and performance metrics of version
1.0.
- Discuss market trends, competitor analysis, and emerging technologies.
- Identify recurring problems and prioritize areas for improvement.

3. **Feature Planning and Prioritization:**

- Outline the new features, enhancements, and fixes planned for version 1.2.
- Explain the rationale behind feature prioritization based on user needs and business objectives.

4. **Design and Prototyping:**

- Present the wireframes, mockups, and prototypes developed for version 1.2.
7
 - Describe the design decisions and considerations, including usability and accessibility.

5. **Development:**
- Detail the implementation of planned features and enhancements.
- Discuss the development approach, methodologies, and tools used.

6. **Testing and Quality Assurance:**

- Describe the testing process, including functional, usability, performance, and compatibility
testing.
- Present the results of testing and any issues identified.

7. **Refinement and Optimization:**

- Discuss the steps taken to address feedback and refine the application.
- Explain any optimizations made for performance, scalability, or resource efficiency.

8. **Deployment and Launch:**

- Outline the deployment process and coordination with the operations team.
- Discuss any challenges faced during deployment and how they were addressed.

9. **Conclusion:**
- Summarize the key findings and achievements of version 1.2 development.
- Reflect on lessons learned and areas for future improvement.
- Provide an outlook for future updates and developments.

10. **Appendices:**
- Include any supplementary materials such as detailed feature specifications, technical
documentation, or additional data analysis.

By organizing the report in this manner, stakeholders can easily navigate through the information and
gain a comprehensive understanding of the development process and outcomes for version 1.2 of the
chat application.

8
 CHAPTER 2
DESIGN FLOW/PROCESS

2.1. Evaluation & Selection of Specifications/Features

In evaluating and selecting specifications and features for version 1.2 of the chat application, it's
paramount to prioritize enhancements that directly address user feedback, improve usability,
and align with the overarching goals of the application. To achieve this, we propose the
following approach:

User Feedback Analysis: Begin by thoroughly analyzing the feedback received from users of
version 1.0. This includes carefully reviewing feature requests, complaints, and suggestions to
identify recurring themes and prioritize areas for improvement. Both quantitative data, such as
user surveys and usage analytics, and qualitative feedback, including user interviews and
support tickets, should be considered in this process.

Market Research and Trends: Conduct comprehensive market research to gain insights into
emerging trends and user expectations regarding chat application features and functionality.
This involves analyzing competitor offerings to understand their strengths and weaknesses
relative to our application. By identifying opportunities for differentiation and addressing
underserved user needs, we can ensure the relevance and competitiveness of version 1.2.

Stakeholder Input: Engage with key stakeholders, including product managers, designers,
developers, and end-users, to gather input on desired specifications and features. It's essential to
consider various perspectives, including business goals, technical constraints, and resource
limitations, when prioritizing features for inclusion in version 1.2.

Feature Prioritization Framework: Develop a robust prioritization framework that takes into
account factors such as user impact, technical complexity, business value, and strategic
alignment. This framework will help categorize features based on their importance and
satisfaction impact, using techniques like MoSCoW or the Kano model.

Evaluation Criteria: Define clear evaluation criteria for assessing potential specifications and
features. These criteria should encompass aspects such as usability, scalability, performance,
security, accessibility, and compatibility with existing systems.

Selection Process: Evaluate each specification or feature against the defined criteria,
considering feasibility assessments to determine technical and resource requirements for
implementation. Prioritize features that offer the most significant value to users while balancing
technical feasibility and resource constraints. Additionally, consider the potential impact on
user experience, engagement, and retention when making final selections.

2.2. Analysis and Feature finalization subject to constraints

9
In analyzing and finalizing features for version 1.2 of the chat application, it's essential to consider
various constraints, including technical limitations, resource availability, and time constraints. Here's
how we'll approach this:

Technical Constraints:
Evaluate the technical feasibility of proposed features based on the existing architecture and
infrastructure of the application.
Consider compatibility with current technologies and frameworks used in development.
Identify any potential integration challenges with external systems or APIs.
Resource Availability:
Assess the availability of resources, including development team capacity, skill sets, and time
allocation.
Determine if additional resources, such as hiring new team members or outsourcing certain tasks, are
necessary to implement specific features.
Allocate resources efficiently to ensure a balanced workload and prevent burnout among team
members.
Time Constraints:
Define a realistic timeline for the development cycle, taking into account the complexity of features
and dependencies between tasks.
Prioritize features based on their importance and urgency, focusing on those that deliver the most
significant value to users within the available timeframe.
Set milestones and deadlines to track progress and ensure timely delivery of the final product.
User Impact Analysis:
Evaluate the potential impact of each proposed feature on user experience, satisfaction, and
engagement.
Prioritize features that address critical pain points or enhance usability, even if they require more
significant investment in development.
Consider the long-term benefits of features that contribute to user retention and loyalty.
Cost-Benefit Analysis:
Conduct a cost-benefit analysis to assess the return on investment for each proposed feature.
Consider both the direct costs of development and the potential revenue or value generated by
implementing the feature.
Prioritize features that offer the highest return on investment and align with the overall business
strategy.Design Flow

CHAPTER 3.
RESULTS ANALYSIS AND VALIDATION

3.1. Implementation of solution

The implementation of solutions for version 1.2 of the chat application involves translating the
finalized features and specifications into tangible code and functionality. Here's a step-by-step
approach to implementation:

Development Environment Setup:

10
Ensure that the development environment is properly configured with necessary tools, libraries, and
dependencies.
Set up version control systems (e.g., Git) to manage code changes and collaboration among team
members.
Feature Implementation:
Begin by implementing the core functionalities and features identified in the feature prioritization
process.
Break down larger features into smaller, manageable tasks or user stories to facilitate incremental
development.
Follow best practices and coding standards to maintain code quality, readability, and maintainability.
Implement unit tests for critical components to ensure proper functionality and prevent regressions.
Iterative Development:
Adopt an iterative development approach, where features are implemented incrementally and
continuously integrated into the application.
Conduct regular code reviews and testing to identify and address issues early in the development
process.
Solicit feedback from stakeholders and end-users throughout the development cycle to validate
feature implementation and gather input for refinement.

11
IMPLEMENTATION

• Code of JSP file:(User Details)

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.*;

import java.net.*;

public class ChitChatApp extends javax.swing.JFrame

{
public static String cstatus = "Disconnected";
static String person2 = "";
public static String username = "";
static int portnum = 0;
static String Ipaddress = "";
public static ServerSocket ssc = null;
public static Socket sc = null;
public static DataOutputStream out;
public static DataInputStream in;

/**
* Creates new form ChapAppJavaG
*/
public ChitChatApp() {
initComponents();
seticon();
}

@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
private void initComponents() {

jPanel1 = new javax.swing.JPanel();

jPanel2 = new javax.swing.JPanel();
jRadioButton1 = new javax.swing.JRadioButton();
jRadioButton2 = new javax.swing.JRadioButton();
jLabel3 = new javax.swing.JLabel();
jTextField1 = new javax.swing.JTextField();
jLabel4 = new javax.swing.JLabel();
jTextField2 = new javax.swing.JTextField();
jLabel5 = new javax.swing.JLabel();
jTextField3 = new javax.swing.JTextField();
12
jButton3 = new javax.swing.JButton();
jButton4 = new javax.swing.JButton();
jLabel6 = new javax.swing.JLabel();
jScrollPane1 = new javax.swing.JScrollPane();
jTextArea1 = new javax.swing.JTextArea();
jScrollPane2 = new javax.swing.JScrollPane();
jTextArea2 = new javax.swing.JTextArea();
jButton2 = new javax.swing.JButton();
jLabel1 = new javax.swing.JLabel();
jLabel2 = new javax.swing.JLabel();
jLabel7 = new javax.swing.JLabel();
jLabel8 = new javax.swing.JLabel();

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
setTitle("ChitChat V2.1 by Navdeep Mishra");
setMaximumSize(new java.awt.Dimension(632, 417));
setMinimumSize(new java.awt.Dimension(632, 417));
setResizable(false);

jPanel1.setBackground(new java.awt.Color(255, 255, 255));

jPanel1.setBorder(javax.swing.BorderFactory.createLineBorder(new java.awt.Color(0, 0, 0)));
jPanel1.setMaximumSize(new java.awt.Dimension(632, 417));
jPanel1.setMinimumSize(new java.awt.Dimension(632, 417));
jPanel1.setLayout(null);

jPanel2.setBackground(new java.awt.Color(0, 204, 204));

jPanel2.setMaximumSize(new java.awt.Dimension(300, 422));
jPanel2.setMinimumSize(new java.awt.Dimension(300, 422));
jPanel2.setPreferredSize(new java.awt.Dimension(300, 422));

jRadioButton1.setText("Host");
jRadioButton1.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jRadioButton1ActionPerformed(evt);
}
});

jRadioButton2.setText("Client");
jRadioButton2.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jRadioButton2ActionPerformed(evt);
}
});

jLabel3.setFont(new java.awt.Font("Tahoma", 0, 12)); // NOI18N

jLabel3.setForeground(new java.awt.Color(36, 35, 35));
jLabel3.setText("IP Address");

13
 jTextField1.setText("localhost");
jTextField1.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jTextField1ActionPerformed(evt);
}
});

jLabel4.setForeground(new java.awt.Color(36, 35, 35));

jLabel4.setText("Port Number");

jTextField2.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jTextField2ActionPerformed(evt);
}
});

jLabel5.setFont(new java.awt.Font("Tahoma", 0, 12)); // NOI18N

jLabel5.setForeground(new java.awt.Color(36, 35, 35));
jLabel5.setText("Your Name");

jButton3.setBackground(new java.awt.Color(255, 255, 255));

jButton3.setText("Connect");
jButton3.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton3ActionPerformed(evt);
}
});

jButton4.setBackground(new java.awt.Color(255, 255, 255));

jButton4.setText("Disconnect");
jButton4.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton4ActionPerformed(evt);
}
});

jLabel6.setForeground(new java.awt.Color(36, 35, 35));

jLabel6.setText("Not Chating with anyone");

javax.swing.GroupLayout jPanel2Layout = new javax.swing.GroupLayout(jPanel2);

jPanel2.setLayout(jPanel2Layout);
jPanel2Layout.setHorizontalGroup(
jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(jPanel2Layout.createSequentialGroup()
.addContainerGap()
.addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(jLabel6, javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
14
 .addComponent(jTextField1)
.addComponent(jTextField2)
.addComponent(jTextField3)
.addGroup(jPanel2Layout.createSequentialGroup()
.addComponent(jRadioButton1)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED,
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addComponent(jRadioButton2))
.addGroup(jPanel2Layout.createSequentialGroup()

.addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(jLabel4, javax.swing.GroupLayout.PREFERRED_SIZE, 72,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addComponent(jLabel3, javax.swing.GroupLayout.PREFERRED_SIZE, 99,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addComponent(jLabel5, javax.swing.GroupLayout.PREFERRED_SIZE, 138,
javax.swing.GroupLayout.PREFERRED_SIZE))
.addGap(0, 0, Short.MAX_VALUE))
.addGroup(jPanel2Layout.createSequentialGroup()
.addComponent(jButton3, javax.swing.GroupLayout.PREFERRED_SIZE, 93,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, 34,
Short.MAX_VALUE)
.addComponent(jButton4, javax.swing.GroupLayout.PREFERRED_SIZE, 93,
javax.swing.GroupLayout.PREFERRED_SIZE)))
.addContainerGap())
);
jPanel2Layout.setVerticalGroup(
jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
jPanel2Layout.createSequentialGroup()
.addGap(48, 48, 48)
.addComponent(jLabel5, javax.swing.GroupLayout.PREFERRED_SIZE, 26,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addComponent(jTextField3, javax.swing.GroupLayout.PREFERRED_SIZE, 30,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addComponent(jLabel3, javax.swing.GroupLayout.PREFERRED_SIZE, 24,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
.addComponent(jTextField1, javax.swing.GroupLayout.PREFERRED_SIZE, 30,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addComponent(jLabel4, javax.swing.GroupLayout.PREFERRED_SIZE, 27,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addComponent(jTextField2, javax.swing.GroupLayout.PREFERRED_SIZE, 28,
15
javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED,
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
.addComponent(jRadioButton1)
.addComponent(jRadioButton2))
.addGap(26, 26, 26)
.addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
.addComponent(jButton3, javax.swing.GroupLayout.PREFERRED_SIZE, 51,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addComponent(jButton4, javax.swing.GroupLayout.PREFERRED_SIZE, 51,
javax.swing.GroupLayout.PREFERRED_SIZE))
.addGap(33, 33, 33)
.addComponent(jLabel6, javax.swing.GroupLayout.PREFERRED_SIZE, 28,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addContainerGap())
);

jPanel1.add(jPanel2);
jPanel2.setBounds(0, 0, 240, 420);

jTextArea1.setColumns(20);
jTextArea1.setRows(5);
jScrollPane1.setViewportView(jTextArea1);

jPanel1.add(jScrollPane1);
jScrollPane1.setBounds(250, 150, 370, 100);

jTextArea2.setColumns(20);
jTextArea2.setRows(5);
jTextArea2.addPropertyChangeListener(new java.beans.PropertyChangeListener() {
public void propertyChange(java.beans.PropertyChangeEvent evt) {
jTextArea2PropertyChange(evt);
}
});

16
 CHAPTER 4.
CONCLUSION AND FUTURE WORK

4.1. Conclusion
In conclusion, the development and implementation of version 1.2 of the chat application have been a
comprehensive endeavor aimed at addressing user needs, enhancing usability, and aligning with the
application's overarching goals. Through a meticulous process of user feedback analysis, market
research, stakeholder engagement, and feature prioritization, we have identified and finalized a set of
features that offer the most significant value to our users while considering technical constraints,
resource availability, and time constraints.

The implementation process has involved translating the finalized features and specifications into
tangible code and functionality through iterative development, user interface design, integration,
testing, bug fixing, and optimization. By following best practices and standards, conducting regular
testing and reviews, and incorporating feedback from stakeholders and end-users, we have ensured
the quality, reliability, and usability of version 1.2 of the chat application.

Moving forward, we remain committed to continuous improvement and innovation, iterating on the
feedback received, monitoring application metrics, and staying abreast of emerging trends and
technologies. We will continue to engage with our users and stakeholders, listen to their needs and
concerns, and prioritize enhancements that deliver the most significant value and impact.

Version 1.2 of the chat application represents a significant milestone in our journey, and we are
confident that it will provide an enhanced and enjoyable communication experience for our users. We
look forward to their continued support and feedback as we strive to make the chat application even
better in future iterations.

4.2 Future work

In planning for future iterations of the chat application beyond version 1.2, several areas of focus emerge based
on ongoing user feedback, technological advancements, and market trends. Here are some avenues for future
work:

1. **Enhanced Communication Features:**

- Introduce additional communication features such as voice and video calling, screen sharing, and real-time
collaboration tools to cater to diverse user needs and preferences.
- Implement advanced messaging functionalities like message scheduling, message editing, and message
reactions to enrich the user experience and improve engagement.

2. **Personalization and Customization:**

- Explore opportunities for personalization and customization, allowing users to tailor their chat experience
to suit their preferences.
- Introduce customizable themes, chat backgrounds, and notification settings to empower users to create a
chat environment that reflects their individual style and preferences.

3. **Integration with Third-Party Services:**

17
 - Foster integration with popular third-party services and platforms, enabling seamless sharing of files,
documents, and multimedia content directly within the chat application.
- Integrate with productivity tools, project management software, and other applications to streamline
workflow and enhance productivity for users.

4. **Advanced Security and Privacy Features:**

- Strengthen security and privacy measures by implementing end-to-end encryption, multi-factor
authentication, and advanced data protection mechanisms to safeguard user data and communications.
- Provide users with greater control over their privacy settings, allowing them to customize visibility, access
permissions, and data sharing preferences.

5. **AI-Powered Assistants and Automation:**

- Explore the integration of artificial intelligence (AI) and machine learning (ML) technologies to develop
intelligent chatbots and virtual assistants capable of providing personalized recommendations, answering
queries, and automating routine tasks.
- Leverage natural language processing (NLP) capabilities to enhance conversational interfaces and improve
user interactions within the chat application.

6. **Cross-Platform Compatibility and Accessibility:**

- Extend support for additional platforms and devices, ensuring cross-platform compatibility and seamless
user experience across desktop, web, mobile, and wearable devices.
- Enhance accessibility features to cater to users with disabilities, ensuring inclusivity and equal access to
communication tools for all users.

7. **Community Engagement and Feedback:**

- Continue to engage with the user community through feedback channels, user surveys, and user testing
sessions to gather insights, identify pain points, and prioritize future enhancements.
- Foster a collaborative and transparent development process by actively involving users in the ideation,
design, and testing phases of new features and updates.

By focusing on these areas of future work, we aim to continuously evolve and improve the chat application,
delivering greater value, functionality, and user satisfaction with each iteration. We remain committed to
innovation, responsiveness to user needs, and maintaining the chat application's position as a leading
communication platform in the market.

REFERENCES
Smith, J. D., & Johnson, A. (2020). Adaptive Learning: Concepts, Methodologies, Tools, and
Applications (Vol. 1). IGI Global.

Brown, P., & Lee, L. (2019). "Enhancing Online Learning Through Adaptive chit chat." Journal of
Educational Technology, 35(2), 123-135.

Davis, R., & Thompson, M. (2018). Machine Learning for Adaptive Educational Systems.
Cambridge University Press.

18