I would like you to ask a couple of questions and provide a yes or no answer before proceeding with the article.

1. Have I used a Linux Distro before?

2. Do I like spending time in the terminal?

3. Am I interested in a deep dive into Linux systems?

In case your answer is yes to more than one question, then you are in. Knowing a bit about the Linux ecosystem gives an edge to quickly grasp further concepts of Linux. Now, let’s quickly understand what the heck is init sys.

What is init sys

In short, the init system is the very first process that starts after the kernel finishes loading. It has a process ID (PID) of 1. Alright, that was a mouthful of information. Let’s try to break it down piece by piece. For that, we need to understand what happens when we press the start button of the computer.

This flowchart illustrates the sequential stages of a Linux system startup process, showing how control passes from hardware initialization to a fully operational user environment. It begins with Power On (represented by a green hatched circle) and flows through six main stages, each depicted as rounded rectangles with pink diagonal hatching:

BIOS/UEFI: The Hardware Detective

When you press that power button, BIOS or UEFI firmware springs into action like a hardware detective. This low-level software performs the Power-On Self-Test (POST), checking if your RAM, CPU, and storage devices are ready for action.

Modern systems use UEFI, which offers faster boot times and support for drives larger than 2TB. You've probably seen this stage if you've ever entered the "BIOS setup" by pressing F2 or Delete during startup.

The firmware then scans your boot devices—whether it's your SSD, USB drive, or network—to find something bootable.

Bootloader: The System's Traffic Controller

Think of the bootloader as a sophisticated traffic controller that decides which operating system gets to run. GRUB (Grand Unified Bootloader) is the most common choice on Linux systems, presenting you with that familiar menu when you dual-boot Windows and Linux.

This tiny program, usually just a few megabytes, has the critical job of loading the Linux kernel from your hard drive into RAM. It also passes important boot parameters like which root filesystem to use and whether to boot in quiet mode or show detailed startup messages.

Kernel: The Digital Brain Awakens

The Linux kernel is where the real magic happens—it's the core that transforms your collection of hardware into a functioning computer. Once loaded, the kernel decompresses itself and immediately takes control of your CPU, memory, and hardware devices.

You'll see this stage if you remove the "quiet" parameter from your boot options—watch as it detects your network card, graphics driver, and storage controllers in rapid succession.

The kernel then mounts your root filesystem (usually from /dev/sda1 or similar) and prepares to hand control over to user space by starting the very first process with PID 1.

Init System: The Process Orchestrator

The init system is the first user-space process that takes control after the kernel loads, and there are several options available. Traditional systems used SysVinit with its simple but slow sequential startup, while alternatives like OpenRC (used by Gentoo) and runit (found in Void Linux) offer different approaches to service management.

However, systemd has become the dominant choice across major distributions like Ubuntu, Fedora, and Red Hat. As process number 1, systemd acts like a conductor orchestrating a complex symphony of services, revolutionizing how modern Linux systems start up.

Unlike older systems that started services one by one, systemd launches multiple services simultaneously, dramatically reducing boot times. You can see systemd in action by running "systemctl status" on most modern distributions. It manages everything from your network connection (NetworkManager.service) to your display server, ensuring dependencies are respected—for instance, making sure the network is up before starting web servers.

System Services: The Background Workforce

While you're browsing the web or editing documents, dozens of background services work tirelessly behind the scenes. These daemons handle everything from managing your WiFi connection (wpa_supplicant) to logging system events (rsyslog) and keeping your system time synchronized (chrony or ntpd).

On a typical Ubuntu desktop, you'll find services like cups-browsed for printer discovery, bluetooth for wireless device management, and systemd-resolved for DNS resolution.

These services communicate through various mechanisms like D-Bus, creating an interconnected ecosystem that keeps your system running smoothly.

Login Manager: The Digital Gatekeeper

The login manager is your system's friendly gatekeeper, presenting either a graphical login screen or a simple text prompt depending on your setup. Desktop environments like Ubuntu use GDM (GNOME Display Manager), while others might use LightDM or SDDM.

This component doesn't just verify your password—it also sets up your user session, loads your desktop environment preferences, and manages multiple user sessions if needed.

Once you successfully authenticate, the login manager launches your chosen desktop environment, whether that's GNOME, KDE Plasma, or a lightweight window manager, finally bringing you to the familiar desktop you interact with daily.

Build our System Service for the Minecraft server

Why do we need a service for a Minecraft server that needs to be managed by an init system? That’s a great question btw. It's because we need our server to run 24/7, running the Minecraft server on a terminal session remains in running mode till the terminal session remains active.

Let’s get our feet wet by quickly installing the Minecraft server from here https://www.minecraft.net/en-us/download/server. After downloading it we will get a server.jar file and our next step is to make it into a service so that run it everytime from the terminal.

The following connand spins the minecraft server, this will come handy while creating the service.

java -Xmx1024M -Xms1024M -jar minecraft_server.1.21.8.jar nogui

1. Create a directory called as minecraft under /opt path and put the server jar file inside that directory.

cd /opt && mkdir -p minecraft/server

2. Goto this path, /etc/systemd/system/

cd /etc/systemd/system/

3. create a minecraft.service file under /etc/systemd/system path

nano minecraft.service

4. Once the nano text editor opens, paste this piece of service configuration.

[Unit]
Description=Minecraft Server
After=network.target
StartLimitIntervalSec=0

[Service]
Type=forking
Restart=always
RestartSec=5
User=minecraft
Group=minecraft
WorkingDirectory=/opt/minecraft/server

