VISVESVARAYA TECHNOLOGICAL

UNIVERSITY
“Jnana Sangama”, Belgaum-590018, Karnataka

Inter/Intra Internship Report [21INT49]

On

“CHAT APPLICATION”
Submitted in partial fulfillment of the requirements for the award of a degree
of

Bachelor of Engineering
In

INFORMATION SCIENCE AND ENGINEERING

Submitted by

1. USN: 1BI21IS069 Name: PAVANA B C

2. USN: 1BI21IS070 Name: PRANESH P

Under the Guidance of

Dr. Jayasheela C S
Assistant Professor
Dept. of ISE, BIT

BANGALORE INSTITUTE OF TECHNOLOGY

K. R. Road, V. V. Pura, Bengaluru – 560004
Department of Information Science & Engineering
2022-23
 BANGALORE INSTITUTE OF TECHNOLOGY
V.V. Puram, K.R. Road, Bengaluru-560004
Department of Information Science & Engineering

CERTIFICATE
Certified that the Internship Project Work entitled “CHAT APPLICATION’’ carried out by
PAVANA B C(1BI21IS069), PRANESH P(1BI21IS070) in partial fulfillment of the
requirements for the IV Semester Bachelor of Engineering in Information Science and
Engineering of Visvesvaraya Technological University, Belagavi during the academic year
2022-2023. It is certified that allcorrections/suggestions indicated for Internal Assessment have
been incorporated in the report deposited in the departmental library. The Internship Project
report has been approved as it satisfies the academic requirements for the said degree.

Dr. Jayasheela C S Dr. Asha T

Assistant Professor Professor and HOD
Department of ISE Department of ISE
BIT, Bangalore
 DECLARATION

We, PAVANA B C(1BI21IS069), PRANESH P(1BI21IS070) students of IV Semester

B.E., in Information Science and Engineering, Bangalore Instituteof Technology hereby
declare that the Internship Project entitled “CHAT APPLICATION” has been carried
out by us and submitted in partial fulfilment of the requirements for the IV Semester
degree of Bachelor of Engineering in Information Science and Engineering of
Visvesvaraya Technological University, Belagavi during academic year 2022-23.

Date: 13/9/23
Place: Bangalore
 ABSTRAC

The Java-based Chat Application project is an innovative and versatile solution engineered
to enable seamless real-time communication among users, leveraging the exceptional
capabilities of multithreading for enhanced efficiency. This project is committed to
delivering a robust, secure, and user-friendly platform that empowers individuals to engage
in instant messaging and dynamic group discussions with confidence and ease.

The Java-based Chat Application project is poised to redefine the landscape of real-time
communication, offering a secure, efficient, and user-centric platform for users to connect,
collaborate, and share across various domains. With a commitment to ongoing
improvement, this project stands at the forefront of modern digital communication solutions.

The development approach of this project hinges on the utilization of Java, capitalizing on
multithreading to manage concurrent user interactions efficiently. Furthermore, stringent
security measures have been meticulously implemented to safeguard user data, preserve
privacy, and ensure confidentiality throughout all communication channels. Additionally,
the user interface has been thoughtfully designed, focusing on intuitive navigation and an
aesthetically pleasing experience, guaranteeing that users can readily engage with one
another without impediments.

In recognition of the ever-evolving digital landscape, this project remains open to future
enhancements that promise to elevate its functionality and utility. Potential improvements
include the implementation of robust end-to-end encryption for heightened data security, the
development of a mobile application version to cater to users on the move, the exploration
of integration opportunities with external services and APIs, and the introduction of
advanced search capabilities and message archiving features to enhance message retrieval
management.
 ACKNOWLEDGEMENT

The satisfaction and euphoria that accompanies the successful completion of any
task would be incomplete without complementing those who made it possible and whose
guidance and encouragement made my efforts successful. My sincere thanks to all those
who have supported me in completing this Internship successfully.

My sincere thanks to Dr. M. U. Aswath, Principal, BIT and Dr. Asha T, HOD,
Department of ISE, BIT for their encouragement, support and guidance to the student
community in all fields of education. I am grateful to our institution for providing us a
congenial atmosphere to carry out the Internship successfully.

I would not forget to remember Prof. Chethana M, Assistant Professor for

Inter/Intra (21INT49) Internship Coordinator, Department of ISE, BIT, for her
encouragement and more over for her timely support and guidance till the completion of
the Internship..

I avail this opportunity to express my profound sense of deep gratitude to

esteemed guide, Dr. Jayasheela C S, Assistant Professor, Department of ISE, BIT, for
her moral support, encouragement and valuable suggestions throughout the Internship.

I extend my sincere thanks to all the department faculty members and non-teaching staff
for supporting me directly or indirectly in the completion of this Internship.

PAVANA B C
1BI21IS069
PRANESH P
1BI21IS070
 TABLE OF
CONTENTS Page No
Chapter 1 – Introduction 01
Chapter 2 – System Architecture 03
2.1 High-Level Overview 04
2.2 Component Diagram 06
2.3 Technology Stack 07
Chapter 3 – Task Performed 08
3.1 Client-Side Tasks 08
3.2 Server-Side Tasks 08
Chapter 4 – Tools & Technologies 10
4.1. Java Programming Language 10
4.2 Java Collections Framework 10
4.3 Object-Oriented Programming (OOP) 11
4.4 IDE or Text Editor 12
4.5 Command Line Interface (CLI) 12
4.6 Java Classes and Objects 13
4.7 Java Constructor 14
4.8 Java Access Modifiers 14
4.9 Multithreading 15
Chapter 5 – Implementation 16
Chapter 6 – Result 26
6.1 Server Output 27
6.2 Client Output 28
Chapter 7 – Reflection Notes 29
7.1 Technical Outcomes 29
7.2 Non-Technical Outcomes 30
Chapter 8 – Conclusion, Applications and Future Work 32
8.1 Applications 33
8.2 Future Work 34
8.3 Conclusion 35
Chapter 1
INTRODUCTION

