Imagine Maria, sitting at her desk in New York, wanting to check the flight status for her friend's arrival in Tokyo. With a few clicks, she opens her browser and navigates to the airline's website. This seemingly simple action triggers an intricate sequence of events across the digital landscape, navigating through layers of network protocols before returning with the information she needs.

Computer networks rely on standardized frameworks to facilitate this type of communication. Two primary models exist: the practical TCP/IP model and the theoretical OSI model. These frameworks are like the postal service of the digital world, ensuring Maria's request reaches the correct destination and that she receives the proper response.

Layer Comparison between TCP/IP and OSI

The TCP/IP model consists of five layers:

1. Physical Layer (1): Handles the transmission of raw bit streams over a physical medium. This includes electrical specifications, cables, connectors, and signaling methods. For Maria, this is where her laptop's network card converts her request into electrical signals that travel through her home's Ethernet cable or Wi-Fi radio waves.

2. Data Link Layer (2): Provides reliable transmission of data frames between two nodes connected by a physical layer. It handles error detection, addressing (MAC addresses), and media access control. Here, Maria's request gets an address label similar to an envelope with a local delivery code.

3. Network Layer (3): Manages addressing, routing, and packet forwarding between networks. The Internet Protocol (IP) operates at this layer, handling logical addressing and path determination. Maria's request now acquires long-distance addressing—like adding a country and city to her envelope—allowing it to navigate across the global internet toward Japan.

4. Transport Layer (4): Ensures complete data transfer by providing end-to-end communication services. TCP (connection-oriented, reliable) and UDP (connectionless, unreliable) protocols operate here, managing port numbers, segmentation, and flow control. This layer ensures Maria's request arrives completely intact, similar to how a registered mail service tracks packages and confirms delivery.

5. Application Layer (5): Provides network services directly to end-users or applications. In TCP/IP, this combines the functions of the upper three OSI layers (Session, Presentation, and Application). This is where Maria's browser formats her request in ways the airline server will understand.

Meanwhile, the OSI model features seven layers:

1. Physical Layer (1): Identical to TCP/IP's Physical layer, managing hardware connections and raw data transmission.

2. Data Link Layer (2): Similar to TCP/IP's Data Link layer, handling frame-based transmission and MAC addressing.

3. Network Layer (3): Equivalent to TCP/IP's Network layer, managing logical addressing and routing.

4. Transport Layer (4): Corresponds to TCP/IP's Transport layer, providing end-to-end communication control.

5. Session Layer (5): Establishes, manages, and terminates connections between applications, not explicitly defined in TCP/IP. For Maria, this layer manages the ongoing conversation between her browser and the airline's server.

6. Presentation Layer (6): Handles data translation, encryption, and formatting, also not explicitly defined in TCP/IP. This ensures the flight information appears correctly on Maria's screen regardless of what type of device she's using.

7. Application Layer (7): Provides network services to end-user applications, similar to TCP/IP's Application layer but more narrowly defined. This is where Maria's browser displays the flight information in a user-friendly format.

Network professionals commonly use the mnemonic "Please Do Not Throw Sausage Pizza Away" to remember these seven layers.

Practical Implementation

While TCP/IP is more commonly implemented in real-world applications, discussions about networking typically reference the OSI model's seven-layer structure. This creates a practical hybrid approach where data transfers through TCP/IP's five layers, but professionals conceptualize them within OSI's seven-layer framework.

In Maria's case, her flight status request actually travels through the TCP/IP model's implementation, but network engineers troubleshooting any connection issues would discuss problems in terms of which OSI layer is affected.

Session and Presentation Layers

In the OSI model, two additional layers exist between the Transport and Application layers:

Session Layer (5)

The Session layer establishes, manages, and terminates connections between applications. Its key functions include:

• Dialog control (determining which device can transmit and when)

• Session establishment, maintenance, and termination

• Synchronization (establishing checkpoints during data transfer)

• Managing session recovery after failures

• Supporting both simplex, half-duplex, and full-duplex operation modes

For Maria's flight check, this layer maintains the connection between her browser and the airline server throughout her session, even as she navigates to different pages to check additional flight details, baggage policies, or terminal information.

Presentation Layer (6)

The Presentation layer prepares data for the Application layer by transforming it into a format that application-level processes can understand. Key functions include:

• Data translation and formatting

• Encryption and decryption

• Compression and decompression

• Character set conversion (ASCII, EBCDIC, etc.)

• Managing file formats (JPEG, TIFF, GIF, etc.)

• Abstracting syntax differences between communicating systems

This layer ensures that when Maria receives flight information that includes the airline's logo, flight status indicators, or maps, these elements are correctly formatted and displayed on her screen regardless of her device or operating system.

Data Encapsulation Process

When data travels from one system to another, it follows a specific encapsulation process, with the data unit having different names at each layer:

1. Initial Connectivity: ARP packets identify the data transfer path, and DNS servers resolve the actual IP address of the destination. When Maria types "tokyoairlines.com" in her browser, DNS servers first translate this name into the actual IP address of the airline's web server.

2. Application Layer (7/5): The data begins its journey at this layer as data or messages. Maria's request for flight JL123's status is prepared for transmission using HTTP or HTTPS protocols.

3. Presentation Layer (6): In the OSI model, the data is formatted, possibly compressed, and/or encrypted for standardized transmission. Maria's request might be encrypted if using HTTPS, protecting her session information.

4. Session Layer (5): The OSI model establishes a session between the communicating applications. The data maintains its form while a unique session identifier is created for Maria's interaction with the airline website.

5. Transport Layer (4): Data receives a header containing port information (port 80 for HTTP or 443 for HTTPS), creating a segment (TCP) or datagram (UDP). This is like specifying which department at Tokyo Airlines should receive Maria's request.

   TCP 3-Way Handshake

   Before Maria's flight status request data can be transmitted, her computer and the airline server must establish a reliable connection. This happens through the TCP 3-way handshake:

   1. SYN (Synchronize): Maria's computer sends a segment with the SYN flag set and an initial sequence number (ISN). This is like Maria saying, "Hello, Tokyo Airlines! I'd like to start a conversation with reference number 1000."

   2. SYN-ACK (Synchronize-Acknowledge): The airline server responds with a segment containing both the SYN and ACK flags, acknowledging Maria's sequence number and providing its own ISN. This is like the airline responding, "Hello Maria! I received your message #1000, and I'm responding with my reference number 2000."

   3. ACK (Acknowledge): Maria's computer sends a segment with the ACK flag set, acknowledging the server's sequence number. This completes the connection establishment. It's like Maria saying, "Great! I confirm receipt of your message #2000. Now we can talk about my flight status request."

Only after this handshake is complete can Maria's actual flight status request be transmitted. This process ensures reliable, ordered delivery of data and is why TCP is considered a connection-oriented protocol.

TCP vs UDP

While Maria's flight status check uses TCP for reliability, her friend Raj is simultaneously streaming the airline's promotional video. His application is using UDP instead:

TCP (Transmission Control Protocol):

• Connection-oriented: Establishes a connection before data transfer

• Reliable: Guarantees delivery through acknowledgments and retransmission

• Ordered: Maintains sequence of packets

• Flow control: Prevents overwhelming receivers with too much data

• Error detection: Checks for corrupted packets

• Examples: Web browsing (HTTP/HTTPS), email (SMTP), file transfers (FTP)

UDP (User Datagram Protocol):

• Connectionless: No handshake, just sends data immediately

• Unreliable: No guarantee of delivery or order