# Adjust memory settings as needed (-Xmx4G = 4GB RAM, -Xms1G = 1GB initial)
ExecStart=/usr/bin/screen -dmS minecraft /usr/bin/java -Xmx4G -Xms1G -jar server.jar nogui

# Graceful shutdown sequence
ExecStop=/usr/bin/screen -p 0 -S minecraft -X eval 'stuff "say Server shutting down in 10 seconds..."\015'
ExecStop=/bin/sleep 10
ExecStop=/usr/bin/screen -p 0 -S minecraft -X eval 'stuff "stop"\015'
ExecStop=/bin/sleep 5

[Install]
WantedBy=multi-user.target

5. After pasting the config, save the file using ctrl+o and then exit out using ctrl+x.

6. Create a minecraft user

sudo useradd -r -m -U -d /opt/minecraft -s /bin/bash minecraft

7. Set the required permision

sudo chown -R minecraft:minecraft /opt/minecraft

8. Enable the minecraft service

sudo systemctl enable minecraft.service

Congratulations we have sucessfully created the minecraft service and its now running in background as a background process🚀

Before we go onto each component of the above diagram we must know the basics. So, first thing first -

tl;dr

Zoom out a bit from complex compiler designs termonologies and whatever scratches the part of your mind at night. We have tons of programming languages, they all are in some form of textual format that is readable by us humans. At the end of the day, all we want is to execute that piece of code inside a processor. Thus all we need to worry about is converting that sugar-coated code into machine code cause our cute little processor only understands that.

The computation in the middle is the real work here. Whatever components a programming language includes all work towards one goal, the goal to spit machine code at the end. Let's bring in some colors. Interpreters, compilers, assemblers, loaders, linkers, and parsers are a few of them that can fit into computation land. Programming languages can utilize the compilation of computation tools like in here Java. It is both compiled and Interpreted. Now let's learn the components involved in executing your Java code, end-to-end.

Components:

Source code is what we refer to as pure language code. It is nothing far from just a text which always gets converted into another text format. It could be compiled, interpreted, or transpiled.

Java uses Javac to compile source code into Bytecode (.class) files.

It is an intermediate representation code with a .class file extension.

It reads Bytecode and converts it into machine code line by line cause it's an interpreter.

Machine code is the most basic form of instruction that a computer's central processing unit (CPU) can execute directly.

FAQs

MDN says...

Let's go the usual way first, I'm going to yoink the definition of wasm from MDN 🫣

WebAssembly is a new type of code that can be run in modern web browsers — it is a low-level assembly-like language with a compact binary format that runs with near-native performance and provides languages such as C/C++, C#, and Rust with a compilation target so that they can run on the web. It is also designed to run alongside JavaScript, allowing both to work together.

WebAssembly says...

WebAssembly (abbreviated Wasm) is a binary instruction format for a stack-based virtual machine. Wasm is designed as a portable compilation target for programming languages, enabling deployment on the web for client and server applications.

https://webassembly.org/

I say...

Now let's see what I gotta offer you from my perspective. In short, WASM is a language-neutral compilation target. I'm extremely sorry if I scared you there 🥹 Don't worry I'm gonna break it down. WebAssembly is still a piece of code that is similar to a low-level format. Lemme show you instead of me ranting 😁.

$noobyco@nixos:~/Desktop/wasm]$ cat hello.wasm

Now lemme show you what the real binary of hello.wasm looks like, Here we go...

$noobyco@nixos:~/Desktop/wasm]$ hexdump -C hello.wasm

I have been doing a ton of research and hands-on on programming language internals, thus it was Lil easy for me to grasp the internals of wasm quickly. Here is my blog post that you might wanna got through to clear out the mud.

But why?

Lemme give a scenario where we wanna use intensive applications like 3D games, Virtual and Augmented Reality, computer vision, and image/video editing, but on the web. It's possible to implement in the traditional way but we have to trade its performance. software needs to be written in near-native speed programming languages like C/C++, Rust, etc. For the web, it was challenging until the birth of WebAssembly, Now we can use Premier Pro and even hardcore games on the web with WASM.

Lemme summarise the benefits we get with WASM -

• Be fast, efficient, and portable — WebAssembly code can be executed at near-native speed across different platforms by taking advantage of common hardware capabilities

• Be readable and debuggable — WebAssembly is a low-level assembly language, but it does have a human-readable text format (the specification for which is still being finalized) that allows code to be written, viewed, and debugged by hand. One of them is WAT.

• Keep secure — WebAssembly is specified to be run in a safe, sandboxed execution environment. Like other web codes, it will enforce the browser's same-origin and permissions policies.

• Don't break the web — WebAssembly is designed so that it plays nicely with other web technologies and maintains backward compatibility.

WASM key concepts

It is important to skim through basic concepts to fully understand the bigger picture. Let's start with Modules.

1. Modules: It represents the WebAssembly binary that has been compiled by the WASM compiler.

2. Memory: A resizable ArrayBuffer that contains the linear array of bytes read and written by WebAssembly's low-level memory access instructions.

3. Table: A resizable typed array of references (e.g. to functions) that could not otherwise be stored as raw bytes in Memory (for safety and portability reasons).

4. Instance: A Module paired with all the states it uses at runtime including a Memory, Table, and set of imported values. An Instance is like an ES module that has been loaded into a particular global with a particular set of imports.

WebAssembly core mechanics

This particular section Is fully dedicated to the internals of WebAssembly. Throughout this, we'll explore its working in the browser as well as outside the browser platform like the server.

Where is it used for

