Forem: Javier Gongora

Binary Tree: Understanding How In-Order Traversal Works

Javier Gongora — Tue, 27 Dec 2022 20:18:25 +0000

Tree traversals are a fundamental concept in computer science and are used to visit all the nodes of a tree in a specific order. In this post, we'll discuss how to implement an inorder traversal using a recursive function in TypeScript, and we'll walk through an example to see how the function calls are added to the call stack and how the root node values are returned.

A way of visiting binary tree nodes

An in-order traversal is a way of visiting the nodes of a binary tree in a specific order. The order is defined as follows:

Visit the left subtree
Visit the root node
Visit the right subtree

This order ensures that the nodes are visited in a left-to-right fashion, which can be useful in certain scenarios, such as printing out the values of a binary search tree in ascending order.

In-order traversal in TypeScript

In order to implement an in-order traversal, we can use a recursive function that follows the steps described above. Here is an example of how we could implement an in-order traversal in TypeScript:

function inorderTraversal(root: Node | null): void {
  if (root === null) return; // base case

  inorderTraversal(root.left); // visit left subtree
  console.log(root.val); // visit root node
  inorderTraversal(root.right); // visit right subtree
}

This function takes a binary tree as an input (the "root" node), and it performs an inorder traversal on that tree. It follows the steps described above: it visits the left subtree, then the root node, and then the right subtree.

Recursive function calls added to the call stack

As the function calls itself recursively, it adds new function calls to the top of the call stack. This creates a stack-like structure, with the most recent function call at the top. Let's see how this looks in practice by considering the following example tree:

    F
   / \
  B   G
 / \   \
A   D   I
   /
  C
 /
E

The inorderTraversal function is called on the root node (F).
The function makes a recursive call on the left subtree of the root node (B).
The function makes a recursive call on the left subtree of the left child (A).
The function returns and prints the value of the left child (A).
The function makes a recursive call on the right subtree of the left child (D).
The function makes a recursive call on the left subtree of the right child (C).
The function makes a recursive call on the left subtree of the left grandchild (E).
The function returns and prints the value of the left grandchild (E).
The function returns and prints the value of the right grandchild (C).
The function returns and prints the value of the right child (D).
The function returns and prints the value of the left child (B).
The function makes a recursive call on the right subtree of the root node (G).
The function makes a recursive call on the right subtree of the right child (I).
The function returns and prints the value of the right grandchild (I).
The function returns and prints the value of the right child (G).
The function returns and prints the value of the root node (F).

Returning the root node values

As you can see, the function calls are being added to the top of the call stack, and the root node values are being printed as the function returns from each recursive call. The node values are visited in the order A, E, C, D, B, I, G, F, which is the in-order traversal of the tree.

I hope this helps you understand how an in-order traversal works and how the function calls are added to the call stack. An in-order traversal can be a useful way to visit the nodes of a binary tree in a specific order, and it can be implemented using a simple recursive function.

It's worth noting that there are other ways to traverse a binary tree, such as pre-order traversal and post-order traversal. Pre-order traversal visits the root node first, then the left subtree, and then the right subtree. Post-order traversal visits the left subtree first, then the right subtree, and then the root node.

If you have any questions, please let me know in the comments section!

How to Contribute to an Open Source Project on GitHub

Javier Gongora — Fri, 23 Dec 2022 19:47:49 +0000

Contributing to an open source project on GitHub is a great way to learn new skills, collaborate with others, and give back to the developer community. In this tutorial, we'll go over the steps you need to take to fork and clone an open source repository, set up the project locally, and create a pull request.

Prerequisites

Before you get started, you'll need to have a GitHub account and have Git installed on your local machine. If you don't have a GitHub account, you can sign up for one for free at https://github.com/. To install Git, you can follow the instructions at https://git-scm.com/downloads.

Step 1: Fork the Repository

The first step in contributing to an open source project on GitHub is to fork the repository. This creates a copy of the repository under your own GitHub account, which you can then use to make changes and submit a pull request.

To fork a repository, follow these steps:

Navigate to the repository you want to fork on GitHub.
Click the "Fork" button in the top-right corner of the page.
Choose the account you want to fork the repository to.
Click the "Fork repository" button.

This will create a copy of the repository under your own account, which you can then clone to your local machine.

Step 2: Clone the Repository

Once you've forked the repository, the next step is to clone it to your local machine. This will allow you to make changes to the code and test them locally before submitting a pull request.

To clone the repository, follow these steps:

Navigate to the repository you forked on GitHub.
Click the "Clone or download" button.
Copy the URL of the repository.
Open a terminal window on your local machine.
Navigate to the directory where you want to clone the repository.
Run the following command to clone the repository:

git clone <repository URL>

Press Enter.

This will create a local copy of the repository on your machine.

Step 3: Set Up the Project Locally

Once you've cloned the repository to your local machine, the next step is to set up the project locally. This typically involves installing any dependencies and running any setup scripts.

To set up the project locally, follow these steps:

Navigate to the directory where you cloned the repository.
Follow the project's setup instructions, which can usually be found in the repository's README file. This may involve installing dependencies, running setup scripts, or both.
Once the project is set up, you can start making changes to the code.

Step 4: Create a Pull Request

Once you've made the changes you want to contribute to the project, the next step is to create a pull request. A pull request is a request to the maintainers of the repository to review and potentially merge your changes into the main branch of the repository.

To create a pull request, follow these steps:

Commit your changes to your local repository.
Push your changes to your fork on GitHub.
Navigate to the repository you forked on GitHub.
Click the "Compare & pull request" button.
Enter a title and description for your pull request.
Click the "Create pull request" button.

This will create a pull request for the maintainers of the repository to review. They may ask for changes to be made or may merge the pull request as-is.

Conclusion

Contributing to an open source project on GitHub is a great way to learn new skills, collaborate with others, and give back to the developer community. By following the steps outlined in this tutorial, you can fork and clone an open source repository, set up the project locally, and create a pull request.

I hope this tutorial was helpful, if you have any questions or would like further information, don't hesitate to ask in the comments section.

Credits:
Image by storyset on Freepik

Asymmetric Encryption and the Diffie-Hellman Secret Key Exchange: Understanding How They Work Together

Javier Gongora — Fri, 23 Dec 2022 00:24:34 +0000

Symmetric encryption, asymmetric encryption, and the Diffie-Hellman key exchange are three important technologies that are commonly used to secure communication over the internet. In this tutorial, we'll go over what these technologies are and how they differ from each other.

What is Symmetric Encryption?

Symmetric encryption is a type of encryption that uses the same key to encrypt and decrypt data. This means that the same key is used to secure the data while it is being transmitted and to decrypt it once it reaches its destination.

One advantage of symmetric encryption is that it is generally faster and more efficient than asymmetric encryption, which we'll discuss later. However, it also has a major drawback: the key must be shared between the sender and the receiver of the data in order for the encryption and decryption to work. This means that the key must be securely transmitted from the sender to the receiver, which can be difficult to do over an insecure communication channel.

What is Asymmetric Encryption?

Asymmetric encryption, also known as public-key encryption, is a type of encryption that uses a pair of keys - a public key and a private key - to encrypt and decrypt data.
The public key is used to encrypt the data, while the private key is used to decrypt it. This means that anyone can use the public key to send an encrypted message to the owner of the private key, but only the owner of the private key can decrypt and read the message.

One advantage of asymmetric encryption is that the key does not need to be shared between the sender and the receiver of the data. This makes it easier to establish a secure connection over an insecure communication channel. However, asymmetric encryption is generally slower and less efficient than symmetric encryption.

What is the Diffie-Hellman Key Exchange?

The Diffie-Hellman key exchange is a method for securely exchanging a secret key over an insecure communication channel. It allows two parties to generate a shared secret key without revealing the key to any third party.

The Diffie-Hellman key exchange is an asymmetric encryption method, which means that it relies on the use of public and private keys to establish a secure connection. However, it also utilizes the benefits of symmetric encryption, which is a type of encryption that uses the same key to encrypt and decrypt data.

To understand how the Diffie-Hellman key exchange works, let's go back to our example of Alice and Bob. Suppose that Alice and Bob want to exchange a secret key to use for symmetric encryption.

To do this, Alice and Bob can use the Diffie-Hellman key exchange as follows:

Alice and Bob agree on two large prime numbers, p and g.
Alice and Bob each generate a secret random number, a and b, respectively.
Alice and Bob each calculate A and B using the following formulas:
A = g^a mod p B = g^b mod p
Alice and Bob each send their calculated values to each other.
Alice and Bob each calculate the shared secret key using the following formulas:
s_Alice = B^a mod p s_Bob = A^b mod p

The shared secret key, s, will be the same for both Alice and Bob. They can now use this key for symmetric encryption to communicate securely.

Conclusion

Symmetric encryption, asymmetric encryption, and the Diffie-Hellman key exchange are all important technologies that play a role in securing communication over the internet. Symmetric encryption is generally faster and more efficient, but requires the key to be shared between the sender and receiver. Asymmetric encryption does not require the key to be shared, but is generally slower and less efficient. The Diffie-Hellman key exchange is an asymmetric encryption method that is used to securely exchange a secret key for use in symmetric encryption.

