Forem: Alex

How to start using Vim

Alex — Mon, 07 Oct 2024 14:34:38 +0000

Almost 30 years have passed since the first version of Vim appeared, but it continues to develop and grow its community. Many projects, such as Neovim, MacVim, etc., were inspired by Vim, which can also be integrated into an IDE or code editor, like Webstorm or VS Code.

I will not compare Vim with other IDEs or code editors because it makes no sense. In return, I will briefly show you the Vim ecosystem. We will look into ways to use it, and you will understand how you can start using it without struggling and fighting with the editor.

This article is for people who know little about Vim, but it is still useful for experienced users.

Vim and Neovim

Currently, two main varieties exist: Vim and its fork, Neovim. Most plugins extending the editor are available in both, so you can choose whatever you prefer.

Earlier, an obvious advantage of Neovim was asynchrony, but modern versions of Vim, starting with version 8, support async I/O. I prefer Neovim, mostly because it has a constantly developing community, plugins better support Neovim than Vim, and actually, it looks much better by default.

Ways to use

Let’s focus on a few ways of using Vim. I will describe the ways I tried myself, and I believe you can find more if you want to.

The first way of using vim is very simple. You can install it and use it in the terminal, just run vim or nvim command to open the editor. In my opinion, it’s not the best way for beginners, and at the start of the Vim journey, it’s better to use it in your favorite code editor or IDE.

The following approach is to use Vim with VsCode. If you use it, just install the Vim plugin. The easymotion plugin will be automatically installed to make you happy. For me, it’s the most important Vim plugin, which significantly increases your coding speed.

You can also integrate Vim with JetBrains IDEs using 2 plugins:

IdeaVim;
AceJump — it’s easymotion implementation for JetBrains;

SpaceVim is a ready—to—use configuration that also provides an interface for configuring the editor and installing plugins. A similar project, Spacemacs, exists on the Internet, which they were inspired by.

It’s a good solution for people who want to try using an editor in the terminal but are too busy to configure Vim from scratch.

If you want to fully immerse yourself in Vim, you can try the Vimium extension. With its help, you can use the browser through Vim.
I only tried the extension for Chrome, but there is Vimium for other browsers.
It’s not the most helpful thing, but it’s worth checking out, and maybe you’ll like it. I didn’t like it personally, but I hope it will be helpful for you.

The most convenient option for a beginner is to integrate Vim and Easymotion into your current editor or IDE, which will be much more convenient than Vim in the terminal.
However, it is unlikely that you will be able to use Vim at work immediately, so it is better to enable it only when you want to learn how to use it and integrate it into your daily work step by step.

Getting Started

To start working with the editor, you should first learn to navigate and learn Vim modes; there should be no difficulties here. After that, you can try writing simple functions and expressions in your favorite programming language just to get used to it.

Then, you can move on to mastering combinations and commands. The most effective way is to learn a few each day. I mean, try them hands-on and use them later. There is much information about this, so I don’t see the point of stopping here.

I will separately emphasize the importance of touch typing. Without it, it is impossible to work fully and comfortably with Vim.

Learning touch typing is not a very pleasant activity and takes quite a lot of time. But if you devote 20–30 minutes a day to it, then in a month, you will be able to type blindly, albeit slowly and with errors.

First, remember the keys’ location and learn to press them without looking at the keyboard. Next, print simple texts. For beginners, the main thing is not speed but quality, so you should ignore the number of characters per minute.

When you feel comfortable, you can practice speed. I think it is optimal to reach 100–120 characters per minute. Then the excitement starts, and you want to speed up more and more. There is much information about correct finger placement on the internet for those just beginning to learn how to type unthinkingly. I will focus on resources where you can improve your skills:

These are beneficial sites. Here, you can increase your speed and reduce the number of errors. In principle, you can learn touch typing while getting to know the combinations in Vim, but it will be more difficult.
After all, the keyboard is your work tool, so touch typing is still worth learning.

Resources

There are many Vim resources on the internet, especially for beginners. One of the best, in my opinion, is vim.fandom.com/wiki/Vim_Tips_Wiki. It is suitable for those familiar with the ecosystem and can at least navigate the editor and use its modes. This site has a lot of material on various editor combinations, commands, and settings. There are also tutorials dedicated to specific aspects of Vim.

Another good site about the editor is wikibooks.org/wiki/Vim. I haven’t used it much, but it’s also worth checking out.

Also, catch some interesting Twitter feeds I read:

I think this information will be enough to understand the editor’s advantages, both separately in the terminal and in connection with popular code editors and IDEs.
I want to emphasize that patience and persistence are key to getting to know Vim (as in learning anything new).

