DEV Community: Abhimanyu Singh Shekhawat

Code Stories: Introduction

Abhimanyu Singh Shekhawat — Thu, 26 Nov 2020 16:37:55 +0000

If you can't explain it simply, you don't understand it well.

Computer Science is often seen as an esoteric discipline. Most of the learners approach it in a convoluted fashion. You hear complex mathematical jargon thrown around in corridors. On top of that Pop culture left no stone unturned to depict Programming as a niche skill possessed by socially anxious(awkward) individuals.

However, I can't blame them entirely. The complexity of a subject depends on a variety of things like:

Are you exposed to similar branches of knowledge?
What do you want to achieve by studying it?
How much time & interest do you have?
How do you plan to approach the subject?

Often learners skip the part where they honestly answer these questions. This leads to all kinds of problems.
It ultimately results in their dry outlook towards a rather succulent and creative branch of knowledge.

Being a Computer Science graduate, I can assure you, things are not as difficult as they look like. Sure, they require novel thinking and good problem-solving skills. But like I said, these are skills and can be developed.

Therefore today, I am starting a series of articles that will take a programming problem and deconstruct it into intuitive puzzles.

You will see, how typical problems can be solved without any complex mumbo-jumbo if we ask ourselves the right questions and approach them systematically.

In the coming series of essays, we will follow a consistent structure:

The Problem 🤔
The Strategy 💡
The Code 🎉

We will start with a detailed problem statement and gradually proceed towards the solution by building upon existing knowledge and intuition. Towards the end, we will code that solution away.

I am a big fan of community learning. When you learn together, it leads to an understanding that is beyond the realm of an isolated study session.
The best way to achieve this is to share your learnings with the community that helped you grow.

I strongly feel that these essays will rekindle your curiosity and soon you will see how fun problem solving is.

The journey of thousand commits begins with a single init 🎊

If you liked this post, you can find similar content by:

Connecting on Twitter: @abshekha 🐶

Connecting on LinkedIn: abhimanyubitsgoa 🐼

Visiting my website: https://abhimanyutimes.com 🐻

Thanks for reading!

The Hitchhiker's Guide to Raspberry Pi

Abhimanyu Singh Shekhawat — Sun, 22 Nov 2020 17:38:14 +0000

Ever felt a bit Starky?

You can deny all you want but seeing Tony Stark designing the sophisticated Iron Man suit had an oomph factor to it.

Now, I want you folks to pause for a moment and think, how unbelievably amazing it will be if you can also design something like this. Not an Iron Man suit ( maybe :P ) exactly but cool stuff like home automation suite or a simple portable gaming console?

The answer lies in exploring this small yet potent device called the Raspberry Pi.

What exactly is Raspberry Pi?

Raspberry Pi 4 Model B

According to the official website, Raspberry Pi can be simply seen as:

A small and affordable computer that you can use to learn programming.

But if we really dive deep into the potential of this device, the above statement will surely look like an oversimplification.

This is essentially a hardware device with computing ability quite similar to your usual desktops or laptops but what makes so useful is the presence of programmable I/O pins popularly known as GPIO pins ( General Purpose ).
It is due to these pins that we are able to interface a variety of sensors to the board to make awesome utilities.

But it can be a bit daunting for a beginner to start working with this marvelous piece of technology as unlike a normal computer the learning curve is a bit steeper here.

So let’s simplify this and bake our very own Raspberry Pi.

Ingredients:

There are several ways to set it up but mostly they require the use of a screen to follow installation instructions.
We are going to set up the Pi in a completely headless (without any output display screen) way.

Let’s look at the tools we need:

Raspberry Pi
Raspberry Pi 15.3W USB-C Power Supply
Raspberry Pi Imager
A Desktop/Laptop
Micro SD card (16 GB or above)

Flashing OS on the SD card:

Since the operating system for Raspberry Pi resides on a micro SD card, we need to flash the downloaded image to the card and boot the Pi from it.
Below are the detailed steps that will help you create a bootable SD Card.

Download the latest version of Raspberry Pi Imager based on the link above and select the OS of your choice to install.
For this tutorial, we are selecting Raspberry Pi OS (32 bit).
Connect your SD card to your computer (use card reader if required) and use the Pi Imager to burn a bootable version of the selected OS on the SD card.