• Lightweight: Minimal header overhead (8 bytes vs TCP's 20+ bytes)

• Faster: No connection establishment, acknowledgments, or retransmission

• No congestion control: Will not slow down when network is busy

Real-World UDP Applications:

• Live Streaming: When Raj watches the airline's promotional video, occasional dropped frames are preferable to buffering delays.

• Online Gaming: When Maria's son plays multiplayer games, the quick response is more important than perfect data delivery.

• VoIP Calls: During Maria's call to confirm her friend's arrival details, brief audio glitches are acceptable but conversation delays are not.

• DNS Lookups: When resolving "tokyoairlines.com" to an IP address, speed matters most.

• IoT Devices: Maria's smart home sensors send frequent but non-critical updates using UDP.

• DHCP: When Maria's laptop first connects to the airport Wi-Fi, it uses UDP to quickly obtain an IP address.

UDP is ideal for time-sensitive applications where losing some data is preferable to waiting for retransmissions. If Maria were video-chatting with her friend about the flight status, the application would likely use UDP for the video/audio and TCP for chat messages and control signals.

6. Network Layer (3): The segment acquires a header with source and destination IP addresses, forming a packet. Now Maria's message has both her return address and the airline server's address.

7. Data Link Layer (2): Adds header and trailer with MAC addresses, creating a frame. This adds the specific information needed to get Maria's request to the first stop on its journey, her local internet gateway.

8. Physical Layer (1): Converts information into bits represented as signals (electrical, optical, or radio) for transmission over the physical medium. Maria's request leaves her laptop as electrical signals through her router.

Data Transmission Path

Maria's flight status request now travels through the network following a specific path:

1. Source Device: The request originates from Maria's laptop in New York and passes down through all layers of the protocol stack, with each layer adding its header information. By the time it leaves her device, the original data has been transformed into bits within a frame.

2. LAN Infrastructure: The frame travels from Maria's laptop to her home's Wi-Fi router, which forwards it based on MAC addresses.

3. Router: The router strips the frame to access the packet, examines the IP addresses, determines the best route, and forwards it toward Tokyo Airlines' servers.

4. Internet/WAN: The packet traverses multiple routers across different networks spanning continents, with each router making independent forwarding decisions to move Maria's request closer to its destination in Japan.

5. Destination Network: Upon reaching Tokyo Airlines' network, the packet is delivered to the appropriate server based on routing information.

6. Destination Device: The frame arrives at the airline's web server, which processes it upward through the protocol stack, removing each layer's header. The process reverses:

   • Frame → Packet → Segment → Data

The original flight status request reaches the web application, which queries its database and prepares a response showing that flight JL123 is "On Time."

The response then follows the same process in reverse, beginning at the application layer of the airline's server and working down through encapsulation, across the internet, and up through the protocol layers of Maria's laptop, until finally, her browser displays "Flight JL123: On Time" on her screen.

This process occurs bidirectionally, allowing for request-response communication between systems. At each step, the networking devices operate only at their relevant layers: switches primarily at Layer 2, routers at Layer 3, and end devices across all layers.

Imagine you live in a small town where everyone sends letters to each other. At first, there was only one mail carrier who would take your letter and shout its contents to everyone in town. This was noisy and everyone heard messages that weren't meant for them!

This old system is like a network "hub" - not very private or efficient.

Then the town got smart. They hired special mail carriers called "switches" who remembered where everyone lived. Now when you send a letter, the carrier takes it directly to your friend's house - no shouting involved!

But what happens when you want to send a letter to someone in another town? That's when you need the main post office, or "router," to help send your message to the right town first.

With this simple system, you can understand how computers talk to each other:

• Switches handle mail delivery within your own town

• Routers help get messages to different towns

• Each town has its own street names and house numbers (like computer networks)

Let's explore how this works in more detail!

Switches

Switches are like smart mail carriers for your local neighborhood of computers. They connect multiple computers through cables called Ethernet ports and make sure messages go exactly where they need to.

From Hubs to Switches

Before switches, we had hubs. When someone sent a message through a hub, it was like shouting in a room full of people - everyone heard it whether it was for them or not! This wasted time and created security problems.

Switches, on the other hand, deliver messages only to the intended recipient. It's like the difference between announcing a secret to an entire room versus whispering it directly to your friend.

How Switches Work

The clever thing about switches is they learn and remember which computer is connected to which port. They do this through:

1. CAM Tables (Content Addressable Memory): Think of this as the switch's address book. It records which computer lives at which "house" (port).

2. Learning Process: When a computer sends a message, the switch makes a note: "Computer A is at Port 3" and writes it in its address book.

3. Smart Delivery: After learning where everyone "lives," the switch can deliver messages directly instead of broadcasting to everyone.

Technical Details

Messages traveling through a switch are called frames. People often call them "packets" in casual conversation, but technically they're frames.

The Role of ARP

When computers talk to each other, they need to know two addresses:

• IP address: Like knowing someone lives on "Main Street" (the general neighborhood)

• MAC address: Like knowing their exact house number

Before sending any actual message, computers first need to find each other. This is where ARP (Address Resolution Protocol) comes in. Think of it as sending a small note asking, "Where exactly do you live?" before sending the main letter.

Here's what happens:

1. Computer A wants to send a message to Computer B, but only knows B's street address (IP address)

2. Computer A first sends a special ARP packet (like a small inquiry note) asking: "Who has IP address 10.1.1.5?"

3. Computer B sees this ARP packet and responds: "That's me! My house number (MAC address) is 00:1A:2B:3C:4D:5E"

4. Computer A writes this down in its "ARP cache" (address book) for future reference

5. The switch also makes a note of this in its CAM table

6. ONLY THEN can Computer A send the actual message, now that it knows exactly where to deliver it

This ARP process happens automatically before any communication between computers that haven't talked before, or when saved address information has expired. The actual message data is only sent after this ARP handshake is complete.

Layer 2: The Switch's Domain

Switches operate at what network experts call "Layer 2" or the "Data Link Layer." This is simply the level of networking that deals with delivering frames between devices on the same network. It's concerned with MAC addresses (the physical addresses of devices) rather than IP addresses.

Think of Layer 2 as knowing the exact house numbers on a street, but not knowing how to get to different streets or towns.

Routers

While switches are excellent for connecting computers in the same neighborhood, routers connect different neighborhoods together.

Life Without Routers

With just switches, computers in the same neighborhood can talk easily. The switch knows everyone's "house number" (MAC address) and can deliver messages correctly.

But what if Computer A (address 10.1.1.80) wants to talk to Computer X (address 234.23.1.45) in a completely different neighborhood? The switch doesn't know how to get there!

Without a router, messages would never find their way to other neighborhoods.

Life With Routers

With a router (usually at address 10.1.1.1 in your neighborhood), here's what happens:

1. Computer A realizes Computer X is in a different neighborhood

2. Computer A needs to send its message to the router first, but doesn't know the router's MAC address

3. Computer A sends an ARP request: "Who has IP address 10.1.1.1?" (the router's address)

4. The router responds with its MAC address

5. Computer A can now send its message to the router's MAC address

6. The router examines the destination IP address (234.23.1.45)

7. The router forwards the message toward the right neighborhood

8. Eventually, the message reaches Computer X

A Detailed Look at Cross-Network Communication

Let's walk through exactly what happens when Computer A (IP: 10.1.1.80) in one network tries to communicate with Computer X (IP: 234.23.1.45) in another network:

1. Finding the Router: Computer A knows X isn't in its neighborhood, so it needs to contact the router (R) first

   • A sends an ARP message through Switch S1 asking: "Who has IP 10.1.1.1?"

   • This ARP request is broadcast to all devices connected to S1

   • Router R recognizes its IP and responds with its MAC address

   • Switch S1 delivers this response to A

2. Sending to the Router: Computer A now prepares the actual message

   • The message has two address layers:

     • Layer 2 (MAC) addresses: From A's MAC to Router's MAC

     • Layer 3 (IP) addresses: From A's IP (10.1.1.80) to X's IP (234.23.1.45)

   • This message goes through S1 to reach Router R

3. Router Processing: When Router R receives the message

   • It removes the Layer 2 wrapper (like taking a letter out of its first envelope)

   • It looks at the Layer 3 address to determine where to send it

   • It needs to create a new Layer 2 wrapper for the next part of the journey

4. Finding the Destination: Router R needs to find Computer X

   • R sends its own ARP request to Switch S2: "Who has IP 234.23.1.45?"

   • S2 broadcasts this to all computers in the second neighborhood

   • Computer X responds: "That's me! Here's my MAC address"

   • This response travels back through S2 to Router R

5. Final Delivery: Router R now forwards the message

   • It creates a new Layer 2 wrapper: From Router's MAC to X's MAC

   • It keeps the original Layer 3 addresses unchanged

   • The message travels through S2 to finally reach Computer X

This journey shows why both switches and routers are essential: switches handle delivery within a neighborhood using MAC addresses, while routers connect different neighborhoods and handle the transition between them.

Layer 3: The Router's Territory

Routers work at "Layer 3" or the "Network Layer." This layer deals with IP addresses and finding paths between different networks.

If Layer 2 is about knowing house numbers on a street, Layer 3 is about knowing how to navigate between different streets and towns using maps.

In an upcoming article, we'll explore all seven layers of the "OSI Model" - the complete framework that organizes all aspects of computer networking from physical cables to the applications you use daily.

A Sneak Peek at DNS

Just as you don't memorize your friends' phone numbers anymore (you just click their name in your contacts), computers use a system called DNS to avoid memorizing number addresses.

DNS (Domain Name System) is like a giant phone book:

• It translates friendly names like "google.com" into computer addresses like "142.250.190.78"

• When you type a website name, your computer first asks DNS, "What's the address for this name?"

• Once it knows the address, routers can deliver your message to the right place

This makes the internet much easier for humans to use - just imagine if you had to type number addresses for every website you visit!

Package Managers

As we all know package managers are programs that help you to manage packages. In linux, to download and use programs, there are primary 2 kind of package managers. One being dpkg and the other being apt. I’ll not waste your time and I’ll just give you a quick overview of these and also write out some important things about these 2

dpkg

This is the low level package manager that helps install packages after you download a .deb or .rpm file in your linux distro. Based on your distro you’ll download either .deb or .rpm.

This package manager is pretty dumb. Let’s say you download a .deb file but there are dependencies in that package, then you’ll have to manually download those dependencies at first and then you can download your application

So, most of the times, we tend to use the other package manager

apt

This is a high level package manager in your linux distro which is not dumb as dpkg. The main problem in dpkg was that you had to manually install the dependencies. But the case of apt is different. If your package has dependencies, it will automatically download it for you thus saving you a lot of time

Installing a package is very simple in this. Just type:

sudo apt install <package-name>

To see your installed packages, you can use this command:

sudo apt list --installed

To remove a command, you can use these commands

sudo apt remove <packagename> # doesn't erase user data and removes application

sudo apt remove <packagename> # removes the applicatio and also user data

Updating and Upgrading

The apt comes with utility commands for both updating and upgrading commands. The two commands being:

sudo apt update
sudo apt upgrade

The sudo apt update command fetches the latest information about available packages from the configured repositories. It essentially tells your system to check for any new or updated software packages that are available for installation or upgrade.

After running sudo apt update, the sudo apt upgrade command downloads and installs the newest versions of the software packages that are already installed on your system. It will only upgrade packages that have newer versions available.

You should use both commands together to ensure that your system is running the latest software and security patches. Running sudo apt update first is crucial because it provides the package manager with the latest information about available updates. Without it, sudo apt upgrade wouldn't be aware of the newest versions and might not install them

snap

Snap is another package manager which are used to download standalone applications which don’t normally interact with other processes. The applications installed using snap are installed in form of containers i.e they are installed in isolated environments with dependencies packaged at once

Normally it is used to download applications e.g vscode

Snap is being managed by a daemon named snapd. If you don’t have snap installed you can easily install it using:

sudo apt install snapd

Processes in Linux

To give you a simple overview processes are instances of running program. To see the processes running in your system, you can use this command

ps aux

Also you can use this command to see processes with realtime usage of CPU, MEMORY:

top # or
htop

You’ll be able to see all the processes that are currently running in your system

If you have vscode installed in your Linux system, do this experiment:

• Open vscode once and then run this:

    ps aux | grep code
  

• Close it and again run the same command

You’ll be able to understand that this returns the currently active processes. The grep part helps to sort out the processed based on the search term you provide

The processes that we open by ourself are known as interactive processes i.e we have to open then only the processes open

When you ran ps aux command, you were able to see a long list of processes. But you didn’t start them right? You will not be able to recognize most of those commands. So who started it?

Daemons

Well, those are system processes that start when your pc boots up. Those are known as daemons. Basically daemons are background processes that we don’t start, it starts at boot time automatically

These are also referred to as systemd units

Systemd

I did talk about what systemd on day 0. But here’s are some points that will give you the idea of what systemd is:

• The master daemon which looks after all the daemons

• This is also known as the service manager or the process manager

• The init system that I talked about in day 0

• Responsible for mounting fs, starting all services

Basically this is the 1st process after the boot cycle in your pc. To see a tree of processes that have ran when your system completed the boot lifecycle, you can use the command:

pstree

You’ll be able to see that the 1st and the topmost process of the tree is systemd

systemctl

This is the systemd utility that helps us to control all our daemons. With the systemctl command, you can start messing up with your background processes. Here are some commands that you can refer to get started:

sudo systemctl start <service>
sudo systemctl stop <service>
sudo systemctl restart <service>

To control weather a service will start at the system start or not, you can use the enable or disable command of systemctl:

sudo systemctl enable <service> # Enables a service at system reboot. Basically tells the pc that the service should start automatically when the pc boots up
sudo systemctl disable <service> # self explanatory

See list of active daemons

To check the list of active daemons, you can use this command:

sudo systemctl list-units

Here, you'll be able to see all kinds of processes including .devices, .services. To see only of type services:

sudo systemctl list-units -t service

Now you are well versed about how to inspect, check which processes are running. But what happens when you want to kill a running process?

kill

The kill command is used to kill a running process in linux. But to kill a process, you need to have a process id. But let me tell you one more command:

ps -u <username>

This command will list out all the processes which is running for a particular user

Now, let’s say you want to kill a process named “abc”. For that, you can use either of these 2 commands:

ps -u <userName> | grep <abc> # or
pgrep <abc> # only returns processid

Now once you have the process id, it is simple to kill a process with one command i.e:

kill <processId>

Conclusion

So, that it for today, I hope I was able to add some value to your life. Also with this article, hopefully we are done with linux as of now. Make sure to explore linux more and also a like and comment would really help me keep myself motivated in continuing this series. Thanks and see ya

I know, that on day 0 of this series I wrote a section in my article which was regarding the Linux File system. Then why again? Well, that was for basic understanding of the Linux filesystem. This will be kind of a deep-dive to the Linux filesystem where you’ll get to know where which thing is present. We will dive into the folders of linux where your configurations are present and have a look at them. So, let’s start:

Let’s start

When you open your terminal, to see where your terminal is open type pwd

Normally you’ll be in the /home/<yourusername> directory. The cd command will help you to change directory right? If you type cd .. it changes the directory to the previous directory. Let’s keep doing it till we reach the parent directory

cd .. # changes to /home/
cd .. # now you are in /
cd .. # doesn't have any effect as you are in the topmost root directory

Now that we are in the root directory, if you do an ls you’ll be able to see a bunch of files

We all know that in Linux based systems, everything is treated like a file. The commands that you type, the devices, network…. everything is treated like a file. So, where does these file lie?

When you do ls inside the / directory, you’ll be able to see a few directories. Some of them go by the names bin, sbin, tmp, dev, usr. These contain the important files that are needed to run your Linux kernel.

bin and sbin

If you do ls bin you’ll be able to see all the list of commands that you use including the one you used rn i.e ls.

Also, there is a dir named sbin. It is a shorthand notation for super bin. It contains commands that administrators can use. One of them is adduser. Here’s a small assignment: Read the manual of the adduser command it will help you to flex your knowledge in front of your friends

Now, let’s jump to the /usr/ dir

usr

Let’s cd to the user dir and see what’s present there by executing ls.

Hmm… There is a bin and sbin there also. If you cd into them and do an ls, you’ll be able to see some new files along with some same files like ls in bin and adduser in sbin. So which one is the real one?

Well, tbh both are real but why are the duplicates present?

Basically /bin holds essential binaries needed for booting and system recovery, while /usr/bin contains regular user applications. Originally, /usr could be on a separate partition, so /bin had to remain available even if /usr wasn't mounted yet

Quick review of other directories in the / dir

• boot contains the files essential for booting

• var contains the log files and essential web application files

• dev contains files about devices

• lib contains the essential shared utility files

Users in Linux

In Linux, when you login, you login as a user right? A user that you created while installing your OS. You can add new users and also check the name of the current user.

Who are you?

The terminal that you are using has an associated user account with it. To know about the user of the current login session, you can type whoami. It will show you the username of the current terminal session

Adding new user

To add new user, use the adduser command. But remember, it is not a normal command so make sure to use sudo

But everything is treated like a file right? So where are the users? To answer your question let’s jump to the home dir

The home dir

Navigate to the / dir first. Now, type ls home. There you’ll be able to see the name of users that you added earlier. It is the home where every user of your Linux system lives

Where is root?

Now, the administrators will not be normal users right? So, where do they live?

Well, they have a different home and the place where they reside is the /root directory. So, when you login into your Linux system normally through your gui, you login as a user. For getting root access to the terminal type sudo su root. And you’ll be able to see that the $ change to #. Which means now you are the root user i.e the administrator or you can call yourself the god of your Linux OS

Better way to check users

One way to look at users you created is by navigating to the home dir and listing the directories. But there is a better way to look at how many users are being created and are present in your machine. That’s what this command does

cat /etc/passwd

This file consists the list of all the users those are present in your system. You’ll be able to recognize the last one as it is the user that you just created.

If you check clearly, the last user will be like this:

test:x:1001:1001:Test,,,:/home/test:/bin/bash

Can I access passwords

The passwords of the user are present in a different file which is in /etc/shadow. But to access that you’ll need sudo permissions so make sure that you use the sudo command

sudo cat /etc/shadow

On typing this you will get the passwords of all the users in your system, the last one for me is this:

test:$y$j9T$A/LaMJOSt9gwnFARUecio0$/YjAeHOxHXmkUvbK5cBRHA0OZvJ0KxPtSq0uUUt4ve3:20205:0:99999:7:::

This is not the password I entered, this is the hashed version of it. So yes, you can definitely access the passwords but you can only access the hashed passwords

Let’s get back to the user

I am typing out how the user looked when I ran cat /etc/passwd again:

test:x:1001:1001:Test,,,:/home/test:/bin/bash

Let’s decode the components present here

• The first word test is its username

• x represents the password

• Then comes the user id(UID) i.e 1001

• Then is the group id i.e 1001

• Then the name

• Then the commas which were meant to be the extra set of metadata which we didn’t provide for which it doesn’t hold any value

• Then is the home directory where our user lives i.e /home/test

• Then the path of the shell that our user will use i.e /bin/bash

So the format is

username:x:UID:groupId:Name,data1,data2,data3,data4:homeDir:shellDir

But why user Id and group Id? You’ll get there soon but as of now let’s just keep this in mind that when you add a user using the adduser command, a group is being created and then a user inside that group is being created. In our case, the group test is being created and then the user test is being created.

useradd

There is a difference between the adduser and useradd command. The adduser command does a lot of work by asking you information about the user like the password and other metadata. It also creates a group

But the useradd is just like you and me. It’s lazy. So let’s see what it does:

sudo adduser test1

As you can see, the useradd command didn’t ask for any password or anything it just created it automatically. But wait, is it added to the users list? Let’s see the file where user info is present. So, type in cat /etc/passwd

Well, I definitely see test1 but there are a few things which are different:

• The name and additional data is not present

• The shell is /bin/sh and not bash

That’s why it is called lazy. It comes in handy when you want to add multiple users so that you don’t have to spend time configuring them

We didn’t give it a password right? Let’s check the /etc/shadow file and see if it is present using the command sudo cat /etc/shadow

Well, we definitely see an entry for our user but we don’t see a password. Okay let’s fix it by giving test1 a password

passwd

To set the password for our user test1, we’ll use the passwd command and obv we’ll have to use sudo because this is a sensitive command which requires administrator previllages

sudo passwd test1

Now, let’s check the /etc/shadow file:

sudo cat /etc/shadow

There we go, we see something. But the shell assigned to test1 is sh and not the bash shell. Let’s fix that

usermod

To modify a created user, we use the usermod command. To know about the usermod command, type out usermod -h. There you’ll be able to see the option -s to modify the shell.

To modify the shell, just type out

sudo usermod test1 -s /bin/bash

Now, if we check the /etc/passwd file to see the configs, you’ll be able to see that the shell has been updated

su command

Now to change the user in your running terminal session, you will have to use the su command. It basically means switch user.

sudo su test1

If you don’t type test1 then you’ll be logged in as the root user which is not a good idea anyways cuz if you mess something up as the root user, it will be bad for your system

Well, now we are logged in as the user test1. Let’s check the passwords file once again:

Well, we get an error. It says that test1 is not in the sudoers file. What is that? Let’s explore

The sudoers file

The sudoers file is a very very important file in your Linux filesystem that you don’t want to mess up by any means because if you do so, your whole linux system can get messed up. So, there are multiple text editos available to view and edit the sudoers file including vim, nano. But the safest way is to use visudo. So let’s exit as test1 and get back as the normal user and check the file

sudo visudo

You might want to scroll down a little till you see this:

Under the user previllage specification, you can see which users have the sudo access and then you can see the syntax for which group has the sudo access. Let’e quickly get through the syntax for a single user for now and experiment with it for a bit:

# to give test1 all sudo command previllage
test1 ALL=ALL

# to give access to only one command previllage you can use the path of that command in the sbin dir
test1 ALL = /sbin/adduser # only gives access to the adduser command

For now, I’ll give test1 all previllage. So once I write test1 ALL=ALL, I’ll press Ctrl+S to save and Ctrl+X to exit.

Now let’s switch the user to test1 and chek if we can execute the sudo command or not

Well, yes we could add our user

userdel

Now let’s delete our newly created user cuz we don’t need hello rn. To do that, let’s use the userdel command. You can again check the passwd file to check if the user has been added or not:

sudo userdel hello

Now, let’s exit out of that login session and login as the default user by typing exit. Now let’s explore groups.

Groups

As the name suggests, groups are simply sets of users who are combined into a single group. Let’s do some basic operations on groups

groupadd

To create a new group, we use the groupadd command. Let’s create a hello group

sudo groupadd hello

You can see all the groups in the /etc/group file. Just use this command and you’ll be able to see all the groups in your system

cat /etc/group

Here are my last 3 lines of that command:

Now let’s add a few users. For now, I’ll just add world1 and world2 and also give them a password. Now, let’s add them in the group

usermod -aG

To add users into a grop, we use the usermod -aG <groupname> <username> command. In our case, to add user world1 to our group, we’ll have to use this command

sudo usermod -aG hello world1

Similarly, add world2 also. Then, when you see the file /etc/group you’ll see this:

Thus world1 and world2 has been successfully added to this group

Since we didn’t update the sudoers file for world1 and world2, so it will naturally not have sudo access. You can check it

But instead of that, we are now going to give the group hello sudo access. So that world1 and world2 both have sudo access. Let’s openup the sudoers file using sudo visudo command and add this line on the groups section

Basically when you type %<name> it specified the group name. Now you can easily execute sudo commands in that group. Check it yourself by switching the user.

Now, let’s try to remove the users from the group

gpasswd

To remove the users from a group, we’ll have to use the gpasswd command. Yes, I know the name says something different, but we have no choice. Use this command to remove user world1 from group hello.

sudo gpasswd -d world1 hello

Now, check if world1 still has sudo access or not, also try to remove world2 from the group

groupdel

For deleting a group, we can use the groupdel command. In our case to delete the group named hello, we’ll use:

sudo groupdel hello

Summary

Let me sum up everything so that you can only use this section to revise the commands quickly:

Linux Filesystem Structure

• The root directory / is the top-level directory containing essential system folders

• /bin and /sbin contain essential commands (binary executables)

  • /bin has regular user commands like ls

  • /sbin (super bin) contains administrator commands like adduser

• /usr/bin vs /bin: Both contain commands, but /bin has essentials needed for booting, while /usr/bin has regular applications

• Other important directories:

  • /boot: Files essential for booting

  • /var: Log files and web application files

  • /dev: Device files

  • /lib: Essential shared utility files

  • /home: Where user directories are stored

  • /root: Home directory for the root user (administrator)

User Management

• whoami: Shows current user of terminal session

• adduser: Creates a new user with full configuration prompts

• useradd: Creates a new user with minimal configuration (the "lazy" version)

• User information is stored in:

  • /etc/passwd: Contains user details (username, UID, GID, home directory, shell)

  • /etc/shadow: Contains hashed passwords (requires sudo access)

• passwd: Command to set/change user passwords

• usermod: Modifies user settings (like changing shell with -s option)

• su: Switches between users in the terminal

• userdel: Deletes users

Group Management

• Groups allow organizing sets of users with similar permissions

• groupadd: Creates a new group

• Group information is stored in /etc/group

• usermod -aG: Adds users to a group

• gpasswd -d: Removes users from a group

• groupdel: Deletes a group

Sudo Access Management

• The sudoers file controls which users/groups have admin privileges

• Best edited with visudo for safety

• Individual users can be given sudo access with: username ALL=ALL

• Groups can be given sudo access with: %groupname ALL=ALL

• Access can be limited to specific commands

Conclusion

Now you know how to poke around the file system, add users when your computer gets lonely, and play permission games with sudo. Not too shabby for a day's work!

Just remember - when in doubt, there's always Google... or you could just try random commands until something works. That's the Linux way! (Kidding, please don't do that.)

Thanks and see ya

Command Line Components

The commands that you type on your fancy linux terminal normally consists of 3 components:

• Command: The name of the program that you want to execute

• Options: As the name suggests, these are options that can be passed to the command to perform variety of tasks

• Arguments: These act as a critical metadata for the options that they are being passed to in the command

There are plenty of commands that don’t have options, arguments or neither

sudo

Sudo refers to superuser do. sudo commands give admin privileges to the user while runtime of the commands. In ubuntu sudo is setup during the installation time, in other distros you might need to put your laziness aside and configure it manually.

Virtual Terminals

Now this is something cool that you can showoff. If you are like me and use an ubuntu system, you can simultaneously open another session that is different from what you are running here.

Virtual Terminals (VT) are basically console sessions that take up you complete screen and keyboard outside of a graphical environment. These are not the terminal that you start inside your gui after you start your ubuntu, you can have as many of them as possible

These are called virtual because, although there can be multiple active terminals, only one will be visible to you. Normally, one virtual terminal (either VT1 or VT7) is being reserved for the GUI of your linux based OS

To switch betwee VTs, you can press Ctrl + Alt + Function key. If you are in ubuntu like me, the place where you see this blog is in VT1. You can switch to another VT by Crtl + Alt + F3 or F4 or F5…. To switch back, you’ll need to press Ctrl + Alt + F1 or F2 again

Basically the function keys are assigned to the VTs, the number of the function key maps to the number of the VT that you’ll use

Now, you can showoff

Turning off your GUI

There’s a fancy GUI developed by smart bros so that you can use your linux distros better. In new operating systems, the GUI can be easily turned off or on as it is treated as a service. In day 0, I wrote about how to turn off a service right? Yes, the systemctl command.

To turn on or off your GUI, you can use these simple set of commands

# For turning off
sudo systemctl stop gdm

# For starting the gui
sudo systemctl start gdm

Basic command line operations

Login

Use the ssh command to login to your system. e.g: ssh hello@world

Shutdown and restart

Use shutdown -h now to shut down your pc immidiately

Use shutdown -r to reboot

Locating Applications

Based on your OS, programs and softwares can be present in multiple directories. In general, the binary and the executable scripts are present in /bin, /usr/bin, /sbin, /usr/sbin directories, or somewhere under /opt. They can also appear in /usr/local/bin and /usr/local/sbin, or in a directory in a user's account space, such as /home/student/bin.

To locate your programs, you can use the whereis command. If you have python3 installed in your linux distro, you can try writing whereis python3

Creating and Accessing directories

• pwd: Displays your current directory

• mkdir dirname: Makes a new directory with name “dirname”

• cd dirname: Change your current directory to dirname

  • cd : Changes to your home directory

• cd ..: Change to the parent directory

• cd -: Change to previous directory

• ls: Lists the contents of that directory

Hard links

Hard links are like another name for an existing file. When you create a hard link, both the original file and the created hard link point to the same inode. If the original file is removed, the hard link still can access the data.

Let’s create a file name file1 and create a hard link for file 1 named file2

# creates a file
touch file1
# creates a hard link
ln file1 file2

Now, if you want to see the 2 files using the ls -li tag, you’ll be able to see the inode number of the file in the 1st column.

You can clearly see that the inode numeber is same for file1 and file2

Soft links

Unlike hard links, soft link is like a shortcut to an existing file. If the original file is removed, the soft link is broken as it points to nothing

To create a softlink, use ln -s command:

Now, after creating a soft link to file1 you can clearly see that the inode is different

Working with files

Viewing files

NOTE*: Use* / to search for a pattern in the forward direction and ? for a pattern in the backward direction. An older program named more is still used, but has fewer capabilities: "less is more". | | tail | Used to print the last 10 lines of a file by default. You can change the number of lines by doing -n 15 or just -15 if you wanted to look at the last 15 lines instead of the default. | | head | The opposite of tail; by default, it prints the first 10 lines of a file. |

Creating files

Use the touch <filename1> <filename2> command to create multiple files in your current directory. To create directories, use the mkdir command

Deleting files and folders

To remove a particular file, use rm <filename> and to remove a folder use rmdir <dirname>. Now, if you want to remove a directory with embedded directories and files which are not empty, then you’ll have to use rm -rf <dirname> command

# remove file
rm file1

# remove directory
rmdir dir1

# remove non empty directory with files and embeded directories
rm -rf dir1

Moving, renaming

The mv command is used to rename a file. Fundamentally if you see, moving a file to another directory is same as renaming the file. Do it practically

# create two folders test1 and test2
mkdir test1 test2

# cd to test1
cd test1
# create a file name hello.txt
touch hello.txt

# cd to the root
cd ../
# see the contents of test1
ls test1/

# now rename the file hello.txt to world.txt
cd test1
mv hello.txt world.txt
# see the contents of test1 now
ls

# cd to the root dir
cd ../

# see contents of test2
ls test2/

# now, we'll move the world.txt file to test2
mv test1/world.txt test2/world.txt

# now check the contents of test1 and test2
ls test1
ls test2

# rename the dirname test2 to test3
mv test2/ test3/

# check again
ls test3

Through this practical exercise, you’ll yourself be able to understand about the mv command. Help yourself by not being lazy and try this

I forgot commands!

As you can see, there are multiple commands in linux. For file handling, for file searching, for copying files, removing files. There are a lot of commands and it is not possible to inspect through every one of them

Using the man command

Smart folks at linux got you covered. If you want to inspect the info about a command, you can use the man command. For example, if I want to know about a command named adduser, I can just type out man adduser and it will show me detailed manual of that command

Here’s what happens when I type man adduser in my terminal. Now, you can do that too, you can inspect through the document of any command and use your arrow keys to read about it

Using the apropos command

But you might think, what happens when we don’t know a command and want to search for it. Let’s say you want to search about which command will help you compress your file. What will your do then?

Well well, just use the apropos command. In our case, to search commands about compression, we’ll just have to type out apropos compress. Yes, it’s that simple

You will get the list of all commands which have the word “compress” in their manual

Conclusion

So, today let’s leave it here itself. Try out some commands in linux and make sure you don’t forget the man and apropos command as it will act as your in your journey to explore linux. We’ll dive deeper into the linux filesystem in the next article, till then keep learning and thanks

Linux Philosophy

Linux was inspired heavily by UNIX. At that time when linux was built, UNIX was not for rookies like you and me. It was built for computers which were much more powerful than ours PCs and were very expensive (IDK about you but I am broke af so I couldn’t buy it)

Linux stores files in a hierarchical file system with the top node being /root or /. In linux, everything including devices, processes, network sockets are treated like a file. Files are not just .txt or .pdf, everything acts as a file (but are not actual files)

Why?

Cuz it makes life easier

How?

• Let’s say you want to read something from your keyboard. It’s easy to read it directly from a file named /dev/keyboard

• Let’s say you want to send something to your printer. It’s easy to write something to a file named /dev/printer

So, you see reading data and writing data in files is very simple. That’s why everything is treated like a file. If you have a linux distro like ubuntu, arch or anything, just open your terminal and type cat /proc/cpuinfo. You’ll be able to see information about your cpu in it

So everything is treated like a file as doing operations like read, write, rename, copy and others are easy in a file that’s why smart bros at linux adopted this philosoply

Fancy Terminologies

These are some terms you should know about Linux that will impress your non-tech friends (or techie friends with low knowledge bandwidth)

• Kernel: I gave a definition previously which is an oddly simple definition

• Boot loader: As the name suggests, it is the program that boots up the operating system

• Services: Programs that run as background processes

• fs (filesystem): The way by which files are organized and managed. e.g: ntfs, ext3, FAT

• X window system: The X window system provides the standard toolkit and protocol for building gui on nearly all linux systems

• Desktop Environment: The GUI built on top of operating system

• Command Line Interface (CLI): The interface used for typing commands

• Shell: The CLI that interprets the command line input and instructs OS to perform necessary tasks based on the user input

• Distributions: A full Linux distribution consists of the kernel plus a number of other software tools for file-related operations, user management, and software package management.

The Boot Process

The boot process is the process by which your system gets initialized. It consists of different processes from powering on your computer to the user interface that you see

But why is it important? It might help you troubleshoot your problems while using your linux based OS

This is the diagram of the internal processes which helps to see your GUI after you power on your pc. Now, I’ll try to explain each part of it

Power On - The Step 0

You already know it

BIOS

When the computer is powered on, the Basic Input/Output System (BIOS) initializes all the hardware components including screen, keyboard in your pc and tests the main memory. This process is called Power on Self Test (POST)

The BIOS software is then stored on your ROM chip in the motherboard. Then the remaining of the boot process is handled by your OS

Boot Loader, MBR, EFI

Well, in the diagram MBR and EFI was before boot loader but its better to study all these together cuz it will ultimately get interliked

After The POST process, the system control is passed to the boot loader. The boot loader is stored on the persistent storage like your slow HDD or fast SSD in either the boot sector (for MBR partition systems) or the EFI partition sector. Then the information on date, time and other settings are being loaded from the CMOS.

Stages

The boot loader has 2 distinct stages:

In BIOS/MBR systems, the boot loader is stored in the first 512 bytes of the hard drive, called the Master Boot Record (MBR). It checks the partition table, finds a bootable partition, and loads a second-stage boot loader like GRUB into RAM.

In UEFI systems, the UEFI firmware reads its Boot Manager to find and launch a UEFI application like GRUB from the EFI partition. This process is a bit more complex but more flexible than MBR.

The second-stage boot loader (stored in /boot) shows a menu to pick an operating system or kernel. Once selected, it loads the kernel into RAM

2 lines to summarize boot loader

The boot loader is responsible for loading the kernal into the RAM so that the computer system can start

It loads the kernel into RAM because RAM is much faster than storage devices, and the CPU can only run programs directly from RAM, not from the hard drive or SSD

Initial Ram Disk

The initramfs is the filesystem image that consists of programs and binary files that contains instructions about mounting proper root fs, kernel functionality, locating devices and driver and then load them. Then it checks for errors in the root filesystem

After the mount program instructs the OS that the filesystem is error free and ready to use, the initialization program (sbin/init) is run after the initramfs gets cleared from the RAM.

Command Shell Using getty

After the init command is executed, the terminal loads up for you to login to your linux OS.

getty is the program that opens the terminal, displays the login prompt, and then hands over control to the login process once you enter your username.

Kernel, init and Services

The Linux Kernel

The boot loader initializes the kernel and the initial RAM file system (initramfs). After the kernel instructions are loaded to the RAM, it immediately initializes and configures the computer memory and all the hardware attached to the PC

/sbin/init and Services

After the kernel sets up the necessary hardware components and mounts the file system, the init process is executed. It is the initial process that gets other systems running. Besides starting the system, the init process is also responsible for starting the PC and shutting it down correctly.

Startup Services

When your system starts, there are scripts that are responsible to start your system. Old Linux boot systems (SysVinit) started things one by one, slowly and step-by-step, which didn’t use modern multi-core processors well.

Back in those days, boot time was not considered as a very vital thing, but then it become a major deciding factor among users. No one wanted a slow ass system which would take long time to boot. To fix this, newer systems were developed:

• Upstart (by Ubuntu, around 2006) — used for a while but later dropped.

• systemd (adopted widely from 2011) — now used by almost all Linux systems.

systemd

Systems with systemd starts up a service much faster than the other init methods. This is mainly because it replaced linear sequential steps to parallel steps. One systemd command (systemctl) can be used to start or stop any services in your pc

Small Exercise using systemctl command

Let’s do a worthless experiment to check the systemctl command:

• In your pc, there is a service named Apache Web Service

• I am using ubuntu so to install Apache Web Service, I’ll run these commands

  •     sudo apt update
        sudo apt install apache2
    

• Now, to stop this service run sudo systemctl stop apache2

• To start this service run sudo sysemctl start apache2

• To check its status run sudo systemctl status apache2

Linux Filesystems

Intro

Different types of filesystems supported by Linux:

• Conventional disk filesystems: ext3, ext4, XFS, Btrfs, JFS, NTFS, vfat, exfat, etc.

• Flash storage filesystems: ubifs, jffs2, yaffs, etc.

• Database filesystems

• Special purpose filesystems: procfs, sysfs, tmpfs, squashfs, debugfs, fuse, etc.

Let’s learn about these now

Partitions and Filesystems

Partition is basically a part of your entire physical storage device that acts as a whole storage volume

A filesystem is a method of storing and accessing files inside a partition

Filesystem Hierarchy

As mentioned earlier, linux uses a filesystem hierarchy to store different files. If you want to know more about this hierarchy, you can read a 50 page pdf written by our smart bros at linux: File System Hierarchy

Some important info:

All Linux filesystem names are case-sensitive, so /boot, /Boot, and /BOOT represent three different directories (or folders). Many distributions distinguish between core utilities needed for proper system operation and other programs, and place the latter in directories under /usr (think user). To get a sense for how the other programs are organized, find the /usr directory in the diagram from the previous page and compare the subdirectories with those that exist directly under the system root directory (/).

Conclusion

Let’s leave this much for today, I hope I was able to add some knowledge to your knowledge stack. One like would really help to keep me motivated. Anyways, thanks for reading

In offline voting systems, if you bribe a person about voting for party A, you don’t get the choice to verify if the person voted for party A or not. But if the person is casting the vote on chain, anyone can publicly see the party you have voted for as it is decentralized. To eliminate this collusion, the concept of MACI (Minimal Anti Collusion Infrastructure) keys were introduced

Voting Systems

I know many of you might think that knowing about voting systems makes no sense, but I would request you to just go through it once again

In-person voting systems​

In short, it's hard to know for sure how current voting systems operate. Governments and corporations spend lots of resources on their systems and processes in an attempt to ensure their integrity, but ultimately neither the systems nor the processes are fully auditable, so we must trust that these security properties are being enforced.

Blockchain voting systems​

Blockchains offer two main features: correct execution and censorship resistance. They process user transactions based on set rules, ensuring no changes to these rules. Anyone can send a transaction if they pay the required fee.

However, blockchain voting has issues. Ethereum, like most blockchains, is transparent, meaning all transaction data is public. This lack of privacy makes bribery easy, as voters can show proof of their vote. Bribery can even be automated with smart contracts, making collusion easy.

Blockchain voting systems (with ZKPs)

Zero-knowledge proofs (ZKPs) allow private voting on blockchains like Ethereum while keeping results public and verifiable. Votes are counted off-chain, but ZKPs ensure they are accurate without showing individual votes.

WTF is MACI?

MACI stands for Minimal Anti Collusion Infrastructure. As the full form suggests, it is an anti-collusion infrastructure made so that on chain voting can be reliable, private while also being censorship resistant. It leverages zk-SNARKs technology to achieve this

Workflow of the entire voting cycle with MACI

There is a detailed article about the workflow on the official MACI docs. I’ll just summarize everything in short

In the voting system, there are 2 parties that are being involved:

1. The User: Who casts the vote

2. The Coordinator: Who verifies and publishes the final results of the vote based on the users choices

   We will always assume that the coordinator is not corrupted

After the poll starts this is what users will have to do to create their vote

Signing Up

Before casting the vote, users will have to generate a public, private keypair which will act as their anonymous identity as the voter. The user will make a function call to the signUp() function of the maci smart contract and register their generated public key as the voter

Casting the Vote

Casting the vote involves a few steps

• Command Creation: The user bundles their vote information (public key, vote option, amount, etc.) into a command.

• Signing: The user signs this command using their private key (from signup) to prove their identity.

After signing the message, comes the part of encryption:

• A unique shared key exists between each user and the coordinator

• The user encrypts both the command and signature together into a message

• This encryption prevents bribers from seeing vote choices in transaction data

Once the encryption is done, the encrypted message can then securely be passed to the contract where it is verified and stored.

VOTE ENDS

A Poll is "closed", when the voting period ends. At this point, no users may submit any more votes. The Poll remains closed until the coordinator tallies the final results.

At this point, the coordinator must process all the messages, tally the results, and publish the proofs on-chain

Hmm.. How did it resist collusion?

Ever wondered how MACI makes vote buying impossible? At its core, MACI uses a clever system of encrypted messages and shared keys. Think of each vote as a letter sealed with special ink – only the voter and the vote counter have the unique ink formula to read it. Even if someone tries to buy votes, they're out of luck. Why? Because even if a voter shows them their voting transaction on the blockchain, all they'll see is encrypted data – like trying to read a letter written in invisible ink without the decoder.

But here's where it gets interesting. Voters can change their votes as many times as they want, and only their last vote counts. Imagine trying to buy someone's vote when they can simply vote again later, completely nullifying their "sold" vote. And the best part? There's absolutely no way to prove if or when someone changed their vote.

The vote counter (called the coordinator) can see and count the votes, but they have to provide mathematical proof that they counted everything correctly. It's like having a referee who has to show their work, making it impossible to fudge the numbers. This creates a perfect balance: complete privacy for individual votes, but total transparency for the final count.

The result? A voting system where even if voters wanted to sell their votes, they simply couldn't prove how they voted. It's like trying to sell a secret when you can't prove you know it – mathematically impossible.

The End

This article is intended to provide you an overview of how BLOCKCHAIN VOTINGS ARE COLLUSION RESISTANT it doesn’t go into the depth of how MACI keys work. If you want to know everything in depth, then refer to the official docs of MACI

Sometimes Artificial Intelligence and Machine Learning are considered to be the same even if they have a difference between them

Artificial Intelligence vs Machine Learning

Imagine, there is a toy robot that can perform different tasks like singing a song, or solving puzzles. This robot is an example of Artificial Intelligence as it can do tasks that require human intelligence.

Now, let's say the robot learns to do a new task like catching a ball or writing a blog article by watching someone else do it a few times. That's what we call Machine Learning (ML). The robot learned how to catch a ball, and write blogs without being explicitly programmed to do so.

The example above gives a brief idea about the difference between Machine Learning and AI. The example is taken from ChatGPT, the modern powerful AI.

So, when I asked this question to ChatGPT, it found an answer which met the needs of my question and answered the question. It did a task that required human intelligence. So, that is why we call Chat GPT an AI

## CHAT GPT PROMPT
differentiate ai and ml such that it can be understood by a 6 years old boy

Now, let's go back to the time when it was created. It was provided a sample set of data which contained a bunch of prompts and their answers. From that data, it learned to answer questions like this. An algorithm was used so that it can extract the data and find patterns between them. Thus, it learned how to answer these kinds of questions by finding similar patterns in data. This process by which the algorithm learned to answer these kinds of questions is a process of Machine Learning.

Roadmap

I have seen many roadmap videos on YouTube and some stuff is common in every Machine Learning Roadmap video. So, I'll give you a detailed roadmap of Machine Learning

A. Mathematics

It is the backbone of machine learning, providing the tools and concepts needed to understand and apply the algorithms and models used in the field. The topics of mathematics required for Machine Learning are:

1. Linear Algebra

2. Statistics and Probability

3. Calculus

Let's learn the importance of these topics

Linear Algebra

Linear Algebra helps in playing with numbers arranged in rows and columns (known as matrices). Imagine, you have a toy box with many toys in it. Each toy can be represented as a number. Linear Algebra helps to work with these kinds of matrices by performing operations like addition, subtraction, and multiplication and it can help to find patterns in the numbers.

So, imagine you have a toy robot that you want to teach to make decisions based on lots of data. You can use Linear Algebra to help the robot understand and analyze the data.

Statistics and Probability

Imagine you want to teach a robot to predict the weather. Statistics and Probability can help the robot understand how likely it is to rain based on past weather data. The robot can then predict the weather.

We use Statistics and probability to help our toy robot guess what might happen in the future, based on what has happened in the past.

Calculus

Calculus is like a GPS system for the robot that helps it find the best way to learn. Just like a GPS helps us find the quickest route to a destination, Calculus helps our robot find the quickest and easiest way to learn new things.

So, the work of optimizing ML algorithms (also called models) is done by Calculus

You don't need to learn everything about these. You can do a Ph.D. in these topics and spend most of your life learning about Maths and not ML also. But if you want the fast way, then learn these specific topics

Linear Algebra Topics

1. Vectors and vector operations:

   • Definition and representation of vectors

   • Vector addition and subtraction

   • Scalar multiplication

   • Dot product and cross product

   • Length and normalization of vectors

   • Angle between vectors

   • Orthogonal and orthonormal sets of vectors

2. Matrix operations:

   • Definition and representation of matrices

   • Matrix addition and subtraction

   • Scalar multiplication

   • Matrix multiplication

   • Transpose of a matrix

   • Trace of a matrix

   • Determinant of a matrix

   • Inverse of a matrix

3. Determinants, inverses, and eigenvalues/eigenvectors:

   • Determinant of a matrix and its properties

   • Inverse of a matrix and its properties

   • Eigenvalues and eigenvectors of a matrix

   • Diagonalization of matrices

   • Characteristic polynomial of a matrix

   • Jordan form of a matrix

4. Linear systems of equations and Gaussian elimination:

   • Solving linear systems of equations using Gaussian elimination

   • Gauss-Jordan elimination

   • LU decomposition

   • QR decomposition

   • Singular value decomposition (SVD)

5. Orthogonality and projections:

   • Orthogonal and orthonormal sets of vectors

   • Projections and orthogonal projections

   • Orthogonal basis and orthonormal basis

   • Orthogonal matrices and orthonormal matrices

   • Gram-Schmidt process

6. Singular value decomposition (SVD):

   • Definition and properties of SVD

   • Computing SVD of a matrix

   • Applications of SVD in data compression and denoising

   • Low-rank approximations of matrices

7. Principal Component Analysis (PCA):

   • Definition and intuition behind PCA

   • Computing the principal components of a dataset

   • Dimensionality reduction using PCA

   • Applications of PCA in data visualization and feature extraction

8. Matrix factorization methods:

   • Non-Negative Matrix Factorization (NMF)

   • Latent Dirichlet Allocation (LDA)

   • Collaborative Filtering

9. Least squares optimization and gradient descent:

   • Least squares optimization

   • Gradient descent algorithm

   • Stochastic gradient descent (SGD)

   • Convergence analysis of gradient descent

   • Batch gradient descent vs. stochastic gradient descent

Statistics and Probability Topics:

1. Probability:

   • Axioms of probability

   • Conditional probability

   • Bayes' Theorem

   • Joint and marginal distributions

   • Independence and dependence

   • Random variables and expected value

   • Variance and covariance

2. Probability Distributions:

   • Discrete distributions (Bernoulli, Binomial, Poisson, etc.)

   • Continuous distributions (Uniform, Normal, Exponential, etc.)

   • Characteristic functions and moment generating functions

   • Estimation of parameters (Maximum Likelihood, Moment Estimation, etc.)

   • Convergence in distribution

3. Hypothesis Testing:

   • Null and alternative hypotheses

   • p-values and significance levels

   • Type I and Type II errors

   • One-sample and two-sample tests

   • t-tests and ANOVA

   • Chi-square tests

4. Confidence Intervals:

   • Definition and properties of confidence intervals

   • Central Limit Theorem and normal approximation

   • t-intervals and proportion intervals

5. Regression Analysis:

   • Simple linear regression

   • Multiple linear regression

   • Logistic regression

   • Polynomial regression

   • Regularization (Ridge, Lasso, etc.)

6. Statistical Inference:

   • Point estimation

   • Interval estimation

   • Maximum Likelihood Estimation

   • Bayesian inference

   • Central Limit Theorem and Law of Large Numbers

7. Machine Learning specific topics:

   • Overfitting and underfitting

   • Bias-variance tradeoff

   • Cross-validation

   • Regularization

   • Maximum likelihood and maximum a posteriori (MAP) estimation

Calculus Topics

1. Differentiation:

   • Limits and derivatives

   • Rules for differentiation (power rule, sum rule, product rule, chain rule, etc.)

   • Partial derivatives and gradient

   • Jacobian matrix

   • Implicit differentiation

2. Integration:

   • Indefinite and definite integrals

   • Fundamental Theorem of Calculus

   • Techniques for integration (substitution, integration by parts, partial fractions, etc.)

3. Multivariate Calculus:

   • Partial derivatives and gradient

   • Hessian matrix and second partial derivatives

   • Laplacian and Laplace's equation

   • Extrema of multivariate functions

   • Constrained optimization and Lagrange multipliers

4. Differential Equations:

   • Ordinary Differential Equations (ODEs)

   • Separation of variables, Euler's method, and Runge-Kutta method

   • Partial Differential Equations (PDEs)

   • Heat equation and wave equation

5. Probability and Statistics:

   • Probability distributions (discrete and continuous)

   • Expectation and variance

   • Joint and marginal distributions

   • Conditional probability

   • Correlation and covariance

6. Optimization:

   • Unconstrained optimization and local minima/maxima

   • Constrained optimization and Lagrange multipliers

   • Gradient descent and stochastic gradient descent

   • Newton's method and quasi-Newton methods

   • Convex optimization

B. Programming

1. Programming with Python

2. Libraries:

   1. Numpy

   2. Pandas

   3. Matplotlib

Now, you have a solid foundation in Mathematics and programming. So, the next step is to learn the basics of ML algorithms

C. Basics of ML Algorithms

1. Supervised Learning:

   • Linear Regression

   • Logistic Regression

   • Decision Trees

   • Random Forest

   • Support Vector Machines (SVM)

   • K-Nearest Neighbors (KNN)

   • Naive Bayes

2. Unsupervised Learning:

   • K-Means Clustering

   • Hierarchical Clustering

   • Density-Based Clustering

   • Principal Component Analysis (PCA)

3. Reinforcement Learning:

   • Markov Decision Processes (MDP)

   • Q-Learning

   • Monte Carlo Methods

4. Deep Learning:

   • Neural Networks

   • Convolutional Neural Networks (CNN)

   • Recurrent Neural Networks (RNN)

   • Long Short-Term Memory (LSTM)

   • Autoencoders

5. Model evaluation techniques:

   • Overfitting and underfitting

   • Bias-Variance tradeoff

   • Cross-Validation

   • Hyperparameter tuning

Now, you have become an intermediate in ML. Its time to upgrade your ML sword now. To sharpen your sword of ML, you must Practice. One great resource is Kaggle

How to Learn

In this article, you have seen the roadmap for learning Machine Learning. But there are some techniques I would like to tell you which will accelerate your learning process.

I have given you individual topics. So, you can search them in sequence one by one on YouTube and Google and you can gather the explanation from there.

I would like to tell you about one of the newest techniques for simplifying your understanding. If you are here, you might know about ChatGPT

You can use that as a tool to accelerate your learning process. Here's how you should learn for a simplified and better understanding:

1. Let's say you want to learn a specific topic from the list

2. Go to Chat GPT and write this prompt

   •     Write a basic article on [topic] so that a child can understand it
     

3. Now, once you know the overview of the topic you are learning, you can search on YouTube or Google for a better understanding

4. Exception: Let's say you didn't understand a subtopic of the topic you are learning (read the sentence again) from YouTube after following my steps. Then repeat the 2nd step and just change [topic] to your [subtopic]

Conclusion

And there you have it folks, everything you need to know about Machine Learning, and the way to learn it. Whether you're a toy robot trying to learn how to solve puzzles or a human trying to understand the complexities of AI, this article has got you covered.

So, dive into the world of ML. And let me tell you one little secret. I have used Chat GPT intensely to make this article also. It gave me an explanation of the robot which I used earlier. The subtopics are also generated by it. So, use ChatGPT and remember one thing that I learned from Kunal Kushwaha's Twitter handle:

AI will not replace you. A person who is using AI will replace you.

Machine Learning is the study of computer algorithms that improves themselves through data

In normal programming problems, we provide the data and some set of rules on which the data is processed and we expect the answer as output. In ML problems, we provide the answers and data to the program and the program finds the rules which connect the data to the answers. These relations are generated during the training process

Fundamental Ideas

• All problems are data and all solutions are relations/functions: In ML problems, we need our answers and data to give to our algorithm as input. The work of the algorithm is to find out the relation between the answers and the data we provided

• We convert qualitative inputs into numbers which become the input data. We call these numbers INPUT VECTORS

• Similarly, the answers or the output we need after training the ML algorithm has to be also converted into numbers which are called OUTPUT VECTORS

• As written earlier, the goal of that algorithm is to find out the relation between the INPUT and OUTPUT VECTORS

Steps in Machine Learning

1. Gathering Data: We need to gather the data that is needed to train the machine

2. Preparing Data: We need to prepare the data to be used in that algorithm

3. Choosing a Model/ Algorithm that meets the needs

4. Training the model on the data

5. Testing Model

6. Hyperparameter Tuning: Tuning the model using parameters whose values are used to control the learning process

The above 6 steps are steps of Training/ Testing the model

1. Prediction: After everything is done, you will deploy your model and then it can be used for the prediction of your needs

Mathematics for Machine Learning

Linear Algebra

ML is about the mapping of INPUT VECTORS to their corresponding OUTPUT VECTORS. To map these vectors, we need to use matrix-based transformations

So, we need to know about Matrices and Vectors in Linear Algebra

Probability

There can be uncertainty in data, e.g if you want to make an algorithm, that predicts the prices of stocks, there can be uncertainty

So, we need to know about PROBABILITY

Statistics

It is the science of collecting, analyzing, presenting and interpreting data. So, we need to use it in the process of Preparing data

Calculus

Optimization of data is done using concepts of calculus

Matrices are a vital part of machine learning, as they are used to represent data in a structured and organized way. In this article, we will discuss the basics of matrices and how they are used in machine learning. We will also discuss some of the different types of matrices and how they can be used in Machine Learning algorithms

What is a Matrix?

A matrix is a two-dimensional array of numbers, symbols, or expressions. In machine learning, matrices are used to represent data sets and to make calculations on them. Each element in the matrix is called a matrix entry or an entry. Entries are arranged in rows and columns, which makes a matrix appear like a table.
Matrices are typically used to store and manipulate multi-dimensional data sets. For example, if you want to analyze the performance of a machine learning algorithm on a data set, you would use a matrix to store the data and then work with it to analyze the results.

Types of Matrices

1. Identity Matrix: An identity matrix is a square matrix with all diagonal entries equal to 1 and all other entries equal to 0. It is often used to represent a linear transformation

2. Square Matrix: A square matrix is a matrix with the same number of rows and columns

3. Diagonal Matrix: A diagonal matrix is a square matrix with all off-diagonal entries equal to zero. It is used to represent a linear transformation, such as an affine transformation

4. Symmetric Matrix: A symmetric matrix is a square matrix where all entries on both the upper and lower diagonals are equal. It is used to represent a linear transformation, such as a rotation

Using Matrices for Machine Learning

Matrices are used in many machine learning algorithms, such as linear regression and neural networks. In linear regression, matrices are used to represent the data points and the coefficients of the regression equation. In neural networks, matrices are used to represent the weights of the network and the data points.

Matrices are also used in other algorithms, such as support vector machines and decision trees. In these algorithms, matrices are used to represent the data points and the parameters of the algorithm.

Conclusion

Matrices are an important part of machine learning, as they are used to represent data in a structured and organized way. Several different types of matrices are used in machine learning algorithms, such as identity matrices, diagonal matrices, symmetric matrices, tridiagonal matrices, and orthogonal matrices. Matrices are used in many machine learning algorithms to represent the data points and the parameters of the algorithm. Understanding matrices and how they are used in machine learning algorithms is essential for any aspiring machine learning engineer.

Mainly there are 2 types of Machine Learning named as:

1. Supervised Learning

2. Unsupervised Learning

Supervised Learning

Here, the model is trained on data of desired Input and output mappings. You give your algorithm the input and the desired output data at first and then train your model. After the model has learned from your data, you give a completely new value to the model and it tries to produce a new output.

Spam filtering and speech recognition are some of the most used applications of supervised learning.

But there are two subcategories to supervised learning too:

1. Regression

2. Classification

Regression

In regression, the algorithm gives output in numbers from many possible output numbers. Let's take an example of house price prediction.

You will need to have a sample dataset of houses with a certain number of rooms, washrooms, and floors and their price. Now, your data will be used to train your ML model

If you need to predict the price of a house with 10 rooms, 3 washrooms and 3 floors, then your ML model will tell you the price.

Classification

In classification, your algorithm will return a category (also called a class) as its output. One of the classic examples of classification is spam filtering

The algorithm is trained on a large dataset of sample emails with input as the sender, the subject line, and the content of the email and the output of a particular email (spam or not spam) is already present there

Then when a new email is sent to a user, the algorithm tries to classify it as spam or not depending on the parameters like the sender, the subject line, and the content of the email

Unsupervised Learning

In supervised learning, we used data that had input and the corresponding correct output pairs. But in unsupervised learning, that output is not present in that data. The algorithm often predicts patterns in data and the data gets categorized by the rules made by the algorithm itself.

Clustering

It is commonly used for tasks such as customer segmentation or document classification. In customer classification, the algorithm tries to classify the customers based on certain parameters like "paying users", "members", "blog readers" etc. etc. When an algorithm does this kind of task of classifying, it is often known as Clustering Algorithm

Anomaly Detection

It aims at identifying any unusual data points that don't fit in any similar pattern of data. It is used in detecting transaction fraud detection

Dimensionality Reduction

It involves reducing parameters from data while having access to much information in the dataset. It is used in tasks like data compression

In this tutorial, we will be showing you how to use Next.js and TailwindCSS to build a desktop app. We will be using Electron, which is a framework for building cross-platform desktop applications with web technologies, to package our Next.js app as a desktop app. Electron allows us to take our web app and wrap it in a native container, giving it the same functionality as a traditional desktop app.

By the end of this tutorial, you will have a basic understanding of how to use Next.js and Electron to build a desktop app. You will also have a working desktop app that you can run on your computer.

Initialize the project

To begin, copy and paste the following code into your terminal to initialize a new project using Next.js, TailwindCSS and ElectronJs

npx create-nextron-app my-app --example with-javascript-tailwindcss

This will create the folders of the app, cd into that directory and install the packages using npm install or yarn .

After that you will be able to see a folder structure that looks like this:

You can see a similar folder structure to that of a bare next js app in the renderer folder. And we will be working on that only

Write npm run dev or yarn dev in your terminal of vs code and you will be able to see your electron app pop out

Initial Configuration for Next Js

In the pages folder, you will see that there is a file named home.jsx , which is equivalent to index.js file in normal Next js applications. Go ahead and rename the home.jsx to index.jsx . You will see the default 404 page of Next js in the window.

To make this thing correct, we will navigate to the background.js file under the main folder and change the following lines:

Now, the renderer folder looks exactly like that of a new Next Js app.

Let's start coding 🫡🫡

What are we making

We will be making a simple javascript code editor. Here's a preview

Coding the app

Paste this code in the app.jsx file so that the layout looks pretty 💘

import React from "react";

import "../styles/globals.css";

function MyApp({ Component, pageProps }) {
  return (
    <div className="bg-gray-700 max-w-screen min-h-screen text-white">
      <Component {...pageProps} />
    </div>
  );
}

export default MyApp;

Now go to the global.css file in the styles folder and remove everything except these

@tailwind base;
@tailwind components;
@tailwind utilities;

Now you have your beautiful app layout. Head on to the index.jsx file and remove everything. Then paste the code below

import React from "react";
import Head from "next/head";

function Home() {
  return (
    <div className="w-screen h-screen flex items-center justify-center relative">
      <Head>
        <title>Code Editor</title>
      </Head>
    </div>
  );
}

export default Home;

Creating the code editor

In this tutorial, we will be utilizing the react-ace library to build a code editor component for our application. So, go ahead and install the react-ace package.

Create a folder named components inside the renderer folder and then create a new file. In my case, it is CodeEditor.js . Below is the given code of that file. To use any other language, you will need to import it using import "ace-builds/src-noconflict/mode-<language>" . Where <language> stands for the language you want to use. Now, for using any other theme, you have to import that using import "ace-builds/src-noconflict/theme-<theme>" .

import React, { useEffect, useState } from "react";
import AceEditor from "react-ace";

import "ace-builds/src-noconflict/mode-javascript";
import "ace-builds/src-noconflict/theme-twilight";
import "ace-builds/src-noconflict/ext-language_tools";

const CodeEditor = () => {
  const [code, setCode] = useState("");

  return (
    <div className="w-[90%] md:w-[70%] flex h-max items-center justify-center shadow-xl">
      <AceEditor
        mode="javascript"
        theme="twilight"
        onChange={(e) => setCode(e)}
        name="coding_area"
        editorProps={{ $blockScrolling: true }}
        value={code}
      />
    </div>
  );
};

export default CodeEditor;

Let's import this file into the index.jsx file and see how it looks

import React from "react";
import Head from "next/head";
import CodeEditor from "../components/CodeEditor";

function Home() {
  return (
    <div className="w-screen h-screen flex items-center justify-center relative">
      <Head>
        <title>Code Editor</title>
      </Head>
      <CodeEditor />
    </div>
  );
}

export default Home;

If you stop the server and restart it, you will see this error

This is coming due to server-side rendering of Next Js. The window object is only defined in the browser, so if you are trying to start the server on the server-side (e.g., using Node.js), the window object will not be defined.

We have to dynamically import the component inside the directory

import React from "react";
import Head from "next/head";
import Link from "next/link";
import dynamic from "next/dynamic";

// Dynamically importing the component
const Editor = dynamic(import("../components/CodeEditor"), { ssr: false });

function Home() {
  return (
    <div className="w-screen h-screen flex items-center justify-center relative">
      <Head>
        <title>Code Editor</title>
      </Head>
      <Editor />
    </div>
  );
}

export default Home;

Now, restart the server and you will see this beautiful screen

Styling the Editor

To customize the code editor, you may want to consider using various props provided by the react-ace library. For a complete list of available props, please see the documentation here: https://github.com/securingsincity/react-ace/blob/master/docs/Ace.md#available-props. Below, we have provided the code to beautify the editor using some of these props:

// components/CodeEditor.jsx
import React, { useEffect, useState } from "react";
import AceEditor from "react-ace";

import "ace-builds/src-noconflict/mode-javascript";
import "ace-builds/src-noconflict/theme-twilight";
import "ace-builds/src-noconflict/ext-language_tools";

const CodeEditor = () => {
  const [code, setCode] = useState("");

  return (
    <div className="w-[90%] md:w-[70%] flex h-max items-center justify-center shadow-xl">
      <AceEditor
        mode="javascript"
        theme="twilight"
        onChange={(e) => setCode(e)}
        name="coding_area"
        editorProps={{ $blockScrolling: true }}
        setOptions={{
          enableBasicAutocompletion: true,
          enableLiveAutocompletion: true,
          enableSnippets: true,
        }}
        showGutter={false}
        className="rounded-lg"
        style={{ width: "100%" }}
        onLoad={(editor) => {
          editor.renderer.setPadding(20);
          editor.renderer.setScrollMargin(20);
        }}
        maxLines={100000}
        minLines={30}
        wrapEnabled
        value={code}
      />
    </div>
  );
};

export default CodeEditor;

Your app should look like this if you write the following stuff

Building the app for your pc

Go ahead and paste npm run build or yarn build in your terminal to start the build

A new dist directory has been built at the root of the project. Since I am using windows, it has created a setup.exe file for me. Install it and your app is ready

Conclusion

In this article, we walked through the steps of creating a desktop app using Next.js. From setting up a new project and installing the necessary dependencies to customizing the user interface and adding features like syntax highlighting, we covered all the basics of building a desktop app with Next.js. By following these steps, you should now have a solid foundation for creating your desktop apps with Next.js. Whether you are looking to build a simple app for personal use or a more complex app for professional purposes, Next.js provides all the tools you need to get started

Adversarial search is a type of search algorithm used in artificial intelligence and computer science to find the best move in a two-player game. In an adversarial search, one player (the maximizer) tries to maximize their score while the other player (the minimizer) tries to minimize the maximizer's score. This is in contrast to non-adversarial search algorithms, which are used to find a solution to a problem without considering the actions of any other player.

Where are they used?

Adversarial search algorithms are commonly used in games such as chess, checkers, and Go, where players take turns making moves and the goal is to win the game. They are also used in other fields, such as finance and military strategy, where there is a need to make decisions in the face of an opposing player.

One of the key components of adversarial search algorithms is the evaluation function, which is used to evaluate the current state of the game and predict the outcome if the game were to continue from that state. The evaluation function takes into account factors such as the number of pieces each player has, their positions on the board, and any potential moves that could be made.

Minimax Algorithm

One popular adversarial search algorithm is the minimax algorithm, which is a recursive algorithm that explores all possible moves and countermoves in a game tree, evaluating the scores of each possible outcome. The minimax algorithm starts at the root of the game tree and works its way down to the leaf nodes, assigning a score to each node based on the evaluation function. The minimax algorithm then "minimizes" the score of the maximizer's moves and "maximizes" the score of the minimizer's moves, leading to an optimal move for the maximizer.

Alpha Beta Pruning

Another popular adversarial search algorithm is the alpha-beta pruning algorithm, which is a variant of the minimax algorithm that reduces the number of nodes that need to be evaluated by "pruning" the game tree. The alpha-beta pruning algorithm uses two values, alpha and beta, to keep track of the minimum and maximum scores that the maximizer and minimizer can achieve, respectively. If the alpha value becomes greater than the beta value, the algorithm can prune the remainder of the game tree, as it is no longer possible for the maximizer to achieve a better score.

Conclusion

Adversarial search algorithms are a powerful tool for finding the optimal move in two-player games, but they can be computationally expensive, as they require the evaluation of a large number of possible moves and countermoves. However, with advances in computer hardware and optimization techniques, adversarial search algorithms have become increasingly efficient and are now commonly used in a variety of applications.

• You must know the fundamentals of programming i.e loops, functions, classes etc.

That's it. If you know that basic stuff, then its completely alright and you can follow along

Starting with an example

5 points denoting 5 places are marked over here named A, B, C, D, E. The arrows represent the directions.

• If you are at B, you can move to C only.

• You can't move back to A. If you are at D, you can only move to E, not any other place.

Now, let's say you want to move from A to E. You have 2 paths to go from A to E: One via B (let's call it Path 1) and other via D (let's call it Path 2).

Considering that equal distances are present between any 2 points, it is clear that you would move using Path 2 cuz' it will take less energy.

There are some basic elements of AI that you need to know:

Elements of AI | 01

Agent: It is an entity that acts upon a given environment. In this case, since you are walking from A to E, so you are the agent.

State: It is the environment in which the agent is present. In this case, the network of the 5 places, is the state.

Initial State: It is the initial environment from where the agent starts. Here, if you are standing at point A, it is the initial state.

Actions: It is the set of choices that can be made in a given state. If you are at B, the set of actions will contain just one action i.e {move from B to C} . If you are at A, the set of actions will contain 2 actions i.e {move from A to B, move from A to D} .

ACTIONS(state) -> returns a set of actions that can be performed in a given state

Now, after you perform an action in a given state, your state has changed. So, the computer must have something to determine the state change. Here's where a Transition Model comes into light.

The Transition Model is a function that returns the result after a particular action is performed in a particular state. It takes in state and action as its arguments.

RESULT(state, action) -> returns the resulting state

In the picture, you are at point A and you perform an action move from A to B . You will get this resulting state 👇

Now, let's say you have reached your goal. There must be a sort of test to determine that right? As a human, you know that you reached your goal but for a computer, the instruction must be given if it has reached its goal or not. That's why we do a Goal Test to determine if the AI has reached its goal or not.

There were 2 ways to go from A to E, right? But why did you choose the 2nd path? It is because it took less energy. A computer should take the 2nd path so that it takes less computing power. The numerical cost associated with a given path is known as Path Cost.

Now there were 2 set of actions that leads you to the goal. This set of actions that lead the agent to the goal state is called the Solution

The Optimal Solution is the solution with the lowest path cost. In this case, Path 2 is the path with the lowest path cost so it is the Optimal Solution to this problem

So, Search Problems are the problems in which an agent is present which starts from an initial state and the AI finds the Optimal Solution for that agent to reach its goal

Solving Search Problems

In a search problem, data is stored in a node. It is a data structure that holds information that is important to the AI. A node contains:

• A state

• Its parent node: The node through which the current node was generated

• The action: That was applied to the parent to get to the current node

• The path cost from the initial state to this node

Algorithm

1. Start with a frontier containing the initial state and an empty set of explored items

2. REPEAT UNTIL THE GOAL IS REACHED

   • if the frontier is empty:

     • return None as there are no solutions.

   • else:

     • Remove a node from the frontier. We will store this node in a variable (let's say the variable is checking_node) for checking.

     • If the checking_node is the goal then return the solution.

     • else:

       • If the checking_node is not present in the explored set then find all the nodes that can be reached through that node and add them to the frontier.

       • Then add the current node to the explored set.

Removing the node from frontier

The Frontier is just a data structure where nodes get added and removed. But there are choices by which these nodes get removed.

We can either use Stack as the data structure for the Frontier or we can use Queue as a data structure for the frontier. If we are using stack, we will be using breadth-first search on the other hand, if we are using a queue, we will be using depth-first search.

Depth First Search (DFS)

For performing DFS, we treat the frontier as a stack. We add nodes at the last and we remove the last added node from the frontier.

The paragraph written below is taken form: https://cs50.harvard.edu/ai/2020/notes/0/

Take a situation where you are looking for your keys. In a depth-first search approach, if you choose to start with searching in your pants, you’d first go through every single pocket, emptying each pocket and going through the contents carefully. You will stop searching in your pants and start searching elsewhere only once you will have completely exhausted the search in every single pocket of your pants.

Breadth First Search (BFS)

For using BFS, we treat the frontier as a queue. We add nodes at the last and we remove the 1st node that was previously added.

The paragraph written below is taken form: https://cs50.harvard.edu/ai/2020/notes/0/

Suppose you are in a situation where you are looking for your keys. In this case, if you start with your pants, you will look in your right pocket. After this, instead of looking at your left pocket, you will take a look in one drawer. Then on the table. And so on, in every location, you can think of. Only after you will have exhausted all the locations will you go back to your pants and search in the next pocket.

Conclusion

There are more kinds of search algorithms like Greedy Breadth First Search and A* search. In the next article, we will look at Adversarial Search

The Start of the Year

The start of the year was pretty wonderful, I was in class 10th and I had seen hype in the crypto space. So, I started learning about web3. Learned solidity, made a few projects and then participated in Thirdweb hashnode hackathon. Learned new things but never shared.

To be very honest, I did it because of the prize. I had never participated in any hackathon before and didn't even earn a penny from programming. So, I thought that I will just participate, make a product and win the prize.

Life gave me a lemon, but I couldn't make lemonade out of it. When I couldn't win the prize, I just didn't feel like participating in any other hackathon

Reality hit hard

I worked very hard for my 10th CBSE board exam. After the board exam was over, I got a freelance client who paid $ 120 for an NFT project. That project was on the Solana Blockchain and I learned a lot again but I never shared my learnings.

I was very happy and thought that class 11th will be easy for me. But I never knew the other side of hard work. I never knew what a mental breakdown was and I never really knew what happens when no expectations get fulfilled.

I was getting bad grades despite working very hard. There was a huge rise in the syllabus and I couldn't handle it at first

Couldn't stay consistent

I couldn't consistently post about my learnings on social media platforms. I started using Twitter but I don't even have 50 followers today. I just have 1 follower in my hashnode as of today.

I don't know why I didn't post and I don't want to waste my thinking of it too. I just know that in the coming year I have to be consistent so that I can break out of this valley of regret.

My Development journey

The only thing which kept me alive and gave me pleasure in this valley of regret is coding. I can code for hours without thinking of anything. I did get to hear a lot of taunts from my parents for this cuz' my school academics were not great like that of 10th but I really don't care about that now.

Web 3

I learned solidity, did freelancing and did get a decent amount of money.

Then I started learning Rust for Solana blockchain. I found that Solana was faster than Ethereum and had very less gas fees. Found out that buildspace was the perfect place for learning that. But after a couple of months, I didn't feel like doing it anymore so I left it and started building apps with what I knew.

Data Structures and Algorithms

I started learning DSA from LearnCodeOnline didn't complete the full course but I learned a lot

DSA is like a fundamental building block. Once you know DSA, it will improve your logic-building skills immensely. I don't know everything about DSA but I have found immense progress in my logic-building skills after learning a few concepts of DSA.

Making Apps

I knew how to make web apps with MERN stack and mobile apps with React Native. But I thought why stop at that I learned NextJs and Prisma. As of today, I can make full-stack apps easily

My current state

I still am in a valley of disappointment. But I will implement my learnings from this year so that I can make myself better. I am currently learning about Artificial Intelligence parallelly to learning DSA. This blog will stay as a reminder to me. It will remind me about what to do next

My Learnings to implement

• I will share what I learn

• I will stop putting expectations in everything

• I am starting today

• I will make a plan for the next day before every night (started this at the start of this month)

• I will go out for a walk for 30 mins thinking about "how can I make this day better" every day (started this at the start of this month)

Quote for me

The best time to start a new thing was in the past

But the second best time is now

Conclusion

If you want to put up some suggestions, then please put them up. This year, I faced hard situations but I have learned from them. Now, I can successfully avoid these traps and make myself better. And yes, I don't expect to win prizes in Dev Retro 2022 😊

Time complexity is basically the relation between input size and running time

Think About It

You obviously have apps in your phone. You are most likely to prefer the ones which takes less time to load the data and consumes less space. The factor which is used to measure the time is related to time complexity. But what about the space? How do we measure the space used by a code?

Space Complexity

The relation between the input size and memory consumed in your system.

If you want your code to be optimized, it should take less time and less space too. So, here's where space complexity comes in place cause this is the way to measure how much space your code will take

Calculating Space Complexity

The space used by a code depends on how many variables are used. The more variables, the more space used.

How much memory consumed by a code is directly proportional to how many variables assigned

sum = 0
i = 0
while (i < 24):
    sum += i
    i += 1
print(sum)

Here, there are 2 variables which we are assigning to the memory that is i and sum. Now, no matter the the value of sum increases the memory used by that one variable would be the same. So, the space complexity for this code will be O(1)

Now, let's take the example of arrays. It is basically a data structure which stores a list of elements. We will talk about arrays deeply later

def create_array(n):
    a = []
    for i in range(n):
        a.append(i)
    return a

In this function, we take integer n as an input. Then we create an array. Using the loop we store the numbers 0 to n-1 in the array. Then we return it. So, basically what we are doing is, we are generating a series of numbers and storing it in an array. Here, with the increasing size of input, the space used by the code also increases. So, the space complexity for this code is O(n)

You can check the size here:

sys.getsizeof() gives out the size of a particular function, class, variable etc. in python

I really hope you understood, if you didn't then feel free to criticize in the comment section. It's okay to criticize if I have wasted your valuable time. Also if you have any doubts, feel free to put it up in the comments section

Approach 1: Time based approach

calculateTime()
function fancyName(){
   do something
}
calculateTimeDifference()

In this approach of judging code, before running a chunk of code, the initial time is taken and after running that code, the final time is taken. Then when the final time is subtracted from initial time, we get the how much time was required for processing of the code.

This method of calculating code performance is rated as average but still this approach is used hugely to judge code

Problems in Approach 1:

• It is based on machine: Depends from processor to processor
• It is based on processing: Depends on the processing power of your PC

Approach 2:

Counting the number of operations in a code. Technically, this literally means that we are going to count the number of operations in a code.

Count Operation in the code below a = a + 1

If you said there is one operation, you are wrong my friend. There are actually 2 operator: "=" and "+"

Now, count the operation in this code

sum = 0
winner = 1
for (i = 1; i < n; i++){
  sum = sum+1
}

Notice closely, that there are several operators. In total, there is 3 "="s, 1 "<", then in i++, there are actually 2 operators which are responsible to increment the value of i, i++ can be written as i = i+1, so in i++ there are 2 operators. Then inside the loop there are 2 operators: "=" and "+"

But, in this code, apart from sum = 0, winner = 1, i=1, all the other operators are dependent on the variable n. So, there are 3 constant operators, and 5 operators which varies with the value of n. Thus there are 3+5n operators

Big O

The whole way of measuring code with number of operators is known as Big O.

Code 1

sum = 0
i = 0
while (i < n):
    sum += i
    i += 1
print(sum)

In this given code, there are 5n+2 operators.

Now, coming to the complexity of the code: To measure the complexity of the code, the constants are to be ignored.

So O(n) [Said as O of n] is the complexity

Code 2

for (------):
  ---------
  ---------
for (------):
  ---------
  ---------

You might think that the complexity of the above code is 2O(n) and that's completely correct. But since the constants are to be ignored, so the complexity will be O(n).

Code 3

for (let i = 0; i < N; i++) {
  for (let j = 0; j < N; j++) {
    sum+=j
  }
}

In the above code, O(n) is inside another O(n). Thus, the complexity of the code becomes O(n^2). If the nested loop would run on a constant and not on N, the complexity would not be O(n^2).

Complexity Notation

This graph shows the time for complexity of code with increasing input.

Why DSA?

The main moto to learn DSA is to know how to write optimized code. In this age of Cloud Functions, the optimized code requires less money as less computation and memory is used in the servers. On the other hand if you don't write optimized code, you will have to pay more money and also the results from the cloud servers would be very slow.

Judging code

Now you know that writing optimized code would save your time. But how will you judge if a code is optimized or not? Many people say that the less number of lines means the more optimized code. But this is a true lie. Optimized code can't be judged by the number of lines but the parameters involved in the code. Judge this case:

Problem Statement: Generate a series of number from 1 to n and store it in a variable or function so that it can be accessed later

Code 1:

def gen_series():
    a = []
    n = int(input("What's n? "))
    for i in range(1, n+1):
        a.append(i)
    return a

def print_series():
    a = gen_series()
    for i in a:
        print(i)

if __name__ == "__main__":
    print_series()

Code 2:

def gen_series():
    n = int(input("What's n? "))
    a = series(n)
    print(a)
    return a

def print_series():
    a = gen_series()
    for i in a:
        print(i)

def series(n):
    d = 11
    for i in range(1, n+1):
        yield i + d
        d += 11

if __name__ == "__main__":
    print_series()

If you count the number of lines, you would say Code 1 is more optimized but is it?

In both the cases the series is generated and stored inside the function named gen_series(). If you know about the sys.getsizeof() method in python, you will know that it gives out the memory used inside a variable, function. If you write this in your code editor, run the program, and enter 200 as the input of What's n?

import sys


def gen_series():
    a = []
    n = int(input("What's n? "))
    for i in range(1, n+1):
        a.append(i)
    return a


def print_series():
    a = gen_series()
    for i in a:
        print(i)


if __name__ == "__main__":
    print(sys.getsizeof(gen_series()))

You will get the memory used in bytes. And surprisingly, you will notice that the 2nd code consumes less memory.

So, we can come to a conclusion that less code always doesn't mean optimized code. For a code to be judged, the parameters are important.

Programming Language

DSA is mostly independent of programming language the main things which matter are the concepts. I'll be using python in the next articles regarding DSA

Before reading this blog, I want to make a clear statement that this blog is written completely based on my understanding about how generators work in python. To move forward, you must be an intermediate in python.

Iterators

An object that contains countable number of values. The next value can be accessed with the next(object_name) parameter

You can know more about iterators here: Iterators by W3 Schools

Case

Let's say you are working in a company and your company gives you a task to write a program to find a series of numbers. Each number having a difference of 12 from the previous. So the series is like: [12,24,36,48.....]

You have to find the series till a number given by the user and store the results somewhere so that others get those values using a loop.

So, if the user enters 10, the program will return a series like: 12,24,36,........,120

You will be like: Okay that's easy

def gen_series():
    n = int(input("What's n? "))
    a = []
    d = 11
    for i in range(1, n+1):
        a.append(i + d)
        d += 11
    return a

if __name__ == "__main__":
    print(gen_series())

Now, your program works nicely if the user inputs numbers like 12, 23, 89, 74.

If you test this code yourself and you enter a number like 1000000000000000 then what happens? Your code starts to hang, the program doesn't work smoothly. So, this is not the best approach to get a series of numbers.

Let's refactor this code a bit

def gen_series():
    n = int(input("What's n? "))
    a = series(n)
    print(a)

def series(n):
    a = []
    d = 11
    for i in range(1, n+1):
        a.append(i + d)
        d += 11
    return a

if __name__ == "__main__":
    gen_series()

Now, the program runs the same but our problem is not yet solved. We want to generate a series of numbers with each number having a difference of 12 from the previous and we want our program to generate as much numbers as we want.

Try to run this code:

def gen_series():
    n = int(input("What's n? "))
    a = series(n)
    print(a)


def series(n):
    d = 11
    for i in range(1, n+1):
        yield i + d
        d += 11


if __name__ == "__main__":
    gen_series()

If you run this code and input a number as 20, you will see the output as <generator object series at 0x0000020B20684350>. Now, if you run again, and input a big number such as 1000000000000000, you will notice that your program doesn't lag. It works perfectly fine and you get the output.

The yield keyword is responsible to make this function a generator.

The series function is now a generator function which generates an iterator. If you have read the article of W3 Schools, you will certainly know that we can easily access the values from an iterator using a loop.

So, here's the definition of generators

Generators

Generators are those kind of functions that return an iterator.

Back to program

Now to print the values of the series we can use another function

def print_series():
    a = gen_series()
    for i in a:
        print(i)

The complete code:

def gen_series():
    n = int(input("What's n? "))
    a = series(n)
    print(a)
    return a


def print_series():
    a = gen_series()
    for i in a:
        print(i)


def series(n):
    d = 11
    for i in range(1, n+1):
        yield i + d
        d += 11


if __name__ == "__main__":
    print_series()

Conclusion

• Generators are functions that return an iterator
• We can turn a normal function to generator by using the yield keyword

If you didn't understand then don't forget to criticize me in the comments. That will help me to come up with a better explanation. It is okay to criticize me if I have wasted your time. Also if you have any questions, please ask me in the comments