Forem: R4V3N

8 Mistakes to Avoid While Learning to Code

R4V3N — Wed, 29 Nov 2023 08:24:32 +0000

Most of us have spent a considerable part of our childhood in cars, observing others drive. However, when it’s our turn to get behind the wheel, we quickly realize that watching isn’t the same as doing. This is a perfect analogy for what I call the “Tutorial Trap” in learning to code.

Understanding the Tutorial Trap

Many aspiring coders fall into the trap of endlessly watching tutorials, hoping to learn coding through observation. But just like driving, coding requires hands-on experience. This method alone often leads to failure, and I’ve identified eight key mistakes in this learning approach.

My Journey and Observations

Having tried and failed to learn coding several times myself, I’ve witnessed these pitfalls firsthand. Moreover, I’ve seen numerous people encounter these same challenges.

The Importance of Questions

Learning to drive involves asking numerous questions, and the same applies to coding. It’s essential to inquire about things you don’t understand. These questions can be directed to a teacher, mentor, online forums, or even AI tools like ChatGPT. But remember, the quality of your questions matters.

Asking the Right Questions

Contrary to the adage, there are ineffective questions. For instance, asking someone to simply fix your problem doesn’t foster learning. A constructive question should include context, what you’ve tried, and a growth-oriented ask, like seeking guidance rather than a quick fix.

Beyond Copy-Pasting Solutions

Avoid the habit of copying solutions from resources like tutorials, ChatGPT, or Stack Overflow without understanding them. Embrace the principle of learning to fish, rather than just being given a fish.

The Fundamentals Matter

Jumping into trendy technologies without a grasp of the basics is akin to building a house without a foundation. Start with core concepts before advancing to frameworks and libraries.

The Role of Practice and Patience

Learning to code is a gradual process. Just as you wouldn’t start driving on the highway immediately, coding requires step-by-step progression and plenty of practice.

The Gap Left by Tutorials

Tutorials often skip the crucial debugging process, a skill every coder needs to develop independently. Deliberate practice in debugging is essential.

The Value of Real Projects

Engaging in real, non-tutorial projects is vital. These projects force you to confront and resolve unique challenges, much like swimming in water compared to practicing on land.

Avoiding Burnout

Lastly, beware of burnout. Learning to code is a marathon, not a sprint. It requires time, often months or years, and cramming can lead to exhaustion and loss of interest.

Conclusion

Learning to code is indeed challenging, but with the right approach and mindset, it can be an incredibly rewarding journey. Remember to avoid these common traps, practice patiently, and enjoy the process of becoming a proficient coder.

This is all. I hope you find this useful. If you do, then don’t forget to give ❤️ and Bookmark 🏷️ for later use and if you have any questions or feedback then don’t hesitate to drop them in the comments below. I’ll see in the next one.
Please visit also my website to read more informative blogposts
Connect with me on LinkedIn to read more about C/C++, Git, Github, and more…!

My VS-Code setup

R4V3N — Fri, 10 Mar 2023 08:49:12 +0000

In this article, I’ll be sharing my VS-Code Setup with you. It includes the theme and Icons that use and Extensions (this is very important).

🎨Theme

I switch between themes.
Most of the Time I use Andromeda as my primary theme for VS Code but sometimes I switch to C/C++ theme.

Andromeda Theme

C/C++ Theme

🪟Icons

For Icons, I sometimes switch between Fluent Icons Theme

and vscode icons.

Now let’s dive into the best part, there are a lot of extensions I mention only my favorite or the one that I use mostly every day. Anyway, let’s start from A to Z.

Better Comments

The Better Comments extension will help you create more human-friendly comments in your code.

Download: Better Comments

C/C++ Extension Pack

An extension package which includes all necessary extensions for C/C++ Developer

Download: C/C++ Extension Pack

C/C++ Include Guard

The C/C++ Include Guard extension enables you to add, remove or update include guard macros to your C/C++ header files in one go.

Download: C/C++ Include Guard

Doxygen Documentation Generator

This VS Code Extensions provides Doxygen Documentation generation on the fly by starting a Doxygen comment block and pressing enter.

Download: Doxygen Documentation Generator

Error Lens

Error Lens turbo-charges language diagnostic features by making diagnostics stand out more prominently, highlighting the entire line wherever a diagnostic is generated by the language and also prints the message inline.

Download: Error Lens

Markdown All in One

All you need for Markdown (keyboard shortcuts, table of contents, auto preview and more).

Note: VS Code has basic Markdown support out-of-the-box (e.g, Markdown preview), please see the official documentation for more information.

Download: Markdown All in One

PlatformIO IDE

PlatformIO IDE is a Professional development environment for Embedded, IoT, Arduino, CMSIS, ESP-IDF, FreeRTOS, libOpenCM3, mbed OS, Pulp OS, SPL, STM32Cube, Zephyr RTOS, ARM, AVR, Espressif (ESP8266/ESP32), FPGA, MCS-51 (8051), MSP430, Nordic (nRF51/nRF52), PIC32, RISC-V, STMicroelectronics (STM8/STM32), Teensy