The report is based on the Inter College Internship Programming carried out by Bangalore
Institute of Technology for the year 2022 for the first-year students at the end of their
first-year course. It is done as per the guidelines issued by Visvesvaraya Technological
University (VTU). The goal of the internship being to indulge in outcome-based learning
initiations and inculcate attributes that fall within the graduate attributes defined by the
NBA.

To test the skill and knowledge attained by the students over the course of their internship
is tested by giving them a problem statement to solve using their creativity and their
understanding of the internship subject. Over the course of this report, the knowledge of
JAVA that has been imparted over the course of the internship has been implemented into
solving the problem statements.

The problem statement introduced is a combination of various problems that are based on
the entirety of JAVA programming. The problem statement given is such that it uses all
the concepts of java and with each part of the problem statement being a problem that
revolves around a certain concept in JAVA. The report contains various topics and
concepts of JAVA that are combined together to cover and solve the problem statement.
All the concepts of JAVA are incorporated together to solve various aspects of the
problem. The application is reduced as much as possible to avoid errors while entering the
data.

The report contains various topics and concepts of JAVA that are combined together to
cover and solve the problem statement. All the concepts of JAVA are incorporated
together to solve various aspects of the problem.

The report contains the information about the System architecture used in the project.
System architecture is the visualization of the program model or a conceptual model that
defines the behavior, structure and working of a system.

Dept. of ISE, 2022- Page

 INTRODUCTION

A system architecture can consist of system components and the assembly of the sub-
systems, that will work together to implement the overall system.

The report contains the description of the tools and techniques that are used to implement
the working of the overall problem statement. It contains the information and explanation
about the tools and technologies, the reason why they are used in the problem, the role
that they play and description about their features and other details.

The report then contains the notes and the written reflection of the thought process that
went into implementing the project report, about the self-assessment and experience
throughout them working on the project. It also contains the non-technical take-outs that
have been taken from the project, like improvement in vocalization skills, communication
skills, time management and more.

Overall, the internship was an excellent and effective step for students to sharpen their
skills and learn new ones to add to their portfolios and resumes. It also created and
opportunity for them to learn and practice team working and effective communicative
skills and enhance their knowledge and make them ready for acing entry-level jobs and
securing a firm place in the industry.

Dept. of ISE, 2022- Page

Chapter 2

SYSTEM ARCHITECTURE

In this phase, a logical system is built which fulfills the given requirements. Design phase
of software developments deals with transforming the client’s requirements into a
logically working system. Normally, design is performed in the following two steps:

1. PRIMARY DESIGN PHASE: In this phase, the system is designed at block

level. These blocks are created on the basis of analysis done in the problem
identification phase. Different blocks are created for different functions with
emphasis put on minimizing the information flow between the blocks.

2. SECONDARY DESIGN PHASE: In the secondary design phase the detailed

design of each block is performed.

The general tasks involved in the design process are the following:
 Design various blocks for overall system processes.
 Design smaller, compact and workable modules in each block.
 Design various database structures.
 Specify details of programs to achieve desired functionality.
 Design form of inputs and outputs of the system.
 Perform documentation of the design.
 System reviews.

Another System design that has been used in the program is the User Interface Design.
User Interface Design is concerned with the dialogue between a user and the computer. It
is concerned with everything from starting the system or logging into the system to the
eventually presentation of desired inputs or outputs. The overall flow of screens and
messages is called a dialogue.

The guidelines for User Interface Design are:

1. The system user should always be aware of what to do next.
2. The screen should be formatted so that various types of information, instructions
 SYSTEM

3. Message, instructions or information should be displayed long enough to allow the

system user to read them.
4. Use display attributes sparingly.
5. Default values for fields and answers to be entered by the user should be specified.
6. A user should not be allowed to proceed without correcting an error.
7. The system user should never get an operating system or fatal error.

The system architecture of the Java-based Chat Application project plays a crucial role in
ensuring its efficiency, scalability, and security. Here's an overview of the system
architecture for the Chat Application:

2.1 High-Level Overview: At a high level, the system architecture can be represented as
layered architecture with distinct layers responsible for handling specific tasks. The layers
interact with each other to achieve the overall functionality of the system. The main layers of
the system architecture include:

 Client-Server Architecture: The Chat Application follows a client-server

architectural model, where the system is divided into two main components:
Client: The client-side application is installed on users' devices (e.g., computers or
mobile devices) and allows them to interact with the chat system. It handles user
interface, message composition, and display.
Server: The server-side component acts as the central hub responsible for managing
user connections, handling message routing, and maintaining user accounts and chat
histories. It is responsible for the core functionality of the chat application.

 Multithreading:
To provide real-time communication, the server employs multithreading to handle
concurrent connections and communication between clients. Each client connection
is managed by a separate thread.

 User Authentication and Authorization:

User authentication is a fundamental component of the system's security. The
server verifies user credentials during the login process and authorizes users to
access their accounts.

Dept. of ISE, 2022- Page

 SYSTEM

 Message Handling:
Message Queuing: The server maintains a message queue for each user or chat
group. When a client sends a message, it is placed in the appropriate message queue
for delivery.
Real-Time Messaging: Messages are delivered in real-time to the intended
recipients. This is achieved through efficient message routing and broadcasting to
relevant clients.

 Data Storage:
User Profiles and Authentication Data: User account information, including
usernames and hashed passwords, are stored in a secure database.
Message History: Chat message history is stored in a database, allowing users to
retrieve past messages and view chat logs.

 Security Measures:
Encryption: The system employs encryption protocols (e.g., SSL/TLS) to secure
data transmission between clients and the server, ensuring the confidentiality and
integrity of messages.
User Data Protection: User data, including login credentials and personal
information, is stored securely with proper encryption and access controls to
prevent unauthorized access.

 User Interface:
The client-side application features an intuitive and user-friendly interface. It allows
users to view their chat history, compose and send messages, create and manage
group chats, and receive real-time notifications for incoming messages.

 Scalability:
The architecture is designed with scalability in mind. It should be capable of
accommodating a growing user base by adding more servers or resources as needed
without significant disruption.

Dept. of ISE, 2022- Page

 SYSTEM

2.2 Component Diagram: A component diagram can illustrate the main components of
the system architecture and their interactions. The chat application can be represented
using a component diagram as follows:

Figure 2.2: Component Diagram of Chat application.

Dept. of ISE, 2022- Page

 SYSTEM ARCHITECTURE

2.3 Technology Stack:

The technology stack used in this client code is straightforward. This technology stack
provides the foundation for developing the server-side components of your Java-based chat
application, allowing you to manage client connections, route messages, and interact with a
database. Depending on project's requirements,we may also need to consider additional
features such as user management, chat room creation, and message persistence.

Client-Side:

Java: The code is written in the Java programming

language. Socket Communication:
Socket API: Java's built-in Socket and ServerSocket classes are used for creating and
managing socket connections.
BufferedReader: Used to read server responses from the socket's input stream.
PrintWriter: Used to send messages to the server through the socket's output stream

Server-Side:

Java SE (Standard Edition): You can create a server application using Java SE, which
provides basic networking capabilities.
Java EE (Enterprise Edition): If you're developing a more complex or scalable chat server,
consider using Java EE, which provides enterprise-level features for distributed applications.
ServerSocket: Java's ServerSocket class is used to create and manage server sockets,
listening for incoming client connections on a specified port.
Java Concurrency: Employ Java's multithreading capabilities to handle multiple client
connections concurrently. Each client connection should be managed by a separate thread.

Dept. of ISE, 2022- Page 7

 Chapter 3

TASK PERFORMED

3.1 Client-Side Tasks:

On the client side, the tasks encompass a wide range of responsibilities aimed at delivering a
seamless and user-friendly experience. User Interface (UI) development takes center stage,
requiring the creation of visually appealing and intuitive interfaces that enable users to
interact effortlessly with the application. Managing user input is another crucial aspect,
encompassing input validation and feedback mechanisms to ensure data integrity.

Network communication is fundamental as clients establish connections to the server using

Java libraries. They send client requests and receive server responses, adeptly handling
network-related issues for a reliable user experience. Additionally, data presentation is
pivotal, as clients are tasked with formatting and rendering data retrieved from the server in
a comprehensible and responsive manner, whether it's presenting dynamic web content or
processing data for mobile applications.

Clients may also employ client-side caching techniques to optimize performance by storing
static resources locally, reducing server requests and enhancing load times. User
authentication mechanisms are often integrated to securely manage user credentials, ensuring
that only authorized individuals gain access to specific resources. Error handling is equally
critical on the client side, encompassing not only input validation but also the graceful
management of network errors and server unavailability to maintain uninterrupted user
interactions.

3.2 Server-Side Tasks:

Conversely, the server-side responsibilities are multifaceted, starting with server

initialization, where server resources are configured, and network ports are set up to
accommodate incoming client connections. Request handling is paramount, involving the
reception of client requests, interpretation of request parameters, and the efficient routing of
requests to the relevant server-side components or endpoints for further processing.

Dept. of ISE, 2022- Page

 TASK PERFORMED

Executing the core business logic is a pivotal task. It involves intricate database operations,
complex calculations, data manipulation, and other crucial functions required to fulfill client
requests. Security measures play a vital role in safeguarding data and ensuring secure
transactions, often including user authentication, authorization, and data encryption.

Response generation is another key duty, with the server-side code preparing appropriate
responses tailored to each client's needs. This often involves formatting data as HTML for
web applications, JSON for APIs, or other relevant formats. Scalability considerations
ensure that the application can handle increased user loads by horizontally or vertically
scaling server resources.

Server-side code may also implement caching mechanisms to enhance performance and
reduce the load on databases. Moreover, meticulous logging and monitoring tools are
integrated to record events, errors, and activities for analysis, troubleshooting, and
performance optimization. The server side is also responsible for managing resources
efficiently, including database connections, file handling, and memory usage, to prevent
resource leaks and maintain application stability.

Lastly, tasks like deployment and maintenance ensure that the server application remains
operational, secure, and up-to-date throughout its lifecycle, contributing to the overall
reliability and efficiency of the client-server Java project.

Dept. of ISE, 2022- Page

Chapter
4
TOOLS AND TECHNOLOGIES

4.1. Java Programming Language:

Originally developed by James Gosling at Sun Microsystems, Java is a high-level, class-
based, object-oriented programming language that is designed to have as few
implementation dependencies as possible. It is a general-purpose programming language
intended to let programmers: write once, run anywhere (WORA), meaning
that compiled Java code can run on all platforms that support Java without the need to
recompile. Java applications are typically compiled to bytecode that can run on any Java
Virtual Machine (JVM) regardless of the underlying computer architecture.
There were five primary goals in the creation of the Java language:
 It must be simple, object-oriented, and familiar.
 It must be robust and secure.
 It must be architecture-neutral and portable.
 It must execute with high performance.
 It must be interpreted, threaded, and dynamic.

A traditional “Hello World” code in JAVA looks as the following:

Figure 4.1: Hello World code in JAVA

