Forem: Insane Logs

Setup Hugo + Obsidian + Git pipeline in Arch Linux

Insane Logs — Sun, 27 Jul 2025 04:03:08 +0000

Insane Hugo Pipeline for Arch Linux

Inspired by NetworkChuck’s I started a blog…..in 2024 (why you should too) video.

The guide is here: https://hugo.insanelogs.xyz/posts/hugo-pipeline/

I made a test Hugo website myself using the same guide. So I decided to put the guide in the test Hugo website too.

🦖

The post Setup Hugo + Obsidian + Git pipeline in Arch Linux appeared first on Insane Logs.

Linux CLI : System information commands #1

Insane Logs — Sun, 20 Jul 2025 12:28:50 +0000

Inspired from hack the box academy linux tutorials

These are some commands which can help you get information about your system. Knowing them might come handy in times of troubleshooting.

I have broken down the commands into chunks of 5 at a time, so I can take time and provide you with proper examples.

1. hostname – Prints the name that you named your linux system while installing it.

The hostname (or simply name) of this system is ubuntuServer

2. whoami – Prints the name of the user currently using the terminal.

Note: You might login into the system via different user and then switch to a different user. It will show the most recent user you switched to.

Currently a user called insane is using the terminal.

3. id – This command simply commands expands on the whoami commands and provides more information like groups the user is into, their respective group ids and userid of the user.

User insane’s userid is 1000. His primary group is also called insane with group id being 1000 (same as userid). Apart from that he is in groups – user (group id: 100 ), developers (group id: 1001 ), docker (group id: 1002 ).

4. uname – Prints basic information about the system.

It simply returns name of the kernel which is linux.

Uname command combined with some flags becomes very powerful and handy, but its a topic for some other time.

5. who – Prints who is currently logged in (like whoami) with some little bit of extra information. It also shows from which virtual terminal user logged in, when did he logged in and ipv4 address of the system.

I logged into this system/ server via root user (later I changed to a user called insane to run all the commands including this one). I logged in via virtual terminal 0. It also shows date and time of login and ipv4 address of this system .

Virtual terminal can be thought of as independent sessions or workspaces for simplicity but it has some quirks. Its not your typical workspaces. In any linux system their are like 6-7 virtual terminals which can be switched via ctrl+alt+f2/f3/etc. I will explain this particular in detail in future probably using a video format in youtube.

That’s it for this post.

Hope you like it :] .

🦖

Source (my blog): https://insanelogs.xyz/posts/linux-cli-system-information-commands-1/

Border vs Outline in CSS – A Simple Explanation

Insane Logs — Thu, 17 Jul 2025 18:04:30 +0000

Border and outline are two ways to add borders around an element in HTML/CSS.

But they don’t behave the same.

Border respects margins between two elements and never spills out.

On the other hand, an outline doesn’t care about margins — it can overflow and bleed into other elements.

Let us understand this with a simple example:

Here I have created two <div>s box1 and box2 having a space (margin) of 10px between them.

<!doctype html>
<html lang="en">
    <head>
        <title>Document</title>
        <style>
            * {
                margin: 0;
                padding: 0;
                margin: 10px;
            }

            .box1 {
                outline: 1px solid black;
            }

            .box2 {
                border: 1px solid black;
            }
        </style>
    </head>
    <body>
        <div class="box1">Box 1 uses outline</div>

        <div class="box2">Box 2 uses margin</div>
    </body>
</html>

Now, no matter how much I increase the border size in box2, the spacing between the two elements is still maintained.

Here I increased the border size to 50px and space between the two boxes is still maintained.

<style>
    * {
          margin: 0;
          padding: 0;
          margin: 10px;
      }

      .box1 {
          outline: 1px solid black;
      }

      .box2 {
          border: 50px solid black; /* Border size increased to 50px */
      }
</style>

