DEV Community: Khoa DINH

In 2022, I Found a Simple Method to Accomplish My Side Projects

Khoa DINH — Sun, 18 Dec 2022 17:42:11 +0000

Let personal projects be fun instead of a burden

How I failed to finish my project

Like other developers, I love building applications. I spend my free time coding because it is fun. In addition, doing projects is my preferred method to improve my coding skills.

However, while starting a new project is always exciting, finishing one is challenging. I faced many problems in completing my applications.

Many factors can prevent us from finishing a project, including a lack of clear goals or direction, distraction, perfectionism, and so on. In my case, I was frequently distracted in the middle of my projects. Here is what is in my head, in order:

Okay, we start a project. We will build an elegant application. Let's implement a scalable architecture with clean code.

Ah, I have new ideas about it.

I will add this new functionality. It’s cool.

I better use this library rather than the current.

Oh… I should not do this in the first place. It is not what I want. Let’s change the code.

I wasted too much time switching between this and that.

Oh… the project looks like a mess… I cannot continue… I want a cleaner project from the beginning.

And I abandoned my projects many times.

My solution

Last year, I started to write articles on Medium. At first, I wrote non-technical articles. Then, while working on my n-th side projects, I considered writing a tutorial on Medium.

And that idea changed the game.

Because I enjoy posting my content, I have the motivation to finish the project and write articles. My project also has a virtual audience.

The objective became clear. I eliminated all fancy but irrelevant ideas. I made an effort to keep the application as simple as possible. Because if it was complicated, I couldn't explain it in the tutorial. It didn't take me a lot of time to choose a library. I use whatever does the job and is well-documented.

And that how I finish this project.
Use AdminJS to Quickly Build an Administration Web App

We can divide the project into several articles if it does not fit into one. Below are some projects that I finished recently, following the same principle.
Web Crawler with JavaScript- These Easy Steps Help Me Get Medium Articles’ Data
Of curiosity, I analyzed ~180 000 articles on Medium

More advantages

Besides the motivation to finish the project, sharing the result on Medium has additional non-negligible advantages.

Learning — the second time

When I write the tutorial, I think about the audience and find a straightforward way to explain the concept. The process of making things simple helps me better understand my code.

Learning by doing is one of the most effective methods. Now we combine it with explaining and teaching to others. Is it the most powerful combination for learning?

Save it for future

Create a tutorial and post it on Medium or your blog, and you will have it forever. You can consult it anytime in the future when you need it.

A little reward. Why not?

You can monetize your articles if you are a member of the Medium Partner Program. If your content engages readers and offers them value, you will probably receive the deserving reward.

A strong point in your profile

Your articles will give recruiters an additional perspective on your abilities. It is more HR-friendly than the list of technologies we usually include on CVs. In my opinion, a public fingerprint is a strong point in the profile when competing with other candidates.

The productive loop

Finally, we must recognize the positive energy generated when content is published and appreciated by readers. From my experience, the moment I felt most motivated was immediately after I posted one. That energy gives us more motivation to start new research! The loop returns to the beginning point.

Notice

One thing to keep in mind when using the method. You should clearly define the goal of the side projects. If you want to learn something new, do not fall back on old ideas simply because your articles in the categories have a lot of views. Publishing the result on Medium is a step in the process for me. I don’t let it take my attention away from the initial objective.

Conclusion

In this article, I explain the simple method to finish my applications. For readers who face the same problem, I hope the article could give you ideas to complete your side projects. Thank you for reading!

More content at **PlainEnglish.io. Sign up for our **free weekly newsletter. Follow us on **Twitter, ***LinkedIn, **YouTube, and **Discord.*

**Interested in scaling your software startup? Check out **Circuit.

4 daily use-cases of first-class functions in JavaScript

Khoa DINH — Wed, 22 Dec 2021 07:10:35 +0000

Every language has features that make it special. In this article, I want to mention the “first-class function” characteristic in JavaScript. The article isn’t a tutorial about how to use it. Instead, I would like to point out some real-life usages of the feature and the benefits it brings to developers. Let’s start!

What is “first-class function” about?

The definition from Wikipedia:

In computer science, a programming language is said to have first-class functions if it treats functions as first-class citizens. This means the language supports passing functions as arguments to other functions, returning them as the values from other functions, and assigning them to variables or storing them in data structures.

For example, in JavaScript, we can assign a function to a variable.

The definition is a bit confusing if we are reading it for the first time. However, the fact is that we used it even without knowing about it.

AddEventListener — The first lesson when learning JavaScript

Back in the past, JavaScript was introduced to add dynamic behaviors to a website. For instance, we want to change the text when the user clicks on the button. Here comes the very first line of code when someone learns JavaScript.

In line 9, we passed the function as an argument to the method addEventListener. The function is associated with the event “click” of the button. When the event is fired, the function will run.

Let’s be curious — Part 1

To understand the role of the feature, let’s think about languages where it isn’t available. Adding dynamic behaviors is something common in UI development, regardless of the programming language. What if we cannot pass the function as an argument? I am looking forward to your response in the comment section.