Connecting the Pi to a computer:

Before we can start working on the Pi, we need to provide a way to connect it with our computer. Raspberry Pi can be independently used as a computer, just by attaching a keyboard and a monitor to it.

Since over here we are focusing on the headless setup, we will be using just our computer to work on the Pi remotely. We will be using SSH to connect over a wireless network, using the following steps:

Put an empty file and rename it to ssh in the boot directory of the SD Card.
This will enable the SSH daemon just after the first boot. Now you can directly connect your computer to the Pi over SSH once you are on the same network.
For allowing the Pi to securely connect to your WiFi network, then you can open wpa-supplicant configuration file in an editor (say nano) and add your entry.
- sudo nano /etc/wpa_supplicant/wpa_supplicant.conf and add the below code to the end of the file.
- ```
 network={
           ssid="testing"
           psk="testingPassword"
        }
```
- For other network configurations visit this detailed guide.

Make sure that the Pi and your computer are on the same network and do an SSH to it. Please note that depending upon the OS your computer is running you will have different methods for this.
You can find out the IP address of your Pi by simply looking at devices connected to your Router's dashboard.

There are other ways to access this information as well due to simplicity we won't go into those details.
For doing ssh, the default username is pi and password is **raspberry.

Use it to log in into the Pi with the shell with ssh pi@192.168.0.80 assuming *192.168.0.12 is Pi's IP.
Now when you are logged in, you need to enable SSH for the subsequent sessions. For doing this, write sudo raspi-config in the terminal and press enter.
Select Expand File System option from the list to so that we can use the entire card space.
Select Interfacing options -> SSH and enable it. Also, enable VNC while we are at this (We will see this next).
Reboot the Pi.

Setup Visuals for the Pi:

Now when we had successfully configured Raspberry Pi to work with the basic command line, we can think more ambitiously in terms of assigning visual access to it.

We will be using Virtual Network Computing (VNC) which is a graphical desktop sharing system. It will allow us to remotely control the desktop interface of the Pi with the help of our computer.

It transfers the keyboard and mouse events to the server running on the Pi and returns the respective updates on the screen. Since we have already allowed VNC above we can just install it by using sudo apt-get install tightvncserver.

Just type tightvncserver in the terminal to start the VNC server on the Raspberry Pi.
You will have to install a VNC client on your computer to connect to the Pi.
Once done, you will be able to communicate with Raspberry Pi, directly from your computer.

Congratulations you have just baked your Raspberry Pi 🎉

If you liked this post, you can find more by:

Following me on Twitter: @abshekha

Connecting on LinkedIn: abhimanyubitsgoa

Visiting my website: https://abhimanyutimes.com

Thanks for reading!

What is SGID in Linux?

Abhimanyu Singh Shekhawat — Thu, 12 Nov 2020 18:16:49 +0000

A few weeks ago, I stumbled upon an interesting problem.

In Linux, if you check the file permissions you will notice the name of the file owner along with the group which owns the file. Note that, It is not necessary for the owner to be a part of the group but usually that is the case.

Imagine this scenario:

There are 3 processes operating in a system:

P1: Runs as root

P2: Creates the directories during the install.

P3: It access files created by P1.

Further, P2 & P3 are the part of the same group, say user_grp and both run as owner user.

Now consider a directory docs which is created by our installer process P2 and its permission looks like this:

drwxr-x---  5 user user_grp  4096 Jul 31 19:56 docs

P1 gets into the directory and wants to create a file called readme.txt for process P3 to read.

Please note that there is an additional constraint here, the read, write & execute access for OTHERS is prohibited.

Nevertheless, P1 goes ahead and creates the file whose permission looks like this:

  -rwxr-----  1 root root  4096 Jul 31 19:56 readme.txt

Can you spot the problem here?

After carefully examining the situation, it is not difficult to judge that Process P3 will fail in reading the file readme.txt because it is neither the owner of file readme.txt nor part of the same group.

There are a lot of ways one can go about solving this access limitation. For example, you can just issue chgrp for the file to change its group to user_grp so that process P3 can access, as it will then belong to the same group. But if there are a lot of files like this in the docs directory and you want P3 to read all of them, rather than firing chgrp for each file, you can opt for a more elegant approach.