Two pointers algorithm explained

Alex — Mon, 07 Oct 2024 10:39:06 +0000

I want to explain a simple and effective technique that you can use in an interview when dealing with Arrays, Strings, Linked Lists, etc. This will also improve your fundamental knowledge about these data structures.

Let’s start from theory. There are two common use cases of this algorithm:

left/right The central concept of this algorithm is to have two integer variables that will move from both sides of a string or array. Usually, people call it left and right. The left will move from the 0 index to the length — 1, and the right is the opposite.
slow/fast Pointers run in the same direction, e.g., from start to end, but one pointer runs faster than another. In this case, people usually call variables slow and fast.

Algorithms are elementary, and the best way to understand them is to look into some examples.

First, let’s look at a case with left and right pointers. Here is an elementary example of a problem we can solve using this algorithm. The goal is clear: we want to find a pair whose sum will equal a given number.
The brute force approach will create nested loops, but there’s a low chance of passing the interview using it.
A better approach would be to use the two pointers algorithm and find it in one loop to have O(n) complexity instead of O(n²)

const findPair = (arr, target) => {
    let left = 0;                 // Start with two pointers left from start, right, from the end
    let right = arr.length - 1;

    while (left < right) { // when pointers meet, finish loop
        const sum = arr[left] + arr[right];

        if (sum === target) {
            return [arr[left], arr[right]];  // Return the pair if we find the target sum
        } else if (sum < target) {
            left++;  // Move left pointer to the right if sum is less than target
        } else {
            right--;  // Move right pointer to the left if sum is greater than target
        }
    }

    return null;  // Return null if no such pair exists
}

const arr = [1, 2, 3, 4, 6];
const target = 6;

findPair(arr, target);  // Output: [2, 4]

Let’s switch to an approach where pointers have different speeds. It’s a frequent problem which you can meet an interview. You need to find the middle of the given Linked List.
The brute force approach is not as bad as the previous example, but the interviewer expects a better one.
With two pointers algorithm, you will solve this problem with O(n) complexity, whereas the brute force approach will take O(2n) if you use two sequential loops.

class ListNode {
    constructor(value) {
        this.value = value;
        this.next = null;
    }
}

const findMiddle = (head) => {
    if (!head) return null;

    let slow = head;
    let fast = head;

    while (fast && fast.next) {
        slow = slow.next;           // Move slow pointer one step
        fast = fast.next.next;      // Move fast pointer two steps
    }

    return slow;  // Slow pointer will be at the middle
}

// Creating a linked list 1 -> 2 -> 3 -> 4 -> 5
const head = new ListNode(1);
const node2 = new ListNode(2);
const node3 = new ListNode(3);
const node4 = new ListNode(4);
const node5 = new ListNode(5);

head.next = node2;
node2.next = node3;
node3.next = node4;
node4.next = node5;

findMiddle(head).value);  // Output: 3 (middle node)

Why it is worth passing HashiCorp Certified: Terraform Associate

Alex — Mon, 07 Oct 2024 09:20:27 +0000

In this article, I will briefly describe certification and the process and explain the advantages of passing it.

Firstly, let’s talk about the exam process. In my case, I registered for the exam and took two weeks to prepare because I had worked with Terraform before. After reading the exam details, I understood it would be enough. Then, I started preparation and spent approximately one hour per working day preparing for the exam, reading the preparation guide, and creating a small pet project where I tested unfamiliar features.

In my opinion, you don’t need to buy courses for this exam. It’s pretty straightforward and almost missing tricky questions where you should understand how it works under the hood. It’s better to have practice on small pet project to remember all the necessary information from the preparation guide.

On an exam day, you must follow the proctor’s instructions about preparing for the workplace. They are strict, and my recommendation is to remove everything from the table, close doors and windows, and remove the watch and other jewelry, not to spend time discussing it with the proctor. And, of course, don’t forget to prepare your ID.

You can ask me why passing this certification came to my mind. I’ve already passed a few IT certifications and can say it’s helpful for a few reasons:

When preparing, you will read about corner cases or things you are not using frequently and understand the whole system
You will recall many Terraform features, methods, and approaches that you can apply to your projects;
When you try to bring Terraform into a new project or move existing infrastructure to IaC, a certificate will be a source of truth you have experience with this;
It will help in the interview, mainly if the company uses Terraform as an IaC solution. Also, the interviewer will most likely skip simple questions, and we will talk about deeper topics in Terraform or IaC in general. It will help you sell your skills better;