Download: PlatformIO IDE

Tabnine AI

Tabnine is an AI code assistant that makes you a better developer. Tabnine will increase your development velocity with real-time code completions in all the most popular coding languages and IDEs.

Download: Tabnine AI

WakaTime

And last but not least WakaTime is an open-source VS Code plugin for metrics, insights, and time tracking automatically generated from your programming activity.

Download: WakaTime

Wrapping up

Setting up a Linux Home Server and Using it to Program with VS Code and GitHub

R4V3N — Mon, 06 Mar 2023 14:04:19 +0000

Linux is a popular open-source operating system that is widely used by programmers and developers around the world. It is a powerful and flexible platform that can be used to create and run a wide range of applications, including web servers, databases, and programming environments. In this blog post, we will guide you through the process of setting up a Linux home server and using it to program with VS Code.

Setting up a Linux Home Server

Step 1: Choose Your Hardware
The first step in setting up a Linux home server is to choose your hardware. You will need a computer with enough memory and processing power to run the operating system and any applications you plan to install. It is also important to choose a machine that has enough storage space to store your files and data.

Step 2: Download Ubuntu
There are many Distribution that you can choose but for this blogpost i choose Ubuntu. Anyways the next step is to download the latest version of Ubuntu from the official website. You can choose between the desktop or server version, but for this tutorial, we will be using the server version.

Step 3: Create a Bootable USB Drive
After downloading the Ubuntu ISO file, you will need to create a bootable USB drive using software like Rufus or BalenaEtcher. Insert the USB drive into your computer, and follow the instructions to create the bootable drive.

Step 4: Install Ubuntu
Once you have created the bootable USB drive, insert it into the machine that you want to use as your server, and boot from the USB drive. Follow the instructions to install Ubuntu, and make sure to choose the server option during the installation process.

Step 5: Configure Ubuntu
After the installation is complete, you will need to configure Ubuntu. This includes setting up a user account, configuring the network, and installing any necessary software packages.

Using VS Code to Program on Ubuntu
Visual Studio Code is a popular code editor that is widely used by developers around the world. It is a powerful and flexible tool that can be used to write code in a wide range of programming languages, including Python, JavaScript, and C++.

Step 1: Install VS Code
The first step in using VS Code to program on Ubuntu is to install the software. You can do this by opening the terminal and running the following command:

sudo snap install --classic code

This will download and install the latest version of VS Code on your machine.

Step 2: Open VS Code
After installing VS Code, you can open the software by searching for it in the Applications menu or by running the following command in the terminal:

code

Step 3: Clone Your Repository
To clone a GitHub repository, open VS Code and click the “Clone Repository” button on the welcome screen. Enter the URL of the repository you want to clone and select the destination folder on your machine. VS Code will then download the repository files and open the project in the editor.

Step 4: Make Changes and Commit Your Code
Once you’ve cloned the repository, you can make changes to the code and commit your changes to the repository. To commit your code, open the Source Control panel in VS Code and click the “+” icon next to the files you want to commit. Enter a commit message and click the checkmark to commit your changes.

Step 5: Push Your Changes to GitHub
After you’ve committed your changes,

you can push them to GitHub to share them with your team or the broader community. To push your changes, click the “…” icon in the Source Control panel and select “Push”. VS Code will then upload your changes to the GitHub repository.

Step 6: Pull Changes from GitHub
If you are working on a project with a team, it is likely that other team members will make changes to the code while you are working on it. To pull these changes from GitHub, open the Source Control panel in VS Code and click the “…” icon. Select “Pull” to download the latest changes from the repository.

Step 7: Resolve Merge Conflicts
Sometimes, when you pull changes from GitHub, you may encounter merge conflicts. These occur when two or more team members make changes to the same piece of code. To resolve merge conflicts, open the file with the conflict in VS Code and look for the lines that have been modified. You can then edit the code to merge the changes together and resolve the conflict.

Conclusion

Incorporating GitHub into your programming workflow can help you collaborate with others, manage your code repositories more effectively, and streamline the development process. By following the steps outlined in this blog post, you can set up a Linux Ubuntu home server, use VS Code to program, and integrate GitHub into your workflow. This will provide you with a powerful and flexible platform that can help you take your coding skills to the next level.

Want to know how to create your own Linux commands instead? I got you covered take a look here to learn how you can create your own Linux Commands

THANK YOU FOR READING

I hope you found this little article helpful. Please share it with your friends and colleagues. Sharing is caring.
Please visit also my website to read more informative blogposts
Connect with me on LinkedIn to read more about C/C++, Git, Github, and more…!

Understanding the Ternary Operator in C and C++

R4V3N — Fri, 03 Mar 2023 15:48:51 +0000

Introduction:

In C and C++, the ternary operator, also known as the conditional operator, is a unique feature that allows for concise and efficient conditional expressions.

Assigning a value based on a condition

The ternary operator can be used to assign a value to a variable based on a condition. For example, let’s say we have two integers a and b, and we want to assign the value of the larger integer to another variable max. We can use the ternary operator to achieve this in a single line of code:

int max = (a > b) ? a : b;