Before going into the rabbit hole for each use case of WASM, we must look at the broad view of its use cases. Go through the official WebAssembly page for the use case.

https://webassembly.org/docs/use-cases/

On browser

WebAssembly in the browser works lil differently than on the server side. Okie let's do it...🚀 Let's be clear that browsers need to load .wasm modules that can be fetched and invoked from the Javascript using WASM web API. The browser has a Stack-based VM ( virtual machine ) that is responsible for executing .wasm files.

If we try to zoom in on the browser section of my scrappy drawing, we will find out that it's more than the compilation of WASM with HTML, CSS, and JS. So what is actually going on inside here? Well, that's a great question there😎...

Dw doesn't directly run .wasm files on the browser, as I earlier it needs to be fetched into Javascript using the WebAssembly web API. After successfully writing wasm code in js we need to load the code into the browser, This process happens when we spin some sort of server-like live-server in VS code. Do open up the dev tool in your browser and navigate to the network tag, If you can't see any files then you definitely need to refresh once. Finally, you will be able to see those files loaded in the browser successfully👏🏻👏🏻

On Server { outside browser }

The WebAssembly technology was Intentionally made to charge up web apps in terms of performance. Web Applications like Figma and Adobe Premier Pro are Intense applications that need to be written in low-level languages like C and C++.

We can also use the same technology outside the browser thanks to WASI { web Assembly system interface } Let's see how the pieces come together here!

It was a time when I could not handle a neverending list of unanswered questions saved in my brain. It was clear that they were taking up a lot of space, so I wrote them on a piece of paper to free my brain storage. 🧠🧟

After week-long sleepless nights, it was the moment when every dot suddenly started to connect. I didn't go through compiler design books but still managed to understand fundamentals which is enough to code up my first programming language haha. BTW I'm not kidding! 🐸

The modern way to explore and learn

Before going into the path that I took to understand the concepts, I want to clarify one thing. Apart from the theories, it was my curious mind being in an unstable state and strong hunger to understand how languages work from the inside.

Traditionally things have been taught like it's detached from reality. Hell, seriously. Lemme give you an example here, for learning an operating system concept the only thing you need do is to `build your operating system`. Yup, it's damm simple. Why do people complicate them with generalized learning approaches where you get multiple random tosses of never used terms?

I'm not opposing the traditional idea, instead, it's not the better initial approach to take when you don't have your fundamentals clear to build more advanced stuff upon.

Considering my magical way to explore stuff that works as fast as NURALINK 🥹. I decided to learn concepts by putting my list of favorite languages on the inspection table😉

The first question in mind

To date, I'm using multiple programming languages combining compiled and interpreted. I wondered how a piece of software can convert highly human-readable language with symbols into the processor's native language or code.

Thus I began my exploration research in a top-down fashion. The languages I'm familiar with gave me enough motivation to start with them cause I use them. Being already informative about compiled language saved me a ton of time. While going through them, I took real-life examples of them like :

1. C/C++

2. Golang

3. Rust

4. Zig

...

Along the way explored multiple terms including Ahead of time, Natively compiled. Things got pretty serious when it was tough to wrap my head around unanswered questions like :

• Can an executable code ( code.exe ) run on the same operating system ( Mac ) but different Instruction set architecture?

• If the operating systems have a binary for multiple processor architectures ( ISA ) why do we need to compile for specific architecture then?

These questions led me to a term called CROSS-COMPILATION, it had all the answers I needed. WoW, problem solved then, Yeah kinda 🥹

Cross-compilation enables us to compile programs for different processor architectures ( ISA ) from being in a single processor architecture. The above diagram illustrates this incredibly ✨

Lemme give you a real-life example of cross-compilation in Golang. Execute the below command in the terminal to compile Caddy for Windows running on amd64 Instruction set architecture.

env GOOS=windows GOARCH=amd64 go build github.com/mholt/caddy/

The executable will be created in the current directory, using the package name as its name. However, since we built this executable for Windows, the name ends with the suffix .exe. Run the below command to verify the created file.

ls | grep caddy

output
caddy.exe

The env the command runs a program in a modified environment. This lets you use environment variables for the current command execution only. The variables are unset or reset after the command executes.

The following table shows some of the possible combinations of GOOS and GOARCH you can use:

What's the matter with JAVA?

I have written Java code before. Initially, I used to run my code in IDE ( Integrated development environment ) - Eclipse, which gave me a sweet abstraction layer to prevail me from looking into the internal execution processes. This was long before in my high school days, but 🍑 things have changed now 🥲

This time I played with SDK instead and did my terminal magic to understand under-the-hood stuff. The very next moment I got myself confused between Javac and Java inside command line env. why do we require a two-step process to execute Java code? why did the .class file gets generated after the first process? My curious mind needs answers now 🤥

// Doing Javac thing first...

javac demo.java

// Doing Java thing second...

java demo

Did some digging and finally got to a question that says, 'Is Java compiled or interpreted?' 🤔 found out that Java is both compiled as well as Interpreted but how? Okie things get pretty juicy here cuz the Java architecture is entirely different than natively compiled languages like zig or rust . Let's look at the bigger picture together.

Phase 1 - Compilation

If we look at things closely, the compiler javac in Java is functionally very similar to natively compiled language, the only dissimilarity is the output of the compiler which is the Bytecode instead of machine code. The Bytecode is also called Intermediate code which is closer to the machine but not as much as the binary stuff.

The question arises here is that why we even need to compile into Bytecode to execute it further by the Interpreter. we can just do direct Interpretation like LISP In the old days. BTW LISP was the first Interpreted programming language.