4.2 Java Collections Framework: The code uses the Java Collections Framework,
specifically the Array List class, which is a dynamic array implementation that provides
methods to manipulate lists. Java Collections can achieve all the operations that you
perform on a data such as searching, sorting, insertion, manipulation, and deletion.

Java Collection means a single unit of objects. Java Collection framework provides many
interfaces (Set, List, Queue, Deque) and classes (Array List, Vector, Linked Link, Priority
Queue, HashSet, Linked Hash Set, Tree Set).

Dept. of ISE, 2022- Page

 TOOLS AND

Framework in JAVA has the properties to:

 It provides readymade architecture.
 It represents a set of classes and interfaces.
 It is optional.
The JAVA collection framework has:
1. Interfaces and its implementations, i.e., classes
2. Algorithm

Figure 4.2: Java Collection Framework

4.3 Object-Oriented Programming (OOP): Object-Oriented Programming (OOP) is a

programming paradigm based on the concept of “objects,” which represent real-world
entities or concepts and encapsulate both data (attributes) and behavior (methods). OOP
focuses on organizing code into reusable, modular units, promoting the principles of
abstraction, encapsulation, inheritance, and polymorphism.

The code demonstrates object-oriented programming concepts by defining classes

(Alumni, Student, and Alumni Information System) that encapsulate data and behavior.
Encapsulation ensures that the data (attributes) and behavior (methods) of an object are
bound together and hidden from external access. Access to the internal state is controlled
through public interfaces (getters and setters).

Dept. of ISE, 2022- Page

 TOOLS AND

4.4 IDE or Text Editor: An Integrated Development Environment (IDE) is a software

application that provides comprehensive tools and features to support software
development. It is a one-stop solution for programmers to write, edit, compile, debug, and
deploy code.

A text editor is a simple software application used for editing plain text files. Unlike
IDEs, text editors lack specialized development features like code compilation,
debugging, and project management.

The code could have been written using any text editor (like Notepad, Sublime Text, etc.)
or an Integrated Development Environment (IDE) such as Eclipse, IntelliJ IDEA, or
NetBeans.

4.4.1 Choosing Between IDE and Text Editor:

 Use an IDE for comprehensive development with debugging, project
management, and specialized language support.
 Use a text editor for quick, lightweight editing or when working on simple
configurations or non-code files. Developers often use text editors alongside
terminal-based tools for quick edits.

4.5 Command Line Interface (CLI): The code can be compiled and executed using a
Java development kit (JDK) from the command line.

The code defines two classes, Alumni and Student, which represent alumni and student
information, respectively. The Alumni Information System class serves as a container for
storing and managing lists of alumni and students. It has methods to add alumni and
student objects to their respective lists and provides getters to access the lists.

In the main method, sample data is added to the Alumni Information System, and then the
alumni and student lists are displayed using System.out.println. The toString methods are
used to represent the objects as strings when they are printed to the console.

Overall, the code is a simple demonstration of a data management system for alumni and
students, written in Java with basic data structures from the Java Collections Framework.

Dept. of ISE, 2022- Page

 TOOLS AND

4.6 Java Classes and Objects:

The code defines two classes, Alumni and Student, to represent alumni and student
objects.
 In Java, a class is a blueprint or template for creating objects. It defines the
structure and behaviour of objects that will be created based on it.
 A class encapsulates data (attributes) and behaviour (methods) that represent the
characteristics and actions of the objects.
 The class declaration starts with the class keyword, followed by the class name
and the class body enclosed in curly braces {}.
 The class body can contain fields (instance variables) and methods (functions) that
define the properties and actions of the objects.
 Classes are used to achieve encapsulation, abstraction, inheritance,
and polymorphism, the four fundamental principles of object-oriented
programming.

These classes have instance variables (name, graduation Year/Admission Year, contact,
email) along with constructors and getter methods (toString, and setters are not explicitly
shown but implied).

4.7 Java Constructor:

 Java constructors are special methods within a class used to initialize objects when
they are created.
 They have the same name as the class and do not have a return type, not even
void.
 Constructors are automatically called when an object is instantiated using the new
keyword.
 They help set initial values for the object’s attributes and perform any required
setup operations.
 If a class does not define any constructors explicitly, Java provides a default no-
argument constructor.
 However, if any constructor is defined in the class, the default constructor is not
automatically provided.
 Constructors can be overloaded, meaning a class can have multiple constructors
with different parameters.

Dept. of ISE, 2022- Page

 TOOLS AND

 This allows objects to be created with varying initial values based on the provided
arguments.
 Constructors are often used to ensure that an object is in a valid state when
created, avoiding uninitialized attributes.
Both client and server classes have parameterized constructors, enabling the initialization
of object instances with provided data during object creation.

Figure 4.3: Code of chat application using Parameterized Constructors

4.8 Java Access Modifiers:

The code uses access modifiers such as private for the instance variables of both the
Alumni and Student classes, which encapsulates the data and restricts direct access to it.
Java access modifiers define the visibility and accessibility of classes, methods, and
variables within a program. There are four main access modifiers in Java:

Public (public): The most permissive access modifier. Members declared as public can be
accessed from any class in the same package or from any other package.

Private (private): The most restrictive access modifier. Members declared as private can
only be accessed within the same class. They are not visible to other classes, even within
the same package.

Dept. of ISE, 2022- Page

 TOOLS AND

Protected : This access modifier is one of the four access modifiers used to control the
visibility and accessibility of class members (fields, methods, and inner classes) within a
class hierarchy.

4.9 Multithreading:

Multithreading is a fundamental concept in computer science and software development

that enables a single program or process to execute multiple threads concurrently. Threads
are the smallest units of execution within a program and represent sequences of
instructions that can run independently.

Multithreading enables both concurrency and parallelism.

 Concurrency allows multiple threads to make progress concurrently, improving