This code first checks if a is greater than b. If it is, the value of a is assigned to max. Otherwise, the value of bis assigned to max.

Returning a value based on a condition

The ternary operator can also be used to return a value from a function based on a condition. For example, let’s say we have a function absolute value that takes an integer as input and returns its absolute value. We can use the ternary operator to simplify the implementation of this function:

int absolute value(int x) {
    return (x < 0) ? -x : x;
}

This code checks if x is negative. If it is, the absolute value of x is returned as -x. Otherwise, the value of x is returned.

Nesting the ternary operator

The ternary operator can also be nested to create more complex conditional expressions. For example, let’s say we have three integers a, b, and c, and we want to find the largest of the three. We can use nested ternary operators to achieve this:

int max = (a > b) ? ((a > c) ? a : c) : ((b > c) ? b : c);

This code first checks if a is greater than b. If it is, another ternary operator is used to check if a is greater than c. If it is, the value of a is assigned to max. If a is not greater than c, the value of c is assigned to max. If a is not greater than b, another ternary operator is used to check if b is greater than c. If it is, the value of b is assigned to max. If b is not greater than c, the value of c is assigned to max.

Conclusion

In conclusion, the ternary operator is a powerful tool in C and C++ that can simplify conditional expressions and make code more concise and efficient. By understanding how to use the ternary operator effectively, you can write cleaner and more readable code.

THANK YOU FOR READING

Understanding Overloaded Functions in C++: Benefits, Limitations, and Best Practices

R4V3N — Wed, 01 Mar 2023 17:46:50 +0000

Introduction:

C++ is a versatile language that supports various programming paradigms such as procedural, object-oriented, and generic programming. One of the key features of C++ is its support for function overloading, which allows developers to define multiple functions with the same name but different parameter lists. This feature is known as overloaded functions.

Overloaded functions:

Overloaded functions are functions that have the same name but different parameters. The parameters can differ in terms of their number, order, or types. When a function is called, the compiler determines which version of the function to call based on the number and types of the arguments passed to it.

For example, consider the following overloaded functions:

void print(int value)
{
    std::cout << "Value: " << value << std::endl;
}

void print(double value)
{
    std::cout << "Value: " << value << std::endl;
}

void print(const std::string& value)
{
    std::cout << "Value: " << value << std::endl;
}

Here, we have three overloaded functions with the same name, print, but different parameter types. The first function takes an integer, the second takes a double, and the third takes a string. Depending on the argument passed to the print function, the compiler will determine which version of the function to call.

When to use overloaded functions:

Overloaded functions are useful when we need to perform the same operation on different types of data. Instead of writing multiple functions with different names, we can use the same name and overload it with different parameter types. This makes the code more readable and easier to maintain.

For example, let’s say we have a function that calculates the area of a rectangle:

double calculateArea(double length, double width)
{
    return length * width;
}

We can overload this function to calculate the area of a circle and a triangle as well:

double calculateArea(double radius)
{
    return 3.14 * radius * radius;
}

double calculateArea(double base, double height)
{
    return 0.5 * base * height;
}

Now, depending on the shape we want to calculate the area of, we can call the appropriate version of the calculateArea function.

Benefits of overloaded functions:

Overloaded functions provide the following benefits:

Readability: Overloaded functions make the code more readable by allowing us to use the same name for similar operations.
Flexibility: Overloaded functions provide flexibility by allowing us to perform the same operation on different types of data.
Reusability: Overloaded functions promote reusability by reducing the need to write multiple functions with different names for similar operations.
Polymorphism: Overloaded functions provide a form of polymorphism by allowing us to use the same name for similar operations on different types of data.

Limitations of overloaded functions:

Overloaded functions can be confusing if not used properly. Here are some limitations to consider when using overloaded functions:

Ambiguity: Overloaded functions can be ambiguous if the
parameter types are too similar. For example, having overloaded
functions with int and long types can cause confusion when
passing arguments.
Code complexity: Overloading functions can increase code
complexity, especially when multiple overloaded functions have
to be maintained.
Function signatures: Overloading functions can result in
function signatures that are difficult to read and understand,
especially if the functions have complex parameter lists.

Conclusion:

Overloaded functions are a powerful feature of C++ that allows developers to write more readable and maintainable code. Overloading functions can make code more flexible and reusable by allowing the same operation to be performed on different types of data. However, overloading

THANK YOU FOR READING

Streamlining Your Development Workflow with GitHub Actions: A Comprehensive Guide

R4V3N — Tue, 28 Feb 2023 15:10:55 +0000

GitHub Actions is a powerful tool for automating your software development workflows. It allows you to define custom workflows, known as actions, to be triggered by events in your repository such as a push to a branch or a pull request being opened. With GitHub Actions, you can automate tasks such as running tests, deploying your application, and more, all without leaving the GitHub platform. In this blog post, we will cover the basics of GitHub Actions and show you how to get started with creating your own workflows.

What are GitHub Actions?

GitHub Actions is a platform for automating your software development workflows. It allows you to define custom workflows that are triggered by events in your repository. These workflows are made up of one or more actions, which are individual units of code that perform a specific task. Actions can be written in any language and can be shared with the GitHub community through the GitHub Marketplace.