1. Performance: Bytecode is a lower-level representation of the code compared to the original source code. This allows the JVM to perform various optimizations during the interpretation or Just-In-Time (JIT) compilation process. These optimizations can result in improved performance and execution speed compared to directly interpreting the source code.

2. Portability: Java aims to be platform-independent, allowing Java programs to run on any system that has a compatible JVM. By compiling Java code into bytecode, which is a standardized intermediate representation, it can be executed on different operating systems and architectures without the need for recompilation.

3. Interoperability: By using bytecode as an intermediate representation, Java programs can seamlessly interact with other languages that target the JVM, such as Kotlin, Scala, and Groovy. These languages can also be compiled into bytecode, allowing them to utilize Java libraries and frameworks.

Phase 2 - Interpretation

We now have bytecode in hand, we just need to pass it on to Interpreter. The Interpreter then analyses the Bytecode line by line and produces direct output instead of an executable file { specific to the operating system }.

Variations in Interpreters

Like Native compilers, Interpreters are rapidly evolving over time. Earlier we used to directly Interpret source code, for example, LISP but now things have gotten advanced. Let's introduce you to JIT what stands for just in time.

Here is a thing, Interpreters are slow than running what's produced by native compilers, and because it's executing bytecode line by line in most of the cases which in result takes a lot of time doing stuff while being in runtime mode. That's why we have JIT with us which optimizes out dynamically typed code on the fly in runtime. Code optimization in Interpreters is not possible because it scans each line and executes it.

Code optimization let us execute the same code much faster than before. we won't go deeper into optimization for now, that's a topic for another blog but you get the point.

Okie here are the Interpreter's variations in terms of architecture that you will see in most cases:

In the background, even the compiled programs( C, C++ etc) are interpreted. There is an interpreter running the binary file which is implemented by the underlying processor. But its not commonly said.

• A CPU can be viewed as a hardware-based interpreter for its machine code.

• A VM can be viewed as a software-based interpreter.

Architectures

Now that I have a broad understanding of a couple of programming language architectures, I began to dig more into language architectures and I found:

1. Natively compiled ✅

2. Direct Interpreter ( with or without JIT ) ✅

3. Bytecode Interpreter ( with or without JIT ) ✅

4. Transpiler

Multiple Implementations of the same language

Let's take it back to 90tees. We all know C language which is epic for system programming but don't have an official implementation like python.org or ruby-lang.org. If you type C programming language in Google you won't get a website dedicated to C language instead you are forced to download its compiler according to the operating system.

List of C compiler Implementations ... https://en.wikipedia.org/wiki/List_of_compilers#C_compilers

Let's roll towards Interpreted language like Python. Earlier, I said Python has an official implementation so why am I talking about it in this section? In addition to official implementation, it has some unofficial implementations like pypy.

List of Python Implementations ...

https://wiki.python.org/moin/PythonImplementations?action=show&redirect=implementation

List of implementations

For learning Implementations of other languages refer to this Link:

https://en.wikipedia.org/wiki/List_of_compilers

Haha just kidding 🫣 😅

Lemme take you on a flashback

The story begins with my desperate desire to be called a developer. It didn't matter what kind of developer I become, as long as I could build something with code. I was limited to programming syntax and found it difficult to break through the barrier :/ So, I decided to call for HELP. I randomly came across Angela Yu's Web Development course and without a second thought, I enrolled in it.

Before I kicked off the course, I didn't know much about HTML and CSS. The backend stuff was also not my strong suit, so I just went with the flow of the course and let it take me wherever it went.

Whoa! Can you believe it's been over a year developing web apps now? My skill set has gone from zero to hero, and it's blowing my mind! When you invest enough time in something, it's like putting on a pair of magic glasses - suddenly, everything looks different!

Let's look at a bigger picture

Before diving into the specifics of the ecosystem lemme show your brain a quick look, at how the javascript world looks like from my experience till now.

Starting out in whatever field in tech is like exploring the never-ending map of Minecraft. There is so much to learn and to keep yourself updated. it might turn out to be overwhelming and annoying after hitting the threshold of brain power to suck up every ounce of information present there. Instead, I would recommend enjoying the process which, I didn't do, haha how paradoxical I'm being here.

Enjoy the process

What do I exactly mean by "enjoying the process"? You don't necessarily need to force yourself to enjoy rather you should focus on tweaking the learning mindset. grasping concepts little by little via project building. This could go in a cycle, you learned something new, just make a project on that or, You made a project which made you learn something new.

Let's dive into the Javascript map

Lemme make it clear that I'm totally focused on the web side of things but also will brief about everything else present on the map, just to give a broad understanding.

Javascript is a land of experiments, where every other day new framework or library pops up. Imagine boxes in the JS map as Bubbles in the JS world. are we good? alright, let's dive now.

Backend

For doing the backend in javascript there is an option to write your code at the runtime level or you could utilize the infinite power of frameworks out there at https://www.npmjs.com/ till eternity. we call them "Backend Frameworks" or if it's specific to runtime like Node.js then it's called "Node.js framework". These frameworks add up sugar on top of the runtime environments and create a sweet spot for the developers to work.

Here is an example of what an HTTP server looks like without a framework in Node.js --> https://github.com/Blaize15/raw-node

There is a list of never-ending backend frameworks you might look into. Btw I learned Express.js.

Each framework provides its own functionality, some functionality makes it stand out from other frameworks. therefore we need to choose frameworks wisely. For instance, Express.js provides Routing, templating, middleware, etc.

