Forem: PARTHIB KUMAR DEB

Linus revolutionizes ☀️

PARTHIB KUMAR DEB — Sun, 03 Aug 2025 18:03:51 +0000

Introduction ✈️

Hello again, curious brains 🧠. In this second chapter of our series, we trace the origins of one of the most influential software developments in history: Linux. While many people recognize the name, few understand the amazing path that began with a single line of code by Linus Torvalds and continued through a critical alliance to the large ecosystem of operating systems we see today. Prepare to discover the critical milestones that developed Linux into the global power it is today.

The Public Post 📷

Personal computers were growing more popular in 1991, but accessible and fully open operating systems remained uncommon. Linus Torvalds, a computer science student at the University of Helsinki, found himself in the exact same scenario. He was working with Minix, an educational Unix-like operating system, but he believed its license was too limited for his needs, and its architecture didn't fully exploit the capabilities of his new Intel 386 CPU. Linus began writing a new operating system kernel from scratch up, motivated by a thorough understanding of Minix and a defined goal. His goal was to construct a UNIX clone, which would match the key features and behavior of existing UNIX systems, including critical elements such as the organized file system layout, process management, and inter-process communication methods. But, unlike the typically proprietary and expensive UNIX versions, his would include a vital change: complete openness and accessible for everybody. This is that auspicious post he made in the comp.os.minix group when we has working on the linux 0.01 - http://groups.google.com/group/comp.os.minix/msg/b813d52cbc5a044b?pli=1):

Hobby Project ⚡

What began as a personal endeavor quickly grew into something far larger. Linus initially created Linux for the Intel 386 processor, and he doubted its portability. However, the emerging community surrounding his work had different perspectives, consistently supporting (and contributing to) a more universal approach. This collaborative atmosphere resulted in a significant breakthrough: on October 5, 1991, the release of Linux 0.02 saw much of the original, platform-specific assembly code recast in the extremely portable C programming language. This significant shift paved the path for Linux to be ported to a wide range of other devices. Interestingly, "Linux" was not even the name he chose for this budding operating system. Linus had lovingly dubbed his brainchild Freax - a creative combination of "free," "freak" (a tribute to the dominant hacker culture), and "X" (indicating its Unix-like characteristics, similar to Minix or Xenix). He even put his project files in a pub/os/freax directory on his local machine.

GNU Approaches 💨

While Linus had successfully created the Linux kernel—the critical core that governs a computer's hardware and software resources—it remained just that: a kernel. To become a usable, complete operating system, it required a wide range of supporting software, including compilers for program writing, shell tools for user interaction, libraries for common functions, and much more.

On the other side of the open-source world, the GNU Project had meticulously developed almost every single one of these necessary utilities and components — from crucial libraries and file system tools to device drivers and powerful command-line shells. What GNU lacked, however, was its own stable, full-fledged kernel.

This is where the magic happened. The Linux kernel became the final—and perhaps most important—piece of the puzzle required to put together a comprehensive, UNIX-like operating system wholly under the free GNU General Public License (GPL). This formidable combination is widely known as GNU/Linux. Today, Linux is a prime example of an open-source, UNIX-like operating system that seamlessly integrates compliance with numerous industry standards, such as SVID, POSIX, and BSD. Its ongoing development still aggressively seeks strict conformity to POSIX as well as the growing standards established by the stewards of the UNIX brand.

The Community ✋

Today Linux development is professionally controlled and safeguarded by the Linux Foundation. This significant non-profit organization, previously known as the Open Source Development Labs (OSDL), changed its name following a strategic merger with the Free Standards Group. Explore their work at https://www.linuxfoundation.org/. Crucially, the Linux Foundation directly employs Linus Torvalds, recognizing his unparalleled role as the creator and lead developer of the Linux kernel. This ensures his continued dedication to guiding the kernel's overarching direction.

The Foundation's impressive list of sponsors reads like a stalwarts of the tech industry, underscoring Linux's massive commercial impact. Major players such as IBM, Red Hat, SUSE, Oracle, HP, Dell, Computer Associates, Intel, and Cisco Systems (among many others) financially back the organization. These companies, despite being competitors in the marketplace, understand that a healthy, evolving Linux ecosystem benefits them all.

The Linux Foundation's core mission is twofold: it aims to protect and accelerate the growth of Linux. It achieves this by providing vital legal protection for Linux developers (shielding them from potential patent disputes or intellectual property challenges) and by establishing and promoting software development standards. This ensures consistency, compatibility, and high quality across the vast Linux landscape, fostering its continued innovation and widespread adoption across servers, embedded systems, cloud computing, and beyond.

Features 📋

So, what makes Linux, born as a hobby and powered by community, such an appealing option for everyday users? Aside from its sophisticated backend, several major elements define your interaction and experience with the operating system:

Diverse & Customizable Desktop Environments

Unlike Windows or macOS, where the desktop experience is generally fixed, Linux provides a wide range of Desktop Environments. You can select between polished, modern interfaces like GNOME and KDE Plasma, lightweight solutions like Xfce and LXQt, and even minimalist window managers. Each DE has a distinctive style, feel, and workflow. With this unequaled freedom, you're not limited to a single design. You may create an environment that is exactly suited to your aesthetic preferences, system resources, and work style, changing everything from themes and icons to keyboard shortcuts and panel layouts. You truly make the OS your own.

Robust Package Management

Linux distributions have very efficient and centralized package managers (such as APT for Debian/Ubuntu, DNF/RPM for Fedora/Red Hat, and Pacman for Arch Linux). These solutions manage the complete software lifecycle, including searching, installing, updating, and deleting applications and their dependencies using simple commands or graphical interfaces. Say goodbye to manually downloading installers from websites. Package managers ease software management, keep all of your programs up to date and secure, and automatically resolve complex dependencies, making software installation a joy.