But when I increase the outline size in box1 to 15px, it simply ignores that 10px space and overflows into box2. (Extra: Yes, 5px bleeds into box2 from box2's upper border)

<style>
    * {
          margin: 0;
          padding: 0;
          margin: 10px;
      }

      .box1 {
          outline: 15px solid black; /* Outline size increased to 15px */
      }

      .box2 {
          border: 1px solid black;
      }
</style>

Same thing happens when outline-offset property of box1 is increased.

Note: Outline offset simply controls how far the outline is pushed outward or inward from its default position.

<style>
    * {
          margin: 0;
          padding: 0;
          margin: 10px;
      }

      .box1 {
          outline: 15px solid black;
          outline-offset: 15px; 
          /* Outline-offset property set to 15px. Default value is 0px. */
      }

      .box2 {
          border: 1px solid black;
      }
</style>

That’s all. Hope it clears the basic difference border and outline in CSS. I have tried to kept the example as simple and possible.

Thank you :] .

Source (my blog): https://insanelogs.xyz/posts/border-vs-outline-in-css-a-simple-explanation/

Process synchronization – An easy explanation

Insane Logs — Thu, 10 Jul 2025 01:04:02 +0000

Process Synchronization is simply about running multiple processes that are accessing the same common resource (or resources) in a specific, controlled order so that everything goes smoothly and there’s no conflict.

Here, multiple processes (or even threads) could be sharing resources like a file, a database, or some part of the memory — and synchronization ensures that they don’t mess things up for each other.

A simple example:

Imagine we have a database and two programs – Program A and Program B.

Program A is responsible for adding/ updating (writing) a record to the database.
Program B is responsible for reading a record from the database.

Now, there are 5 records in the database. Program B wants to read record 5, while Program A wants to edit and update record 5. If both programs attempt to access the record simultaneously, it could lead to problems, such as Program B reading a half-updated record.

To avoid this, synchronization is essential. The solution here is to lock the resource while either program is using it. If Program B decides to read record 5, the database should be locked from Program A’s access. This ensures that Program B reads the complete, unaltered data. (However program B here would be reading old data which is later updated)

Similarly, when Program A is updating the record, the database should be locked for Program B’s access. Once Program A has finished updating this lock is released.

Note: Multiple programs that only want to read from the same database can do so simultaneously without locking each other out. This is because reading data doesn’t change anything, so one program’s reading doesn’t affect another’s.

Well that was all 🙂 .

Source (my blog): https://insanelogs.xyz/posts/process-synchronization-an-easy-explanation/

Memory effect in batteries

Insane Logs — Sun, 06 Jul 2025 12:45:46 +0000

Memory effect is also known as battery effect , lazy battery effect , or battery memory. It an issue observed mostly in nickel-cadmium batteries (Ni-Cd) and to some extent Nickel-Metal Hydride (NiMH) batteries.

It is situation where a battery forgets its maximum capacity and instead remembers a smaller one. Thus it shows full even though its not.

Why it happens?

This usually happens if we charge the batteries very frequently , like plugging it every time it drops to 50 or 40 percent. This is also called partial charging.

In reality it is not so simple to understand as to what really happens, but we can get an idea of what it is with a simple analogy. You can deep diver on your own if you got the curiosity 😉 !

Simple analogy

Let us understand it with a liters analogy.

Suppose a battery has a capacity of 1 lite r. When you fill all 1 liter it gets fully charged and shows 100%. But over time due to partial charging the battery forgets this capacity and thinks 500ml is its full capacity. So next time when you fill it up to 500ml only, the battery will think it has reached its full capacity and won’t accept any more water (charge). It will thus show 100% even though it actually isn’t.

Memory effect illustration

Please note this is a very simplified analogy just to get the gist of the concept. You are free to comment and point out any mistakes I made 🙂 .

The most common fix

It is often fixable by completely draining the battery to 0% and recharging it back to 100%. It is known as re calibrating the battery.

What about modern batteries?