You might be wondering about Node.js being the single most Runtime available for javascript at the backend, then you are wrong🥲 Javascript is the language with a billion choices🥹 What are the other Runtimes then :

1. https://deno.com/

2. https://bun.sh/

Frontend

Frontend has interesting evolution right from Jquery.js. Why do we need a framework here, even if everything is possible with Vanilla Javascript? I guess you know it already, those who have used juicy frameworks like React.js, Angular.js, Vue.js, and many more popping up every other second. Obviously, they make application development a breeze.

You might know browsers live in noisy and chaotic environments where we cannot guarantee cross-browser compatibility. To have maximum utilization across multiple leading browsers frameworks need to make sure of it.

1. Module bundler: A module bundler is a web development tool that bundles different kinds of modules with dependencies into static assets.

   

2. Babel: A javascript compiler that compiles your javascript code to a specific version that you want.

Javascript transpilers

A transpiler, also known as a source-to-source compiler, is a tool that translates source code written in one programming language (the source language) into equivalent code in another language (the target language). Transpilers are commonly used to convert modern or alternative language features into a more widely supported language, allowing developers to leverage new language capabilities while maintaining compatibility with existing platforms.

Some of the cool-sounding transpilers are :

1. Typescript - The Grandaddy

2. Elm - purely functional in case you are wondering.

3. ClojureScript

4. pureScript

Native capabilities

Javascript is also used to build native applications supporting Desktop and Mobile. Surely you can take advantage of npm ecosystem to build your native apps.

1. React Native for Mobile - https://reactnative.dev/

2. Electron for Desktop - https://www.electronjs.org/

IoT

This could be fairly new stuff in front of web developers, but there is a great saying Dig deeper into whatever scares you the most haha.

Do :

$ npm i mqtt

& You are good to create your next IoT product 💥 ( Smile in pain ) 🥲

A mess, How?

I'll point out some of my personal experiences with the javascript ecosystem in general just to be safe from Js wizards 🪄🥲

It ain't consistent

I mean there is a billion other way of doing the exact same thing. it has a multitude of frameworks, libraries, and tools for various purposes, such as frontend development, backend development, testing, and build processes. The rapid pace of innovation has led to fragmentation in the ecosystem, with new tools and frameworks emerging frequently. This can create decision paralysis for developers and a steep learning curve when trying to navigate the ecosystem.

Lack of standardization

JavaScript lacks strict standardization compared to some other programming languages. This flexibility allows for creativity and experimentation but can also lead to inconsistencies in coding styles, patterns, and best practices across projects and libraries. It can make it challenging for developers to adopt new libraries or collaborate on projects.

Compatibility issues

Compatibility Issues: JavaScript runs in different environments such as browsers, server-side with Node.js, and mobile applications with frameworks like React Native. Each environment has its own set of APIs, behaviors, and limitations. Ensuring cross-platform compatibility and dealing with browser inconsistencies can be time-consuming and challenging.

Despite these challenges, it's important to note that the JavaScript ecosystem is also vibrant and filled with innovation. The large community, extensive package availability, and flexibility of the language have contributed to its popularity and power. The ecosystem is constantly evolving, and efforts are being made to address the challenges and improve the developer experience. With time, experience, and familiarity, developers can effectively navigate and leverage the rich JavaScript ecosystem to build robust and scalable applications.

1. Lil History.

2. Modern language support in microcontrollers.

3. Will my development board support these languages?

4. Let's blink Leds with a couple of these modern languages.

What has changed in the microcontroller ecosystem?

Before grasping modern advancements in the ecosystem, we should know a little bit about the history around it.

Phase 1: World's first microcontroller

Gary Boone along with Michael Cochran created the first Microcontroller at Texas Instruments around 1970 - 1971. It was given a name similar to some weird codename equals 'TMS1802NC'

Phase 2: Assembly & C

These tiny legacy microcontrollers used to be coded in assembly code. One of the great disadvantages of writing in assembly is that you can't run the same code on different microcontroller architectures like { arm64, arm32, PowerPC, etc } also it's equivalent to writing binary still🥹

Then the 'C' miracle was adopted by the ecosystem and every other vendor was shipping their microcontroller with their own SDK. That made it difficult for developers to quickly hop from one board to another.

Phase 3: Arduino breakthrough

Arduino developed an IDE that supports a wide range of microcontrollers. It's 'C/C++' like syntax with a '.ino' Extention with tons of libraries and built-in support. developers loved the idea of 'write once run anywhere' at least Arduino products for a moment. Later non-Arduino boards start to become Arduino compatible like ESP32.

Phase 4: Modern language integration

How awesome it would be on integrating your most loved programming languages like Python or Golang into your favorite microcontroller board. Guess what it's happening now, & you are a couple of steps away to run blink LED code in your favorite language of choice. Skip to the "Hands-on" section to try it yourself.

For each language brief skip to the "Modern language support" section.

Important dates to compare

Modern language support

Well, there are multiple modern languages with multiple solutions to bring them into the micro-ecosystem. What exactly do I mean by solution here? lemme give you a real example before taking you into a rabbit hole😅

If you wish to write Python on your development board, then you may need https://micropython.org/ or https://circuitpython.org/ as a solution.

Now lemme give you a list of solutions for a couple of languages.

1. Python

   1. http://micropython.org/

   2. https://circuitpython.org/

2. Javascript

   1. https://jerryscript.net/

   2. https://www.espruino.com/

   3. https://kalumajs.org/ { Only for Pi Peco }

3. Go

   1. https://tinygo.org/