How to get started with GitHub Actions

Getting started with GitHub Actions is easy. The first thing you need to do is create a new repository or use an existing one. Once you have your repository set up, you can create a new workflow file by navigating to the Actions tab in your repository and clicking on the “New workflow” button. This will open a new file in your repository called main.yml.

The main.yml file is where you define your workflow. It is written in YAML, a human-readable data serialization language, and consists of one or more jobs. Each job is made up of one or more steps, which are individual actions that perform a specific task.

Here is an example of a simple workflow that runs tests every time a pull request is opened:

name: Run tests on pull request
on:
  pull_request:
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v2
      - name: Install dependencies
        run: npm install
      - name: Run tests
        run: npm test

In this example, we have defined a workflow called “Run tests on pull request” that is triggered by the pull_request event. The workflow consists of one job called “test” that runs on the latest version of Ubuntu. The job has three steps: checking out the code, installing dependencies, and running tests.

Understanding workflows, jobs, and steps

As mentioned earlier, workflows are made up of one or more jobs, and jobs are made up of one or more steps. Let’s take a closer look at each of these components.

Workflows

A workflow is a collection of jobs that are triggered by a specific event in your repository. Workflows are defined in YAML files and can contain one or more jobs. Workflows can be triggered by a variety of events, including push and pull request events, scheduled events, and more.

Jobs

A job is a set of steps that are executed on the same runner. Jobs can run in parallel or sequentially, depending on your needs. Jobs are defined in the jobs section of your workflow file.

Steps

A step is a single task that is executed by an action. Steps can be used to perform a wide range of tasks, such as checking out code, running tests, deploying code, and more. Steps are defined in the steps section of your job.

Using pre-built actions

One of the great things about GitHub Actions is that there are a lot of pre-built actions available in the GitHub Marketplace. These actions are reusable pieces of code that perform a specific task, such as deploying your code to AWS or sending a message to a Slack channel. Using

pre-built actions can save you a lot of time and effort, as you don’t need to write the code yourself.

To use a pre-built action, you simply need to reference it in your workflow file. Here’s an example of how you might use the actions/setup-node action to set up Node.js in your workflow:

name: Example workflow
on:
  push:
    branches:
      - main
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v2
      - name: Set up Node.js
        uses: actions/setup-node@v2
        with:
          node-version: '14.x'
      - name: Install dependencies
        run: npm install
      - name: Build and test
        run: |
          npm run build
          npm test

In this example, we are using the actions/setup-node action to set up Node.js version 14.x. We then use the npm command to install dependencies, build and test the application.

Creating custom actions

While there are many pre-built actions available in the GitHub Marketplace, there may be times when you need to create your own custom actions. Custom actions can be written in any language and can be used to perform a wide range of tasks.

To create a custom action, you need to create a new repository that contains your action code. Your action code can be any executable command or script that performs a specific task.

Here’s an example of how you might create a custom action that sends a message to a Slack channel:

1.Create a new repository on GitHub for your action code.

2.Create a new file called Dockerfile in the root of your repository. This file will contain the instructions for building your action as a Docker container.

3.Create a new file called entrypoint.sh in the root of your repository. This file will contain the code that your action will execute.

Build your action as a Docker container by running the following command:

docker build -t my-action .

1.This will create a new Docker image called my-action that contains your action code.
2.Push your Docker image to a container registry such as Docker Hub or GitHub Container Registry.
3.Create a new workflow file in your repository that uses your custom action. Here’s an example:

name: Example workflow
on:
  push:
    branches:
      - main
jobs:
  send-message:
    runs-on: ubuntu-latest
    steps:
      - name: Send message to Slack
        uses: docker://my-action
        with:
          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
          MESSAGE: "Hello, world!"

1.In this example, we are using our custom action to send a message to a Slack channel. We are passing in two inputs, SLACK_WEBHOOK_URL and MESSAGE, which are defined as secrets in our repository.

Conclusion

GitHub Actions is a powerful tool for automating your software development workflows. With GitHub Actions, you can define custom workflows that are triggered by events in your repository and automate tasks such as running tests, deploying your application, and more. By using pre-built actions and creating your own custom actions, you can save time and effort and streamline your development workflow. We hope that this blog post has given you a good introduction to GitHub Actions and shown you how to get started with creating your own workflows.

THANK YOU FOR READING

Why Linux is the Go-To Operating System for Developers and Servers?

R4V3N — Thu, 23 Feb 2023 18:58:58 +0000

Looking for a reliable, customizable, and cost-effective server operating systems ? Look no further than Linux ! This open-source platform has become the go-to choice for developers and businesses alike, thanks to its stability, security, flexibility, and low resource usage.
In my latest blog post, I explore the advantages of Linux for servers and developers, and why it continues to dominate the server market. From its availability of development tools to its compatibility with other open-source software, Linux offers a wide range of benefits that make it an ideal choice for a variety of use cases.
So, whether you're a developer looking for a reliable operating system for your projects or a business in need of a server solution that won't break the bank, be sure to check out my latest blog post on why Linux is the go-to operating system for developers and servers.