Sending HTTP requests — The common task in JavaScript

I will take Axios as an example. It is one of the most popular JavaScript libraries to send HTTP requests. In a project, we might need to add some common configurations. For example, to send the JWT to the server, we want to add the header Authorization to all requests. So, we need a function to grab the JWT somewhere and add it to the header. It could be done using interceptors.

Again, we pass 2 functions as arguments of the use method. The first function sets the token in the request’s header. The second function runs if there is an error (we don’t define it here for simplicity). When Axios processes a request, it will run all interceptors one by one to transform the user’s config to the full configuration. Then it will send the request to the server.

The way Axios processes interceptors is a nice illustration of first-class function in JavaScript.

In line 23, the fulfilled and rejected functions we pass in the usemethod are added to the requestInterceptorChain. We store functions in an array. Then Axios will run each of them. Inside the while loop, you can see functions are assigned to variables to be called.

Let’s be curious — Part 2

Sending HTTP requests is not limited to frontend development. When developing the backend part, we might need to send requests to an external server. Could you explain to our community how HTTP request configurations are processed in your preferred language?

Handling HTTP requests in Node.js

With Node.js, we can develop the backend part using JavaScript. Backend development is about handling HTTP requests, that is: to receive them, parse them, find the correct answers, and respond to clients. One of the most used frameworks of Node.js is Express.js. This framework uses middleware to do the tasks mentioned above. Here is the definition of middleware from Express official page:

Middleware functions are functions that have access to the request object (req), the response object (res), and the next middleware function in the application’s request-response cycle.

You can see the example of middleware below.

The middleware function is passed in the use method. It, in turn, accepts another function next as an argument. The next function is called at the end to pass the control to the following middleware in the stack.

Express is popular and widely used for its simplicity. “An Express application is essentially a series of middleware function calls.” Despite the trivial looks, Express’s middleware can help us do all tasks of a web server: logging the request, compressing the response, setting cookies, preventing XSS attacks … just to mention a few.

Let’s be curious, again!

How HTTP requests are processed in other backend frameworks? Can you compare it to Express middleware? What are the advantages/disadvantages of each method? You see, there are a lot of questions to study!

Last but not least — Callback hell in JavaScript

As you know, JavaScript is single-threaded. But it provides an effective mechanism to deal with long-running tasks. Instead of waiting for the task to be finished, we can immediately start the next one, and define what we need to do when the former task has been accomplished. It’s where callback functions come from — to define what should be run after a long-running task.

Callback functions give us a powerful tool to deal with I/O bound applications. However, every good thing can go bad if it is abused. You can see the example below.

Multiple callback functions and if/else statements make the code hard to understand. It can become unmaintainable in the future if we add more logic. Because of this problem, newer features are introduced. Promises appeared to help us write a cleaner program. Async/await keyword allows us to write asynchronous code that looks like synchronous code.

Wrap up

In the article, I showed you some real-life examples of using “first-class function” in JavaScript. We use this feature daily and take it for granted. Through the examples, I hope you can see some cool things that the peculiarity offers to us. I left many questions for you as well. Curiosity is one of the characteristics that help us grow up. I will be glad to see your answer in the comment section so that we can learn from each other. You can also share the article with developers in other languages to discuss. Thank you for reading!

Resources

How BASIC knowledge helps us solve a ~2 million views question

Khoa DINH — Tue, 21 Dec 2021 23:37:21 +0000

You can check out the question here. It’s the problem with the SSH private key. The answer is at the end of the article, I have created links in the table of contents for you to navigate. However, to enjoy the “that makes sense” moment, I encourage you to walk through each part of the article.

Table of content

Introduction
Background knowledge - Encryption
2.1 Definition
2.2 Symmetric encryption
2.3 Asymmetric encryption
Real-life examples of using SSH
3.1 Using SSH with Git hosting service
3.2 SSH configuration files
Answer the question
Wrap up

Introduction

To manipulate the remote server, we need a method that allows us to connect to them from our computer. SSH is one of those methods.

SSH is a method that helps us establish a secure connection to a remote server.

This connection allows us to work directly with the server’s shell. From there we can do all the tasks like we are doing with our machine.

In the next section, I would like to review some background knowledge before starting to talk about different use cases of this tool. This part will help us to understand the meaning of a config file or an error message. So that we can determine what we need to do even when copying someone’s magic commands from Google.

Background knowledge : Encryption

In the previous section, we mentioned security. SSH allows you to establish a secure connection. To do that, SSH uses different encryption algorithms.

Definition

You can find the classic full definition of encryption at this link. To keep it simple, I would like to use my version.

Encryption is expressing information in a form that cannot be understood unless we have the means to decode it.

There are 2 categories of encryption algorithms: symmetric encryption and asymmetric encryption.

Symmetric encryption

Symmetric encryption is a class of encryption algorithms in which the encryption and decryption phase share a single key (decryption is the reverse process of encryption). This key is a secret between the two parties in the conversation.

Symmetric encryption keeps the information exchanged confidentially. Only those with the key can decrypt the information.

Asymmetric encryption

