Category: Ruby

Introduction

In this blog post, we’ll walk through the steps of creating an Internet Relay Chat (IRC) server using the Ruby programming language. IRC is a protocol for real-time communication over the internet, and is often used for chat rooms and online communities.

Prerequisites

Before we get started, you’ll need to have a few things installed on your machine:

• Ruby: You’ll need to have Ruby installed on your machine to follow along with this tutorial. If you don’t already have Ruby installed, you can download it from the official website (https://www.ruby-lang.org/en/downloads/) or use a package manager like Homebrew (for macOS) or apt-get (for Linux).
• Bundler: We’ll be using Bundler to manage our dependencies, so you’ll need to have it installed as well. You can install it by running gem install bundler on the command line.

Step 1: Set up the project

First, let’s create a new directory for our project and navigate to it in the terminal. We’ll call our project “irc-server”:

$ mkdir irc-server
$ cd irc-server

Next, let’s create a Gemfile to manage our dependencies. This file will specify the libraries we need for our project, and Bundler will handle installing them for us.

Create a new file called Gemfile in the irc-server directory and add the following contents:

source "https://rubygems.org"

gem "eventmachine"
gem "em-irc"

The eventmachine and em-irc gems will provide us with the necessary tools to build our IRC server.

Step 2: Write the server code

Now that we have our dependencies set up, let’s start building the actual server. Create a new file called server.rb in the irc-server directory and add the following code:

# Load the necessary libraries
require "eventmachine"
require "em-irc"

# Define the server hostname and port
HOSTNAME = "localhost"
PORT = 6667

# Create a new instance of the IRC server
EventMachine.run do
  # Set up the connection
  EventMachine::IRC::Server.new do
    # Set the hostname and port
    hostname HOSTNAME
    port PORT

    # When a client connects...
    on :connect do |client|
      puts "Client #{client.inspect} connected"
    end

    # When a client disconnects...
    on :disconnect do |client|
      puts "Client #{client.inspect} disconnected"
    end

    # When a client sends a message...
    on :privmsg do |client, message|
      puts "Client #{client.inspect} sent message: #{message}"
    end
  end
end

This code sets up a new instance of an IRC server using the EventMachine and em-irc libraries. It listens for connections on the specified hostname and port (in this case, localhost and 6667), and logs messages when a client connects, disconnects, or sends a message.

Step 3: Start the server

To start the server, simply run the server.rb file from the command line:

$ ruby server.rb

You should see a message in the terminal indicating that the server is listening on the specified hostname and port.

Now that the server is running, you can connect to it using an IRC client. Some popular IRC clients include mIRC (for Windows) and HexChat (for macOS and Linux).

To connect to the server using an IRC client, simply enter the hostname and port (in this case, localhost and 6667) in the client’s connection settings. Once connected, you should be able to join channels and start chatting with other users.

Relaying chat messages

To relay chat messages using em-irc and Ruby, you can use the on :privmsg event to listen for messages from clients and the send_raw method to send messages to clients.

Here’s an example of how you can implement channels in your IRC server:

# Load the necessary libraries
require "eventmachine"
require "em-irc"

# Define the server hostname and port
HOSTNAME = "localhost"
PORT = 6667

# Create a new instance of the IRC server
EventMachine.run do
  # Set up the connection
  EventMachine::IRC::Server.new do
    # Set the hostname and port
    hostname HOSTNAME
    port PORT

    # When a client connects...
    on :connect do |client|
      puts "Client #{client.inspect} connected"
    end

    # When a client disconnects...
    on :disconnect do |client|
      puts "Client #{client.inspect} disconnected"
    end

    # When a client sends a message...
    on :privmsg do |client, message|
      # Split the message into command and parameters
      command, *params = message.split(" ")

      # If the command is "JOIN"
      if command == "JOIN"
        # Get the channel name
        channel = params[0]

        # Join the channel
        client.send_raw("JOIN #{channel}")
With these basic building blocks, you can start building your own custom IRC server and chat application.
        # Send a message to the channel announcing the client's presence
        client.send_raw("PRIVMSG #{channel} :#{client.nick} has joined the channel")
      # If the command is "PRIVMSG"
      elsif command == "PRIVMSG"
        # Get the target (either a channel or a user) and the message
        target, message = params[0], params[1..-1].join(" ")

        # Relay the message to the target
        client.send_raw("PRIVMSG #{target} :#{message}")
      end
    end
  end
end

In this code, we listen for messages from clients using the on :privmsg event. If the message is a JOIN command, we add the client to the specified channel and send a message announcing their presence. If the message is a PRIVMSG command, we relay the message to the specified target (either a channel or a user).

Conclusion

In this tutorial, we learned how to create an IRC server using Ruby and the eventmachine and em-irc libraries. We set up the project, wrote the server code, and started the server, and were able to connect to it using an IRC client. With these basic building blocks, you can build more advanced features such as channel moderation, user lists, and more.

Welcome to the final part of our tutorial on how to implement a chess board representation class in Ruby that can be used to generate moves efficiently! In the previous parts, we introduced the basic structure of the chess board class and implemented the move generation functions, including a “perft” function that can be used to iterate through all moves from a given position up to a specified depth. In this part, we will create a FEN-string parser and serializer as member functions in the board class.

The Forsyth-Edwards Notation (FEN) is a standard way of representing chess positions as strings. It consists of six fields separated by spaces, which represent the following information:

1. The piece placement on the board
2. The active color (whose turn it is to move)
3. The castling rights
4. The en passant square (if any)
5. The halfmove clock (the number of halfmoves since the last pawn advance or capture)
6. The fullmove number (the number of the full move)

Here is an example of a FEN string that represents the starting position of a chess game:

rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1

To implement the FEN parsing and serialization functions, we can define two member functions of the chess board class: from_fen and to_fen. The from_fen function will take a FEN string as input and initialize the board with the position represented by the string. The to_fen function will take the current board position and return a FEN string representing that position.

Here is an example of how we might implement the from_fen function:

def from_fen(fen)
  fields = fen.split(" ")
  # Parse piece placement field
  rows = fields[0].split("/")
  for i in 0..7
    for j in 0..7
      c = rows[i][j]
      if c == "p"
        @board[:pawns] |= (1 << (8 * i + j))
        @board[:black] |= (1 << (8 * i + j))
      elsif c == "P"
        @board[:pawns] |= (1 << (8 * i + j))
        @board[:white] |= (1 << (8 * i + j))
      # Parse other pieces
      # ...
    end
  end
  # Parse active color field
  if fields[1] == "b"
    @turn = :black
  else
    @turn = :white
  end
  # Parse castling rights field
  # ...
  # Parse en passant square field
  # ...
  # Parse halfmove clock field
  # ...
  # Parse fullmove number field
  # ...
end

This function parses the fields of the FEN string and initializes the board accordingly. The to_fen function can be implemented in a similar way, by constructing a FEN string from the current board state.

With these functions in place, we can now easily convert between FEN strings and chess board positions, allowing us to load and save positions in this standard format.

And that’s it! We have now completed our tutorial on how to implement a chess board representation class in Ruby that can be used to generate moves efficiently. We hope that you have found this tutorial helpful and that you now have a better understanding of how to create a chess board class and optimize the move generation process.

To summarize, we have covered the following topics in this tutorial:

• The basics of creating a chess board class in Ruby
• How to use bitwise operations to optimize the move generation process
• How to implement a “perft” function to iterate through all moves from a given position up to a specified depth
• How to parse and serialize chess positions in the standard FEN format using member functions of the board class

We hope that you have enjoyed following along with this tutorial, and that you will have fun experimenting with the chess board class that we have created. Happy coding!

• Go to part 1
• Go to part 2
• Go to part 3

Welcome to the second part of our tutorial on how to implement a chess board representation class in Ruby that can be used to generate moves efficiently! In the previous part, we introduced the basic structure of the chess board class and outlined the member functions that we will need to implement. In this part, we will focus on implementing the move generation functions, including a “perft” function that can be used to iterate through all moves from a given position up to a specified depth.

To generate moves efficiently, we will need to use some clever techniques to minimize the number of checks and calculations that are required. One way to do this is to use bitwise operations to manipulate the board representation and determine the legal moves for each piece type. For example, we can use a bitboard representation of the board to quickly determine which squares are occupied and which are empty, and then use this information to generate moves for each piece.

Here is an example of how we might implement the generate_moves function using a bitboard representation:

def generate_moves
  moves = []
  # Generate pawn moves
  pawns = @board[:pawns]
  while pawns != 0
    from_square = pawns.bit_length - 1
    pawns &= ~(1 << from_square)
    to_square = from_square + 8
    if (1 << to_square) & @board[:empty] != 0
      # Pawn can move one square forward
      moves << Move.new(from_square, to_square)
      # Check if pawn can move two squares forward
      if from_square < 16 && (1 << (to_square + 8)) & @board[:empty] != 0
        moves << Move.new(from_square, to_square + 8)
      end
    end
    # Check for pawn captures
    if (1 << (to_square + 1)) & @board[:pieces] != 0
      moves << Move.new(from_square, to_square + 1)
    end
    if (1 << (to_square - 1)) & @board[:pieces] != 0
      moves << Move.new(from_square, to_square - 1)
    end
  end
  # Generate moves for other pieces
  # ...
  moves
end

This function iterates through all pawns on the board using a bitboard representation, and generates the legal moves for each pawn by checking the squares in front of and to the sides of the pawn. If a square is empty, the pawn can move to that square. If a square is occupied by an enemy piece, the pawn can capture that piece.

Once we have implemented the generate_moves function, we can then use a “perft” function to iterate through all moves from a given position up to a specified depth. This can be useful for testing and debugging the move generation code, as well as for analyzing the positions and determining the branching factor (the average number of moves that can be made from a given position).

Here is an example of how we might implement the perft function:

def perft(depth)
  if depth == 0
    return 1
  end
  nodes = 0
  moves = generate_moves
  moves.each do |move|
    if legal_move?(move)
      make_move(move)
      nodes += perft(depth - 1)
      unmake_move(move)
    end
  end
  nodes
end

This function recursively iterates through all moves from the current position, making each move and then unmaking it after the recursive call has completed. If the depth has been reached, it returns 1. Otherwise, it adds up the number of nodes generated by the recursive calls and returns the total.

With the perft function in place, we can now use it to test and debug the move generation code and analyze the positions. In the next and final part of this tutorial, we will implement the FEN parsing and serialization functions as member functions of the board class. Stay tuned!

• Go to part 1
• Go to part 2
• Go to part 3

Welcome to the first part of our tutorial on how to implement a chess board representation class in Ruby that can be used to generate moves efficiently! In this tutorial, we will guide you through the process of creating a chess board class that can be used to store and manipulate chess positions, and optimize the move generation process to make it as efficient as possible.

The first step in implementing a chess board class is to decide on the data structure that will be used to represent the board. One option is to use a two-dimensional array, with each element representing a square on the board. Another option is to use a bitboard representation, where each square on the board is represented by a single bit in a 64-bit integer.

For the purposes of this tutorial, we will use a two-dimensional array representation, as it is simpler and easier to understand. However, it is worth noting that bitboard representations can be more efficient in terms of space and performance, especially when it comes to generating moves.

To implement the chess board class, we will need to define several member functions that can be used to manipulate the board and generate moves. These may include functions to:

• Initialize the board with a given position
• Place pieces on the board
• Remove pieces from the board
• Move pieces on the board
• Generate legal moves from a given position
• Check if a given position is a checkmate or a stalemate
• Check if a given move is legal

In addition to these core functions, we may also want to include additional utility functions such as a function to display the board in a readable format, and functions to parse and serialize positions in the standard FEN (Forsyth-Edwards Notation) format.

To start, we can define the basic structure of the chess board class as follows:

class ChessBoard
  def initialize
    # Initialize board with starting position
  end

  def place_piece(piece, square)
    # Place a piece on the board
  end

  def remove_piece(square)
    # Remove a piece from the board
  end

  def move_piece(from_square, to_square)
    # Move a piece on the board
  end

  def generate_moves
    # Generate all legal moves from the current position
  end

  def checkmate?
    # Check if the current position is a checkmate
  end

  def stalemate?
    # Check if the current position is a stalemate
  end

  def legal_move?(move)
    # Check if a given move is legal
  end

  def display
    # Display the board in a readable format
  end

  def to_fen
    # Convert the current position to a FEN string
  end

  def from_fen(fen)
    # Initialize the board with a position represented by a FEN string
  end
end

With this basic structure in place, we can now start implementing the member functions of the chess board class. In the next part of this tutorial, we will focus on implementing the move generation functions, including a “perft” function that can be used to iterate through all moves from a given position up to a specified depth. Stay tuned!

• Go to part 1
• Go to part 2
• Go to part 3

Blockchains are decentralized, distributed ledger systems that enable secure and transparent record-keeping of transactions. They are made up of a chain of blocks, each containing a list of transactions and a cryptographic hash of the previous block. This design makes it extremely difficult to alter the contents of a block once it has been added to the chain, as doing so would require changing all subsequent blocks as well.

In this tutorial, we will learn how to create a basic blockchain in Ruby. We will start by understanding the fundamentals of blockchains and how they work. Then, we will implement a class for the blockchain and define functions for adding blocks and transactions to the chain. Finally, we will implement a mechanism for finding the proof of work for a new block and validating the proof.

First, let’s create a new Ruby file and define the Blockchain class:

# Define a class for a blockchain
class Blockchain
  attr_reader :chain, :current_transactions

  def initialize
    # Create an array to store the chain of blocks
    @chain = []

    # Create an array to store the current list of transactions
    @current_transactions = []

    # Create the first block in the chain (the "genesis block")
    create_block(previous_hash: 1, proof: 100)
  end
end

The Blockchain class has two instance variables: @chain, which is an array that stores the chain of blocks, and @current_transactions, which is an array that stores the current list of transactions. The initialize method creates these instance variables and creates the first block in the chain, known as the “genesis block”.

Next, let’s define a function to create a new block in the chain:

# Define a function to create a new block in the chain
def create_block(proof:, previous_hash:)
  # Create a new block and add it to the chain
  block = {
    index: @chain.length + 1,
    timestamp: Time.now,
    transactions: @current_transactions,
    proof: proof,
    previous_hash: previous_hash,
  }

  # Reset the current list of transactions
  @current_transactions = []

  # Add the new block to the chain
  @chain << block

  # Return the new block
  block
end

This function creates a new block using a hash that contains the following information:

• index: the position of the block in the chain
• timestamp: the time at which the block was created
• transactions: the list of transactions contained in the block
• proof: the proof of work for the block (more on this later)
• previous_hash: the cryptographic hash of the previous block in the chain

Once the block has been created, the function resets the current list of transactions and adds the new block to the end of the chain. It then returns the new block.

Now that we have a way to create new blocks, let’s define a function to add new transactions to the list of current transactions:

# Define a function to add a new transaction to the list of current transactions
def add_transaction(sender:, recipient:, amount:)
  # Add a new transaction to the list of current transactions
  @current_transactions << {
    sender: sender,
    recipient: recipient,
    amount: amount,
  }

  # Return the index of the block that the transaction will be added to
  @chain.length + 1
end

This function adds a new transaction to the list of current transactions using a hash that contains the following information:

• sender: the address of the sender
• recipient: the address of the recipient
• amount: the amount of coins being transferred

It then returns the index of the block that the transaction will be added to.

Here is the rest of the proof_of_work function:

# Define a function to find the proof of work for a new block
def proof_of_work(last_proof)
  # Set the initial proof to 0
  proof = 0

  # Keep incrementing the proof until it is valid
  while valid_proof?(last_proof, proof) do
    proof += 1
  end

  # Return the proof
  proof
end

This function starts with an initial proof of 0 and increments it until it becomes a valid proof. The valid_proof? function, which we will define next, checks if the proof is valid.

Finally, let’s define the valid_proof? function:

# Define a function to validate the proof of work for a new block
def valid_proof?(last_proof, proof)
  # Calculate the hash of the proof
  guess = "#{last_proof}#{proof}"
  guess_hash = Digest::SHA256.hexdigest(guess)

  # Check if the hash starts with four leading zeros
  guess_hash[0..3] == "0000"
end

This function calculates the hash of the proof using the Ruby Digest module and checks if the hash starts with four leading zeros. If it does, the proof is considered valid. Otherwise, the proof_of_work function will continue to increment the proof until it becomes valid.

In the valid_proof? function, the hash of the proof is compared with four leading zeros because this is a common way to verify that a proof of work is valid. A proof of work is a mathematical problem that is designed to be computationally difficult to solve, but easy to verify. It is used to secure a blockchain by requiring users to perform a certain amount of work in order to add new blocks to the chain.

The concept that this comparison represents is known as the “difficulty” of the proof of work. The more leading zeros that are required, the more difficult the proof of work becomes. In the example code, we are using a difficulty of four leading zeros, which means that the proof must be a number that, when hashed, produces a hash that starts with four zeros. This can take some time to find, as the proof must be incremented until a valid hash is found.

The use of proof of work helps to prevent fraud and ensure the integrity of the blockchain. It ensures that new blocks cannot be added to the chain without performing the necessary work, and it makes it difficult for an attacker to alter the contents of a block once it has been added to the chain.

Now that we have implemented all the necessary functions for our blockchain, let’s try it out. Create a new instance of the Blockchain class and add some transactions to it:

# Create a new blockchain
blockchain = Blockchain.new

# Add some transactions to the blockchain
blockchain.add_transaction(sender: "Alice", recipient: "Bob", amount: 10)
blockchain.add_transaction(sender: "Bob", recipient: "Charlie", amount: 5)

# Create a new block
blockchain.create_block(proof: 123, previous_hash: 1)

# Add some more transactions to the blockchain
blockchain.add_transaction(sender: "Charlie", recipient: "Alice", amount: 3)
blockchain.add_transaction(sender: "Alice", recipient: "Bob", amount: 7)

# Create another new block
blockchain.create_block(proof: 456, previous_hash: 123)

# Print the blockchain
puts blockchain.chain

This code creates a new blockchain, adds some transactions to it, creates two new blocks, and prints the final chain. The output should look something like this:

[{:index=>1, :timestamp=>2022-12-19 13:43:01 -0800, :transactions=>[], :proof=>100, :previous_hash=>1}, {:index=>2, :timestamp=>2022-12-19 13:43:01 -0800, :transactions=>[{:sender=>"Alice", :recipient=>"Bob", :amount=>10}, {:sender=>"Bob", :recipient=>"Charlie", :amount=>5}], :proof=>123, :previous_hash=>1}, {:index=>3, :timestamp=>2022-12-19 13:43:01 -0800, :transactions=>[{:sender=>"Charlie", :recipient=>"Alice", :amount=>3}, {:sender=>"Alice", :recipient=>"Bob", :amount=>7}], :proof=>456, :previous_hash=>123}]

This is the final state of the blockchain, with three blocks containing the transactions that we added. You can see that each block contains the list of transactions, the proof of work, and the hash of the previous block.

Congratulations, you have successfully implemented a basic blockchain in Ruby! In the next tutorial, we will learn how to enhance this blockchain with advanced features such as a decentralized network of nodes, consensus algorithms, and cryptography.

I hope this tutorial has been helpful and that you have a better understanding of how blockchains work and how to implement them in Ruby.

How to write a Slack bot in Ruby:

1. First, make sure you have Ruby installed on your system. You can check if you have it installed by running ruby -v in a terminal. If you don’t have it installed, you can download it from the official Ruby website (https://www.ruby-lang.org/) or use a package manager like apt or yum to install it.
2. Next, you’ll need to create a new Slack bot. Head to the Slack API website (https://api.slack.com/) and log in with your Slack account. Click on the “Start Building” button, give your bot a name, and select a development workspace. Click the “Create App” button to create your bot.
3. On the next page, click the “Bots” tab and then click the “Add a Bot User” button. Give your bot a display name and default username, and click the “Add Bot User” button. This will create a new bot user for your app.
4. Now it’s time to start writing some code. Create a new Ruby script and import the slack-ruby-client gem at the top of the file:

require 'slack-ruby-client'

5. Next, create a new Slack::Web::Client object and use the auth_test method to verify that your bot can authenticate with the Slack API:

client = Slack::Web::Client.new

client.auth_test
puts 'Successfully authenticated with Slack API!'

6. To start listening for events, you’ll need to use the rtm_start method to start a Real Time Messaging (RTM) session and receive a WebSocket URL that you can use to connect to the Slack API:

rtm_client = client.rtm_start

puts "Connected to Slack RTM API! WebSocket URL: #{rtm_client.url}"

7. Now it’s time to start listening for events and responding to them. You can use the Slack::RealTime::Client class to connect to the RTM API and handle events as they occur. For example, you can use the on :message event to have your bot respond to messages in channels:

Slack::RealTime::Client.new.tap do |rtm|
  rtm.on :message do |data|
    case data['text']
    when /^!hello/
      rtm.send_message(channel: data['channel'], text: 'Hello!')
    end
  end
end

This code will have the bot respond with “Hello!” whenever it sees a message starting with “!hello”.

8. You can also use the Slack::Web::Client to send messages to channels or users using the chat_postMessage method. For example:

client.chat_postMessage(channel: '#general', text: 'Hello, world!')

This will send a message to the #general channel saying “Hello, world!”.

9. To deploy your bot, you’ll need to run your script on a server that is always online. You can use a hosting service like Heroku or AWS to run your bot 24/7. Alternatively, you can run your bot on a dedicated server or a virtual private server (VPS).
10. To run your bot on a VPS, you’ll need to install Ruby and any required dependencies on the server, and then set up a process manager like pm2 to keep the bot running in the background. For example:

# Install Ruby and dependencies
apt install ruby ruby-dev
gem install bundler

# Install pm2
npm install -g pm2

# Run the bot with pm2
pm2 start my_bot.rb

This will start the bot in the background using pm2, which will keep it running even if you close the terminal or log out of the server.

11. Finally, you can use the SLACK_APP_TOKEN and SLACK_BOT_TOKEN environment variables to store your Slack API tokens and use them in your Ruby script. To set these variables, you can use the export command in the terminal:

export SLACK_APP_TOKEN='YOUR_SLACK_APP_TOKEN_HERE'
export SLACK_BOT_TOKEN='YOUR_SLACK_BOT_TOKEN_HERE'

Then, in your Ruby script, you can access these variables using the ENV object:

client = Slack::Web::Client.new(token: ENV['SLACK_BOT_TOKEN'])

This will allow you to easily manage your API tokens without hardcoding them into your script.

I hope this tutorial has been helpful and gives you a good starting point for building your own Slack bot in Ruby!

Here’s how you can build a real-time chat API with Sinatra and Ruby, and connect it to an HTML GUI using JavaScript:

First, you’ll need to install the faye-websocket gem, which provides support for web sockets in Ruby. You can do this by adding the following line to your Gemfile and running bundle install:

gem 'faye-websocket'

Next, you’ll need to set up a web socket server in your Sinatra application. You can do this by creating a new route that listens for web socket connections and sends messages to connected clients when they arrive:

require 'sinatra'
require 'faye/websocket'
require 'sequel'  # or whichever database library you're using

DB = Sequel.connect('postgres://localhost/my_database')  # replace with your own database connection details

# You might also want to set up your database tables here, if you don't have them already
DB.create_table? :messages do
  primary_key :id
  String :sender
  String :recipient
  String :text
  Time :timestamp
end

get '/websocket' do
  if Faye::WebSocket.websocket?(request.env)
    ws = Faye::WebSocket.new(request.env)

    ws.on :open do |event|
      puts 'Web socket connection opened'
      # You might want to store the client's connection in a list here, so you can send messages to it later
    end

    ws.on :message do |event|
      puts "Received message: #{event.data}"
      data = JSON.parse(event.data)
      sender = data['sender']
      recipient = data['recipient']
      text = data['text']
      timestamp = Time.now
      message_id = DB[:messages].insert(sender: sender, recipient: recipient, text: text, timestamp: timestamp)
      # You can process the message here and then send it to all connected clients using the following line:
      ws.send({ message_id: message_id, sender: sender, recipient: recipient, text: text, timestamp: timestamp }.to_json)
    end

    ws.on :close do |event|
      puts 'Web socket connection closed'
      # You might want to remove the client's connection from your list here
    end

    ws.rack_response
  end
end

Next, you can create an HTML GUI for your chat application. This could include a form for sending messages and a list or chat window to display received messages. Here’s an example of what this might look like:

<form id="message-form">
  <input type="text" id="sender" placeholder="Your name">
  <input type="text" id="recipient" placeholder="Recipient's name">
  <input type="text" id="text" placeholder="Type your message here">
  <button type="submit">Send</button>
</form>
<ul id="messages"></ul>

You’ll also need to include a script tag to reference your JavaScript file, where you’ll handle the web socket connection and message handling:

const socket = new WebSocket('ws://localhost:4567/websocket');
const messageForm = document.getElementById('message-form');
const messagesList = document.getElementById('messages');

socket.onopen = function(event) {
  console.log('Web socket connection opened');
};

socket.onmessage = function(event) {
  console.log(`Received message: ${event.data}`);
  const messageData = JSON.parse(event.data);
  const messageItem = document.createElement('li');
  messageItem.innerHTML = `${messageData.sender}: ${messageData.text}`;
  messagesList.appendChild(messageItem);
};

socket.onclose = function(event) {
  console.log('Web socket connection closed');
  // You might want to reconnect to the server here
};

messageForm.addEventListener('submit', event => {
  event.preventDefault();
  const sender = document.getElementById('sender').value;
  const recipient = document.getElementById('recipient').value;
  const text = document.getElementById('text').value;
  socket.send(JSON.stringify({ sender: sender, recipient: recipient, text: text }));
});

With this setup, you can now send and receive real-time chat messages between the server and the client using web sockets, and display them in the HTML GUI.

To import a JavaScript file into an HTML document, you can use the script tag and specify the path to the file in the src attribute. Here’s an example of how you might do this:

<script src="path/to/your/javascript/file.js"></script>

Alternatively, you can also include the JavaScript code directly in the HTML file by placing it inside a script tag without a src attribute:

<script>
  // Your JavaScript code goes here
</script>

It’s generally a good idea to keep your JavaScript code in separate files to keep your HTML clean and organized, but the inline method can be useful for smaller scripts or when you want to include the code in a specific part of the HTML document.