THANK YOU FOR READING

Git 101: A Beginner’s Guide to Understanding and Using Git

R4V3N — Wed, 22 Feb 2023 07:40:32 +0000

Introduction
Git is a distributed version control system that helps you track changes to your code over time. It’s used by software developers, web developers, and other professionals who work with code. Git makes it easy to collaborate with others on a project and keep track of changes to your codebase.

With Git, you can:

Keep track of changes to your code over time.
Create branches to work on different parts of your codebase independently.
Merge changes from different branches.
Collaborate with others on a project.
Installing Git
To use Git, you need to install it on your computer. Here are the steps to install Git on Windows, Mac, and Linux.

Windows

Go to the official Git website at https://git-scm.com/.
Click on the “Download” button to download the latest version of Git for Windows.
Run the installer and follow the prompts to complete the installation.

Mac

Using Homebrew
Open Terminal on your Mac.
Install Homebrew by running the following command: /bin/bash -c “$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)”
Install Git by running the following command: brew install git
Using MacPorts
Open Terminal on your Mac.
Install MacPorts by downloading the package installer from https://www.macports.org/install
Install Git by running the following command: sudo port install git
Linux
Ubuntu or Debian
Open Terminal on your Linux machine.
Run the following command to update your package list: sudo apt-get update
Install Git by running the following command: sudo apt-get install git
Fedora or CentOS
Open Terminal on your Linux machine.
Run the following command to update your package list: sudo dnf update
Install Git by running the following command: sudo dnf install git

Basic Git Concepts

Git uses repositories to store your codebase. A repository is a directory where you store your code, along with all the history of changes to that code. A commit is a snapshot of your code at a specific point in time. When you make changes to your code, you create a new commit.

You can create branches to work on different parts of your codebase independently. For example, you might create a branch to work on a new feature or fix a bug. When you’re ready to merge your changes back into the main branch, you can use the git merge command to combine the changes from different branches.

Git Commands

Git has many commands, but you only need to know a few to get started. Here are some common Git commands and their uses:

git add
Add changes to the staging area. The staging area is where you prepare changes to be committed. Use this command to tell Git which changes you want to commit.

git add <filename>

git commit
Create a new commit with the changes in the staging area. When you create a commit, you’re creating a snapshot of your code at a specific point in time. Use this command to save your changes to your local repository.

git commit -m "commit message"

git push
Upload your local commits to a remote repository. When you push your changes, you’re sharing them with others who have access to the remote repository.

git push origin <branch>

git pull
Download changes from a remote repository to your local repository. When you pull changes, you’re updating your local repository with changes made by others.

git pull origin <branch>

git branch
Create, list, or delete branches. Use this command to manage your branches.

git branch <branch_name>  # create a new branch
git branch  # list all branches
git branch -d <branch_name>  # delete a branch

git merge
Combine changes from different branches. Use this command to merge changes from one branch into another.

git merge <branch_name>

Working with Git

Now that you understand the basic concepts and commands of Git, here are some tips for working with Git:

1. Create a new branch for each feature or bug fix

Create a new branch for each feature or bug fix to keep your changes organized and to make it easier to merge changes later.

git branch <branch_name>
git checkout <branch_name>

2. Commit often

Committing often helps you track changes and roll back if something goes wrong.

git add <filename>
git commit -m "commit message"

3. Pull changes frequently

Pulling changes frequently helps you keep your local repository up-to-date with changes made by others.

git pull origin <branch_name>

4. Push changes regularly

Pushing changes regularly helps you share your changes with others and keep everyone on the same page.

git push origin <branch_name>

5. Use descriptive commit messages

Use descriptive commit messages to help others understand the changes you made.

git commit -m "Add login functionality"

Conclusion

Git is a powerful tool for managing your codebase and collaborating with others. With Git, you can keep track of changes to your code over time, create branches to work on different parts of your codebase independently, merge changes from different branches, and collaborate with others on a project. By following best practices and using descriptive commit messages, you can make working with Git even more productive and efficient.

THANK YOU FOR READING

Using Linux on Windows with WSL 2: Tips on Installation and Usage

R4V3N — Tue, 21 Feb 2023 18:40:19 +0000

Windows has long been the go-to operating system for most PC users, thanks to its ease of use and broad compatibility with hardware and software. However, for those who are interested in the power and flexibility of Linux, there has always been a trade-off: either switch to Linux completely or set up a dual-boot system, which can be time-consuming and cumbersome. Fortunately, with the advent of Windows Subsystem for Linux (WSL) 2, you can now run Linux on your Windows machine, without having to sacrifice your Windows environment.

What is WSL 2?
WSL 2 is a feature in Windows 10 and 11 that allows you to run a Linux distribution directly on your Windows machine. Unlike a virtual machine, which emulates a separate operating system on top of your existing operating system, WSL 2 integrates Linux into Windows at a system call level, allowing for faster and more seamless performance.