Today, most devices use Lithium-ion (Li-Ion) or Lithium Polymer (Li-Po) batteries. These don’t suffer from memory effect , and partial charging is fine for them.

However, since they’re still made of chemical compounds, they will naturally wear down over time , and their maximum capacity will reduce. This isn’t the memory effect — it’s just normal aging.

Source (my blog): https://insanelogs.xyz/posts/memory-effect-in-batteries/

Micro logs #1: Dry run with pacman package manager

Insane Logs — Wed, 25 Jun 2025 13:50:59 +0000

Dry run with pacman package manager

Source : https://wiki.archlinux.org/title/Pacman

pacman : Package manager for Arch Linux

-p flag can be used with pacman to dry run commands — that is, see what your command is going to do before it actually does anything.

Might not work with certain flag combinations like -n, and it will simply throw an error.

Optional explanation with simple examples.

pacman -Rs : To remove a package and its dependencies which are not required by any other installed package.

Normal Behavior
-p works and shows in a list format the final packages which will be removed
-p doesn’t work when used with -n flag

Source (my blog): https://insanelogs.xyz/posts/micro-logs-1-dry-run-with-pacman-package-manager/

Detect datatype of variables in C

Insane Logs — Sun, 22 Jun 2025 17:57:16 +0000

A simple Marco which uses generics in C to help you detect data type of any variable like you do with type() function in python 🙂.

The code snippet contains examples on how to use it.

Extend it as much as you like 🙂.


#include <stdio.h>
#include <stdlib.h>

#define TYPE_CHECK(var) _Generic((var),     \
    int             : "int",                \
    float           : "float",              \
    double          : "double",             \
    char            : "char",               \
    char*           : "string",             \
    int*            : "int pointer",        \
    float*          : "float pointer",      \
    double*         : "double pointer",     \
    char**          : "string pointer",     \
    void*           : "void pointer",       \
    short           : "short",              \
    long            : "long",               \
    unsigned int    : "unsigned int",       \
    unsigned long   : "unsigned long",      \
    unsigned short  : "unsigned short",     \
    default         : "unknown type"        \
)

int main(void) {
    // Basic types
    int a = 10;
    float b = 5.5f;
    double c = 3.14159;
    char d = 'A';
    char* str = "Hello, World!";

    // Pointer types
    int* p_a = &a;
    float* p_b = &b;
    double* p_c = &c;
    char** p_str = &str;
    void* p_void;

    // Print types using TYPE_CHECK
    printf("Type of a: %s\n",       TYPE_CHECK(a));         // Outputs "int"
    printf("Type of b: %s\n",       TYPE_CHECK(b));         // Outputs "float"
    printf("Type of c: %s\n",       TYPE_CHECK(c));         // Outputs "double"
    printf("Type of d: %s\n",       TYPE_CHECK(d));         // Outputs "char"
    printf("Type of str: %s\n",     TYPE_CHECK(str));       // Outputs "string"
    printf("Type of p_a: %s\n",     TYPE_CHECK(p_a));       // Outputs "int pointer"
    printf("Type of p_b: %s\n",     TYPE_CHECK(p_b));       // Outputs "float pointer"
    printf("Type of p_c: %s\n",     TYPE_CHECK(p_c));       // Outputs "double pointer"
    printf("Type of p_str: %s\n",   TYPE_CHECK(p_str));     // Outputs "string pointer"
    printf("Type of p_void: %s\n",  TYPE_CHECK(p_void));    // Outputs "void pointer"

    // Example of using malloc
    void* ptr = malloc(sizeof(int));
    printf("Type of ptr: %s\n",     TYPE_CHECK(ptr));       // Outputs "void pointer"

    // Good practice :)
    free(ptr);

    return 0;
}

Source (my blog): https://insanelogs.xyz/posts/detect-datatype-of-variables-using-generics/

Learn C Programming: A Beginner’s Guide

Insane Logs — Fri, 13 Jun 2025 16:33:39 +0000

A simple guide to learn C programming.