overall program responsiveness.
 Parallelism is a subset of concurrency where threads execute tasks simultaneously,
typically on multiple CPU cores, to enhance performance in CPU-bound tasks.

Threads, the smallest units of execution, share the same memory space within a process,
enabling them to access and modify shared data. To ensure data consistency and prevent
issues like data corruption and race conditions, multithreaded programs use synchronization
mechanisms like locks, semaphores, and monitors.Multithreading can also achieve
parallelism when tasks are executed simultaneously on multiple CPU cores, enhancing the
performance of CPU-bound operations.

While multithreading offers numerous benefits, it introduces complexities related to

synchronization, thread safety, and coordination between threads. Careful design and
management are essential to create reliable and efficient multithreaded applications.
Overall, multithreading is a critical concept in modern software development, enabling
applications to efficiently utilize available CPU resources, improve responsiveness, and
handle concurrent tasks effectively.

Dept. of ISE, 2022- Page

Chapter 5

IMPLEMENTATION

The provided code defines a Java class client that represents information about client.Let's
go through the code and explain its components:

Figure 5.1: Snippet code 1

Explaination of snippet code 1:

1. Import necessary Java libraries for networking and input/output operations.
2. Define a Java class named "Client" to encapsulate the client functionality.
3. Declare class-level variables for socket communication: a Socket object for the
connection, a BufferedReader for reading server responses, and a PrintWriter for
sending messages to the server.
4. Start defining a constructor method for the Client class.
5. Inside the constructor, display a message to indicate that the client is attempting to
connect to the server.
6. Create a socket object and establish a connection to the server at IP address "127.0.0.1"
(localhost) and port 7777.
7. Print a message to confirm that the connection is successfully established.
8. Initialize a BufferedReader to read data from the input stream of the socket.
9. Initialize a PrintWriter to write data to the output stream of the socket.

Dept. of ISE, 2022- Page

 IMPLEMENTATION

10. Call the startReading() method to start reading data from the server.
11. Call the startWriting() method to start writing data to the server.
12. Implement a try-catch block to handle exceptions that may occur during socket
communication.

Figure 5.2: Snippet code 2

Dept. of ISE, 2022- Page

 IMPLEMENTATIO

Explaination of snippet code 2:

1. Method Signature:
 public void startReading() : This method is declared as public, takes no
arguments, and returns void.
2. Thread Creation:
 Runnable r1 = () -> : A new Runnable object r1 is created using a lambda
expression. This object represents a thread that will be responsible for
reading data from the server.
3. Thread Start Message:
 System.out.println("reader started..."): A message is printed to the console
to indicate that the reader thread has started.
4. Exception Handling:
 try : The code within a try block is used to handle exceptions that may occur
during socket communication.
5. Infinite Loop:
 while (true) : An infinite loop is started to continuously read data from the
server.
6. Reading Data:
 String msg = br.readLine(): Within the loop, a String variable msg is used to
read a line of text from the BufferedReader br. This line represents a
message received from the server.
7. Exit Condition Check:
 if (msg.equals("exit")) : The code checks if the received message is "exit,"
indicating that the server wants to terminate the chat.
8. Termination Handling:
 If the received message is "exit":
 System.out.println("Server terminated the chat");: A message is
printed to inform that the server terminated the chat.
 socket.close(): The socket connection is closed to terminate the
communication with the server.
9. Display Received Message:
 System.out.println("Server: " + msg): If the received message is not "exit,"
it is displayed on the console, indicating that it is a message from the server.

Dept. of ISE, 2022- Page

 IMPLEMENTATIO

Figure 5.3: Snippet code 3

Explaination of snippet code 3:
For the startWriting() method:
1. public void startWriting() : This method is responsible for sending messages to the
server.
2. Runnable r2 = () -> : A new thread (r2) is created using a lambda expression to
handle message sending.
3. System.out.println("writer started..."): A message is displayed to indicate that the
message sender has started.
4. try : The code inside the try block is used to handle potential errors.
5. while (true && !socket.isClosed()) : It creates a loop that runs as long as the
connection is open.

Dept. of ISE, 2022- Page

 IMPLEMENTATIO

6.BufferedReader br1 = new BufferedReader(new InputStreamReader(System.in));: It sets

up a way to read what the user types in the console.
7.String content = br1.readLine(): The user's input is read and stored in the variable
content. 9.out.println(content): The user's input is sent to the server through the PrintWriter
out.
10. out.flush(): The flush() method ensures that the message is immediately sent to the
server.
11. if (content.equals("exit")) : It checks if the user wants to exit the chat.

12.socket.close(): If the user types "exit," the connection to the server is

closed. 13.break: The loop is exited to stop further message sending.
14. System.out.println("connection is closed"): A message is displayed to indicate that the
connection is closed.
15. catch (Exception e) : This block is used to handle any unexpected issues or

errors. 16.e.printStackTrace(): If an error occurs, it prints details of the error.

17. new Thread(r2).start(): Finally, a new thread (r2) is started to handle message sending.

The provided code defines a Java class server that represents information about server.Let's
go through the code and explain its components:

The server-side code in a client-server Java project serves as the backbone of the application,
responsible for handling incoming client connections and managing the core functionality. It
begins by initializing a server socket and continuously listens for incoming client
connections. When a connection is established, the server spawns a new thread or process to
handle the client's requests concurrently, ensuring that multiple clients can be served
simultaneously. The server-side code processes client requests, executes the underlying
business logic, and generates responses tailored to each client's needs. Security and
authentication mechanisms are often implemented to protect resources and ensure that only
authorized clients can access specific functionalities. Error handling, resource management,
and concurrency management are essential aspects of server-side development, guaranteeing
the application's robustness and reliability. Finally, the server-side code must be properly
deployed on a production server to make the application accessible to clients over the