Summarizing the above, I think it’s a good investment for your future. It costs about 70$ but gives you many more opportunities.

Also, here, I will leave sources where you can prepare for the certification:

The main steps I follow when kicking off Node.js projects

Alex — Mon, 07 Oct 2024 07:28:08 +0000

In this article, I want to emphasize some steps I follow when developing Node.js applications. These steps help me deliver reliable apps that cover business needs and are flexible and scalable for long-term growth.

Before starting with approaches and technologies that can solve problems, you should understand which issues you will solve. That’s why the essential thing you should be thinking about is the business context.
You can’t predict how the project will grow after production and what the business will need later. What you can do is discuss what the company needs for the MVP and develop the project in a scalable manner to prepare for later changes and migrations.

After you have concepts and goals for the MVP, let’s move down to the engineering level and examine approaches and technologies that can help ensure the application's scalability and reliability.

Framework

It’s better to start by choosing the architecture you will implement — monolith, serverless, or microservices. There’s the most common architectural approach for now, but you are not limited here.
You can choose a framework based on the architecture. Be careful here because many frameworks exist in the Node.js ecosystem.
My choices are:

Express.js is excellent for small projects or prototypes, which will be replaced later.
Nest.js covers several architectures, which is a default framework I consider when deciding what to use. It’s excellent for the monolith, which will be divided into domains and later transformed into separate microservices.
Moleculer will be good if you consider microservices. Still, I’m not a big fan of creating microservices when the project starts due to the complexity of the infrastructure and overall development processes. It’s an excellent framework for building microservices around your monolith or migrating from monolith to MS.
Next.js. Yes, I also consider it when deciding what I should use. It’s perfect if you are the only engineer who will work on the project or if all engineers are full-stack developers. Along with Vercel, you will have many benefits and be able to move quickly. However, later, you will probably need to migrate the backend to a separate codebase due to complexity.
Serverless is fantastic and probably the only solution for handling serverless architecture. It’s incredible for prototyping or small APIs. Still, I prefer to use it along with monolith or MS architectures as additional services or to handle narrow application parts where serverless is suitable.

Typescript

It’s suitable for almost every project and architecture. However, I don’t want to stop here because different articles have extensively described its benefits and drawbacks.

Data storage

Of course, you must choose SQL or NoSQL databases based on your business needs, or maybe you need both types of storage. I frequently select from several databases I worked on and have extensive experience with.

My default choice is PostgreSQL. It’s perfect relational storage with one of the best optimizers. It can cover most of your needs.
Frequently, I consider MongoDB, especially the serverless version. It’s a robust database that benefits from the relational model and is a powerful NoSQL database with many features that most storages don’t provide.
If you need a powerful NoSQL solution without relational benefits, consider DynamoDB. I also use it frequently, but mostly to handle narrow parts of projects. Be careful with this database because it has a special design you must learn before use. Don’t be like people who create many tables and try to use them as MongoDB or even as relational DB. In this case, you will have big problems when the product grows.

Also, I want to mention non-persistent storages like ElasticSearch and Redis, which I frequently use. ElasticSearch is not good when the project starts, but you can take it into account and use it later when you need to handle complex indexes and searches. Redis or another memory database is friendly and easy to implement. We frequently need a cache even at the beginning of the project, so it’s nice to have it.

Data access layer

Here, I use different approaches depending on the product side. I like starting with ORM and migrating to query builder or raw SQL in narrow parts. For NoSQL databases, I wouldn’t say I like ODM’s and prefer using drivers. For example, I don’t particularly appreciate using Mongoose and choose Node.js driver instead of this. I think it’s more flexible and simple than ODM, and it doesn’t require you to use the relational model.

For relational databases, there are many different libraries you can use here, but if you use an SQL database, you can consider TypeORM.

Development workflow

The last thing I want to mention is the development workflow. I like to keep it as simple as possible and use easy-to-implement tools to help automate workflows, moving to more flexible and complex solutions if needed. Here are my recommendations for tools you can consider:

Github actions. It’s an excellent CI/CD tool you can configure quickly and easily.
Dependabot is a fantastic tool for keeping packages in the latest versions and searching for vulnerabilities.
Terraform. I use it to manage infrastructure. It simplifies many things if at least a few people work on a project. As the project grows, it becomes massive, and maybe for better state management, you will need tools like Terragrunt to keep infrastructure-related code simple. If you use AWS as a cloud provider, you can also use AWS CDK. It’s a nice tool with Typescript support, but it’s available only for AWS, and if you need something from a different cloud infrastructure, the code will be much more complex than Terraform. That’s why I prefer the Terraform even for AWS.