DEV Community: Amal Satheesan

Pi-hole setup(docker) for ad blocking

Amal Satheesan — Mon, 27 Oct 2025 13:31:49 +0000

Recently, I set up Pi-hole for network-wide ad blocking, starting with the goal of blocking ads on TV subscriptions like JioHotstar, YouTube, and other video streaming platforms.

Disclaimer: This didn’t work for streaming services, since their CDNs now frequently change and serve content and ads from constantly rotating domains.

Still, Pi-hole is a powerful tool for disabling redundant ads. What impressed me most was how it blocked about 20% of all requests sent from my devices. Even without noticing issues, it was eye-opening to analyse online activity across my home network. I could see just how many unnecessary requests my devices make — when I connected my laptop for five minutes while idle, it sent over 400 requests.

I highly encourage anyone with a Raspberry Pi to set up Pi-hole. It’s a great way to gain insight into your network activity and enjoy a cleaner web experience. I’ll follow up this post with a new blog about using PiVPN and WireGuard, though there are a few nuances I missed—currently, the tunnel isn’t working properly.

Get started

Install docker and docker-compose

sudo apt install docker docker-compose

Add the user to the group:

$USER
sudo usermod -aG docker $USER

Then, either log out and log back in or restart the system to apply group membership changes.

Link to repo

Copy the docker-compose.yml file:

# More info at https://github.com/pi-hole/docker-pi-hole/ and https://docs.pi-hole.net/
services:
  pihole:
    container_name: pihole
    image: pihole/pihole:latest
    ports:
      # DNS Ports
      - "53:53/tcp"
      - "53:53/udp"
      # Default HTTP Port
      - "80:80/tcp"
      # Default HTTPs Port. FTL will generate a self-signed certificate
      - "443:443/tcp"
      # Uncomment the line below if you are using Pi-hole as your DHCP server
      #- "67:67/udp"
      # Uncomment the line below if you are using Pi-hole as your NTP server
      #- "123:123/udp"
    environment:
      # Set the appropriate timezone for your location (https://en.wikipedia.org/wiki/List_of_tz_database_time_zones), e.g:
      TZ: 'Europe/London'
      # Set a password to access the web interface. Not setting one will result in a random password being assigned
      FTLCONF_webserver_api_password: 'correct horse battery staple'
      # If using Docker's default `bridge` network setting the dns listening mode should be set to 'all'
      FTLCONF_dns_listeningMode: 'all'
    # Volumes store your data between container upgrades
    volumes:
      # For persisting Pi-hole's databases and common configuration file
      - './etc-pihole:/etc/pihole'
      # Uncomment the below if you have custom dnsmasq config files that you want to persist. Not needed for most starting fresh with Pi-hole v6. If you're upgrading from v5 and have used this directory before, you should keep it enabled for the first v6 container start to allow for a complete migration. It can be removed afterwards. Needs environment variable FTLCONF_misc_etc_dnsmasq_d: 'true'
      #- './etc-dnsmasq.d:/etc/dnsmasq.d'
    cap_add:
      # See https://github.com/pi-hole/docker-pi-hole#note-on-capabilities
      # Required if you are using Pi-hole as your DHCP server, else not needed
      - NET_ADMIN
      # Required if you are using Pi-hole as your NTP client to be able to set the host's system time
      - SYS_TIME
      # Optional, if Pi-hole should get some more processing time
      - SYS_NICE
    restart: unless-stopped

Make sure the Docker daemon is actually running before you run the compose command.

sudo systemctl status docker
sudo systemctl restart docker

If the status is active, run the following command in the directory you created the docker-compose.yml file:

sudo docker-compose up -d

It will pull all the images, after successful installation, run:

docker ps

If you see the pi-hole container is running, open a new tab in your preferred web browser. Before that:

Get the PI IP:

hostname -I

Copy the first local IP address of your Pi. Then type:

<PI_IP_ADDRESS>/admin

into the web browser.

You will need to log in using an existing account. The password is given in the docker-compose.yml file under the variable: FTLCONF_webserver_api_password: 'correct horse battery staple'

Copy the password and log in.

Connecting devices:

In mobile:

Wifi -> Advanced Settings -> DHCP -> Manual

Then, on the DNS-1 server, add your Pi IP address you just copied. Then save it.

Look into the client connection in the Pi-Hole dashboard. You will see the connected device IP address.

In a laptop:

Wifi -> Connection Manager -> Update the DNS there.

Adding custom blocklist

If you go to Lists in the dashboard, you can already see a list added by the Pi-Hole team. An extensive list. You can find more lists on GitHub and the internet. You can add an allowlist and a blocklist to the connections based on your needs.

Some of the lists I use:

After you add this list as a blocklist, go to tools -> update gravity -> update

Now we have successfully added a custom list as well. Now you can monitor your network by device. Which are sending which, why, what type of request and more.