WSL 2 uses a lightweight virtual machine to run the Linux kernel, which means you can run a wide range of Linux applications and utilities, without having to install a full-blown Linux distribution. This makes it an ideal solution for developers, system administrators, and anyone who needs access to Linux tools and utilities on a Windows machine.

Installation
To get started with WSL 2, you need to enable it on your Windows machine. Here’s how:

Make sure you’re running Windows 10 version 2004 or later.
You can check this by going to Settings > System > About and looking under “Windows specifications”.
Enable virtualization in your BIOS settings. Most modern CPUs support virtualization, but it may be disabled by default. You’ll need to check your motherboard manual or manufacturer’s website to find out how to enable virtualization.
Enable WSL 2 in Windows.
To do this, follow these steps:

Open the Start menu and search for “Windows Features”.
Select “Turn Windows Features on or off”.
Scroll down to “Windows Subsystem for Linux” and check the box next to it.
Scroll further down to “Virtual Machine Platform” and check that box too.
Click “OK” and let Windows install the necessary components. Install a Linux distribution from the Microsoft Store. Some popular options include Ubuntu, Debian, and Kali Linux. Once you’ve installed a distribution, launch it from the Start menu or by typing “wsl” into the command prompt. Usage After you’ve installed a Linux distribution, you can launch it from the Start menu or by typing “wsl” into the command prompt. When you launch a Linux distribution for the first time, you’ll be asked to create a username and password.

Here are some tips to make the most of your Linux experience on Windows:

Use the Windows Terminal:
The Windows Terminal is a powerful tool that allows you to open multiple tabs and panes, and switch between them with ease.
You can also customize the appearance and behavior of the Terminal to suit your needs.
To install the Terminal, go to the Microsoft Store and search for “Windows Terminal”.
Share files between Windows and Linux: By default, your Linux file system is isolated from your Windows file system. However, you can access your Windows files from within Linux by navigating to /mnt/c (or /mnt/d, /mnt/e, etc. for other drives). You can also access your Linux files from within Windows by going to \wsl$.
Install your favorite Linux tools: One of the biggest advantages of using Linux on Windows is the ability to use Linux tools and utilities.
You can use the apt-get package manager to install your favorite Linux programs, such as Git, Vim, and Node.js.
To install a package, open the Terminal and type “sudo apt-get

Conclusion
WSL 2 is a powerful tool that allows Windows users to enjoy the benefits of Linux without having to give up their Windows environment. With the right setup and some basic Linux skills, you can use WSL 2 to run powerful Linux tools and utilities, share files between Windows and Linux, and even develop and deploy Linux-based applications on your Windows machine. Give it a try and see how much you can accomplish with this powerful combination of operating systems.

THANK YOU FOR READING

How to Create Your Own Commands in Linux

R4V3N — Sun, 19 Feb 2023 13:57:15 +0000

In this article, we will discuss the process of creating customized Linux commands. This is an essential skill for Linux users, as it can greatly enhance their productivity and efficiency when working in the command line interface. By following the steps outlined in this guide, you will learn how to create personalized commands that suit your specific needs and preferences. So if you’re ready to take your Linux skills to the next level, read on and discover the power of creating your own Linux commands.

What are Alias commands in Linux?

The alias command is a powerful tool in the Linux command line that can help you save time and effort. With it, you can create customized shortcuts for frequently used commands, making them much easier to remember and use. Essentially, the alias command provides a string value that replaces a command name when it is entered. The best part? These shortcuts have the same functionality as the full commands they represent, making your workflow more efficient and enjoyable.

So, if you’re tired of typing out long and complex commands every time you need to perform a task, why not give the alias command a try? You may just find that it adds a whole new level of convenience and fun to your Linux experience!

How to Create Your Own Linux Commands
By utilizing the alias command, you can create your own custom commands in a straightforward and efficient manner.

This is a valuable skill that can significantly streamline your Linux workflow and enhance your productivity. The syntax for the alias command is as follows:

alias [alias-name[=string]...]

To illustrate the process of creating your own custom command, consider the following example.

Suppose you wish to create a command named “cdv” that instantly takes you to the Videos directory when entered in the terminal.

Typically, navigating to a directory requires using the “cd” command followed by the directory name. However, in this case, we can simplify the process by creating an alias command that directly takes you to the desired directory. As demonstrated in the accompanying screenshot:

Terminal command to navigate to Videos directory
Let’s create our command called cdv to navigate to the Videos directory.

To achieve that, you have to enter the following command in your terminal:

alias cdv="cd Videos"

Terminal (alias) command to create our own command
We have created our command. From the above screenshot, you can see that it does not return anything.

But, how can we verify that the command is created and it is working?

There’s only one way to verify if the command is working: that’s by executing the created command.

Run the cdv command on your terminal to see what happens:

Run the created cdv command
And with that, you have successfully created your own custom command. Congratulations! This newfound skill can greatly improve your efficiency and productivity in the Linux command line interface. So take pride in your accomplishment and keep exploring the possibilities of customizing your commands.

How to Show your created Alias Commands
You may have the following question after creating a few commands:

Let’s assume I created multiple alias commands. How can I view all of them together? How can I view the equivalent command of my alias?