Powerful Command-Line Interface (CLI)

At its core, Linux has an extremely strong and efficient Command-Line Interface (CLI). For those who desire it, scripts can be used to automate activities, conduct complex procedures rapidly, and administer distant servers efficiently. While the CLI provides unrivaled control and efficiency for power users and developers, it is critical to emphasize its versatility for everyday use. Modern Linux distributions provide user-friendly graphical interfaces, so you're never compelled to use the command line if you don't want to. It is a powerful weapon at your disposal, not a necessary obstacle.

Security by Design

From a user standpoint, Linux's security paradigm requires you to function as a normal user without administrative capabilities by default. This drastically reduces malware's ability to gain system-wide control. When combined with a rapid, community-driven update cycle, security patches for newly found vulnerabilities are frequently produced and deployed quickly. This powerful security architecture results in fewer viruses and malware issues in your daily computing. You may surf, email, and work with far greater confidence, often without the use of third-party antivirus software.

Open Source Ecosystem

Beyond system utilities, Linux has a large and expanding ecosystem of high-quality, frequently free and open-source software. Most popular tasks have great open-source equivalents, including office suites like LibreOffice, image editors like GIMP, and video editors like Kdenlive, as well as web browsers like Firefox and Chrome. Additionally, many proprietary software (such as Steam, Spotify, and VS Code) have native Linux equivalents. You receive powerful, full-featured applications with no licensing fees. This access to a large software library enables a wide range of activities, from productivity and creativity to gaming and development, with greater transparency and community support than proprietary alternatives.

Performance on Diverse Hardware

Linux is extremely efficient and can run smoothly on a wide range of hardware, from cutting-edge workstations to older, resource-constrained devices. Its versatility enables you to remove unneeded components while improving it for unique systems. This implies you can revitalize aging laptops or PCs that struggle with resource-intensive operating systems. It provides a practical, high-performance alternative that extends hardware lifespan and reduces e-waste.

The Bigbang 💥

PARTHIB KUMAR DEB — Mon, 28 Jul 2025 11:17:20 +0000

Introduction 🏁

Welcome, fellow explorers 👋, to the inaugural post of Linux Empire. This isn't just a series of articles; think of it as a fascinating web-series where each blog post is an episode, gradually unveiling the remarkable story that shaped the open-source operating system we rely on today. In this first episode, The Big Bang, we're heading back to the 20th century 🕰️. We'll explore the early rivalries among tech giants — a significant period that laid the groundwork for modern computing.

I encourage you to accompany me on this voyage ⛵ to truly understand Linux's motive and its profound impact on computing, from past centuries to future inventions.

Mainframes and Multics 🏬

In the mid-20th century, computing was dominated by massive mainframes and time-consuming punch card batch processing, with programmers waiting hours for results. This inefficient, solitary technique inspired the concept of interactive time-sharing. The enormous Multics (MULTiplexed Information and Computer System) project was born, a large "computer utility" proposed by MIT, Bell Labs, and General Electric.

Multics was designed to store and retrieve large data sets, to be used by many different people at once, and to help them communicate. However, Multics' overwhelming complexity was destined for failure. It suffered from the second-system effect , which occurred when too many revolutionary innovations were included at the same time, resulting in a bloated and constantly delayed system. Development was extremely slow, and the ongoing need for more powerful, costlier hardware rendered it financially unsustainable for Bell Labs. The frustration of working with a system that was constantly behind schedule and difficult to manage eventually drove Bell Labs to withdraw in 1969, leaving a critical void and a clear lesson in over-engineering.

The Bell Minds 💡

During that era, the extensive telecommunications giant AT&T, often called Ma Bell, held a virtual monopoly over telephone services in the USA. Its extensive research arm, Bell Labs, had been part of the ambitious Multics project and it was located in Murray Hill, New Jersey. However, after its failure , Bell Labs employees Ken Thompson and Dennis Ritchie embarked on their own, setting out to create an operating system that would offer a simpler, more efficient environment for developing software - The UNIX.

The UNIX Era 🌐

The UNIX (or UNICS - UNiplexed Information and Computing System) operating system was born out of a collaborative, developer-driven environment. This project was Heavily funded by the Department of Defense’s Advanced Research Projects Agency (then known as ARPA). Its inception was not motivated by commercial needs or corporate requirements, but by a sheer desire to remove the actual constraints experienced by programmers while building software. AT&T provided free Unix samples to university students in the 1970s. Unix outperformed all other operating systems in terms of satisfaction among researchers and students. The system was cost-effective, adaptable, and used low-cost hardware. It met their needs better than any other available option. Universities lacked the necessary hardware to compete with Unix operating systems, which were either not "free," or were still being developed in labs.

In his seminar 1980 lecture, "The Evolution of the UNIX Time-sharing System," Dennis Ritchie eloquently summed up the spirit that ignited UNIX. He stated:

"What we wanted to preserve was not just a good environment in which to do programming, but a system around which a fellowship could form. We knew from experience that the essence of communal computing as supplied by remote-access, time-shared machines is not just to type programs into a terminal instead of a keypunch, but to encourage close communication."

UNIX's foundation included many crucial elements:

The Shell 🔥

From its inception, UNIX created a rudimentary command-line interpreter known as the shell, which served as the primary interface for user interaction. Rather than a modern graphical user interface, users typed commands directly into the shell, which translated them into actions that the kernel could perform. It was The Thompson shell (sh), which was included in the first UNIX systems. It appeared in 1971 with Version 1 and It was written by Ken Thompson. However, when most people emphasize the Shell's potential for automation and complex scripting, they are typically referring to the Bourne Shell (sh). It was Created by Stephen Bourne and introduced with UNIX Version 7 in 1979. The Bourne Shell brought a revolution in UNIX, transforming the shell into a full-fledged programming language with numerous advanced capabilities.
The Unix filesystem 📂