The current setup is enough to play around with the tool, thus figure out and break things, and explore other solutions. Mantra: "Use this until it breaks down". Use this as a monitoring tool heavily rather than an ad blocker. There are hidden gems there.

Web Architecture: Web1.0 to Web3.0

Amal Satheesan — Sat, 16 Aug 2025 18:09:12 +0000

The invention of the internet can be traced back to the 1960s, when researchers, government officials, and other operational heads needed to share information with one another. However, the Internet phenomenon began in the 1990s, when renowned Tim Berners-Lee introduced the "World Wide Web" in 1989.

His work was closed during that time, but it was made available to the general public in 1993, and it has since progressed to where we are today. His primary focus was on the inefficient management of files and information at his organization CERN. So he suggested a linked system of information nodes.

This work can be accessed in the following

w3.org

System diagram

This is a simple system diagram to demonstrate how web1.0 works:

Web 1.0 was the "read-only" web with mostly static web pages. Means it allowed people to only search and view information online, it means none can interact and post to the web, a one way communication.

The most important point here is, the Websies at that point of time were informational, created and controlled by owners.

Relevance to Today’s Architecture:

Linked nodes and links shaped the Web’s HTML, URLs, and hyperlinks.
Separation of servers and browsers underpins modern web and APIs.
Common interfaces enable integration of diverse data sources.
Live links relate to dynamic content and real-time APIs.
Graph-like structures influence modern databases and the semantic web.
User-centered browsing guides web design today.
Early privacy and annotation ideas appear in social networks.

Emergence of Web2.0

One of the drawbacks of Web 1.0 is the lack of a "POST" function; from static websites, the web evolved into something more interactive and collaborative. It enabled users to create, share, and comment on content, rather than just viewing it.

Personal activities that gained momentum for web2.0 are of the following:

Blogs
Feeds (RSS)
Social networking
Video sharing
Podcast
Etc.

Simple Architecture

During this time, websites became more dynamic, with content added by users and communities. For example, readers were able to leave comments beneath the blogs. So it addressed Web 1.0's one-way communication limitation.

Social media, blogs, and wikis became popular with Web 2.0 and it enabled user participation, social networking, and content sharing.

The other important point to consider in web2.0 is, control shifted from just owners to users contributing content.

One of the papers that served as a foundation for the development of web2.0 discussed the following principles for being a web2.0 technology:

Deliver services instead of packaged software, enabling cost-effective scalability.
Maintain control over unique, hard-to-recreate data sources that grow richer with increased user participation.
Trust users as co-developers and collaborators.
Harness collective intelligence from the user community.
Leverage the long tail by enabling customer self-service.
Provide software that operates beyond a single device or platform.

Refer here:
https://papers.ssrn.com/sol3/papers.cfm?abstract_id=1008839

Comes Web3.0

Before we set out, I'd like to provide a simple analogy for why we simply require web3. Let's say we're playing our favorite game and making some in-game purchases. You should understand that the money in the game is just some numbers stored in a database, and any internal developer can empty your account by simply updating the database. However, with web3, the money, purchase, and game are all public assets for us, and no one can intervene until we transfer ownership to someone else. Nobody else is in the middle.

In essence, it solved the centralized control and data privacy issues of Web 2.0. To give users full ownership and control over their data and digital assets.

Some of the features:

It enable decentralized applications without intermediaries using blockchain.
To enhance security, transparency, and trust via immutable, tamper-proof ledgers.
To create new economic models like decentralized finance (DeFi) and token economies.
To improve interoperability and allow seamless interaction across platforms.

Why Early Web3 Was Full of Scandals?