I hope this tutorial was helpful in introducing you to the differences between symmetric encryption, asymmetric encryption, and the Diffie-Hellman key exchange. If you have any questions or would like further information, don't hesitate to ask in the comments section.

Credits:
Image by rawpixel.com on Freepik

Writing More Effective Front-End Tests with Jest

Javier Gongora — Thu, 22 Dec 2022 21:36:36 +0000

Front-end testing can be challenging as it often involves testing complex user interfaces and interactions. In this tutorial, we'll go over some tips for writing more effective front-end tests with Jest.

Test the component, not the implementation

One of the key principles of front-end testing is to test the component, not the implementation. This means that you should focus on testing the output and behaviour of the component, rather that the specific implementation details.

For example, consider the following component:

function MyButton(props) {
return <button onClick={props.oncClick}>{props.children}</button>

To test this component effectively, you should focus on testing the output (e.g. the rendered HTML) and the behaviour (e.g. the onClick event) rather than the specific implementation details (e.g. the fact that it uses a button element).

Use the right test utilities

Jest provides a variety of test utilities that can make it easier to write effective front-end tests.

For example, the @testing-library/react library provides utility functions for rendering and interacting with React components in a test environment.

The @testing-library/jest-dom library provides additional utility functions for making assertions about the DOM, such as expect(element).toHaveTextContent(text) and expect(element).toBeDisabled().

Using the right test utilities can make it much easier to write tests that are both effective and easy to maintain.

Test asynchronous behaviour

Many front-end components have asynchronous behaviour, such as making network requests or updating the DOM after a delay. Testing this behaviour can be challenging, but Jest provides a variety of tools for handling asynchronous code in tests.

For example, you can use the async and await keywords to write asynchronous tests:

test('async test', async () => {
const result = await asyncFunc();
expect(result).toEqual('hello');
});

You can also use the done callback to write asynchronous tests that don't use async and await:

test('async test', (done) => {
  asyncFunc().then((result) => {
    expect(result).toEqual('hello');
    done();
  });
});

Testing asynchronous behaviour is essential for ensuring that your front-end components behave correctly in a real-world environment.

Write testable components

Finally, it's important to design your front-end components in a way that makes them easy to test. This might involve extracting logic into separate functions, using props for input and state for output, and avoiding side effects where possible.

By writing testable components, you'll be able to write more effective tests that are easier to maintain and less prone to breaking when the implementation changes.

Credits:
Image by vectorjuice on Freepik

Using the Rsync Command for Copying and Synchronizing Files and Directories

Javier Gongora — Thu, 22 Dec 2022 21:27:01 +0000

Rsync is a powerful Linux/Unix command that allows you to copy and synchronize files and directories between local and remote systems. It is particularly useful for synchronizing large numbers of files, as it is efficient and only transfers the differences between the source and destination files.

Here's a brief overview of how to use the Rsync command:

Copying files and directories locally

To copy a file or directory from one location to another on the same system, you can use the following syntax:

rsync <source> <destination>

For example, to copy a file named file.txt from the current directory to the /tmp directory, you could use the following command:

rsync file.txt /tmp

To copy a directory and its contents, you can add the -r flag to the command:

rsync -r <source> <destination>

For example, to copy the /var/www/html directory and its contents to the /tmp directory, you could use the following command:

rsync -r /var/www/html /tmp

Copying files and directories remotely

To copy a file or directory from a remote system to a local system, you can use the following syntax:

rsync <user>@<remote_host>:<source> <destination>

For example, to copy a file named file.txt from the /tmp directory on a remote system with hostname example.com to the current directory on your local system, you could use the following command:

rsync user@example.com:/tmp/file.txt .

To copy a directory and its contents, you can add the -r flag to the command as before:

rsync -r <user>@<remote_host>:<source> <destination>

For example, to copy the /var/www/html directory and its contents from a remote system with hostname example.com to the /tmp directory on your local system, you could use the following command:

rsync -r user@example.com:/var/www/html /tmp

Synchronizing files and directories

To synchronize files and directories between two systems, you can use the -a flag, which stands for "archive" and preserves the file attributes and permissions. You can also use the -u flag, which stands for "update" and only transfers files that are newer on the source system:

rsync -au <user>@<remote_host>:<source> <destination>

For example, to synchronize the /var/www/html directory and its contents from a remote system with hostname example.com to the /tmp directory on your local system, making sure to only transfer newer files and preserve file attributes and permissions, you could use the following command:

rsync -au user@example.com:/var/www/html /tmp

Whether you're looking to simply copy files from one location to another, or synchronize entire directories between systems, Rsync can be a valuable tool to have in your toolkit. So give it a try and see how it can streamline your file management processes.

Credits:
Image by storyset on Freepik

Setting up Apache Virtual Hosts on an Ubuntu Server

Javier Gongora — Thu, 22 Dec 2022 04:35:54 +0000

Virtual hosts allow you to host multiple websites on a single server. This can be useful if you want to host multiple websites on a single instance, or if you want to run multiple versions of a website (e.g. staging and production).

In this tutorial, we'll go through the steps of setting up Apache virtual hosts on an Ubuntu server.

1. Install Apache:

First, make sure that Apache is installed on your server. If it's not already installed, you can install it with the following command:

sudo apt-get install apache2

2. Enable Apache's virtual host module:

Next, we need to enable Apache's virtual host module. This can be done with the following command:

sudo a2enmod vhost_alias

3. Create a new virtual host file:

Next, we'll create a new virtual host file for each website that we want to host. These files can be placed in the /etc/apache2/sites-available directory.

To create a new virtual host file, copy the default virtual host file and modify it to suit your needs. For example:

sudo cp /etc/apache2/sites-available/000-default.conf /etc/apache2/sites-available/example.com.conf

Then, open the new virtual host file in a text editor and modify it to specify the document root (i.e. the directory containing the website's files) and the server name:

<VirtualHost *:80>
  ServerName example.com
  ServerAlias www.example.com
  DocumentRoot /var/www/example.com/public_html
  <Directory /var/www/example.com/public_html>
    AllowOverride All
  </Directory>
</VirtualHost>

Be sure to replace example.com with the actual domain name of your website.

4. Enable the new virtual host:

To enable the new virtual host, use the following command:

sudo a2ensite example.com.conf

5. Restart Apache:

Finally, restart Apache to apply the changes:

sudo systemctl restart apache2

That's it! You should now be able to access your website at the specified domain name.

How to use SSH keys with GitHub repositories

Javier Gongora — Wed, 21 Dec 2022 16:48:18 +0000

SSH (Secure Shell) is a network protocol that allows you to securely connect to a remote computer. It is commonly used for remote command-line access and remote command execution.

In this tutorial, we'll go over how to use SSH to work with GitHub repositories on a MacOS or Linux system.

Generating an SSH key

Before you can use SSH to connect to a remote system, you'll need to generate an SSH key. An SSH key consists of a public key and a private key. The public key is used to encrypt data, while the private key is used to decrypt it.

To generate an SSH key on a MacOS or Linux system, open a terminal and enter the following command:

ssh-keygen -t rsa -b 4096 -C "your_email@example.com"

Replace "your_email@example.com" with your email address.

This will generate a new SSH key pair and prompt you to enter a file in which to save the key. You can accept the default location by pressing Enter.

You will then be prompted to enter a passphrase for the key. This is an optional security measure that allows you to protect your private key with a password.

Adding the SSH key to your GitHub account

Once you have generated an SSH key, you'll need to add it to your GitHub account. To do this, follow these steps:

Open a terminal and enter the following command to print your public key:

cat ~/.ssh/id_rsa.pub

Copy the output of the command to your clipboard.
Go to your GitHub account settings and select the "SSH and GPG keys" tab.
Click the "New SSH key" button.
In the "Title" field, enter a descriptive name for the key (e.g. "Work laptop").
In the "Key" field, paste the public key that you copied to your clipboard.
Click the "Add SSH key" button to add the key to your account.

Cloning a repository using SSH

Now that you've added your SSH key to your GitHub account, you can use SSH to clone a repository. To do this, follow these steps:

Go to the repository page on GitHub.
In the "Clone or download" dropdown, click the "Use SSH" button.
Copy the SSH URL of the repository to your clipboard.
Open a terminal and navigate to the directory where you want to clone the repository.
Enter the following command to clone the repository: git clone <repository_url> Replace <repository_url> with the SSH URL of the repository that you copied to your clipboard.

The repository will be cloned to the current directory.

Working with a repository using SSH

Once you have cloned a repository using SSH, you can work with it as you would with any other local repository. To push changes to the repository, use the git push command.

For example, to commit and push changes to a repository, you can use the following commands:

git add .
git commit -m "Commit message"
git push

Note that you may be prompted to enter your SSH passphrase when pushing changes to the repository.

Troubleshooting

If you encounter any issues while using SSH, there are a few things you can try:

Make sure that your SSH key is correctly added to your GitHub account.
Make sure that you are using the correct SSH URL for the repository. You can find the SSH URL in the "Clone or download" dropdown on the repository page on GitHub.
If you are prompted for a password when connecting to the remote system, make sure that you have entered the correct SSH passphrase for your private key.