The innovative filesystem was a key feature of UNIX's architecture. It provided a remarkably easy approach to organize files and folders thanks to its hierarchical structure, which allowed several layers of subdirectories. Furthermore, UNIX made external administration significantly easier by representing devices like disks and tapes as distinct device files that could be read and changed like any other file in the directory tree.
Redirection ⤴️

Early UNIX was known for its beautiful command-line interface, which included input redirection and pipes. The > sign allows users to redirect command output to a file. Subsequently, the pipe (|) operator was developed, allowing the output of one command to be fed directly into another, resulting in strong data flows.
Portability 🔦

UNIX's outstanding portability came from its elegant design. UNIX abstracted hardware details by treating device drivers as files within the filesystem tree , providing applications with a uniform interface. This meant that only the drivers needed to be modified to migrate UNIX to new platforms, while the application programs stayed untouched - a big step forward in cross-platform compatibility. Realizing this potential required a high-level programming language, thus Dennis Ritchie created the C programming language. In a watershed event in 1973, UNIX was rebuilt in C.

USA vs AT&T ⚡

For most of the 20th century, AT&T had a near-absolute, government-sanctioned monopoly on the United States telephone system. This extensive control included local and long-distance services, as well as the manufacture of most telephone equipment through its subsidiary, Western Electric. Indeed, companies that would later become giants, such as Verizon and Qwest, were once integral parts of this unified system. Given AT&T's enormous telecommunications market strength, the US government became increasingly concerned that an unconstrained "Ma Bell" would dominate the massive computer sector. As a result, the US Department of Justice filed a broad antitrust lawsuit against AT&T in 1974. Before the divestiture of AT&T, it was restricted to sell computer systems in US. For this reason, the UNIX source code found its way into universities, licensed for only a nominal fee. AT&T only distributed UNIX as source code, so users had to compile it themselves. But after 1984, divestiture was behind AT&T and it was ready to really start selling UNIX. This caused the formation of a separate UNIX Laboratory between AT&T and a part of it which were invested in the making of UNIX from beginning, which moved out of Murray Hill and down the road to Summit, New Jersey.

Berkeley Software Distribution 😄

UNIX Version 6 was the first version made generally accessible outside of Bell Laboratories in 1975. The University of California at Berkeley developed the first significant UNIX variation using this early UNIX source code. They referred to it as the Berkeley Software Distribution (BSD). Over the next decade, the BSD and Bell Labs versions of UNIX diverged. BSD maintained the free-flowing, share-the-code approach of the early Bell Labs UNIX, while AT&T focused on commercializing UNIX.

Commercializing UNIX 💰

Initially, Unix spread widely because AT&T licensed its source code cheaply to universities. This freedom, however, led to many different versions of Unix being created, sparking the UNIX Wars as these versions often didn't work well together.

Following the significant legal developments of 1974, including AT&T's separation (which removed constraints), AT&T felt it was time to profit from Unix and reclaim control. Their plan was sound: they attempted to persuade major computer manufacturers such as HP, Sun Microsystems, and IBM to use AT&T's version of Unix (System V) as their primary operating system. To make this happen and bring order to the chaos, AT&T began defining clear rules for what a system had to do to still be called "UNIX." This effort led to key standards like the Portable Operating System Interface (POSIX) and AT&T's own UNIX System V Interface Definition (SVID). These specifications allowed different vendors to create compatible Unix systems.

Interestingly, despite all this, AT&T continued to distribute Unix source code. It wasn't until 1992, when AT&T formed a joint company with Novell or Univel (later fully sold to Novell), that a ready-to-use, commercial version of UNIX called UnixWare was finally sold directly from the source code. Ultimately, these very same standardization documents (POSIX and SVID) also served as crucial guides for the creation of Linux.

AT&T vs BSD 😞

For a time, the legendary BSD project was the strongest contender to become the most popular open-source kernel, possibly even before Linux. By the late 1980s, developers at the University of California, Berkeley (UC Berkeley) had precisely recreated the majority of the UNIX source code they had acquired a decade prior. UC Berkeley's independently built UNIX-like code, Net/1, was released in 1989, followed by Net/2 in 1991. In 1992, just as they were about to distribute a complete, UNIX-like operating system free of all AT&T code, AT&T filed a big lawsuit against them.

The suit aggressively claimed that BSD's software was developed using trade secrets stolen from AT&T's proprietary UNIX system. It's crucial to understand that BSD developers had meticulously rewritten the code to avoid direct copying, primarily focusing on circumventing AT&T's copyrights, which were then the main legal protection for the UNIX code. Some legal and historical observers even suggest that if AT&T had instead protected its core UNIX concepts with patents, the landscape might be entirely different today — perhaps there would be no Linux or any other UNIX clone.

While the lawsuit was eventually dropped when Novell acquired UNIX System Laboratories from AT&T in 1994, the damage was done. During that critical two-year period, the pervasive fear and doubt surrounding the legality of the BSD code caused it to lose significant momentum within the burgeoning open-source community. This unfortunate legal battle ultimately created the vacuum that Linux would soon fill.

GNU Appears 😇

Long before the pivotal lawsuit against BSD, another crucial player entered the market: The GNU Project, launched in 1984. This ambitious undertaking was started by Richard M. Stallman, and its name itself is a recursive acronym: "GNU is Not UNIX."

GNU's key objective was to embark on a comprehensive re-coding of the entire UNIX operating system, with the basic idea that it may be freely supplied to anyone. Developers immediately discovered that they could achieve the same outcomes with wholly new code, and in many cases, their freshly developed components even outperformed the original UNIX versions. This open development strategy was groundbreaking: because everyone could openly inspect the code, poorly written pieces could be quickly changed, or even replaced with better alternatives over time.