Because, it had a rough start, because of the idea of decentralization affected the control for regulation (in some way it's good, but do they?). The rapid growth, and overhyped expectations attracted a lot of scams, frauds, hacks, and failed projects especially in crypto and NFT's. Lack of governance and standards causes abuse and exploitation. Also the inexperience of developers and bad actors exploited decentralization.

Publishing a static website from Raspberry Pi

Amal Satheesan — Mon, 02 Sep 2024 17:36:06 +0000

Securing Your WordPress Website on Raspberry Pi with Cloudflare Tunnel

You're halfway through releasing your website to the public from your Raspberry Pi. Before proceeding, ensure you have the following essentials:

Raspberry Pi with a WordPress site installed.
Nginx server configured on the Raspberry Pi.
An active Cloudflare account.
A registered domain.

Step 1: Update DNS Records in Your Domain Dashboard

Log in to Cloudflare: Access your Cloudflare dashboard.
Add Your Domain: Go to the “Websites” section and register a new domain.
Update DNS Settings: Follow the on-screen instructions to update the DNS records on your domain registrar’s dashboard with the nameservers provided by Cloudflare.
Wait for Propagation: DNS changes can take some time to propagate. Once the nameservers are updated and Cloudflare has authorized your domain, you're ready to move on.

If you have any doubts about these steps, feel free to ask in the comments section.

Step 2: Install the Cloudflared Daemon on Raspberry Pi

Download Cloudflared: Depending on your Raspberry Pi architecture, use the appropriate wget command to download Cloudflared:

- For ARMv7 (Raspberry Pi 2 and 3):

```bash
wget https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-arm
```

- For ARMv6 (Raspberry Pi Zero):

```bash
wget https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-armv6
```

- For ARM64 (Raspberry Pi 3/4 with 64-bit OS):

```bash
wget https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-arm64
```

Move the Downloaded File:
```
sudo mv cloudflared-linux-arm /usr/local/bin/cloudflared
```
(Adjust the filename if you downloaded a different architecture version.)

Make the Binary Executable:

sudo chmod +x /usr/local/bin/cloudflared

Verify Installation:
```
cloudflared --version
```

Step 3: Authenticate Cloudflared with Cloudflare

Log in to Cloudflare:
```
cloudflared login
```
Authorize Cloudflared: Copy the URL displayed in the terminal and open it in your browser. Select your domain in Cloudflare and click Authorize. Make sure you're already logged in to your Cloudflare dashboard to complete this step seamlessly.

Step 4: Create a Secure Tunnel

Create the Tunnel:
```
cloudflared tunnel create mywpsite
```
Save Important Details: Make a note of the tunnel ID and the path to the JSON file generated. You’ll need these later.

Step 5: Configure Cloudflared

Create a Configuration File:
```
sudo nano ~/.cloudflared/config.yml
```
Add Configuration Details:
Replace the placeholders with your actual tunnel UUID, JSON file path, domain, and Raspberry Pi IP address:
```
tunnel: your-tunnel-uuid
credentials-file: /home/pi/.cloudflared/your-tunnel-uuid.json
ingress:
 - hostname: yourdomain.com
   service: http://your-raspberry-pi-ip-address
 - service: http_status:404
```
Note: Ensure you update pi with the correct username and remove any trailing slashes from the IP address (e.g., http://192.168.*.* is correct).
Save and Exit: Press CTRL + X, then Y, and hit Enter to save the configuration.

Step 6: Create DNS Entry in Cloudflare

Route DNS:
```
cloudflared tunnel route dns mywpsite yourdomain.com
```
Troubleshooting Tip: If you encounter an error, log in to your Cloudflare dashboard, delete any existing DNS records for your domain, and run the command again.

Step 7: Run the Cloudflare Tunnel

Start the Tunnel:
```
cloudflared tunnel run mywpsite
```
Verify: Visit https://yourdomain.com to ensure your site is live and accessible.

If your network changes and local ip changes, just login to the tunnel in cloudflare and change the local ip their itself and will work as same before.

Step 8: Update WordPress Settings

Access WordPress Admin: Go to http://your-raspberry-pi-ip-address/wp-admin and log in.
Update URLs: Under Settings > General, update both the WordPress Address and Site Address to https://yourdomain.com.

Step 9: Run Cloudflare Tunnel as a Service

Move Configuration File:

sudo mv /home/pi/.cloudflared/config.yml /etc/cloudflared/

Install as a Service:
```
sudo cloudflared service install
```

By running Cloudflared as a service, your Raspberry Pi will automatically start the Cloudflare tunnel whenever it reboots, ensuring continuous availability of your site.

With these steps completed, your WordPress site on Raspberry Pi is securely accessible from the internet, complete with SSL encryption, thanks to Cloudflare Tunnel.

Will share more update regarding a updated version on this setup if it works soon. Stay tuned, will host a real website with multiple webpages.

Wordpress installation in Raspberry Pi using Nginx

Amal Satheesan — Mon, 02 Sep 2024 15:53:39 +0000

We will be continuing from were we left off. Disclaimer: You can use apache if you want. Apache is easier to setup compared to Nginx.

Keywords used in the guide:

Raspberry Pi
NGINX server
WordPress
MySQL
PHP

Step 1: Update the Raspberry Pi

First, make sure your Raspberry Pi is up-to-date:

sudo apt update 
sudo apt upgrade -y

Step 2: Install NGINX

NGINX will serve as your web server.

Install NGINX:
```
sudo apt install nginx -y
```

Start and enable NGINX:

sudo systemctl start nginx
sudo systemctl enable nginx

Verify NGINX is running:
```
sudo systemctl status nginx
```
Check in a browser by typing your Raspberry Pi's IP address (e.g., http://192.168.x.x).

Step 3: Install MySQL (MariaDB)

WordPress needs a database, so we will install MariaDB.

Install MariaDB server:
```
sudo apt install mariadb-server -y
```
Secure the installation:
```
sudo mysql_secure_installation
```
Follow the prompts to secure your database (set root password, remove anonymous users, disable root login remotely, etc.).
Log in to MariaDB:
```
sudo mysql -u root -p
```

Create a database for WordPress:

CREATE DATABASE wordpress;
CREATE USER 'wpuser'@'localhost' IDENTIFIED BY 'password';
GRANT ALL PRIVILEGES ON wordpress.* TO 'wpuser'@'localhost';
FLUSH PRIVILEGES;
EXIT;

Step 4: Install PHP

PHP will be used to process dynamic content for WordPress.

Install PHP and necessary extensions:

sudo apt install php-fpm php-mysql php-curl php-gd php-xml php-mbstring -y

Step 5: Configure NGINX to Use PHP

Create an NGINX server block for WordPress:

sudo nano /etc/nginx/sites-available/wordpress

Add the following configuration:

server {
    listen 80;
    server_name _;
    root /var/www/wordpress;

    index index.php index.html index.htm;

    location / {
        try_files $uri $uri/ =404;
    }

    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/var/run/php/php-fpm.sock;
    }

    location ~ /\.ht {
        deny all;
    }
}

Enable the configuration:

sudo ln -s /etc/nginx/sites-available/wordpress /etc/nginx/sites-enabled/
sudo rm -r /etc/nginx/sites-enabled/default

Test and restart NGINX:

sudo nginx -t
sudo systemctl restart nginx

Step 6: Download and Configure WordPress

Install wget and unzip (if not installed):
```
sudo apt install wget unzip -y
```

Download WordPress:

cd /var/www
sudo wget https://wordpress.org/latest.zip
sudo unzip latest.zip
sudo mv wordpress /var/www/

Set correct permissions:

sudo chown -R www-data:www-data /var/www/wordpress
sudo chmod -R 755 /var/www/wordpress

Configure WordPress to connect to your database:

cd /var/www/wordpress
sudo cp wp-config-sample.php wp-config.php
sudo nano wp-config.php

Update the database settings in wp-config.php:

define( 'DB_NAME', 'wordpress' );
define( 'DB_USER', 'wpuser' );
define( 'DB_PASSWORD', 'password' );
define( 'DB_HOST', 'localhost' );

Step 7: Complete WordPress Installation

Open your web browser and navigate to http://your_domain_or_IP.
Follow the on-screen instructions to complete the WordPress installation.

After these steps, your Raspberry Pi should be hosting a fully functional WordPress site using NGINX, PHP, and MariaDB.

In the next blog, we will be hosting the site to public using a secure tunnel. Stay tuned for that....!

Setting Raspberry Pi with Laptop

Amal Satheesan — Thu, 27 Jun 2024 17:48:52 +0000

Requirements

Raspberry Pi (all models)
Memory card (16GB or larger recommended)
SD Card adapter
LAN cable
Power adapter

Disclaimer:

You can use any operating system of your choice. I'll be demonstrating with Arch Linux, but the steps are applicable across different OSes.

Installing the Operating System

Start by downloading your preferred Raspberry Pi operating system here. If you prefer another ARM-based OS, feel free to download it instead.

Flashing the OS

To flash the OS onto your SD card, download Raspberry Pi Imager from here or from their GitHub repository for other systems.

Connect the SD card to your computer.
Open Raspberry Pi Imager.
Select your device.
Choose the downloaded OS.
Select the SD card as the storage location.
Configure hostname, username, and password.
Enable SSH.
Write the image to the SD card.

My setup:

I already downloaded the OS to local system. Also using a raspberry pi 4 Model B having 4 GB of RAM. My settings will be this:

Also, you need to make sure you are remembering the settings in this page:

Setting Up Remote Access

After flashing:

Create an empty file named ssh (without an extension) in the bootfs directory of the SD card.
Eject the SD card and insert it into your Raspberry Pi.
Power on the Raspberry Pi.

Enabling VNC

Open a terminal or cmd. Type

ssh <username>@<localhost-name>.local

Type yes and enter the password you set during setup. You will be logged into the terminal and you are good to go.

Get the IP address of the Raspberry Pi:

ip a

Remember the local IP address of the device connected to the device (This only works when the pi and your device are both connected to the same network).

To enable VNC for graphical access:

sudo raspi-config

Navigate to:

Display options: Set a resolution.
Interface options: Enable VNC.

Access pi by typing ip address into your VNC top bar for connection.

Stay tuned for more exciting projects and tutorials in my Raspberry Pi series! Happy tinkering!

How to install Anaconda on Arch Linux

Amal Satheesan — Wed, 26 Jun 2024 17:36:15 +0000

Update 16/08/2025:

When I was writing the blog, I was a beginner to Arch Linux, so I forgot it was also a linux machine. There's a simple way to install both anaconda and miniconda to your system, follow the link to this index page:

Miniconda: https://repo.anaconda.com/miniconda/
Anaconda: https://repo.anaconda.com/archive/

Can get all the release from this page, follow the command for linux:

wget <filename>

curl -o <filename>

After the package is delivered, open the folder with the directrory and run the file as bash:

Example:

bash ~/Miniconda3-latest-Linux-x86_64.sh

Accept the terms and conditions and install the location you want to install. The default directory is /user/home/miniconda/ if you want to change the location you can use -p -u <directory-link>.

or desired location

bash Miniconda3-latest-Linux-x86_64.sh -u -p /home/user/Downloads/Installation/miniconda

No need to follow the below instruction, make sure to close the terminal for enabling the service or you can reload your shell based on the install.

Links:

Anaconda: Anaconda AUR Package
Miniconda: Miniconda AUR Package

Step 1: Clone the Package to Your System

Click on the Git Clone URL and copy the repository link.
Open your terminal and navigate to your desired directory. Here, I'm moving to the /Downloads/ directory.

git clone https://aur.archlinux.org/packages/anaconda

Once the cloning process completes successfully, proceed to the next step.

Step 2: Install the Package into Your System

Open a terminal and change directory to where you cloned the repository.

cd /Downloads/anaconda

Build and install the package using makepkg.

makepkg -si

This process will take some time. Once it finishes, proceed to the next steps.

Locate the installation script, typically named anaconda_xxxxxx.sh. Make it executable from the terminal.

sudo chmod +x anaconda_xxxxxx.sh

Execute the installation script.

sudo ./anaconda_xxxxxx.sh

Follow the on-screen prompts, including reading the agreement and typing yes to proceed with the setup.

Creating Environment and Example

To activate the base environment:

conda activate base

You'll see (base) in front of your terminal prompt indicating the base environment is active.

For those who installed Anaconda, you can launch Anaconda Navigator using:

anaconda-navigator

That's it for Anaconda installation.

Miniconda Verification

Verify the Miniconda installation by checking its version:

conda --version

Checking Miniconda Path

To ensure Miniconda's binaries are in your PATH:

echo $PATH

Look for a directory like /path/to/miniconda3/bin in the output. If it's missing, you'll need to add it to your PATH.

Assuming everything is correct, activate the base environment again:

conda activate base

Opening Jupyter Notebook

Install Jupyter Notebook:

conda install jupyter notebook

Then, launch Jupyter Notebook:

jupyter-notebook

You've successfully run Jupyter Notebook with Miniconda.

Extra Perks

1. Creating a New Conda Environment

Create a new environment specifying Python version and install packages:

conda create -n <env_name> python=<version>
conda activate <env_name>

For example:

conda create -n myenv python=3.9
conda activate myenv
conda install numpy

2. Listing and Deleting Environments

List all environments:

conda env list

Delete an environment:

conda env remove -n <env_name>

3. Deactivating an Environment

Deactivate the current environment:

conda deactivate

For more information on managing environments, refer to this link.

OSPF vs. RIP: A Comparison of Interior Gateway Protocols

Amal Satheesan — Fri, 21 Jun 2024 08:51:42 +0000

This is a submission for DEV Computer Science Challenge v24.06.12: One Byte Explainer.

Explainer

OSPF and RIP are different roads:

OSPF is a well-planned city highway, managing traffic capably with clear signs and fast adjustments.
RIP is a simpler, slower rural road network, with fewer signs, suited for smaller towns with fewer routes to manage.

Difference between var and let in Javascript

Amal Satheesan — Wed, 10 Apr 2024 16:40:01 +0000

Why Two Ways to Declare Variables in JavaScript?

When you're starting with JavaScript, you might wonder why there are two ways to declare variables (var and let).

Different Methods for Variable Declaration

JavaScript offers multiple keywords for variable declaration:

var
let
const (introduced in ES6)

Here are some examples:

var num1 = 5;
let name1 = "Someone";
const pi = 3.14;  // Constant value (cannot be reassigned)

Reasons for let and const (Introduced in ES6)

ES6 introduced const and let to address limitations with var. While var allowed variable declaration, it caused issues due to:

Hoisting: Variables declared with var are accessible before their declaration, leading to unexpected behavior.
Scope: var is function-scoped, meaning variables can be accessed throughout the entire function regardless of code blocks. This can make code harder to reason about.

const and let fixed these issues by introducing block-level scoping, preventing unexpected behavior and making code more predictable and maintainable.

The Problem with `var` for Beginners

Without proper understanding, beginners might not be familiar with the differences between let and var. This can lead to confusion and potential bugs in their code.

Understanding Scope

var: Function-scoped. A variable declared with var is accessible throughout the entire function it's declared in, regardless of code blocks.
let: Block-scoped. A variable declared with let is only accessible within the code block (like an if statement or loop) where it's declared.

Example: Scope Difference

function letSci() {
  let x = 1;
  if (true) {
    var y = 2;
    x = 2; // Modifying `x` declared outside the block with `let` is allowed
    console.log(x); // Output: 2
  }
  console.log(x); // Output: 2 (x is accessible here)
}

letSci();

// y can be accessed here because it's function-scoped with var
console.log(y); // Output: 2 (assuming y was declared before letSci())

Hoisting and Redeclaration

var: Hoisted to the top of their function scope. You can access them even before they are declared in the code.
let: Not hoisted. You cannot access them before their declaration.

This prevents errors that might occur with var due to accessing an undeclared variable.

Example: Hoisting Difference

console.log("var section\n");

console.log(y); // This will result in an error because `y` is declared with `var` later in the code
var y = 10;
console.log(y); // Output: 10

console.log("let section\n");

console.log(x); // This will result in an error because `x` is declared with `let` and cannot be accessed before its declaration
let x = 5;
console.log(x); // Output: 5

Additional Considerations

While not covered here due to space limitations, exploring const is also recommended. It's used for variables that shouldn't be reassigned after their initial declaration.

By understanding the differences between var, let, and const, you can write cleaner, more maintainable JavaScript code.

Getting your basics ready | Data types, Control flow, and Functions in GOLANG

Amal Satheesan — Sun, 08 Oct 2023 14:30:51 +0000

Data Types in Go: A Fun-filled Adventure

Ahoy there, fellow code wranglers! Today, we're delving into the marvelous world of data types in Go, also known as Golang. You might be wondering, "Why should I care about data types?" Well, my friends, data types are like the spice of programming. They add flavor, structure, and a touch of elegance to your code. So, let's embark on this data-driven journey, but before we get too carried away, let's put on our professional hats, just for a moment, shall we? 😎

Now, let's uncover the thrilling reasons why data types are the superheroes of the programming universe:

The Fantastic Functions of Data Types

Data Organization: Imagine your code as a chaotic kitchen with ingredients scattered everywhere. Data types act like tidy organizers, neatly categorizing your data into logical containers.
Data Validation: Have you ever tried to slice a tomato with a spoon? Data types ensure that you're using the right tool for the job by making sure your data is appropriate for the task at hand.
Memory Efficiency: In the realm of data, space is precious. Data types are like expert Tetris players, ensuring that every byte is utilized efficiently.
Error Prevention: Picture this: you're making a sandwich, and someone hands you a rubber duck instead of a tomato. Data types act as vigilant gatekeepers, preventing such absurd scenarios in your code.
Code Clarity: Readable code is like a good book you can't put down. Proper data types make your code a page-turner, enhancing its clarity and maintainability.
Functionality: Different data types come with their own bag of tricks. They bring built-in functions and methods to the party, making your life as a programmer easier and more fun.
Data Integrity: Just like a good friend who keeps your secrets, data types maintain the integrity and consistency of data within your program, ensuring that nothing goes awry.

The Fabulous Four Categories of Data Types in Golang

Now, let's slice this data pie into four delightful categories:

Basic types: These are the humble heroes of data types, including booleans, integers, floating-point numbers, and strings. They're like the bread and butter of programming.
Aggregate types: These data types are the Frankenstein's monsters of the programming world. They're made up of other data types, such as arrays, slices, and structs. Imagine a sandwich made of smaller sandwiches!
Reference types: These data types are the GPS of programming; they point to other data in memory. We're talking about pointers, slices, maps, functions, and channels. They help you navigate through the data wilderness.
Interface types: Last but not least, interface types are like the universal remote controls of programming. They define a set of methods that any type can implement. It's the ultimate "plug-and-play" experience for your code.

Now, let's consult this handy table for a quick overview:

Data type	Category	Example
bool	Basic	true, false
int	Basic	1, 100, -1000
uint	Basic	1, 100, 1000
float32	Basic	3.141592653589793, 1.234567890123456, -1.234567890123456
float64	Basic	3.141592653589793, 1.234567890123456, -1.234567890123456
string	Basic	"Hello, world!", "1234567890", ""
[]int	Aggregate	[1, 2, 3, 4, 5]
[]string	Aggregate	["Hello", "world", "!"]
struct { name string; age int }	Aggregate	{ name: "Alice", age: 25 }
*int	Reference	var p *int = nil
map[string]int	Reference	map[string]int{"Alice": 25, "Bob": 30}
func()	Reference	func() { println("Hello, world!") }
chan string	Reference	chan string = make(chan string)
interface{}	Interface	var i interface{} = 10

Let's Inject Some Variable Fun into Go!

Ahoy, Go enthusiasts! We're setting sail on a thrilling journey into the heart of variables in Go. Buckle up because things are about to get wild in the world of data storage. 🚀

Rules of the Variable Jungle

But before we jump into the variable jungle, let's lay down some ground rules:

Variables are like pets; they need names. So, we start with a letter or an underscore _.
They're not picky eaters; they can gobble up letters, digits, and underscores.
No spaces, please! Variables have a strict diet.
Finally, they can't pretend to be Go keywords. Let's not play dress-up with variables, okay?

Here are some examples of well-behaved variable names:

my_integer
my_float
my_string
my_array
my_slice

The Grand Declaration

Now, let's talk about declaring variables. There are two ways to do it, and they each have their own flair:

1. The Normal Way

In the normal way, you play it by the book. You use the var keyword, followed by the variable name and the data type, like a proper introduction:

var my_integer int = 10

2. The Short Variable Way

Now, here's where things get spicy! You can declare a variable in a shorter, snappier way using the := operator. It's like a casual nod instead of a formal handshake:

my_integer := 10

But wait, there's a catch! The short variable declaration can only be used inside functions. It's like the cool kid who's only available at the weekend party.

Spot the Difference

So, what's the deal? Why choose one declaration over the other? Here's the scoop:

Normal Declaration: This one is like the boss telling you exactly what to do. It explicitly states the data type of the variable:
Short Declaration: It's like having a friend who just gets you. It infers the data type from the value you assign to it:

See the magic? In the short declaration, Go looks at the value and says, "Ah, this must be an integer!" It's like Go's version of mind-reading.

But remember, the normal declaration can be used anywhere, even outside functions. Meanwhile, the short declaration is a party animal, only allowed inside functions. 🎉

Arrays and Slices in Go: A Tale of Two Data Structures

Ah, the dynamic duo of data structures in Go – arrays and slices! They're like Batman and Robin, always ready to save the day in your coding adventures. But don't be fooled, they have their own superpowers and quirks. Let's dive into the exciting world of arrays and slices!

Crafting Arrays and Slices

Array

To conjure an array in Go, you wield the following spell:

var myArray [array_size]data_type

The array_size determines how many elements your array can hold, and data_type specifies the type of data it will store.

Slice

Now, let's talk about slices. To summon a slice, you chant:

var mySlice []data_type

The data_type remains the same, but here's the kicker: slices are dynamic! They can grow and shrink as your code demands.

Accessing Elements from Array

To retrieve the treasure (element) from an array, you use this incantation:

myArray[index]

The index is like a treasure map, guiding you to the element you seek. But beware, it must be a non-negative integer smaller than the array's size.

For slices, it's the same chant:

mySlice[index]

Again, the index should be a non-negative integer, but this time, it should be smaller than the slice's length.

Enchanting Updates

To weave a new spell (update) on an array, you recite:

myArray[index] = new_value

The index directs your magic to the specific element you wish to change, and new_value is the enchantment you bestow upon it.

For slices, it's déjà vu:

mySlice[index] = new_value

The index still follows the same rules - non-negative and less than the slice's length.

Two sides: Arrays vs. Slices

Let's put on our boxing gloves and compare these titans:

Characteristic	Array	Slice
Size	Fixed	Dynamic
Access	Square brackets	Square brackets
Update	Can be updated	Can be updated
Comparison	Can use == and !=	Can use == and !=
Passing to Functions	Passed by value	Passed by value

Whom to choose?

So, when do you call upon arrays, and when do you summon slices?

Arrays are like trusty Swiss army knives; use them when you know the exact size of your data collection.
Slices are your shape-shifters, perfect for dynamic data collections and when you want to share your data with functions without creating copies.

Remember, whether you're wielding arrays or unleashing slices, you've got the tools you need to conquer the coding kingdom! So, go forth, brave programmer, and may your arrays and slices always be in your favor! 🦸‍♂️🚀

Navigating the Control Flow in Go

Ah, control flow statements in Go – the rudders that steer the ship of your program's execution! These are the tools that keep your code on the right track. Let's embark on a voyage through the seas of control flow!

If-Else: The Decision Maker

The trusty if-else statement is your first mate when it comes to making decisions in your code. It works like this:

if condition {
    // Code to be executed if the condition is true
} else {
    // Code to be executed if the condition is false
}

The condition can be any Boolean expression. If it's true, the code in the if block sails smoothly. Otherwise, the ship navigates towards the else block.

Switch: The Multitasker

Next up is the switch statement, the multitasker of the control flow crew:

switch expression {
case value1:
    // Code to be executed if the expression equals value1
case value2:
    // Code to be executed if the expression equals value2
// ...
default:
    // Code to be executed if the expression doesn't match any cases
}

The expression can take on various values. The switch statement evaluates it and compares it to each case value. If it matches one, the corresponding case block sets sail. If no match is found, the default block becomes the navigator's choice.

For Loop: The Repetition Enthusiast

The for loop is the workhorse of the control flow family:

for initialization; condition; post-iteration {
    // Code to be executed in the loop
}

The initialization block sets the stage before the loop.
The condition is evaluated before each loop iteration. If it's true, the loop's code is executed; otherwise, the journey ends.
The post-iteration block ensures something happens after each iteration.

While Loop: The Persevering Explorer

Finally, we have the while loop, the tireless explorer:

while condition {
    // Code to be executed in the loop
}

The condition is evaluated before each iteration. If it remains true, the loop keeps marching forward; otherwise, it bids adieu.

Declaring and Defining Functions in Go

To declare a function, you use the func keyword, followed by the function name and parameters in parentheses. The function body goes inside curly braces. For example, here's a function named add() that takes two integers and returns their sum:

func add(a int, b int) int {
  return a + b
}

To define a function, simply assign a function body to it:

func add(a int, b int) int {
  return a + b
}

Passing Arguments to Functions

To pass arguments to a function, list them in parentheses when you call the function:

result := add(1, 2)

Arguments are passed by value, so changes inside the function don't affect the caller's scope.

Returning Values from Functions

Functions can return values using the return statement:

func add(a int, b int) int {
  return a + b
}

The caller can access the returned value using a variable:

result := add(1, 2)

Function Signatures

A function's signature is its name and the types of its parameters and return value:

func add(a int, b int) int

This tells us add() takes two integers and returns an integer.

Named Returns

Named returns let you name the values returned from a function:

func add(a int, b int) (sum int) {
  sum = a + b
  return
}

The caller can then access the returned value by name:

var sum int
sum = add(1, 2)

Variadic Functions

Variadic functions take a variable number of arguments. Declare them with ... before the last parameter:

func sum(numbers ...int) int {
  var total int
  for _, number := range numbers {
    total += number
  }
  return total
}

They can be called with any number of arguments:

result := sum(1, 2, 3)

Now you're ready to navigate the high seas of control flow and harness the power of functions in Go! Fair winds and happy coding! 🌊🚢🌟

Some challenge:

Problem Statement:

You are tasked with creating a command-line calculator program in the Go programming language. This calculator should be able to perform basic arithmetic operations, including addition, subtraction, multiplication, and division. The user will input two numbers and an operator, and the program will display the result of the operation.

Requirements:

The calculator should support the following operations:

- Addition (+)
- Subtraction (-)
- Multiplication (*)
- Division (/)

The program should take three command-line arguments:

- The first argument should be a floating-point number (operand 1).
- The second argument should be one of the supported operators (+, -, *, /).
- The third argument should be another floating-point number (operand 2).

If the user provides incorrect or insufficient arguments, the program should display a usage message explaining how to use the calculator.
For division, the program should check if the denominator is zero to avoid division by zero errors. If the denominator is zero, an error message should be displayed.
The program should perform the requested operation and display the result with two decimal places.

Example Usage:

$ go run calculator.go 5 + 3
5.00 + 3.00 = 8.00 

$ go run calculator.go 10.5 - 3.2 
10.50 - 3.20 = 7.30 

$ go run calculator.go 2.5 * 4.0 
2.50 * 4.00 = 10.00 

$ go run calculator.go 6 / 0 
Error: division by zero

I even spend so many times mitigating even small errors in the code. So refer this code if needed:
https://github.com/kutt27/go_series/blob/main/Beginner/calculator_cli/dev_calculator_program.go

To run the code, follow:
https://github.com/kutt27/go_series/blob/main/Beginner/calculator_cli/runnning_the_program.md

If you encounter any problem or any error, pull a PR.

Thanks again for reading!!! 😊🚀

How to Print Hello World in Go: A Beginner's Guide

Amal Satheesan — Sat, 23 Sep 2023 11:02:23 +0000

Introduction

This post will guide you through printing the universally beloved "Hello, World!" message in Go. But before we dive into the code, let's provide a brief introduction to the Go programming language:

Go, also commonly referred to as Golang, emerged in 2009 as a statically typed, compiled programming language developed by Robert Griesemer, Rob Pike, and Ken Thompson at Google. Although it shares syntactical similarities with C, Go incorporates memory safety, garbage collection, structural typing, and CSP-style concurrency.

Go is a modern and versatile programming language, purpose-built for simplicity, efficiency, and reliability. Its capabilities span across various domains, including web development, distributed systems, command-line tools, and more.

If you've already set up your Go environment on your system, feel free to follow along. If not, don't worry; we'll also discuss setting up your Go environment.

Writing Your First Go Program

Let's embark on the journey to print everyone's favorite:

Hello, World!

Create a Directory

Begin by creating a new directory for your Go project, giving it a name of your choice. For this example, we'll call it hello-world.

mkdir hello-world

Navigate into your newly created directory:

cd hello-world

Create a Go File

Inside your project directory, create a new file named main.go. You can use any text editor or integrated development environment (IDE) to create and edit the file.

Hello, World Program

Within the main.go file, insert the following code:

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

Remember to save the file. That's all there is to it.

Running Your Go Program

Open the terminal, either within your IDE or using your system's built-in terminal.
To execute the program, utilize the go run <filename> command.

go run main.go

You should see the following output:

Hello, World!

Congratulations! You have successfully run your first Go program, printing the timeless "Hello, World!" message. This marks the beginning of your exciting journey into the Go programming language.

Stay tuned for more Go tutorials and exploration. Happy coding! 😊