4. Rust

   • Writing code in Rust is a little more complex than above languages 🥲

     The Rust language can be compiled specifically for development boards whose ISA { Instruction set architecture } can be found at https://doc.rust-lang.org/nightly/rustc/platform-support.html.

   • The Embedded Rust can be written in two ways :

     1. Rust::Unsafe mode - which means direct access to memory for low-level hardware access like timers, interrupts, etc.

     2. HAL { Hardware abstraction layer } - which means, you no longer have to directly communicate bare metal. Now you can get specific 'HAL crates' for your board. Crates can be found at https://crates.io/. These crates are like APIs to access low-level stuff.

   • Embedded repo resource for Rust - https://github.com/rust-embedded

Will my board run modern languages?

Most language Runtime firmware is open-sourced with diverse communities constantly contributing to the project. As a new dev board pops into the market, the community is there to add support for it.

lemme give you a list of boards for specific languages.

MicroPython - https://github.com/micropython/micropython/tree/master/ports

CircuitPython - https://github.com/adafruit/circuitpython/tree/main/ports

TinyGo - https://github.com/tinygo-org/tinygo/tree/release/targets

JerryScript - https://github.com/jerryscript-project/jerryscript/tree/master/jerry-port

Rust - https://doc.rust-lang.org/nightly/rustc/platform-support.html

NOTE: You can find any other language runtime or language-specific board support in the project repository.

Hands-on

Here I'm demonstrating LED blink fin MicroPython, you can test it out for others, or lemme know if you want a dedicated blog for that.

I'm using Raspberry Pi Pico for the demonstration, you can either go for the same board or use another with maybe a slightly different installation of MicroPython firmware.

Follow the below docs to install MicroPython firmware.UF2 file on it.

After successfully getting your REPL up and running, try running the below code to blink the built-in LED on Pi Pico.

from machine import Pin, Timer
led = Pin(25, Pin.OUT)
timer = Timer()

def blink(timer):
    led.toggle()

timer.init(freq=2.5, mode=Timer.PERIODIC, callback=blink)

Here is a list of reference articles referred to write this blog :

https://www.raspberrypi.com/news/multilingual-blink-for-raspberry-pi-pico/

While there are numerous reasons to learn Linux, my personal motivation was to explore cybersecurity. I started with the basic command line and gradually expanded my knowledge. Here are some facts that highlight the importance of learning Linux.

1. It's free

2. It's robust

3. Runs on millions of servers

Linux and Distro

Technically Linux is a kernel used in distribution. The kernel is very essential for an operating system to function. People usually call Linux an operating system, it's fine to say it so unless you ain't talking technical.

You might have seen Linux mentioned as one of the platforms when you download software. The vs code has "Linux x64" mentioned as the Operating system option to download along with { Windows, Macos }. It's understandable in this situation, although technically it sounds weird.

Choosing a right Linux distribution

It might be overwhelming for beginners to choose their first Linux distribution. You have to start somewhere to kick off your Linux journey. It doesn't matter initially as long as you focus on learning Linux concepts.

Take a look at the Linux distro map : Distrowatch

Burning Linux onto hardware

This is the part where you start hands-on with the Linux box. How to install a Linux distro of your choice to a particular hardware? how to even choose the right hardware for your Linux box. Time to get your hands dirty 💩

Choosing hardware

The Linux kernel is capable of running on multiple "Instruction set architectures" like x86, mips, arm, riscv. Refer to this Link to know about the supported ISA ( Instruction set architectures ) by the Linux kernel. Theories aside let's talk about the hardware available for common ISA.

Ways to run your Linux distribution

Now that you have your choice of hardware with you, next you need to install/burn the Linux distribution on it. There are a couple of ways to install the distro. I'll go with beginner-friendly installation from the top to all the way till the end.

1. Google Cloud console

2. Live boot

3. Using hypervisors

4. cloud vms

5. WSL2

6. Wipe up and install fresh

7. Dual boot

Refer to my other blog on Linux to learn deep about each installation method 👇

Why you shouldn't dual boot

Check this amazing content by "HackerSploit". Shoutout to him✨

How to find good Linux resources

I remember endless research for resources to learn Linux. Research is the key to resources on any topic but what really helped me to reach some of the juicy content on Linux is by finding people who have already done some good work around the Linux ecosystem. If they make content in form of videos, blogs, or whatever, do follow them only if they have proof of their work. Further, connect with them and learn along 🙂

My favorite resources for Linux till now are :

1. Linux Journey

2. Over The Wire

Personal tip

I you are one of those who are struggling to maintain consistency but still wanna learn it, then you should definitely consider making Linux distro your primary Operating System and use it as your daily driver.

Entering into the world of Linux can be overwhelming 🤯

You might indeed have heard, Linux is used by cool punk hackers showing their terminals with constant texts popping up after banging some commands. If you flip the coin you will encounter the deepest darkest secret hidden from people like you who are getting started, just kidding 🤣. well, I'm not scaring you exactly rather trying to demystify.

In what sense it can be overwhelming

1. There is too much distribution out there 😣

2. I can't install my favourite code editor "vs code" 😣

3. Lot more 😣

1. There is too much distribution out there 😣

You may have heard some of the most popular distributions like Kali Linux Ubuntu and may have assumed Ubuntu == Linux or Kali Linux == Linux, I was in your place once believe me 😁

There's brand new distribution popping up now and then. but windows is just one freaking thing, is there any problem with Linux being prone to mutation? 😥well Linux is just a major part of the entire operating system called ' kernel '. it's also called, the heart of the operating system. we won't trouble ourselves going deep into the kernel for now.