It's important to note the evolving terminology here. Over time, the term "free software" – which is still preferred by the Free Software Foundation (https://www.fsf.org/) – has largely been supplemented by open source software. The latter term is championed by the Open Source Initiative.

The GPL License 💫

The GNU project developed the GNU General Public License (GPL) specifically to dictate how free software should be treated and distributed. Although various other licenses exist, offering different methods for preserving software freedom, the GPL stands out as the most prominent, and it is the license under which the Linux kernel is released. Key principles of the GNU GPL include:

Author's Rights Retained: The original creator of the software retains their copyright and ownership, even while granting extensive freedoms to others.
Freedom to Distribute and Modify: Users are free to use, modify, and redistribute the GNU software, even incorporating it into their own projects. Crucially, any distribution of the software (modified or not) must include its source code or make it easily accessible.
Copyleft Principle (Preserved Freedoms): If you distribute or even sell software under the GPL, you must ensure that all future recipients receive the same freedoms you did. This means the GPL's terms must accompany the software, giving everyone the right to access, change, and redistribute the source code.

The GNU GPL explicitly states there is no warranty on the software. This means the original developers are under no obligation to fix any issues that may arise. However, numerous organizations, ranging from small businesses to large corporations, do offer paid support services (often through subscriptions) for GNU software.

Open Source Kernel ⭐

Despite its remarkable success in developing thousands of essential UNIX utilities, the GNU Project critically struggled to produce its own working kernel. Its ambitious efforts to build an open-source kernel, known as the GNU Hurd (link: www.gnu.org/software/hurd), proved largely unsuccessful in gaining widespread adoption, preventing it from becoming the dominant open-source kernel.

MINIX and the void 😕

At the beginning of the 1990s, the ideal version of a truly free and open-source operating system, free of proprietary licenses and legal issues, remained frustratingly out of reach. In this terrain of imperfect solutions and legal issues, stepped MINIX, a tiny, Unix-like operating system built by Andrew Tanenbaum in 1987. MINIX soon became a crucial teaching tool, created especially for academic purposes. MINIX's primary innovation was a microkernel architecture: unlike previous systems' monolithic kernels, the tiny microkernel handled only basic tasks like inter-process communication (IPC), memory management, and process scheduling, while other services ran as distinct, separated processes. However, Linus Benedict Torvalds, who was a student at the University of Helsinki during this time-period, delved into MINIX, he quickly identified its limitations for practical, cutting-edge development. He recognized that while great for learning, MINIX wasn't designed for the robust, high-performance computing he sought.

Conclusion 🎌

This unique convergence of factors – the GNU kernel's continued absence, BSD's legal battle, and the practical and licensing constraints of MINIX – created a palpable void and a clear opportunity. It directly inspired Linus Torvalds to embark on creating what would become Linux: a truly free, powerful, and unencumbered Unix-like kernel.

Stuck with Golang installation ? Can't decide how to fix your toolchains ? You just need this blog

PARTHIB KUMAR DEB — Thu, 10 Apr 2025 15:28:50 +0000

PARTHIB KUMAR DEB

Apr 10 '25

Hasslefree version management of Golang

#go #backenddevelopment #webdev #microservices

Comments 2

8 min read

Hasslefree version management of Golang

PARTHIB KUMAR DEB — Thu, 10 Apr 2025 11:03:41 +0000

📌 Introduction

Hey folks , it's me 😊. Well , this time I have come with an awesome as well as debatable topic which roam around developer's minds 🧠. Developers who are passionate about building scalable backends with Golang , often suffer from keeping its multiple versions alive in a system 😵‍💫.Golang's installation doesn't discuss this issue elaborately. So there are scattered opinions and methods to arrange the versions together. Some refers to use an external package called - gvm , but believe me , it has its own faults. gvm is only suitable to download older go versions but its not suitable to install new ones. In this blog 🖋️ , I am going to discuss my steps and key takeaways to manage golang's different version in my system, without using any external packages or libraries. I have done this in my WSL ubuntu , so it will surely work in your native LINUX (can't say more about WINDOWS , sorry!! 😼). But Before that Let's discuss what is golang and how it became so popular

📌 A little bit about Golang

Go is a general-purpose programming language that was created by Google in 2007. Google created Go to serve as a contemporary substitute for C. Well , it couldn't do that but got its own position. Nowadays ,it is mostly used to create reliable backends 💿 of various applications that require characteristics like concurrency for scalability. Go is a compiled language so it doesn't need the overhead of any virtual machine . The standard go toolchain builds the filename.go code into bytecode . Does Golang follow any precise architecture like any framework ? Yes . The official docs says that a golang project must have 3 folders :

bin/ 📂 (for storing the binary executables of your go files)
pkg/ 📂 (the packages which you install from any server like GitHub , golang , bitbucket)
src/ 📂 (the folder where you create your go files). But do you know what's the most interesting part of it ? Your Golang source project is itself built by this architecture, means the whole Golang installation creates a folder where you will see these 3 folders inside it and if you look into src/ folder you will go files, wow , so self-dependent language it is.

But this same solution creates another problem which I am going to tell later on in the what went wrong section. Now, be comfortable with some terminologies around golang -

Toolchain ⛓️‍💥 - A set of essential tools provided by the Go programming language for developing, building, testing, and managing Go code. It's the foundation you rely on to work with Go effectively. When you install a go version in Linux , its corresponding toolchain is downloaded inside the source project folder (specifically in the pkg/mod/golang.org)
Based on this primary version and toolchain , you can only download other golang toolchains and use them.
GO ENV 🌳 - A set of environment variables that go borrow and set inside your Linux system . Few important ones among them are -
A. GOROOT - The entire Go installation lives here
B. GOPATH - The workspace where Go will download its packages
C. GOBIN - The bin/ folder inside GOPATH
D. GOTOOLCHAIN - it decides which other toolchains of golang is eligible to install
E. GO111MODULE - Helps to download other golang toolchains
F. GOPROXY - configure to use a module proxy server. Instead of directly downloading dependencies from their version control system repositories (like GitHub, Bitbucket), Go will fetch them from the specified proxy.
G. GOSUMDB - Helps to check the integrity and authenticity of downloaded modules by verifying the checksum of each package and a database stores this checksums