Let's issue this command on docs directory to set GID bit, we will come back to what it actually means in a moment.

$ chmod g+s docs

Look at the file permission of the docs directory:

drwxr-s---  5 user user_grp  4096 Jul 31 19:56 docs

Notice there is an 's' in place of 'x' in the directory permissions. Now let's allow process P1 to create a file readme2.txt in the docs directory.

-rwxr-----  1 root user_grp  4096 Jul 31 19:56 readme2.txt

This is the magic of SGID!

When you set the SGID on a directory, all the files and directories inside it will inherit the parent directory's group.

So even though root is creating the file readme2.txt inside docs, the process P3 can easily read it because the file now has the same group as process P3, i.e. user_grp instead of root. Hence, SGID bit can be very useful for dealing with situations like the one above.

Linux holds deeper truths, we just have to MAN ^[1] up to get there!

Notes

[1] I am not trying to label courage as a masculine trait. It is just that Linux manual is called MAN pages. So a puny pun 😛

If you liked this post, you can find more by:

Following me on Twitter: @abshekha

Connecting on LinkedIn: abhimanyubitsgoa

Visiting my website: https://abhimanyutimes.com

Thanks for reading!

Newton & Square Roots

Abhimanyu Singh Shekhawat — Sun, 08 Nov 2020 14:43:50 +0000

The web is an interesting place, it humbles you down and shows how little you actually know. While hitchhiking through the hyperlinks, I had one such realization recently.

What if I ask you to calculate the square root of a number? Depending upon your background you are likely to come up with a variety of solutions. Let me talk about that specific fraction of you who will be interested in churning out code for doing so. [No, sqrt()]

Binary Search seems to be a valid and intuitive approach, after all, we can easily discard half of the search space in each iteration. But I want you to hold that thought and glance over this small snippet below.

double sq(double num)
{
    double xn = num/2;
    while(abs((xn*xn)-num)>eps) //eps is precision
    {
        xn = (xn + num/xn)/2;
    }
    return xn;
}

Magical isn't it? When I first looked at this, I was really startled by the elegance of this solution. So what is it and why does it work?

Sweet Mathematics

You just witnessed the glamour of Newton Raphson method.

In simple terms, it is a way to quickly find a good approximation for the roots of a real-valued function f(x) = 0.

This is our cue, square root for a number can be minimally represented by solving for the roots of f(x) = x² - N, where N is the number we have to find the root of.

That is all cool! But how does it actually work? Let's look at the simple math behind this:-

Consider a general function: y = f(x)

We start by choosing an arbitrary value x1 as our starting point^[1]. For our specific case, we can choose N/2 as our starting point and can safely discard values greater than that from the candidature of √N.
Now let's draw a tangent (Differential) to the curve at that point and mark its intersection with the x-axis. Let's call this x2.
Repeat step 2 for point x2 to obtain x3. You must have noticed that with each iteration we are nearing the roots of the quadratic equation. Slow and steady!

Depending upon the precision, you can decide upon the number of iterations required.

Formal Expression

Let's try to workout an elegant formula for f(x) = x² - N which will get us the compact code we saw in the beginning. Please note that we are aiming to get a relation between N^th and (N+1)^th iteration.

For any point xN, by using the equation of line we can get:
f'(xN) = (f(xN+1) - f(xN))/(xN+1 - xN)
[f'(x) being the slope at point x]
Putting 0 for y coordinate at point xN+1 where tangent crosses x-axis we get:
f'(xN) = (- f(xN))/(xN+1- xN)
Rearranging the terms & putting f'(x) = 2xN we have our final expression:
xN+1 = (xN + N/xN)/2

Visualising Newton Raphson method for N = 10000

Notes

[1] For the sake of simplicity, I have omitted the details about choosing the initial value which plays a crucial role in more complex functions.

Special thanks to AMSI for facilitating illustrations

If you liked this post, you can find more by:

Following me on Twitter: @abshekha

Connecting on LinkedIn: abhimanyubitsgoa

Visiting my website: https://abhimanyutimes.com

Thanks for reading!