In contrast to symmetric encryption, asymmetric encryption algorithms use 2 different keys to encrypt and decrypt information. Each person needs a key pair consisting of a public key and a private key. While the public key can be made public to everyone, the private key is private to each person and cannot be shared with anyone. When information is encrypted with one of the keys in a key pair, only the other key in the same pair can decrypt it.

(Notice the difference between a secret key and a private key. The private key cannot be shared. The secret key in symmetric encryption can be shared between the two parties.)

Asymmetric encryption also gives us the same security as symmetric encryption. If Alice encrypts the message with Bob’s public key, then only Bobs with his private key can decrypt the message.

In addition, it provides two extra possibilities that symmetric encryption does not:

Allow us to identify who sent the information. (*)
The person who sent the information cannot deny the action.

This is the case when Alice encrypts the message with her private key. Bob uses Alice’s public key to decrypt. If the decryption is successful, it proves that the message can only be sent from Alice. At the same time, Alice cannot deny that she sent this message. Because if it was sent by someone else, Bob couldn’t use the public key of Alice to decrypt.

The characteristic (*) is an important foundation for SSH because it helps the server identify who is connecting to the system. This allows the server to accept or reject the connection. Authentication using SSH does not require a password. Instead, each person will use his/her private key to connect to the server, and the server keeps track of the list of people who can connect (see authorized_keys in the next section). Comparing two authentication methods using password and using the private key, the latter is the winner because:

Authentication with the private key tells us who accessed the system, and that person cannot deny the fact. In the first method, anyone who knows the password can connect to the system.
By not using a password, authentication with a private key is more convenient. Each person in a group can use their private key to log into the common system instead of sharing a password. Password sharing in the workplace can expose the business to risks. Therefore, we should avoid shared passwords whenever possible.
Private key authentication allows us to automate commands because the server shell does not prompt for the password.

Those are also the powers of SSH, and that’s why more and more systems move to this method. Now, we will talk about using SSH in practice.

Real-life examples of using SSH

Using SSH with Git hosting service

When working with Git hosting services like GitHub or GitLab, we can clone, push, pull a repository using HTTPS or SSH protocol.

If we use HTTPS, every time we push, pull … We need to enter the username and password.

If we use SSH, we need to give GitHub/GitLab our public key. Then, every time we push, pull, instead of having to enter the username and password, we just need to enter the password of the private key (passphrase). If we don’t use the passphrase, then we don’t need to type anything! GitHub uses the public key to verify who we are and check if we have permission to read/write the repository.

The second way is more convenient because we don’t have to manually type the username and passwords each time. If no passphrase is configured for the key, the push/pull command can be done by running a script. This allows us to automate the integration and deployment phase.

SSH configuration files

To configure SSH, we will work with the .ssh directory under the home directory. This is the directory where the important files to use the SSH protocol locate. They are authorized_keys, known_hosts, and config. Below, I would like to explain the meaning of each file:

authorized_keys: This file contains a list of public keys that are allowed to access the system. When someone connects to the server, the message (encrypted with their private key) is decrypted by the public keys in this file. If the decryption is successful, the person is identified and is allowed to connect to the server.

So, if you want to access the servers using the SSH protocol, you just need to add your public key to this file. The same principle applied when AWS gives us a .ppk file to access the container.

known_hosts: This file contains a list of public keys of remote servers that you have visited before. The information in the file helps the computer check the identity of the destination to make sure it is connecting to the right place, to avoid being redirected to a machine of a bad guy.
config: This file contains SSH settings. When we use frequently one particular SSH connection, we can save the parameters of that connection to this file. Then, the SSH command can be shortened. For example, when you save the following text in the file ~/.ssh/config

Host alias  
   HostName hostname  
   User username  
   IdentityFile ~/.ssh/private_key

Then these 2 commands below will give the same result:

ssh alias
ssh username@hostname -i ~/.ssh/private_key

I use this config file to set up a second GitLab account. You can see the tutorial here.

Answer the question

Let’s go back to the question at the beginning. When the private key is not secured, you will see a message like this.

This is a common mistake when the private key is not protected as it should. In the theory section, we said that the private key is private to each person and is not shared with anyone. In this case, the key has a permission of 644, which means that the contents of the key can be read by anyone. That violates the principle of the private key and leads to the error.

The problem is clear, we need to limit the permission of the file. We can use the permission of read-only or read-write by the owner. And the magic command is:

chmod 400 ~/.ssh/[[PRIVATE KEY]]or chmod 600 ~/.ssh/[[PRIVATE KEY]]

Done!

Wrap up

SSH is a protocol that we use daily at work. At first, I blindly copied and pasted the commands I found from Stack Overflow and hope it will work. But I did not understand why. When I had to configure more complex cases or recently worked with GitLab CI/CD, I was very confused. After revising the basics, I better understand SSH now. Through this post, I hope we can see the close relationship between basic knowledge and practical usage and feel more confident when dealing with issues.

Resources

— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —

I look forward to connecting with other people to learn from your perspectives. If you’ve ever had those “That makes sense!” moments, you can also share them in the comment section. That will help us learn from each other. Thank you for reading!