Now till now , if I have created some interests to learn golang within you , you can follow my tutorial in GitHub - Tutorial. No doubt , you will code 'Hello World' in Golang if you follow my tuts 😄.

Now without any further story-telling , let's hop into the main chapter

📌 What went wrong

If you have never installed golang into your system , means you are a newborn 🧒 to golang's world . No worries my friend , you are also welcomed . You will directly get the nutritious foods 🍲without tasting other foods.

But if you've installed golang into your system from the official website , at least once , then you are my type of guy 🫂 . In the previous section , I have told you about golang's folder architecture . Now the problem occurs when go claims to create its own environment. Peeps who are coming from python , developed some stuffs there , knows about Virtual Environment. This venv is an isolated area inside the project's physical location where you do install some libraries , write some code , get your job done , without actually cluttering the memory with these libraries permanently .
But that doesn't happen for Golang , golang tell us to follow a specific architechture which is also being followed by itself. So when you make a golang based project and follows the architecture (bin-pkg-src) , you are passively recreating the go source project :)

Sounds Crazy, right? Let's dissect a real life scenario -

Let's say , you have downloaded go1.22.x version in your linux to learn golang . You have unzipped the tar file in /usr/local location and that's your GOROOT which you have appended in the PATH environment variable . For GOPATH , you just gave the location of your go-programs folder because the golang's docs doesn't really say anything about it. Your go-programs folder reside in the ~/ folder , mind it. Your go-programs folder follows bin-pkg-src architecture and yeah! you think you have done correct , because what will be the location other than your folder where you will download necessary go packages inside pkg/ folder .
It has been 2 months and you have done some coding in golang (created some go files in src/ folder , downloaded some packages in your own folder) . Now you have decided to install another version of golang by using go install golang.org/dl/go1.23.x.... & go1.23.x.. download (as per the docs). Maybe you succeed . You have also kept in mind that this is just another toolchain which is being installed using the base source project of version 1.22.x . So you know when you will do go version it will throw 1.22.x but when you run go1.23.x version you EXPECT to see 1.23.x but NO!! That doesn't happen. Instead you see , command not found from bash.
While inspecting in ~/ folder 📂 , you see a sdk/ 📂 folder. This folder contains only bin/ pkg/ and inside pkg/mod/golang.org there are 2 toolchains. You became shocked , how can it be possible 🫢, even after installation of new toolchain you can't use it !!
So you decided to remove all go source projects from /usr/local to sdk/ to just install the new version , because you thought that as you have hardcoded the environment variables GOROOT in .bashrc or .zshrc , that's became the problem and you have to install the new go 1.23.x from source. You do it , you changes the GOROOT but don't change GOPATH , because it targets your go-programs where your packages will be installed . Seems simple . Well that's the actual reason of failure . After installation when you will run go version you will expect to see 1.23.x but instead , it automatically starts to download go 1.22.x . That go1.22.x is now a toolchain inside go1.23.x/pkg/mod/golang.org but its the default and if you have to use your go1.23.x , you have to create a go.mod file manually without using go mod init.....

At this point , you are pretty much messed up 😖 .You are having terrible thoughts 😡. But wait! DON'T BREAK YOUR PC or LAPTOP :), there is definitely a way to get rid of this problem. You can also think about how unorganized your go source project is , inside your Linux system , it's terrible! and t*he go docs doesn't really address this problem.* That's why I have come here to show you the right way , the perfect way to manage your go-programs and go-source project .
Let's go for the solution

📌 Solution

A short disclaimer to you : I have decided to keep both go source project and my own go programs both in ~/ directory but you can keep them different locations. But remember , other than ~/ directory , all directories need strict permission and its can be accessed by sudo only , you will have to change the permission and that's harmful for your system because for you tiny go source code that entire system directory became prone to malicious attacks. So its safe to do everything inside ~/ directory

If you have installed and used golang for quite a while . Remove all your go folders (source and own programs) by sudo rm -rf.... Then run this two commands in your Linux system ,

find . -name go.mod

This command will find if there is anything with go.mod inside every folder of your Linux system . Will quickly execute and return nothing if there is no go.mod . Why you need to do this ? because go.mod is the requirements.txt for golang , except it also stores the snapshot of the golang version which forces to download that exact version of toolchain in the previous section . So your system should not have any of this go.mod

env | grep GOROOT

This command will show if there is any variable named GOROOT inside your .bashrc or .zshrc . If it gives some output , just open the .bashrc or .zshrc and remove all GOROOT,GOPATH,PATH (that one which connects the GOROOT to PATH , not other PATH), GOxx variables and do source ~/.bashrc. It will be better , if you restart the system.

Now your system is ready to begin . Let's make folder 📂 by naming something like go-toolchains/ or go-source/ where your entire go source project will reside . Inside that folder , create 2 folders source/ and packages/. This source/ will be your new GOROOT and packages/ will be your new GOPATH. NO , this GOPATH will have no connection to your go-programs ,will come up to that later. Inside packages/ make 2 folders - bin/, pkg/ (because here you won't write any go files so you don't need any src/ folder)

You came inside the source/ folder again , downloaded the tar.gz file here and you need just one more command to run ,

tar --strip-components=1 -xzf go1.24.2.linux-amd64.tar.gz