You can view all your alias commands by appending the -p flag to the alias command like this:

alias -p

Terminal command to view all the created alias commands
How to Remove an Alias Command in Linux

Pass your alias name to the unalias command as an argument to remove the alias command.

unalias alias_name

Terminal command (unalias) to remove an alias command

How to Remove All Alias Commands in Linux

Let’s assume you have added around 20 alias commands. After some time, you realized that using alias commands will make you forget other commands in the long term. Fearing that, you wish to remove all the alias commands.

We have a command to achieve that:

unalias -a

You may be curious to know more about one thing that I’ve written in the above passage.

“After some time, you realized that using alias commands will make you forget other commands in the long term”

Is this something you should worry about? Can this happen?

The answer to your first question is, yes. Definitely, you’ll get this feeling when you’re learning and trying out alias commands. Because I had the same feeling.

The answer to your second question is, absolutely no. This will result in increased productivity. There’s a high chance that you’ll forget the command you created but you’ll never forget the original command. So I always recommend revisiting your alias commands often and ensure you’re using all the alias commands you created.

I have a shocking surprise for you. Open a terminal window and create an alias command (we’ll use the cdv command we created above). Open another terminal window and type the cdv command there.

Terminal command showing the output of non-existing alias command
Surprised?

Yes. If you create an alias command, it’ll be active only for the particular instance of the terminal. It’ll not be created permanently, so you won’t be able to access it in two different terminal windows unless you run the alias command on both terminals.

How to Create a Permanent Alias Command

To create a permanent alias command, you have to add the alias command to the shell configuration file. There are many shell configurations available. A few of the well-known shells are:

Bash – ~/.bashrc
Zsh – ~/.zshrc
Fish – ~/.config/fish/config.fish
Most Linux distros work with bash, so let’s look at creating a permanent alias in the bash shell. Other shells work pretty much the same.

Let’s open the .bashrc file using nano.

sudo nano ~/.bashrc

Navigate to the bottom of the file. Add the alias command you want to add permanently.

alias cdv="cd Videos"

Save and exit nano by pressing the Ctrl and x key.

Every time you make a change to the shell configuration file, you have to reload the file again for your changes to take effect immediately.

All the terminal windows you open from now will contain your alias command by default.

You may open multiple windows and check by entering the alias -p command.

Some Helpful Alias Commands to Try

Here’s a bonus for you all.

You can either follow the instructions in the README file of this repo or follow the instructions below to set up the alias commands on your machine.

Navigate to the Home folder
Navigate to home directory

cd ~/
Clone the repo
Clone the alias commands repo from GitHub:

git clone https://github.com/gogosoon/x-commands.git

Add a reference to the alias command file
Open the ~/.bashrc file using nano:

sudo nano ~/.bashrc

Add the following line at the end of the file:

source ~/x-commands/aliasCommands.sh

Save and exit nano by pressing the Ctrl and x key.

Reload the terminal
Reload the terminal by running the following command:

source ~/.bashrc

That’s it. You’re all set. To verify that the setup is done and it’s up and running, run the following command in the terminal:

welcome

You’ll be asked to enter your name. Type your name and press Enter.

You’ve installed it the right way if you get the above message.

Let me explain the alias commands you’ll have access to using this repo.

Unfortunately i cant post a table here the explanation is postet on my site.

If you look at the aliasCommands.sh file carefully, you’ll see that I’ve added a few functions. You may wonder why I use functions. Read more to have a quick dive into this topic.

How to Run Multiple Commands in a Single Alias Command

You can achieve this in 2 ways. Let me explain both of them here.
Let’s learn this with an example.

Say you have to create an alias command called gohome. Running this command should take you to the home directory and display the “Navigated to home directory” message.

Method #1:

This way is the usual way of adding an alias command. You have to add the two commands separated by a semicolon (;).

alias gohome="cd ~/;echo Navigated to home directory"

Method #2

This is a bit of a different way. To achieve this you have to make a change in your .bashrc file. You have to define a function in the .bashrc file with all the commands nested within it.

Open the .bashrc file using nano.

sudo nano ~/.bashrc

Create a function named gohome with the above 2 commands.

function gohome() { cd ~/ echo Navigated to home directory }
Save and exit nano by pressing the Ctrl and x key.

Reload the terminal by running source ~/.bashrc and you’ll be able to verify the gohome command now.

Note: Creating a function will not list it as an alias command on running the alias -p command.

Conclusion
In this article, you learned how to create your own commands in Linux.

Using an alias command will definitely increase your productivity. I’ve witnessed exponential growth in many people after seeing them using alias commands. I would recommend that you all setup your own alias commands.

THANK YOU FOR READING

10 Essential Clean Coding Techniques

R4V3N — Mon, 06 Feb 2023 07:41:15 +0000

Here are 10 critical techniques for writing clean, organized, and understandable code in any programming language:

Keep it Simple
The first and most important rule of writing clean code is to keep it simple and readable. As the saying goes, “Keep It Simple, Stupid”. The simpler your code is, the fewer errors it will have and the easier it will be for others to understand. Writing clean code is an art, but it’s crucial to remember that code is not a canvas for your creativity. Rather, it’s a tool for solving problems. By keeping your code simple, you’ll reduce the risk of introducing bugs and make it easier for other developers to work with your code
Develop Processes and Follow Them
As your code gets more complex, you’ll face challenging problems. The best way to tackle these problems is to break them down into smaller, more manageable parts and develop a process for solving each part. Over time, you’ll develop a set of processes that work for you, and your code will become cleaner and more efficien
Comments Are For Winners
As you gain more experience as a programmer, it’s easy to forget one of the most fundamental tips: leave comments in your code. Comments are important in any programming language. They make updating, debugging, and analyzing your code much easier and more efficient. Comments are also critical when other developers need to work on your code. So, make it a habit to leave comments in your code, explaining what you’re doing and why.
Keep it Small
Writing a 10,000 line code doesn’t make you a great developer. Reducing a 10,000 line code to something smaller, without sacrificing functionality, does. To keep your code small, avoid repeating code and use programming tools such as functions, objects, and arrays effectively. Optimizing your code is what sets great developers apart from good ones.
Mind Your Indentation
Indentation is essential for organizing and structuring your code, especially when you’re working on a team. Think of your code as a grocery store. If all the dairy products aren’t in one section, it can be tough to find the milk. The same is true for your code. If you don’t indent your code properly, it can be difficult to understand and work with.
Use Proper Naming Conventions
This is one tip that keeps popping up in nearly every discussion about the correct way of working on any programming language, and still people tend to forget or neglect it. Using proper naming conventions is a critical part of writing clean code. It makes it easier for other developers to understand your code and reduces the risk of introducing bugs. Make sure to name elements based on what they are and maintain a consistent naming convention throughout your code.
Explore and Learn
Become your own teacher and explore as much as you can. There are
plenty of online courses and experienced developers who share
their insights. The more you code, the better you’ll get. So,
never stop learning. Always look for opportunities to explore new
techniques and improve your skills.
Use Your Brain
Instead of copying and pasting code from other sources, use your brain. Optimize the code you have and work through problems on your own. By using others’ code, you might get a quick fix, but you won’t learn how to write clean code until you use your brain.
Test, Test, Test
Running into bugs in your code is absolutely frustrating, but it obviously will happen. To reduce these situations, test your code often. It takes time to run tests which is why some coders don’t do it, but I guarantee it will save work in the long run.
Play with Code
Being a great developer is both an art and a science. You must practice writing code and learn new programming languages. Humans generally learn best by doing, and from what we can tell of the animal world at large, play is a huge part of learning. Play will result in failure, but play also allows us a fun opportunity to try again and again until we get it right. Play with code like it’s a toy, enjoy what you do, and it will translate into making you a better coder.

THANK YOU FOR READING

The Importance of Writing Clean Code

R4V3N — Mon, 06 Feb 2023 07:32:07 +0000

Writing clean code is a crucial aspect of software development that ensures the longevity and maintainability of a project. Clean code is characterized by clear, concise, and self-explanatory variable and function names, as well as well-organized and consistent indentation and spacing. The purpose of this blog post is to explore the importance of writing clean code and provide examples to illustrate the concepts.

The Benefits of Clean Code
One of the main benefits of clean code is its ability to improve the readability and understandability of the code. This is particularly important when working on a team, as it allows other developers to quickly understand the purpose and logic behind the code. In addition to improving readability, clean code also helps to prevent bugs and errors, as well as making it easier to test and debug. Clean code also ensures that the code is maintainable over time, making it easier to add new features and fix bugs, as well as to make performance improvements and update libraries and dependencies.

Examples of Clean Code
Let’s consider the following example in C:

#include <stdio.h>

int main()
{
    int x, y, z;
    scanf("%d%d", &x, &y);
    z = x + y;
    printf("%d", z);
    return 0;
}

While this code may work as expected, it is not considered clean code. The variable names, x, y, and z, do not provide any context for their purpose, making it difficult for others to understand the code. In addition, there is no proper indentation or whitespace, making the code appear cluttered and difficult to read.

Now, let’s consider a cleaned up version of the same code:

`#include <stdio.h>

int addNumbers(int firstNum, int secondNum) {
  return firstNum + secondNum;
}

int main() {
  int firstNumber, secondNumber, result;
  printf("Enter two numbers: ");
  scanf("%d%d", &firstNumber, &secondNumber);

  result = addNumbers(firstNumber, secondNumber);
  printf("The result of adding the two numbers is: %d", result);

  return 0;
}`

In this version, the variable names are descriptive and provide context for their purpose. The function addNumbers is also named in a descriptive manner, and its purpose is clear. In addition, proper indentation and whitespace make the code easier to read and understand.

The same principles of clean code apply to C++ code as well. By following best practices for writing clean code, C and C++ developers can ensure that their projects are readable, maintainable, and of high quality.

Conclusion
In conclusion, writing clean code is essential for ensuring the longevity and maintainability of software projects. Clean code improves readability, reduces bugs and errors, makes it easier to test and debug,