Dept. of ISE, 2022- Page

 IMPLEMENTATIO
network.

Dept. of ISE, 2022- Page

 IMPLEMENTATIO

Figure 5.4: Snippet code 4

Explaination of snippet code 4:

This Java code defines the constructor of a server application. It's responsible for setting up
the server's initial state, including creating a ServerSocket to listen for incoming client
connections, and initializing input and output streams to communicate with connected
clients. Here's an explanation of the code in simple terms:

1. ServerSocket server: Declares a variable named server to hold a reference to a

ServerSocket object. This object listens for incoming client connections.

2. Socket socket: Declares a variable named socket to hold a reference to a Socket

object. This object represents a connection to a specific client.

3. BufferedReader br: Declares a variable named br to hold a reference to a

BufferedReader object. It's used to read data sent by the client.

4. PrintWriter out;: Declares a variable named out to hold a reference to a

PrintWriter object. It's used to send data back to the client.

Dept. of ISE, 2022- Page

 IMPLEMENTATIO

Figure 5.5: Snippet code 5

Figure 5.6: Snippet code 6

Dept. of ISE, 2022- Page

 IMPLEMENTATIO

Explaination of snippet code 5 and 6:

For the startReading() method:

1. public void startReading() : This method sets up a thread to continuously read

messages from the connected client.
2. Runnable r1 = () -> {: It creates a new thread (r1) using a lambda expression to
handle message reading from the client.
3. System.out.println("reader started..."): A message is displayed to indicate that the
message reader has started.
4. Inside a try block, there's a loop that runs indefinitely to keep reading messages.
5. String msg = br.readLine(): It reads a line of text from the BufferedReader (br),
representing a message from the client.
6. if (msg.equals("exit")) : It checks if the received message is "exit," indicating that the
client wants to end the chat.
7. If "exit" is received:
 System.out.println("Client terminated the chat");: A message is displayed to
inform that the client terminated the chat.
 socket.close(): The socket connection to the client is closed.
 The loop is exited to stop further message reading.
8. System.out.println("Client: " + msg): If the received message is not "exit," it is
displayed on the server's console, indicating that it's a message from the client.
9. Inside the catch block, any exceptions that occur during reading are caught. In this
case, exceptions are handled by displaying a message indicating that the connection
is closed.
10. new Thread(r1).start(): Finally, a new thread (r1) is started to handle message
reading from the client.

Dept. of ISE, 2022- Page

 IMPLEMENTATIO

For the startWriting() method:

11. public void startWriting() : This method sets up a thread to send messages to the
connected client.
12. Runnable r2 = () -> : It creates a new thread (r2) using a lambda expression to handle
message writing to the client.
13. System.out.println("writer started..."): A message is displayed to indicate that the
message writer has started.
14. Inside a try block, there's a loop that runs indefinitely to keep sending messages.
15. while (true && !socket.isClosed()) : It creates a loop that runs as long as the
connection to the client is open.
16. BufferedReader br1 = new BufferedReader(new InputStreamReader(System.in)): It
sets up a way to read what the server operator types in the server's console.
17. String content = br1.readLine(): The server operator's input is read and stored in the
variable content.
18. out.println(content): The input is sent to the client via the PrintWriter (out).
19. out.flush(): The flush() method ensures that the message is immediately sent to the
client.
20. if (content.equals("exit")) : It checks if the server operator entered "exit" to end the
chat.
21. If "exit" is entered:

 socket.close(): The socket connection to the client is closed.

 The loop is exited to stop further message sending.

22. Inside the catch block, any exceptions that occur during writing are caught. In this
case, exceptions are handled by displaying a message indicating that the connection
is closed.
23. new Thread(r2).start(): Finally, a new thread (r2) is started to handle message writing
to the client.

Dept. of ISE, 2022- Page

 IMPLEMENTATIO

Explaination of whole code:

The server application initializes a server socket on a specific port (7777) to listen for
incoming client connections. When a client program connects to the server, a new socket is
created to represent this specific client's connection. The server sets up input and output
streams for communication with the client. A BufferedReader (br) is created to read
messages sent by the client, and a PrintWriter (out) is created to send messages back to the
client.
The server creates a separate thread (r1) responsible for reading messages from the client.
This thread continuously checks for incoming messages from the client and displays them on
the server's console. Another separate thread (r2) is created to handle sending messages to
the client. This thread continuously waits for the server operator to type a message and sends
it to the client. If either the operator or the client types "exit," the chat is terminated, and the
respective side (server or client) that initiated the exit will close its connection. Both threads
for reading and writing will stop when the chat ends.

Exception handling is included to deal with potential errors during socket communication.
Any exceptions that occur are caught, and a message is displayed indicating that the
connection is closed. The startWriting() method is called, creating another separate thread
(r2) responsible for sending messages to the client. This thread operates in a loop as well,
waiting for the server operator to type a message in the server's console. When a message is
typed, it's sent to the client via the PrintWriter (out). If the operator types "exit," the chat
ends, and the client connection is closed.

The main method is the entry point of the program. When executed, it displays a message
indicating that this program is the server and starts the server. The server then waits for
incoming client connections, enabling real-time chat between the server operator and
connected clients.

Dept. of ISE, 2022- Page

CHAPTER 6

OUTPUT

The output content in a client-server Java project represents the data or responses sent from
the server to the client. This content can take various forms depending on the project's
requirements. For web applications, the output content is often HTML, which is rendered
by the client's web browser to display web pages. In RESTful APIs, the output content is
typically in JSON or XML format, containing data requested by the client. In more
complex systems, it might include serialized Java objects, images, files, or any other data
relevant to the application. The output content is the information that the server delivers to
the client, enabling the client to interact with and display the results of its requests
effectively.

Figure 6.1:Output

Dept. of ISE, 2022- Page

 OUTPUT

6.1 Server Output:

1. Server Startup:
 When you start the server component of the Java chat application, it may
display startup messages such as the server's IP address, port number, and any
other configuration details.
2. Listening for Connections:
 The server will typically display a message indicating that it is listening for
incoming connections on a specific IP address and port. This message
confirms that the server is ready to accept client connections.
3. Client Connections:
 As clients connect to the server, the server may display messages indicating
that a new client has connected. These messages might include information
about the client's IP address or username.
4. Chat Room or Channel Creation:
 If the server supports multiple chat rooms or channels, it may display
messages when new rooms are created or when clients join or leave these
rooms.
5. Received Messages:
 When clients send messages to the server, the server will receive and process
these messages. It might display these messages in its logs for debugging
purposes. The format of these messages may include the client's username
and the content of the message.
6. Broadcasting Messages:
 If the server is responsible for relaying messages from one client to others
(group chat functionality), it will display messages being broadcasted to all
connected clients.
7. Errors and Alerts:
 The server may output error messages if it encounters issues like a client
disconnecting unexpectedly or if there are problems with the network or
configuration.
8. Server Shutdown:
 When you choose to shut down the server, it may display a closing message
and indicate that it is no longer accepting new connections.

Dept. of ISE, 2022- Page

 OUTPUT

6.2 Client Output:

1. Client Startup:
 When a client starts the Java chat application, it may display startup messages
and request user input for things like entering a username or connecting to the
server.
2. Connecting to Server:
 The client will attempt to connect to the server, and if the connection is
successful, it will display a message indicating that the connection has been
established.
3. Chat Interface:
 Once connected, the client will display the chat interface, which typically
includes a list of users or chat rooms and a message input area.
4. Sending Messages:
 When the user sends a message, the client will display the message in the
chat interface, including the sender's username and the content of the
message.
5. Receiving Messages:
 Messages from other users or the server will appear in the chat interface as
they are received. These messages will also include the sender's username
and message content.
6. System Messages:
 Similar to the server, the client may display system messages such as
notifications when users join or leave the chat room.
7. Errors and Alerts:
 If there are any errors or alerts on the client side, such as failed message
delivery or connection issues, the client may display error messages or pop-
up notifications.
8. Exiting the Application:
 When the user decides to exit the chat application, the client may display a
closing message or confirmation prompt before terminating the application.

Dept of. ISE, 2022- Page

Chapter 7

REFLECTION NOTES

Reflection on Internship Experience:

During my internship, I had the opportunity to work with a forward-thinking organization
that provided me with valuable technical and non-technical learning experiences. Over
the course of the internship, I was involved in various projects that allowed me to
contribute to the organization's goals while also enhancing my skills and personal growth.

7.1 Technical Outcomes:

7.1.1 Java Programming Proficiency:

The internship primarily involved Java development, and I got hands-on experience with
Java programming. I learned how to create classes, utilize object-oriented principles,
implement data structures like ArrayList, and effectively use methods and constructors.
This experience significantly improved my Java skills and coding proficiency.

7.1.2 Object-Oriented Design:

Working on the Alumni and Student classes in the provided code helped me understand
the importance of object-oriented design principles like encapsulation, abstraction,
inheritance, and polymorphism. I was able to apply these principles to create well-
structured and maintainable code.

7.1.3 Java Collections Framework:

The project's requirement to manage lists of alumni and students led me to work
extensively with Java collections, especially ArrayList. I learned how to manipulate data
in collections, iterate through lists, and perform common operations like adding and
removing elements.

7.1.4 Git and Version Control:

During the internship, I collaborated with other developers using Git version control. I
became familiar with concepts like branching, merging, and resolving conflicts. This
knowledge was crucial for effective team collaboration and code management.

Dept. of ISE, 2022- Page

 REFLECTION

7.1.5 Problem-Solving Skills:

Working on various tasks and projects exposed me to real-world challenges, requiring me
to analyse problems and devise efficient solutions. I learned to break down complex
problems into smaller, manageable tasks and approach them systematically.

7.2 Non-Technical Outcomes:

7.2.1 Verbal and Written Communication:

Throughout the internship, I had to communicate with team members and supervisors
regularly. This experience improved my ability to convey technical ideas clearly, both
verbally and in written communication. I became more confident in expressing my
thoughts and ideas effectively.

7.2.2 Personality Development:

The internship environment encouraged me to take initiative, ask questions, and seek
feedback. As a result, I developed a more proactive and inquisitive attitude. Additionally,
collaborating with diverse team members from different backgrounds enhanced my
adaptability and interpersonal skills.

7.2.3 Time Management:

Balancing multiple tasks and meeting project deadlines taught me the importance of time
management. I learned to prioritize tasks, set realistic timelines, and stay organized to
ensure timely completion of assignments.

7.2.4 Resource Utilization:

While working on the projects, I learned to utilize available resources effectively. I
explored online documentation, tutorials, and educational materials to enhance my
technical knowledge and find solutions to problems independently.

7.2.5 Professional Ethics:

Being part of a professional team reinforced the significance of ethical behavior in the
workplace. I understood the importance of integrity, accountability, and respecting
intellectual property rights.

Dept. of ISE, 2022- Page

 REFLECTION

Overall, my internship experience was invaluable in terms of technical growth and

personal development. I not only gained proficiency in Java and related technologies but
also developed soft skills that are essential for a successful career. The supportive and
collaborative work environment played a significant role in making this internship a
rewarding and enriching experience. I am grateful for the opportunities provided and look
forward to applying my newfound knowledge and skills in future endeavors.

Dept. of ISE, 2022- Page

 Chapter 8

Conclusion, Applications and Future Work

8.1 APPLICATION:

Real-time applications are software programs designed to provide instant feedback or

updates to users, typically with very low latency. These applications are widely used in
various domains and have become essential for providing seamless and responsive user
experiences. Here are a few real-time applications and their use cases:

1. Messaging and Chat Applications: Real-time messaging apps like WhatsApp, Slack,
and Facebook Messenger enable users to send and receive messages instantly. These
apps use real-time communication protocols to deliver messages quickly, making
them ideal for personal and business communication. They also support features
such as group chats, multimedia sharing, and voice/video calls.

2. Online Gaming: Multiplayer online games heavily rely on real-time communication

to provide an immersive gaming experience. Games like Fortnite, League of
Legends, and Among Us use real-time networking to synchronize actions and events
across players, ensuring that gameplay remains responsive and synchronized.

3. Collaborative Tools: Real-time collaborative tools such as Google Docs, Microsoft

Teams, and Trello enable users to work together on documents, projects, and tasks in
real time. Multiple users can edit documents simultaneously, and changes are
instantly visible to all participants, fostering efficient teamwork.

4. Financial Trading Platforms: In the financial industry, real-time applications are

critical for trading platforms. Stock trading systems need to provide up-to-the-second
market data and execute trades with minimal latency to react to changing market
conditions. Algorithmic trading relies on real-time data analysis and decision-
making.

5. IoT Monitoring and Control: The Internet of Things (IoT) leverages real-time
applications for monitoring and controlling connected devices. Smart home systems,
 CONCLUSION,APPLICATION AND FUTURE

industrial automation, and vehicle telematics use real-time data streams to make
decisions and respond to sensor inputs in real time.

6. Live Streaming and Video Conferencing: Live streaming platforms like YouTube
Live and Twitch deliver video and audio content in real time to global audiences.
Video conferencing tools such as Zoom and Microsoft Teams provide seamless
video and audio communication for remote meetings and webinars.

7. Transportation and Navigation: Real-time applications are crucial in transportation

and navigation systems. GPS-based navigation apps like Google Maps provide real-
time traffic data and route adjustments. Ride-sharing services like Uber and Lyft rely
on real-time location tracking for matching drivers and riders.

8. Social Media Updates: Social media platforms like Twitter and Instagram use real-
time feeds to deliver updates, posts, and notifications to users as they happen. Users
receive instant alerts for likes, comments, and messages.

9. Emergency Services and Public Safety: Emergency response systems use real-time
applications to dispatch first responders, monitor incidents, and communicate vital
information during crises. Public safety applications help improve response times
and coordination.

10. Online Banking: For secure transactions and account management, online banking
systems utilize client-server architectures to ensure data integrity and confidentiality.

There are numerous other applications across various domains that leverage client-server
architectures to facilitate secure communication, data sharing, and efficient functionality,
demonstrating the versatility and wide-ranging impact of this model in our digital world.

Dept. of ISE, 2022- Page

 CONCLUSION,APPLICATION AND FUTURE

8.2 FUTURE WORK:

The future of chat applications is likely to see several exciting developments and trends.
Here are some potential areas of future work and innovation in chat applications:

1. AI-Powered Chatbots and Assistants: Integrating advanced AI chatbots and virtual

assistants that can understand and respond to natural language conversation more
effectively. These chatbots will become more context-aware and capable of handling
complex tasks, making them valuable in customer support, personal productivity,
and more.
2. Multimodal Communication: Enhancing chat applications to support not only text
but also voice, video, and augmented reality (AR) communication. This will enable
users to switch between different modes seamlessly during a conversation.
3. Personalization: Leveraging AI and machine learning to provide highly personalized
experiences in chat apps. This includes personalized content recommendations,
conversation suggestions, and tailored user interfaces.
4. Privacy and Security: Continued focus on enhancing privacy and security features,
including end-to-end encryption, secure authentication methods, and robust data
protection measures to safeguard user data.
5. Interoperability: Developing standards and protocols to enable cross-platform chat
communication. Users should be able to seamlessly communicate with others
regardless of the chat app they use.
6. Integration with Ecosystems: Further integration with other apps and services, such
as e-commerce platforms, productivity tools, and IoT devices, to make chat
applications a central hub for various tasks.
7. Real-time Translation: Improved real-time language translation capabilities to break
down language barriers and facilitate global communication.

Dept. of ISE, 2022- Page

 CONCLUSION,APPLICATION AND FUTURE

8.3 CONCLUSION:

In the context of a client-server Java project, the server-side code serves as the backbone of
the application. It initializes a server socket, listens for incoming client connections, and
concurrently processes client requests using multithreading or processes. This code is
responsible for executing the core business logic, such as database operations and data
manipulation, ensuring the security and authentication of client requests, and handling errors
gracefully.

The server generates output content tailored to each client's needs, which can range from
HTML for web applications to JSON or serialized Java objects for APIs. Scalability
considerations enable the system to adapt to increasing user loads by horizontally or
vertically scaling server resources. Data persistence involves managing structured or
unstructured data often stored in databases.

When it comes to delivering results to clients, the server crafts output content to match the
client's request and needs. This output varies widely, from HTML for web applications to
JSON or custom data structures for APIs, and even serialized Java objects for certain
scenarios.

Caching mechanisms improve performance by storing frequently accessed data in memory,

reducing the need for repeated processing or database queries. Logging and monitoring tools
play a vital role in tracking events, errors, and activities, facilitating troubleshooting, and
ensuring the application's health and performance are continually monitored. These aspects
collectively contribute to the robustness, scalability, and efficiency of client-server Java
projects in diverse application domains.

Dept. of ISE, 2022- Page