The argument --strip-component doesn't make another folder but makes the existing one as the source folder by flooding every files and folders inside it , similar like . in python where the source project is flooded inside the existing directory.

Now open then .bashrc or .zshrc in your favourite editor with sudo command (precisely ~/.bashrc or ~/.zshrc) . You have to paste these environment variables whose explanations I have given long before in this blog. You should not change the values of the variables

  export GOROOT="$HOME/go-toolchains/source"   
  export GOPATH="$HOME/go-toolchains/packages"
  export GOBIN="$GOPATH/bin"                
  export PATH="$GOROOT/bin:$GOBIN:$PATH"    
  export GOTOOLCHAIN='auto'       # Check before paste
  export GO111MODULE='on'         # Check before paste
  export GOPROXY="https://proxy.golang.org,direct"    # Check before paste
  export GOSUMDB="sum.golang.org"   # Check before paste

NOTE : Do go env and see if GOTOOLCHAIN , GO111MODULE , GOPROXY, GOSUMDB is previously set to the values mentioned in the snippet given above , if not then change it to these values.

Save it inside the file , do exit from the editor and run source ~/.bashrc or source ~/.bashrc. Its preferred to do a restart again.

Now when you will write go version, you will see go1.23.x . Not only that , if you install any other toolchains using go install golang.org/dl/go.... & go...download , you will see it has been installed inside go-toolchains/packages/pkg/mod/golang.org. Also if you do go... version, you will definitely see the new toolchain and it's version whereas if you do go version, you will see the base version.

📌 Conclusion

That's it. Now you can download your go-programs which may have some other versions and no worries , your base-version will help to install that toolchain . You can see how this solution not only solves the problem of version conflict but also keeps things in a single location and restricts to mix up with your own go-program folder. With that said , now it's time to bid goodbye 👋 . will meet in some other beautiful day.

Unlock Web : The Client-Server

PARTHIB KUMAR DEB — Wed, 24 Jan 2024 17:48:09 +0000

Hey Fellas 👋. Welcome Back to my blog 😄. So this blog is going to deal about how actually your browser requests data and get it as a cluster of html pages 💻. No , I am not gonna describe in a bore bookish way 📖. Rather , I will mention the members that help to create this connection , in a pointwise manner. It is going to be a precise walkthrough - which will grow your interest about how data transmission is done from far-away server to your webpage. This is common in any development, and important if you decided to go for web development ,but jumped upon it without any prior experience 🔰 😃. Let's start , shall we?

💡 Layered Networking Architechture 🌭

Before hopping into any fancy terms ,let me tell that, all developments are somehow came from a core computer science subject - Computer Networking 🗼 🗼 Although that's another world, but I am going to highlight 🔦 only important concepts that actually get utilised in every corner of various developments. So , computer network majorly plays with some architechtures which actually helps to send your data or request 🌿 🌿. Few of you if know about this , there are 2 types of architechtures - OSI architechture (Open System Interconnections , came at late 1970s) and TCP/IP architechture (Transmission Control Protocol / Internet Protocol , came at 1960s). Though these two big models have their own layerwise differences, but we will just dive into two specific common layers - Application Layer 🌍 and Transport Layer 🚐. Here Application layer is the topmost layer and transport layer is just behind it. Remember, the upper layers in these architechtures are always dependent on its lower ones - that's how request message transcends , breaks into pieces and attached by different headers. In the same way , inside the destination device , the lower layers do certain stuffs , based on the attached headers and uplifts the data-packets into the application layer. Have a look in this diagram,

Overwhelming right ?! 😯. To understand this coordination of layers - let me take one example of how you travel via airplane ✈️. In the airport , you reach with your ticket. Then you go for baggage check. Then you enter inside the plane. The plane have its own routes. After landing , you took your stuff from baggage center and leave .

Now replace the steps with each layers, you will get the brief overview. But what the layers actually Do ?? What happens when you hit the search button in a e-commerce app ?? How do you know about how many items left ?? That's all done by some Protocols , configured in these layers. Protocols are some set of rules defined to perform specific tasks. Although there are many protocols , but we will discuss about two of them -HTTP and TCP protocols. These protocols contribute to create a basic secure connection with the database server and your client browser. Let's dive into that.

💡 HTTP and TCP Protocol 🌐

HTTP (Hypertext Transfer Protocol) is the dominant protocol in the application layer. There are several versions of HTTP (HTTP/1.0 - 1996s , HTTP/1.1 - 1997 , HTTP/2.0 - 2015). Also, there is one more corollary protocol of HTTP which is more reliable in terms of security - HTTPS (Hypertext Transfer Protocol Secure). But we are not bothered about the differences between plain old HTTP and Upgraded HTTPS , in this context. I am just going to share steps that more or less both protocols follow - along with the added security advantages of the HTTPS. But do the HTTP works alone - No . There comes the TCP (Transmission Control Protocol). It is a dominant transport layer protocol beside the UDP (User Datagram Protocol). TCP is known for building a more secure connection between sender and receiver device. It ensures that either the data packets will go to proper receiver or it will be just destroyed. That's why HTTP uses TCP as an underlying protocol. So , how this TCP makes a successful connection - answer is 3-way Handshake 👐. Your browser sents a dummy message or request to the server or another online device. In response , the second device also sends a response that it is live. At the third stage , now the browser sents the appropriate message to the server and got its acknowledgement. Each of this Request-Response Pair takes a certain ammount of time called , Round-Trip Time(RTT) 🌀. Each of these RTT have some computational costs , so it is recommended to create only a single TCP connection between two fixed devices for all transmissions , otherwise multiple TCP connections will create a overload. Now how the sender client (browser here) will know that the receiver (server or any other device) is authentic or not? - SSL/TLS comes into play

💡 SSL and TLS🔑