So if Linux is the kernel, then what distribution is? 🧐Linux is an open-source kernel, so developers out there grab it and smash it right into their codes to bake an operating system also called a distribution or Distro for short. but why do people commonly say distro rather than operating system? cause there are a lot of operating systems/Distro sharing the same kernel which is Linux, made by Linus Torvalds.

You can explore Distros here 👉 Distro tree

2. I can't install my favourite code editor "vs code" 😣

Typically, users in windows would download the installer for particular software and the installer would guide and does most of the part itself. below is one example of a software installer for windows.

what about the case of Linux distros? well, they are very much different from windows kinda installing software. they use something called a package manager to manage software/packages. what does managing mean in Linux distro?

📩 Installing software

⚙ Updating software

❌ Deleting software

🥤 Much more juicy stuff

Some package managers used by different distributions are :

apt or apt-get --> Debian-based distributions

rpm or yum --> Redhat-based distributions

If you can relate to the package managers inside programming languages like python = pip, javascript = npm, and so on. Explore most of the package managers for programming languages - Libraries.io

3. Lot more 😣

Once you start using Linux distros as your daily driver then you gradually start to pick up the whole ecosystem a lot faster. It also prioritized more on the command-line interface CLI over the graphical user interface or GUI . This command line has a steep learning curve than graphical once such as the one and only freakin Windows.

You might be thinking "Hey Noobyco why ain't you mentioned mac anywhere?", well well, mac is based on Unix so it is an all-rounder when it comes to both GUI and CLI. you can think of it as, visually friendly like windows and extremely robust as well as juicy like Linux distros.

NOTE

You may have heard developers saying Linux to describe an operating system rather than ' kernel ', it's totally fine as long as you understand the difference. another term ' terminal ' is thrown a lot in this field which Is the software providing CLI in Linux distros and mac ecosystem, there are a variety of terminals out there to use. but in the case of windows, currently, we have only two, PowerShell and CMD.

Our target reader

1. Transitioning to backend development 👩‍💻

2. Transitioning to an administration job ⌨

3. Hobbyist 🐧

1. Transitioning to backend development 👩‍💻

Most people transitioning into the backend are front-end guys, there are also some people directly hopping into the backend, so we'll consider both situations. In the case of front-end dudes, they tend to use CLI far less than server guys. when I say CLI it does not refer to a Linux terminal rather it's the interface used by operating systems for various reasons.

there are no specific prerequisites for people falling into this category, except basic IT knowledge includes knowing how to use an operating system for daily use.

2. Transitioning to an administration job ⌨

majorly there are two teams in a software producing company, one which writes software AKA software developer ( Includes all sub-categories like web development, mobile ... ) another maintains production servers in which the software runs. administrative jobs fall under server Maintainance also called operations in IT. Network admin, System admin and help desk are some of the roles that come under this. these guys can't live without a terminal.

3. Hobbyist 🐧

they are my favourite set of tech-savvy, always prone to explore new stuff and open to learning out of their curiosity.

Let's get our hands dirty with Linux

Enough talking, it's time to execute some stuff. let's proceed according to standard OS users.

1. Windows savvy

Users coming from a Windows background has some of the following ways to spin up a Linux distro for them

• WSL2

• Live boot

• Dual boot

• Using hypervisors

• Google Cloud console

• Wipe up and install fresh

• Virtual machines on Cloud

There are many ways to get your Distro rolling, but ill recommend doing Live boot, Using hypervisor and Google Cloud console initially, later on, you can try left-out things on your own or comment me down if you want a detailed blog on a specific topic.

1. Hypervisors are the most common way of spinning a distro, it uses the virtualization technique. refer to this tutorial kinda video to set up your hypervisor.

1. Live boot is a way of booting up the distro without installing it into your secondary storage i.e hard disk. well, now it's something getting interesting haa 🧐.

1. Google Cloud console is one of the easiest options to opt for among the three, cause there the distro spins on Google servers. they have exposed a console to use it, all you need is a google account, that's it.

   Hit HERE

2. Mac savvy

Do not need to worry about any of the installation process cause mac is Unix based, thus it already has a terminal pre-baked from the factory.

juicy platform to learn Linux

Of course, I can explain every basic concept along with examples here, but that would be pointless for this blog, there is already a platform to practice and reference. you can do ChatGPT and fetch a lot of valuable resources and references for you, but AI != Human so I'm sharing my favourite platforms with you

• Use Over The Wire to practice your Linux skills by playing games.

I would recommend beginners start with video content rather than textual content, cause when you are starting with something, it requires more focus during those initial days. Visual content grabs your focus and makes it a lot more interesting than textual content. I agree visual contents consume a lot of time but it pays off in the beginning.

In the end, the only method that works the best is to force yourself to learn Linux by wiping up your hard disk and freshly installing Linux distro and using it as your daily driver. before doing that make sure you back up every bit of data.

Why should we learn Linux?

well, it depends on what kind of person you are. In the tech field, developers use it, the server maintainers, cybersecurity professionals, and DevOps guys. I can go on listing roles on and on but I wanna make a point about the factors causing these roles to adapt. of course, we can run web servers on the windows operating system ( windows server ) or do bug bounty on windows or any other operating system. The fact we all should notice Linux being run on the majority of servers and used in various roles because of the following factors :

Command line

Both Linux and mac have a robust command line interface, which is often preferred by developers because it allows them to automate tasks and work more efficiently. Windows on the other side is not fully featured as the one on Linux and mac.

Compatibility with open source

Many open-source tools and frameworks are developed on and for Linux and mac systems.