It's better to be able to write programs you would like to, instead of mastering every small details of the language on your first day.

1. Watch a C Tutorial Playlist on YouTube

Pick up any beginner-friendly C tutorial playlist - ideally which is short and simple. Don’t stress too much over finding the “perfect” channel. At this stage, your goal isn't to master every detail but to simply start writing and running C programs.

Focus on practical understanding.
Don’t worry about:
- Depth of concepts
- Minor mistakes or bad practices in the videos
- etc

Most YouTube tutorials are surface-level and may even have some flaws — but they’re visual and fast, which helps you quickly gain the ability to write code and see results. That early momentum is valuable.

Note: Don't go for extremely long courses thinking they will give you more knowledge. You will end up being overwhelmed and its much better to spend that much time on a quality book rather than a course/ playlist.

2. As you go through the playlist:

Try out the examples shown, change certain things and try to figure out the reasons for the output you get.
Ask google or Chatgpt for things you don't understand.

Focus on: To get this type of behavior I must do this or tweak this. Then try to figure out the reasons yourself. You’ll be surprised how much you learn just by debugging and tweaking code.

By the end of the playlist, you’ll likely be able to code simple things in C and have much more confidence.

You now have the ability to build and understand simple to intermediate programs even without understanding the why of everything. This is a valuable skill in programming :)

3. Build Small Projects

Have fun! Google simple projects and try to implement them. This helps reinforce what you’ve learned and shows you how to put things together.

Probably you can even build and understand more complex projects. However their is much more you can learn to get ahead of the crowd.

4.: Level Up with Books

You now have a good practical knowledge of the language. You may now focus more on the theory side of the language which is basically under the hood details, answers to why certain things behave the way they behave, etc. Books are great for this.

This stackoverflow post contains a good list of C books: The Definitive C Book Guide and List.

As you read more and more you will be able to take better and complex projects that you may have wished to develop.

5. Keep practicing and exploring

As you continue building projects or reading more advanced material, you'll naturally begin to understand what else you need to learn, where to find it, and which areas of computer science would help you. Your journey from here will vary based on what you want to build. Just learning C programming isn’t enough — for example, graphics programming may require knowledge of rendering techniques and math, while network programming will involve understanding computer networking. These are areas beyond just the C language, and exploring them will broaden your skills.

Why Not Start With a Book?

Good books are very lengthy! You would have to read lots and lots of pages and theories before you can actually start writing something useful beyond "Hello World". Also things can get overwhelming very fast due to the amount of information books have. This is often demotivating, exhaustive and you get a feeling of reaching nowhere. Also not fun at all.

The steps I told is basically a breath first approach of learning which I personally follow. You cover the breath first then dive deeper.

Note: To absolutely know the nuts and bolts of C or any programming language down to the machine level, you would require knowledge of other computer science topics such as compiler design, assembly languages, etc. Which is why I don't recommend depth first approach as you would get stuck in a rabbit hole and end up getting overwhelmed.

Source (my blog website): https://insanelogs.xyz/posts/learn-c-programming-a-beginners-guide/

Blender hard light vs soft light in 2min

Insane Logs — Fri, 13 Jun 2025 09:04:30 +0000

When we render a model in blender we can have at the most basic two types of lighting – Hard lighting and soft lighting which determines how harsh or soft the shadows are.

In hard lighting the bright areas appear very bright and dark areas (shadows appear harsher) appear very dark compared to soft lighting (shadows appear softer). Lets use point light source for example. If we use increase the radius of the light then it would be soft lighting and if we would decrease the radius of the light source it would be hard lighting.

In hard lighting – shadows are harsh
In soft lighting – shadows are soft

Here we can see when the radius of the light source is 0 the shadow seems to be very harsh on the object.

However when the radius is increased to 0.39 we can see the shadows become much softer.

Source (my blog website): https://insanelogs.xyz/posts/blender-hard-light-vs-soft-light-in-2min/