Before going to talk about these two things - lets know what is socket 📣? In a precise manner , socket is the interface between any architechture's Application layer and Transport Layer. Socket helps to work the HTTP in a partnership with TCP / UDP and helps to interreact your http message with other layers. To provide an additional layer of security to socket - we have SSL(Secure Socket Layer) 🚔🚔.

SSL encrypts the TCP link between two hosts which ensures that all data passed between them remain private and free from attack. Any TCP connection is successfully built after getting the SSL certificate. That means , SSL protocols are actually the part of the 3-way handshake. There are many SSL protocols out there - you can check it out. Wooh!! So many things running 😮 😮. Yeah !! really it is not so simple to just dig into the data servers or to talk online with others 😎. So now let's unveil the TLS.

TLS or Transport Layer Security is another security protocol acts within the TCP link. They share a intimidating history - SSL v3 is earlier version and came before TLS. The SSL protocol was originally designed by Netscape, but the basic ideas behind securing TCP had predated Netscape’s work. So, Since its inception, SSL and its successor TLS have enjoyed this journey together. TLS is supported by all popular Web browsers and Web servers. TLS provides a simple API with sockets, which is similar and analogous to TCP’s API. When an application wants to employ TLS, the application includes SSL classes/libraries. Although TLS technically resides in the application layer, from the developer’s perspective it is a transport protocol that provides TCP’s services enhanced with
security services.

The TLS protocol uses one session encryption key for all subsequent encryption and data integrity checking and that's how the protocol also participates in the 3-way handshake. In simple terms - you can call both TLS and SSL as Digital Signature (Although its a term , majorly used in cryptography and block chain , but the base concept is same). But how servers recognize us (client browsers) , they simply send some cookies (not the things to eat) 🍪. Once the cookie got accepted by our device , it got stored in our system ,and only our browser can access that when we visit the website again.

💡 Host To Ip ♠️♦️

But How this Request response cycle turns out when we type the URL in the browser. Do browsers know Alphabets?? No!!. But what they do know the Ip-address. what is this ? In simple terms , IP is an unique 32 bit (IPV4) or 128 bit (IPV6) online address which can not be altered. This address is generated by IP protocol (Network Layer protocol). But how this pneumonic code to numeric bits happens ? DNS (Domain Name System) manages this matter.

The DNS is an application-layer protocol that allows hosts to query the distributed database. It is a collection of servers where one url are mapped to a certain IP-address - the address at which the website's own database server is located. After making the secure connection , when you hit a request to get data from a web URL , browser tries to find the the hostname in a hierarchy of DNS servers . On gradual assesment , atlast the IP-address is found.

Searching starts from Root Level server. From there browser gets some Top Level Domain Servers (e.g: .com , .in servers) and authorative server. Searching gradually proceeds in these servers and we get the IP address. That's Good!! Now you can realize how actually your URL so quickly shows the data you want to see. DNS is the crucial part of the whole Internet, and if it fails , so fail the internet.

💡 Responding the Request 🌐

Now let's see and make a complete breakdown of general web request and response. A typical web Request can be broken into 2 parts - Request Line and Header lines. On further breakdown , Request Line can be divide into 3 parts - Request Method (GET , POST , PUT , PATCH , HEAD , DELETE etc) , Hostname or Urlname , HTTP Version. On the other hand , a web response includes 3 things - Response line , Header lines , Data or Payload. Response line can be divided into 3 parts - HTTP Version , Status Code , Status Phrase. These things are entirely predefined stuffs , you can observe below -

Request Message -

Response Message -

You can see now , that the first line of the request is the request line as well as response message has its first line as response line . All the other lines apart from the first line , are header lines. Headers can be of many types - General Headers , Request Headers , Response Headers. Else we have different status codes which shows is the success or failure of the data retrieval. You can search online for the varieties of Headers and status codes.

That's It !! Now you have a clear idea of how you can shop items on amazon and do other manipulations with data so quickly. 😄 and tell your friends about the working behind the blackbox. Well , time to leave 👋. Surely we will meet in the next blog and till then stay healthy and Happy Hacking !! 🤖

Unlock Django : The Full stack Guide

PARTHIB KUMAR DEB — Wed, 27 Dec 2023 10:43:57 +0000

Welcome fellas 😄, this is my first blog 📄. Here, I will discuss about the collective steps that will lead you in a journey of a successful django developer 💻. But before heading towards the steps, let us know what is this framework all about ? Django is very robust, powerful , fullstack framework from python, which got recognized for its justified tagline - The web framework for perfectionists with deadlines. Born in 2003 👶, as being used for a famous news journal's website , django has spent almost 21 years upto its version 5.0 (beta , released in 2023). So, how it had survived so long ? , the answer is its MVT architecture (Model-Views-Template) and built-in ORM(Object Relational mapper). Django has its native support for all SQL databases(like SQLite, PostgreSQL, MySQL, SQL server), but, nowadays we can integrate it with some big NoSQL giants also (like MongoDB , Redis , Graphql) and some advanced databases (like appwrite , firebase). Although, Django was a gigantic monolithic during its birth time ,but now we can just use some its cool functionalities without its restricting environment and by the boon of APIS like REST and others it has become possible in the industry. So, now you can see 😮😮, django is one of the rapidly evolving fish 🐟 of this enormously large ocean of web development 🌊. So , after this profound introduction , lets put some spotlights on the key-steps for being a well-known django developer📋.

❗ ❗ Please copy the links and paste in new tab . All links are valid . There is some problem from this website.

Step-1💡Know Python A-Z 🐍

Its obvious that you have to know python and not by some teaspoon ammount, topics are -