Customizability

Linux and mac systems offer more customization options than Windows, which can be attractive to developers who want to tailor their development environment to their specific needs.

My journey into Linux

I remember completely wiping up my disk and installing Debian based Distro Kali Linux as my first Linux exposure. I was curious to explore the very concepts Linux is different from Windows. I heard the term Linux during high school but used to wonder about it being run on the system. my school computer labs had windows installed on them so I used to play crazy on the CMD command line. create a batch script and do all sorts of harmful executions to destroy systems completely, although I enjoyed those days 😅.

Back in 2k22, I was exploring cybersecurity, and this was the main reason to start learning Linux in the first place. I discovered my favourite platforms to learn it. one of my all-time favourite is Linuxjourney, unfortunately, it's down currently 😢.

The one strategy I always used is to `learn something if you know its why` in my case I was learning to learn cybersecurity concepts. I call it reverse engineering .

Conclusion

Some of you might be wondering, where are commands in this blog 😅. Intentionally I designed this blog the way it is cause it's for dummies. Let's assume you heard about Linux from your friend circle and you come back home spin your Linux distro and start banging commands onto the terminal. sixty-nine minutes passed and you have no idea what's going on 😂. This situation matches perfectly to script kiddies in the world of hacking.

Now after reading this one can be comfortable in the ecosystem and keep learning on top of that. Let me know if you guys want more blogs around Linux or if you wanna explore ChatGPT to learn the same.

Let me introduce myself. I'm a student who is interested in electronics, I know that I threw a pretty vague term there but lemme explain. When I was very young, maybe in 6th std (excuse me I don't know the exact year) my sister gave me a light bulb, one with a filament on it. From there my interest in electronics started and later aligned with the field of computers... cause

COMPUTERS == APPLICATION_OF_ELECTRONICS

Back in the year 2k21, this was the year after I started college. I used to watch build videos of electronic projects like LED cube matrix or POV displays but in the end, something I wanted to do out of my **curiosity **, of knowing how those devices would work, and that stuff really fascinated me.

After getting loaded with a bunch of electronic project ideas, there was one project which stuck on my mind for a very long time. In that project, I wanted to control my home light bulbs and fans via my smartphone. Then my research journey began...

Let the journey begin

I was not sure how to achieve that result, thus I started Dorking Google. I saw the most common method to achieve my result, and that was using services like Arduino IoT cloud or Blynk, etc. At that time I had only one board which was Raspberry pi 3. Because of the following factors, i could not use those appealing services :

• I wasn't aware of the platform which supports Raspberry pi and

• I had no dev board other than raspberry pi cause

• I was poor

Communication between things

In this particular project, the things were two, and they were :

• Raspberry pi + LED connected to it

• web app to fire commands

I was looking for some kinda glue to stick them both together so that they could start communicating via messages. That was the very basic plan but before hitting google I thought to myself, what if we could use the HTTP protocol to enable the communication? I was familiar with some of the networking stuff, so I picked up my raspberry pi and installed an apache server, and coded a Lil .py script to control the led on the pi connected via GPIO.

The idea was to deploy my web app onto the raspberry pi, on doing so I could write a script onto the backend of the web app to directly control the LED via commands coming from the frontend.

I ended up not applying the HTTP protocol and began research. Then I found the MQTT protocol and this time I'm using it.

MQTT test

So I wrote the .py script on two different files. One for the publish.py and the othersubscribe.py. I ran both scripts using two separate terminals. the publish.py file was responsible to publish a msg into the broker and subscribe.py was to subscribe. The broker is the central MQTT server which is stateless.

As I published a msg from one terminal, immediately i could see the msg appearing on the other terminal. I was so happy that I took that laptop that day and showed it to my whole family.

Way to fire commands

Here comes the juicy stuff. MQTT demo was working flawlessly, now there was the challenge to code UI and get command from there and POST to backend. I chose Express+Node setup at the backend with no database involved. The plan was to make it less complicated. On the frontend side, i used simple HTML+CSS.

The web app is ready, time was to add MQTT flavor to the backend to communicate via a broker. Thus i used the npm package called also mqtt. Glued everything together and landed with this beast...

Web-App

Pi setup

On the PI I modified the subscribe.py file and interfaced it with a GPIO pin for controlling the LED attached to it.

import paho.mqtt.client as mqtt
import time
import RPi.GPIO as GPIO

#setmode
GPIO.setmode(GPIO.BCM)

#pin_setup for led.

GPIO.setup(4,GPIO.OUT)

def on_message(client, userdata, message):
    msg = str(message.payload.decode("utf-8"))
    if(msg == "on" or msg=="ON" or msg=="On"):
        GPIO.output(4, GPIO.HIGH)
    elif(msg == "off" or msg=="OFF" or msg=="Off"):
        GPIO.output(4, GPIO.LOW)
    print("received message: " ,str(message.payload.decode("utf-8")))

mqttBroker ="broker.hivemq.com"

client = mqtt.Client("internet")
client.connect(mqttBroker) 
#Loop_Start
client.loop_start()

client.subscribe("internet")
client.on_message=on_message 

time.sleep(90000)
#Loop_End
client.loop_stop()

Zoom out a Lil bit

I just finished the three major parts of the project :

• Web-App

• MQTT broker

• Pi script

If we tryna understand what's really going on under the hood then we need to step back zoom out a Lil bit and see the bigger picture. I won't explain you in the text but on looking at the below image you'll get what i wanna explain.

Get the GitHub repo : Github

I made a video documentary on this project : Documentary