(Basic to Intermediate - can't skip)

1. Variable and Datatypes
2. Conditionals
3. Loops
4. Strings (including slicing , f-strings)
5. Functions (including Higher order funcs also)
6. Scopes
7. Python Data structures (List ,sets ,tuples, dictionaries) and 
   their short comprehensions
8. Basics of File handling
9. Error Handling
10. Enumerate
11. Decorators
12. Packages , Modules and IMPORT st.
13. OOPS

(Advanced - Can do after few 3-4 steps)

14. Asynchronous Programming and Threading (after python 3.4x)

Spend at least 6-8 months for learning and revising by making some small projects.

Step-2💡Know DBMS 📖

So, when you have spent your half of the year behind python , now you can move to another important chapter - DBMS (Database Management System). Topics you must follow up are -

1. What is DBMS and why we use it?
2. 2 tier , 3 tier and 3 schema architechture
3. ER model
4. Relational Algebra
5. SQL (what is it , about schema , keys, tables , row , column) 
   + COMMANDS

Spent the rest 3-4 months for learning DBMS.

Step-3💡Know the Web 💎

Try to know how a Web-App works by covering these topics -

1. what is HTTP
2. What are the status codes in HTTP
3. How the connection is made between server and user [importance 
   of HTML,CSS,JS (just their roles in the web)]
4. What are APIs , types and Roles in this connection

For APIs and HTTP : https://sambitchak.hashnode.dev/.

These are not some book-bound studies. Read blogs and watch some worthy content in YouTube to just make an idea from all these topics, it will mostly take 2-3 weeks at most.

Step-4💡Know about database connections 📎

Now are good to start the stuffs of sole backend , cover this topics like -

1. What is a middleware (basic idea)
2. What are the middlewares used to connect SQL databases into 
  python scripts
3. Learn about Request Module in Python
4. Try to make a small project covering all 1-3 points

These will mostly take 1.5 months , things will start to move a little fast from this point.

Step-5💡Know about framework 🔎

Now are good to start the stuffs of sole backend , cover this topics like -

1. What is a framework (basic idea)
2. Framework architechtures : especially MVT , MVC
3. What is ORM and what are other alternatives of that

For Django's Own ORM : https://parthib23.hashnode.dev/demystifying-django-orm. All these topics will take 2 weeks.

So this is the point where you just one step away from diving into the depths of django. Congratulates yourself, 😃

Step-6💡Know about Django 🏆

I will not narrate anything about django, because it has a very user-friendly , well-managed documentation , by experienced developers
https://www.djangoproject.com/
Although , I will suggest to start from -
https://docs.djangoproject.com/en/5.0/intro/overview/

Now from step-6 , spend couple 3-4 months , build some 1-2 small projects by reading the documentation .You can use bootstrap or similar ready-made templates at this point. No shame!! From Step 1-6 , easily 1.5 - 2 years will be gone, but don't panick !!, jobs are not flying away!!

Step-7💡Know about essentials 🔆

I hope, you have spent atleast 1.5 years by learning django and stuffs. Now just take a break from django (Not from the journey man 😆) , and focus on these topics

1. Git and Github (2 weeks)
2. HTML + CSS (don't have to be expert, just spend 1.5-2 months)
3. Javascript (Dedicate 3-3.5 months here, don't think about django now)

4. Make some small projects covering these 3 points and push to Github

All these 4 steps will take atmost 6-8 months . So use your time with very accurate ratios.

Step-7💡Know about REST API 💎

Now, let's move forward to some advance stuffs like REST API. Previosuly , you had an idea about APIs. Now focus more on REST API. Read blogs and watch quality contents. So, when you are done with the basic understanding with REST API , dive to DRF (Django REST Framework) https://www.django-rest-framework.org and see how django can change its monolithic behaviour by connecting itself to giant JS frontend frameworks.
Learn and make some projects upto step-7. Spend more 2-3 months. At this points, only small projects will help you to learn and grow more.

So, successfully spending 2.5-3 years, you will have a decent crystal clear knowledge on django. But don't stop. Revise every previous steps, and learn how to integrate new stuffs with django , that's more important!! If you have reached to this very end 😄. then, I hope you have enjoyed and realized what I wanted to say. Bye!! and will meet to the next blog 👋👋

Forem: PARTHIB KUMAR DEB

Linus revolutionizes ☀️

Introduction ✈️

The Public Post 📷

Hobby Project ⚡

GNU Approaches 💨

The Community ✋

Features 📋

Diverse & Customizable Desktop Environments

Robust Package Management

Powerful Command-Line Interface (CLI)

Security by Design

Open Source Ecosystem

Performance on Diverse Hardware

The Bigbang 💥

Introduction 🏁

Mainframes and Multics 🏬

The Bell Minds 💡

The UNIX Era 🌐

The Shell 🔥

The Unix filesystem 📂

Redirection ⤴️

Portability 🔦

USA vs AT&T ⚡

Berkeley Software Distribution 😄

Commercializing UNIX 💰

AT&T vs BSD 😞

GNU Appears 😇

The GPL License 💫

Open Source Kernel ⭐

MINIX and the void 😕

Conclusion 🎌

Stuck with Golang installation ? Can't decide how to fix your toolchains ? You just need this blog

Hasslefree version management of Golang

Hasslefree version management of Golang

📌 Introduction

📌 A little bit about Golang

📌 What went wrong

📌 Solution

📌 Conclusion

Unlock Web : The Client-Server

💡 Layered Networking Architechture 🌭

💡 HTTP and TCP Protocol 🌐

💡 SSL and TLS🔑

💡 Host To Ip ♠️♦️

💡 Responding the Request 🌐

Unlock Django : The Full stack Guide

Step-1💡Know Python A-Z 🐍

Step-2💡Know DBMS 📖

Step-3💡Know the Web 💎

Step-4💡Know about database connections 📎

Step-5💡Know about framework 🔎

Step-6💡Know about Django 🏆

Step-7💡Know about essentials 🔆

Step-7💡Know about REST API 💎