DEV Community: Harshit Rawat

Build Smarter: 8 Powerful APIs every Dev must try in 2025 🔥

Harshit Rawat — Thu, 01 May 2025 06:21:03 +0000

As developers, we’re always on the lookout for ways to enhance our projects, streamline our workflows, and reduce development time.

APIs are invaluable tools that allow us to leverage existing functionalities without reinventing the wheel. Whether you’re building a social media platform, a fitness tracker, or a financial management app, the right APIs can elevate your project and simplify your development process.

In this article, I’ll share 8 such essential APIs that can help you optimize your workflow, minimize repetitive coding, and create awesome applications with ease.

So, let’s dive in and explore these API's !

SerpAPI - Fetch live , Google, Bing & more!

Imagine you’re developing a web application that relies heavily on search engine data to drive traffic and engagement.

To stay competitive, you need to understand how your content ranks, what keywords are trending, and how your competitors are performing in real-time.

But manually tracking search results across different regions and devices? That’s a daunting task. Enter SerpAPI, the ultimate solution for accessing Google search results effortlessly.

SerpAPI doesn’t just provide basic search results, it delivers comprehensive data, including organic listings, ads, and rich snippets, all in a structured format. This API is perfect for SEO analysis, market research, and content optimization, allowing you to tailor your strategies based on real-time insights.

curl 'https://serpapi.com/search.json?q=coffee&api_key=YOUR_API_KEY'

The api response with

{
  "search_metadata": {
    "id": "1234567890",
    "status": "Success"
  },
  "organic_results": [
    {
      "position": 1,
      "title": "Best Coffee Beans",
      "link": "https://example.com/best-coffee-beans",
      "snippet": "Discover the best coffee beans for your brew."
    },
    {
      "position": 2,
      "title": "Coffee Brewing Techniques",
      "link": "https://example.com/coffee-brewing",
      "snippet": "Learn how to brew the perfect cup of coffee."
    }
  ],
  "ads": [
    {
      "position": 1,
      "title": "Buy Coffee Online",
      "link": "https://example.com/buy-coffee",
      "snippet": "Get your favorite coffee delivered to your door."
    }
  ]
}

Why should you consider using SerpAPI?

✅ Comprehensive Data: Access a wealth of information, including ads, organic results, and SERP features.
✅ Real-Time Insights: Stay updated with the latest search trends and competitor strategies.
✅ Ease of Use: Simple integration with clear documentation makes it easy to get started.
✅ Scalability: Handle large volumes of requests without compromising performance.

🚀 Explore more about SerpApi here.

AssemblyAI Api - Converts speech to text with sentiment analysis.

Okay so, Imagine you’re developing a web application that relies heavily on speech-to-text capabilities to transcribe audio, analyze conversations, and extract meaningful insights from voice data.

To stay competitive, you need an accurate, scalable, and real-time transcription service that supports multiple languages, speaker identification, and advanced audio intelligence.
AssemblyAI doesn’t just provide basic transcriptions, it delivers highly accurate speech-to-text conversion, along with features like summarization, sentiment analysis, entity detection, and even automatic content moderation.

# Upload your audio file to AssemblyAI

curl -X POST "https://api.assemblyai.com/v2/upload" \
  -H "authorization: YOUR_API_KEY" \
  --data-binary @"call.wav"

once uploaded

# Start transcription with sentiment analysis
curl -X POST "https://api.assemblyai.com/v2/transcript" \
  -H "authorization: YOUR_API_KEY" \
  -H "content-type: application/json" \
  -d '{
    "audio_url": "https://cdn.assemblyai.com/upload/<UPLOAD_URL_FROM_PREVIOUS_STEP>",
    "sentiment_analysis": true
  }'

# Poll the status (replace with actual transcript ID)
curl -X GET "https://api.assemblyai.com/v2/transcript/your-transcript-id" \
  -H "authorization: YOUR_API_KEY"

# Final response:
# {
#   "text": "Thank you for calling...",
#   "sentiment_analysis_results": [
#     { "text": "Thank you for choosing Devto", "sentiment": "POSITIVE" },
#     { "text": "I appreciate you read my articles.", "sentiment": "POSITIVE" }
#   ]
# }

Why should you consider using AssemblyAI?
✅ Accuracy: Leverages deep learning models to provide high-accuracy transcriptions.
✅ Advanced AI Features: Beyond transcription—includes summarization, sentiment analysis, and entity detection.
✅ Real-Time & Async Processing: Get live transcriptions or process large batches efficiently.
✅ Easy Integration: Simple REST API with clear documentation and multiple SDKs.

🚀 Explore more about AssemblyAI here

Open Food Facts API - Scan food barcodes and fetch nutrition details.

Every day, we consume packaged food without knowing much about its ingredients, additives, or environmental impact. But what if you could scan the barcodes of food products around you and instantly get detailed nutritional information, allergen warnings, and even sustainability scores?

To make this possible, you need access to a comprehensive food database that provides structured and real-time data on millions of products worldwide.

Open Food Facts doesn’t just offer basic product details, it enables health-conscious decisions, dietary tracking, and transparency in food consumption by providing detailed insights into ingredients, Nutri-Score, carbon footprint, and even eco-friendly packaging data.
Also, Let’s say you build an app that allows users to scan food barcodes to show ingredients and nutrition details.

# Step 1: Use the Open Food Facts API to fetch product details by barcode

# Example would be, if the scanned barcode is: 737628064502 (Tomato Ketchup)

curl -X GET "https://world.openfoodfacts.org/api/v0/product/737628064502.json"

The response you'll see on the app:

{
  "status": 1,
  "product": {
    "product_name": "Tomato Ketchup",
    "brands": "Kissan",
    "ingredients_text": "Tomato concentrate, vinegar, sugar, salt, spice...",
    "nutriments": {
      "energy-kcal_100g": 100,
      "sugars_100g": 22.8,
      "salt_100g": 1.8
    }
  }
}

Why should you consider using Open Food Facts API?
✅ Scan & Learn: Retrieve instant information about food products by scanning barcodes.
✅ Global Database: Access millions of products with detailed nutritional and ingredient data.
✅ Health & Safety Insights: Identify allergens, additives, and nutritional quality for better dietary choices.
✅ Eco-Conscious Data: Get sustainability ratings, packaging impact, and carbon footprint details.

🚀 Explore more about Open Food Facts API here

CoinGecko API - Get live cryptocurrency data.

So, Let's say you entered into Web3 space and want to explore and build some cool projects in it, maybe a financial dashboard, a crypto portfolio tracker, or even a DeFi analytics tool. To make it truly valuable, you need real-time cryptocurrency prices, historical market trends, and key financial metrics, all in a reliable and developer-friendly format.

CoinGecko API is the go-to solution for fetching accurate, up-to-date crypto market data. It doesn’t just provide basic price tracking, it delivers insights into market capitalization, trading volume, exchange data, historical price trends, and even sentiment analysis across thousands of cryptocurrencies.

# If you want to get the price of multiple cryptocurrencies
https://api.coingecko.com/api/v3/simple/price ids=bitcoin,ethereum,dogecoin&vs_currencies=usd

Integrating into your codebase:

// get prices for multiple cryptocurrencies
async function getCryptoPrices() {
  const response = await fetch('https://api.coingecko.com/api/v3/simple/price?ids=bitcoin,ethereum,dogecoin&vs_currencies=usd');
  const data = await response.json();

  // Display the prices
  console.log('Bitcoin Price (USD):', data.bitcoin.usd);
  console.log('Ethereum Price (USD):', data.ethereum.usd);
  console.log('Dogecoin Price (USD):', data.dogecoin.usd);
}

getCryptoPrices();

Why considering CoinGecko API is best?
✅ Real-Time Market Data: Get up-to-the-second price updates for over 13,000+ cryptocurrencies.
✅ Historical & Trend Analysis: Retrieve price charts, volume trends, and historical OHLC (Open, High, Low, Close) data to track market movements.
✅ Exchange & Liquidity Insights: Access exchange rankings, liquidity scores, and DeFi-specific metrics for informed decision-making.
✅ Free & No API Key Required: Unlike many paid alternatives, CoinGecko offers a free API with generous rate limits.

🚀 Explore more about CoinGecko API here

Replicate API - Vector database for fast similarity searches.

Imagine you want to integrate powerful AI models into your application, whether it’s for image generation, text-to-speech, code completion, or AI-powered video editing. Training and hosting these models yourself is costly and complex. You need a simple, scalable way to run cutting-edge machine learning models without managing infrastructure.

Replicate API is the perfect solution, it allows developers to run state-of-the-art AI models on the cloud with just a few API calls. Instead of setting up GPUs and managing ML deployments, you can instantly access and execute models for a variety of tasks, from generating images with Stable Diffusion to transcribing audio with Whisper.

Let's say you decide to make an image generation app or a similar feature to add into your existing project, you can use Replicate API key.

Once you sign in to Replicate, get you API key.

# Below is a basic sample program on how to setup the replicate API key inside the project

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Image Generator</title>
</head>
<body>
  <h1>Generated Image</h1>
  <img id="generated-image" src="" alt="Generated Image" />
  <p id="loading-message">Generating your image...</p>

  <script>
    async function generateImage() {
      const apiKey = 'YOUR_API_KEY';  // Replace with your actual Replicate API key
      const versionId = 'model-version-id';  // Replace with the correct model version ID


      const prompt = 'A place full of happy people';

      try {
        const response = await fetch('https://api.replicate.com/v1/predictions', {
          method: 'POST',
          headers: {
            'Authorization': `Token ${apiKey}`,
            'Content-Type': 'application/json',
          },
          body: JSON.stringify({
            version: versionId,  // Use the model version ID, get it from replicate
            input: { prompt: prompt },  
          }),
        });

        const data = await response.json();


        const imageUrl = data.output[0]; 
        document.getElementById('generated-image').src = imageUrl; 
        document.getElementById('loading-message').style.display = 'none';  
      } catch (error) {
        console.error('Error generating image:', error);
        document.getElementById('loading-message').innerText = 'Error generating image.';
      }
    }

    generateImage();  
  </script>
</body>
</html>

Why should you consider using Replicate API?
✅ Cutting-Edge AI Models: Run the latest AI models, including image generation, NLP, speech recognition, and video processing, directly via API.
✅ Pay-As-You-Go: You only pay for what you use, making it cost-effective for both small and large-scale applications.
✅ Simple API Integration: With clear documentation and an easy-to-use REST API, integrating powerful AI into your project takes just a few lines of code.
✅ Custom Model Hosting: Got your own AI model? Upload and deploy it on Replicate without worrying about scaling or performance issues.

🚀 Explore more about Replicate API here

Fixer API - Get real-time foreign exchange rates

Imagine you’re developing a global e-commerce platform, a travel expense tracker, or a financial dashboard. Your users need up-to-date currency exchange rates to make informed decisions. But fetching accurate forex data manually? That’s impractical.

Fixer API simplifies currency conversion by providing real-time and historical exchange rate data for over 170 world currencies. Whether you need to convert prices dynamically, display forex trends, or integrate multi-currency support, Fixer makes it effortless.

Once you sign for a free account

Choose Method: GET

URL: https://api.apilayer.com/fixer/latest?base=USD&symbols=EUR,GBP,JPY

Sample Response:

{
    "success": true,
    "timestamp": 1617123456,
    "base": "USD",
    "date": "2025-01-05",
    "rates": {
        "EUR": 0.85,
        "GBP": 0.74,
        "JPY": 110.23
    }
}

You can also use this API in your app or script.


async function getExchangeRates() {
  const apiKey = 'YOUR_API_KEY'; // Replace with your actual Fixer API key
  const url = `https://api.apilayer.com/fixer/latest?base=USD&symbols=EUR,GBP,JPY`;

  const response = await fetch(url, {
    method: 'GET',
    headers: {
      'apikey': apiKey,
    },
  });

  const data = await response.json();
  console.log(data);
}

getExchangeRates();

Why should you consider using Fixer API?
✅ Live & Historical Rates: Access real-time forex data, plus historical rates dating back years.
✅ 170+ Currencies: Get exchange rates for almost every global currency.
✅ High Accuracy & Reliability: Data sourced from trusted financial providers and updated every 60 seconds.
✅ Simple REST API: Easily integrate with your website or app with minimal effort.

🚀 Explore more about Fixer API here

Perigon News API – - Real-time AI-Powered News Aggregation

Imagine building a custom news dashboard, sentiment analysis tool, or AI-driven media monitoring platform. You need access to real-time, structured news data from trusted sources worldwide. Scraping news manually? That’s outdated.

Perigon News API delivers real-time, structured news articles enriched with AI-powered categorization, sentiment analysis, and entity recognition. It’s perfect for tracking industry trends, monitoring competitors, or powering content-driven applications.

# Get your API key
# Test the API via GET Method
URL : https://api.perigon.com/v1/news?apiKey=YOUR_API_KEY&category=business

Sample Response:

{
  "status": "ok",
  "totalResults": 100,
  "articles": [
    {
      "source": { "id": "cnn", "name": "CNN" },
      "author": "John Doe",
      "title": "Tech Innovations in 2025",
      "description": "A look at the upcoming tech trends expected to dominate the market in 2025.",
      "url": "https://cnn.com/article1",
      "content": "The technology industry is set for massive innovations..."
    },
    {
      "source": { "id": "bbc", "name": "BBC" },
      "author": "Jane Smith",
      "title": "AI in Business: What's Next?",
      "description": "Exploring the role of artificial intelligence in modern business.",
      "url": "https://bbc.com/article2",
      "content": "Businesses are increasingly turning to AI to streamline operations..."
    }
  ]
}

You can fetch the latest news on a given topic and display it in your application

const fetch = require('node-fetch');

async function fetchLatestNews() {
  const apiKey = 'YOUR_API_KEY'; // Replace with your Perigon API key
  const url = `https://api.perigon.com/v1/news?apiKey=${apiKey}&category=technology`;

  const response = await fetch(url, {
    method: 'GET',
    headers: {
      'Authorization': `Bearer ${apiKey}`,
    },
  });

  const data = await response.json();
  console.log(data);

}

fetchLatestNews();

Why should you consider using Perigon News API?
✅ Real-Time Global News: Access breaking news from thousands of trusted publishers worldwide.
✅ AI-Powered Insights: Get sentiment analysis, topic categorization, and entity extraction for deeper context.
✅ Advanced Filtering: Search by date, category, location, sentiment, and even specific companies or topics.
✅ No Paywalls: Get the full text of news articles, not just snippets.

🚀 Explore more about Perigon News API here

Open-Meteo API – Hyperlocal Weather Data (Fast & Free)

Open-Meteo API – - Hyperlocal Weather Data

Imagine you’re developing a weather forecasting app, an outdoor adventure planner, or a precision agriculture tool. You need highly accurate, real-time weather data—but most APIs are slow, expensive, or locked behind complex authentication processes.

This isn’t just another weather API. Open-Meteo API is a blazing-fast, free, and developer-friendly weather API designed for high-performance applications. Whether you’re tracking live conditions, forecasting severe storms, or optimizing farming operations, Open-Meteo delivers precision weather insights at scale—without the hassle of API keys.

You don't need any API key to use this:

Test the URL via GET Method
URL: https://api.open-meteo.com/v1/forecast?latitude=28.6139&longitude=77.2090&hourly=temperature_2m&timezone=Asia/Kolkata

Sample Response

{
  "latitude": 28.6139,
  "longitude": 77.209,
  "generationtime_ms": 1.8,
  "utc_offset_seconds": 19800,
  "timezone": "Asia/Kolkata",
  "timezone_abbreviation": "IST",
  "elevation": 216,
  "hourly_units": {
    "temperature_2m": "°C"
  },
  "hourly": {
    "time": [
      "2025-05-01T00:00",
      "2025-05-01T01:00",
      "2025-05-01T02:00",
      ...
    ],
    "temperature_2m": [
      26.3,
      25.7,
      25.1,
      ...
    ]
  }
}

Example UseCase for my City:

async function getWeather() {
  const url = 'https://api.open-meteo.com/v1/forecast?latitude=28.6139&longitude=77.2090&hourly=temperature_2m&timezone=Asia/Kolkata';

  const response = await fetch(url);
  const data = await response.json();

  const times = data.hourly.time;
  const temps = data.hourly.temperature_2m;

  console.log(`Hourly temperatures for Delhi, India:`);
  for (let i = 0; i < 6; i++) {
    console.log(`${times[i]} — ${temps[i]}°C`);
  }
}

getWeather();

Why should you consider using Open-Meteo API?
✅ Free & Open-Source: No API key required—start using it instantly.
✅ Ultra-Fast Requests: Optimized for low-latency, high-performance applications.
✅ Accurate Forecasts: Get real-time, hourly, and 7-day weather predictions.
✅ Global Coverage: Supports any latitude/longitude worldwide.
✅ Multiple Weather Variables: Fetch temperature, precipitation, wind speed, humidity, and more.
✅ Great for real-time weather dashboards, travel planners, or smart IoT devices.

🚀 Explore more about Open-Meteo API here

Conclusion ⭐
Alright, so we’ve covered a bunch of APIs, some powerful, some underrated, and all insanely useful. From turning speech into text with AssemblyAI to tracking crypto prices in real time with CoinGecko, we’ve seen how the right APIs can save time, add value, and unlock new possibilities.

Thank you for making it to the end! I hope you will definitely join these communities. If you enjoyed the content, please consider sharing it with someone who might benefit from it.
Feel free to reach out to me on Twitter, LinkedIn, Youtube, Github.
Thankyou Once Again!!

Build an AI Personality Analyzer with Groq and Node.js 🤩

Harshit Rawat — Fri, 21 Feb 2025 16:18:11 +0000

Introduction

Hey everyone, Good to see you back! We're going to build an AI-powered personality analyzer using the Groq SDK with Node.js. The app will analyze user responses to fun questions and match them with characters from Stranger Things. Why Stranger Things? Because it's awesome!

We'll be using one of the models given by Groq to build this application. The main reason behind using Groq is its high RPM (Requests Per Minute), making it ideal for building fast and scalable applications.

This project is ideal for beginners who want to explore how AI can be used to create fun and interactive applications. However, even experienced developers will enjoy the process, and your suggestions are always welcome!

Setting up the Project

To setup the project start with first initializing nodejs into the project. Create a directory "aiapp".
Type the command below to initialize a npm project.

npm init y

Dependencies setup

To make this project we need few dependencies to install. Type the below command onto your terminal.

npm install dotenv express groq-sdk

Here's how package.json should look like:

Don't forget to add the script : start: node app.js

Here we need express to setup the server for our nodejs project, followed by dotenv to load the values (Api keys) from our .env file and finally the groq-sdk package provided by groq that will be used to analyze the personalities.

Inside your projects directory , create a file named .env. Add the below code inside the file.

GROQ_API_KEY= your api key  #generated by groq

Where can you get the Api key from?

Visit the official website of groq here, sign up for a free account and visit the api keys section.
Here, click generate api key and copy the key generated , create a env file in the project's root and paste the key in your env file.

Let's configure the server
Follow the below folder structure for setting up the project.

The files inside the folders can be accessed here. Make sure to star the project :)

Create a file app.js and write the following code inside it (The whole code can be accessed here)

const express = require('express');
const path = require('path');
require('dotenv').config();

const questionsRoutes = require('./routes/questions');
const quizRoutes = require('./routes/quiz');

const app = express();
const port = 3000;

app.use(express.json());
app.use(express.static(path.join(__dirname, 'public')));

app.use('/questions', questionsRoutes);
app.use('/quiz', quizRoutes);

app.get('/', (req, res) => {
  res.sendFile(path.join(__dirname, 'public', 'index.html'));
});

app.listen(port, () => {
  console.log(`Server listening at http://localhost:${port}`);
});

I have added another file, script.js in order to fetch the questions, This allows for dynamic loading of questions without requiring a full page refresh.

Now, we can Start the server, run the below command.

npm start

I have created some questions for users to answer and match with a stranger things personality. Let's check if we can access them, visit any of the api testing platforms, I'm using Thunder Client.

It works!!

Setting up Groq and prompts

Now that we have created the server let's now setup groq and feed in some data inside the utils/analysis.js that can be used further.

const { Groq } = require('groq-sdk');

const groq = new Groq({ apiKey: process.env.GROQ_API_KEY });

const characterDescriptions = { "This data can be accessed from the below link" };

async function analyzePersonality(answers, questions) {
  const prompt = " This data can be accesses from the below link"

  try {
    const response = await groq.chat.completions.create({
      model: "llama3-8b-8192",
      messages: [{ role: "user", content: prompt }],
    });

    return response?.choices[0]?.message?.content || "Error analyzing personality.";
  } catch (error) {
    console.error("Error analyzing personality:", error);
    return "Error analyzing personality.";
  }
}

module.exports = { analyzePersonality };

Use the link, for accessing the Character details and prompt.

The above code uses the Groq SDK to define a function analyzePersonality that analyzes personality traits based on user input by interacting with the Groq API. Here I'm using the llama3-8b-8192 model, which is part of the LLaMA family and perfectly balanced generating human-like text in applications like personality analyzer. The model's size and capabilities allow it to understand provide relevant responses efficiently, making it a practical choice compared to smaller or more resource-intensive alternatives.

Let's now check the functionality of our application, run the server visit http://localhost:3000 to see the live application.

Testing

Let's now test the app if its working as expected and check what character will I receive.

npm start

and visit localhost:3000 and answer all the questions.

Ohhh Nice! I got Lucas, such a practical and trustworthy Character, I'm excited to see what character you get.

Conclusion

With this we have successfully integrated AI inside our app using Groq, this can be further used in creating many such fun projects. Thankyou If you made it to last.
I hope you found the content enjoyable and inspiring for your own projects! If you have any suggestions for improvements or enhancements, please don’t hesitate to share your thoughts in the comments.

Also, consider sharing this with anyone interested in creating exciting projects using AI!

For paid collaborations mail me at: harshit77dev@gmail.com
Feel free to reach out to me on Twitter, LinkedIn, Youtube, Github.
Thankyou Once Again!!

Master Shell Scripting – Zero to Interview Ready!🔥

Harshit Rawat — Mon, 10 Feb 2025 16:12:57 +0000

Introduction

Hey Everyone, Good to see you back! For us programmers, diving into the world of Bash scripting is really important. It's all about creating scripts, which are essentially mini-programs, to automate those tedious, repetitive actions we face daily. Instead of manually running commands over and over, we use scripts to make them easy.

It's about making our lives easier by automating the mundane, freeing us to focus on the more exciting aspects of development.

Over the next few minutes, we'll explore the fundamentals of Bash scripting with practical examples. By the end, you'll have a solid understanding of streamlining your workflows and boosting your productivity.

Are you excited?

Any Prerequisites?
If you are a window user, you need to setup WSL for using Linux on your system. You can explore more about it here.

Note: In this article, the terms "shell script" and "Bash script" are used interchangeably. Bash is the most common shell, and for the purposes of this discussion, they can be considered the same.

Covering the Basics

What exactly is a Bash Script ?
Think of it as creating a mini-program to automate tasks you'd normally do manually. These scripts are plain text files containing commands you would typically type into the command line. An example could be, Let's say you need to copy all 100 files from folder A to folder B, well this task is really boring and repetitive, hence you can write a bash script to copy all the files from A to B.

Why do we need it, Is it that important ?
We need Bash scripting because it saves us time and effort. Think of it as having a assistant who can handle all the boring, repetitive tasks, so you can focus on the interesting stuff. Yes it really helps in automating big tasks for Organizations.

Where do we write these scripts ?
We write these scripts inside text editors. In our case we will be using VIM editor that comes inside our Linux distribution.

This is how a shell looks like:

Bash Commands

Here, we'll understand about the most used bash commands.

It's important to know the path you are present currently, this get's confusing when we work on multiple projects. To get the current directory we use the command pwd which means 'print working directory'

pwd

Now that we know our present directory, Let's make a new folder (u also call it a directory) where we can keep our files. To do this, we use the mkdir command, which means "make directory."

mkdir <specify your folder name>

After creating you directory you can view inside it using ls command.

ls

You can also use ls -ltr command, this lists the contents in long format (-l), sorted by modification time (-t) with the oldest entries displayed first (-r).

ls -ltr

Now, For moving inside the folder/directory you write the command cd which stands for change directory, using cd you can enter inside the folder and again typing ls will show all the files inside that folder.

cd <folder_name>

In order to come out of the directory you are currently in, you can use the command cd .., this let's you out of the directory.

cd ..

In order to remove a file or complete directory we use the command rm -r

rm -r <name of file or folder>

We can rename a file using the command mv.

mv <your-file-name> <new-file-name>

Let's make a file now, To make a file we use the touch command.

touch <filename>

To print the content inside a file we make use of the cat command.

cat <filename>

The file initially is empty because we haven't added anything inside the file. Let's add some content to the file. we'll use vim editor(complete detail ahead in the article) to edit the file , save it and then use the cat command.

Vim editor

The file is now showing the content we have written.

Lastly, If we want to print something on the shell, we use the command echo.

Okay, great! We've learned the basic commands to move around in the shell. Now we can move on to more interesting stuff. It's not really hard, so don't worry!

Bash Script & VIM editor

Now, If you have never done scripting before, you might not be familiar with vim and all the memes associated with it. Well, vim is an editor that is used for writing bash scripts on terminal, there are many such others editors like neovim, nano that can help you to write scripts but we'll be using vim in this tutorial.

Note: For first timers, you may struggle using vim, don't worry, it's pretty normal.

Let's write our first bash script

"#" symbol is used to show the content is a comment not a part of program.
# Type the below command on the shell.

vim bashscriptfile.sh

Yeahh!!, you are now inside the vim editor.

Note: You won't be able to type or Insert anything on the editor right now, because it doesn't open by default in Insert mode.

To enable Insert mode you need to press the i key on you keyboard, Now you'll be able to write like on a normal editor.

You can see the editor is in Insert mode now.

Tricky part
Now that you have done writing on vim you need to save it and come out of the editor, To save you progress we first need to come out of insert mode by pressing esc key, now we type :w command and this will save our progress, To come out of vim after saving progress, we use :q command.

We can use :wq! command directly to save and exit out of the editor.

you can also use the command :x, for the same.

You can simply write the command bash or sh (we'll talk about them soon) followed by the file name to run your sample script.

Now you might have noticed , that I've changed the file extension to .sh, The .sh extension in filenames like bashscriptfile.sh indicates that the file is a shell script, which contains a sequence of commands to be run by a Unix shell.

Now, Let's write a much better shell script. In the above file we haven't used #!/bin/bash in our vim editor, this is because it was a very normal script that was just printing the command we provided but in reality we work with complex scripts that has lots of code which needs to be compiled/interpreted.

The shebang line, #!/bin/bash, at the start of a shell script tells the operating system which interpreter, in this case, the Bash shell located at /bin/bash, should be used to execute the script, ensuring it runs correctly and consistently regardless of the user's default shell.

#! : These two characters indicate that the file is a script, and what follows is the path to the interpreter.
/bin/bash : This is the path to the Bash shell interpreter.

Now, Let's write a shell script that automates the process of file and folder creation, The script will create a folder and 5 files inside the folder when executed.

vim firstscript.sh

#!/bin/bash

# this is used to ask the name of folder/directory u wanted to create.
read -p "Enter the directory name: " dir_name

# if the folder/directory already exist, show error
if [ -d "$dir_name" ]; then
  echo "Error: Directory '$dir_name' already exists."
  exit 1
fi

# Creating the directory
mkdir "$dir_name"

# if we are able to create it or not
if [ ! -d "$dir_name" ]; then
  echo "Error: Failed to create directory '$dir_name'."
  exit 1
fi

# Creating 5 files inside the directory we made.
for i in {1..5}; do
  file_name="$dir_name/file_$i.txt"
  touch "$file_name"
  if [ ! -f "$file_name" ]; then
    echo "Error: Failed to create file '$file_name'."
  fi
done

echo "Directory '$dir_name' and 5 files created successfully."

exit 0

After writing the script save it, come back to terminal and run the below command, Let's see if we really automated file creation.

bash firstscript.sh

It'll then ask you to enter a folder name, I entered "firstdirectory".

🎉🎉 Woo hoo!, you have written you first bash script, If you are enjoying this, consider following me for more such content!!

File Permissions

While executing your shell script, when you type ./ <sample.sh> command to run the file, you will see permission error, this is because you don't have permissions to execute the file.

File permissions in Shell scripting are crucial for managing access control in Unix-like systems. The chmod command is used to change these permissions, determining who can read, write, and execute files.

The chmod command uses numeric codes to set permissions, based on the 4-2-1 rule. Each digit represents the permissions for the owner, group, and others, respectively.
4: Represents read permission.
2: Represents write permission.
1: Represents execute permission.

4+2+1 = 7, It means giving complete access of the file to everyone, (not advised).

chmod 777 demo.txt

chmod +x demo.txt

In the above command, you are giving complete access to file anyone can read write and execute this file.

You can explore more about the chmod command here.

Bash vs Sh

Above we talked command commands for executing our shell scripts. We can use both sh and bash. sh focuses on prioritizing portability and adhering to POSIX standards for maximum compatibility across Unix-like systems. bash is a more feature-rich shell common on Linux and macOS, offering conveniences like command-line editing and arrays storing command history, but sacrificing some portability.

We can say that bash is sh but with some more advanced features.

Networking in Shell scripting

Networking in shell scripting involves using command-line tools within shell scripts to interact with networks, transfer data, and manage network configurations. It allows automation of network-related tasks, such as checking network connectivity, downloading files, configuring network interfaces, connecting to remote instances etc.

Shell scripting's ability to automate tasks, manage configurations, and handle file manipulation makes it invaluable for professionals in system administration, DevOps, and development.

Common Commands
curl: Transfers data to or from a server using network protocols.
Below command will output the HTML code of the Dev Community homepage to your terminal.

curl https://dev.to

ping: Checks the connectivity of a system to another host.

ping www.google.com

ssh: Connects to a remote host securely. The command is used in connecting to remote instances like Ec2.

ssh username@ip-address

Conditional Statements & Positional Arguments

They are the normal if/else statements just like in any other language. It differentiates as fact that at the end we use fi to indicate the ending.

if [[ condition1 ]]
then
  commands1
elif [[ condition2 ]]
then
  commands2
else
  commands3
fi

let's create a very simple script.

vim condition.sh

save the script properly

Positional Arguments : We have a concept of positional arguments in shell script which stores the command-line arguments passed to a shell script. They are referred to as $1, $2, $3, and so on, where $1 is the first argument, $2 is the second argument, and so on. $0 reserved for script file name.

You can type the arguments after the bash command and file name

Loops & Functions

There are primarily three types of loops in shell scripting: for, while, and until. The for loop iterates over a sequence of items, the while loop executes as long as a condition is true, and the until loop executes as long as a condition is false.

for i in {INITIAL_VALUE..TERMINATING_VALUE}
do
  # Code 
done

vim forloop.sh

Now save the file

Functions, As we know are named blocks of code that can be called and reused throughout a script.

function_name() {
  # Commands
}

vim functions.sh

This script defines a function called follow that takes one argument and prints the statement.

Let's write a script using both functions and loops.

vim sumScript.sh

Note: If you forgot how to type inside vim , remember to press i to enable insert mode.

#!/bin/bash

# Calculate the sum of numbers from 1 to n.

sum_numbers() {
  local n=$1
  local sum=0
  local i=1

  while [[ $i -le $n ]]; do
    sum=$((sum + i))
    i=$((i + 1))
  done

  echo "Sum of numbers from 1 to $n is: $sum"
}

while true
do
  read -p "Enter a positive integer or press q to exit:" input
  if [[ "$input" == "q" ]]; then
    break
  fi

  # Check if input is a number
  if ! [[ "$input" =~ ^[0-9]+$ ]]; then
    echo "Invalid"
    continue
  fi

  sum_numbers "$input"
done

echo "Script completed."

save the script

Deep dive: Some More Interesting Commands 🚀

Piping | & Redirections (>>)

Piping, represented by the | symbol, is a powerful feature in shell scripting that allows you to chain commands together. The commands after the pipe symbol are always dependent on the commands before the symbol.

echo 'Hello, Bash piping!' | wc -w

The wc -w command counts the number of words in its input, resulting in the output ‘3’, which clearly shows how it is dependent on the input.

Grep Command

The grep command is a powerful tool in Linux used for searching text or patterns within files. In order to search for a keyword, process or anything that is specific to an organization, grep command comes in handy.

grep "keyword" <filename>

Here's how I searched for the word demo in the file created above.

Now, Let me demonstrate how to find running processes on your system using the grep command. Grep is invaluable in industries for identifying keywords of interest within large log files, very much like we searched for particular process.

ps -ef | grep "postgres"

Sed Command

The sed command, also "stream editor," is a command-line utility in Unix-like operating systems used for text manipulation.
You can perform search, replace, insert, and delete operations on text within files or input streams without opening the file in a text editor.

let's run a bash script for replacing text within a file. Let's make a touch sedfile.txt and write "This is a bash scripting tutorial" in it , followed by:

vim sedsamplefile.sh

It will open the vim editor, enable insert mode.

Now let's run our scripts.

Note: I have already written the content inside the sedfile.txt using vim editor. Now we'll run the scripts.

You can see that scripts worked as expected and bash gets replaced by shell.

sed can be used to convert data formats, clean up messy data, automating repetitive text editing tasks in shell scripts, find and replace operations across multiple files, and generating code snippets.

Awk Command

The awk command in shell scripting is a powerful text-processing tool used for pattern scanning and processing. It can filter and manipulate text data, making it useful for reports, calculations, and text transformations. AWK processes files line by line, splitting each line into fields.

vim awk_script.sh

Let's add a script to show only the usernames of logged in users.

save the file

You can clearly see it prints the name of users who logged in today.

# The $2 indicates the column 2 which was assigned to username and similarly $1 was assigned to date.

awk '{print "User: " $2 " logged in on " $1}'

AWK is commonly used for log processing, data extraction, and text transformation. For example, if we have a log file with columns like date, username, and action performed like the above one, we can use AWK to extract only the relevant information like username above.

I/O Redirections : Redirections allows you to change the input and output streams of commands. By default, commands receive input from keyboard and send output to terminal screen But Redirection lets you change where the input comes from or where the output goes.

Redirecting Output to a File (>)

Earlier we have used vim editor to edit the sedfile.txt but it can be done using the terminal only, using redirection operators.

The > operator is used to send output to a file, overwriting any existing content.

echo "Hello, World!" > sample.txt

This will insert the text "Hello, world!" inside sample.txt file.

Appending Output to a File (>>)

The >> operator appends output to an existing file instead of overwriting it.

echo "This is an appended line." >> sample.txt

This will append the line below the "Hello, world!" text.

Input Redirection (< Command)

The < operator is used to take input from a file instead of the keyboard.

 cat < output.txt

Redirecting Both Output and Errors (&> and 2>)

Redirects error messages to a file.

ls random_file 2> error_log.txt

Output will be ls: cannot access 'random_file': No such file or directory

Redirecting Both Output and Error (&> Command)

Sends both standard output and standard error to a single file.

ls valid_file Invalid_file &> output.txt

Expected output:

valid_file
ls: cannot access 'Invalid_file': No such file or directory

Earlier we have used vim editor to edit the sedfile.txt but it can be done using the terminal only, using redirection operators.

I/O redirection is a fundamental Linux concept that allows users to manage data efficiently.

Error Handling and Debugging

Error handling as always is crucial for creating reliable shell scripts. It involves managing unexpected situations during program execution and ensuring that the script behaves predictably.

Basic Error Handling

# This option causes the script to exit immediately if a command fails.
set -e

Let's write a sample script.

vim sample.sh

Adding a script that can print the content of a file but here we'll be learning how set -e comes in handy during an error.

In the above script I'm trying to view a non-existing file and set -e will be executed immediately and the script breaks.

Practical usecase: Let's say, If any of the AWS CLI commands (e.g., aws ec2 run-instances, aws ec2 authorize-security-group-ingress) fails, the script will immediately exit. This prevents the script from continuing to provision resources in a potentially broken state.

Trap : The trap command in Bash is a built-in function that allows you to execute a specific action when a script receives a particular signal.

Signal: Signals are software interrupts sent to a process to notify it of an event.

Task Scheduling

I believe we all know what Scheduling our tasks means. In shell scripting, it can be done using tools like crontab, It's a utility in Unix-like operating systems that allows you to schedule jobs to run automatically at specific intervals. These scheduled jobs are known as "cron jobs."
Practical usecases include Ec2 Instance management, syncing data at scheduled time with database etc.

To dug deeper into task scheduling and Crontab you can explore here.

Background and Foreground Jobs

Foreground jobs, runs directly in the terminal and block further input until completion, and background jobs, enabled by appending "&" to a command, which free up the terminal.

These jobs are essential for efficiency, especially in software development where compiling code, running tests, and deploying applications can be time-consuming.

By running lengthy tasks like model training or database backups in the background, while other monitoring tasks are in the foreground, users can continue to work, maximizing productivity and resource utilization.

Time to understand this through Scripts.

vim sample.sh

Copy the below script

#!/bin/bash

# Foreground task
echo "Starting a foreground task..."
sleep 3 # Wait for 3 seconds
echo "Foreground task completed."

# Background task
echo "Starting a background task..."
sleep 5 & # Run the sleep command in the background
echo "Background task started!"

echo "Doing other things while background task runs..."
sleep 1
echo "Script is still running."

#The other process runs while this message is being displayed.
sleep 2
echo "All done."

This script demonstrates the use of foreground and background jobs.

You can see "Starting a foreground task..." and then have to wait 3 seconds before anything else happens. This demonstrates that foreground tasks block further input until completion.
You can see "Starting a background task..." and "Background task started!" almost immediately, before the background task's sleep 5 command is finished. This is because the & puts the sleep 5 command in the background.
After starting the background task, the script immediately moves on to print "Doing other things while background task runs..." and then pauses for another sleep 1. This demonstrates that the terminal is free to perform other tasks.
The final "All done." message appears even though the background task (sleep 5) is likely still running. The script doesn't explicitly wait for the background task to complete before exiting.

Shell scripting best Practices 🌟

Keep Scripts Simple: Aim for simplicity by ensuring each script has a single responsibility.
Use Version Control: Store your scripts in a version control system (like Git) to track changes, collaborate with others.
Check Working Directory: Verify that the script is being executed in the correct directory.
Logging and Troubleshooting: Implement logging mechanisms to capture script execution details and errors.
Documentation and Help Options: Include documentation within the script using comments, and provide help options (e.g., -h or --help) to guide users on how to use the script effectively.
Use Local Variables in Functions: When defining functions, use local variables to limit their scope and avoid unintended interactions with global variables.

Real world applications of shell scripting 🌠

Automation of Infrastructure: AWS relies on shell scripts to automate many infrastructure management tasks. For instance, shell scripts can automatically create new servers, configure resources, and manage updates, ensuring consistent and reliable operation across its vast infrastructure.
Routine Checkups: Google uses shell scripts to automate routine system administration tasks, such as user account management, log file maintenance, and monitoring system resources. This automation helps maintain system health and stability
Configuration Management: Shell scripts ensure all the settings for applications are correct and consistent. They can set up database configurations, manage how applications interact with other services, and handle log management.
Deploying Applications: Shell scripts can be used to automate application deployment by packaging applications, copying them to servers, and configuring them to run in the desired environment.

Further Learning Resources

Conclusion

Yes, It's finally over, We've explored the depth and breadth of shell scripting, We've seen how it powers critical tasks in DevOps, system administration, data processing, and more, within organizations of all sizes, including giants like AWS and Google. By automating routine tasks, managing configurations, monitoring systems, and facilitating deployments, shell scripting continues to be an indispensable tool.

Congratulations 🎉🎉 & Thank you so much if you really made it to the end.

If you have enjoyed this whole tutorial, consider sharing it with someone who really needs this and follow me for more such content.
For paid collaborations mail me at : harshit77dev@gmail.com

Feel free to reach out to me on Twitter, LinkedIn, Youtube, Github.
Thankyou Once Again!!

You need to use these AI tools right now !! 🌟

Harshit Rawat — Sun, 26 Jan 2025 07:51:40 +0000

Hey everyone! Good to see you back! I have been struggling to find the perfect AI tool for my next project, video and blog that's when, I thought you might feels the same. So, I’ve put together a curated list of AI tools to help you save time and boost productivity. Whether you’re looking to streamline repetitive tasks, manage projects more efficiently, or enhance your creativity, this list has something for everyone. With multiple tools available for similar tasks, you can quickly find the one that fits your workflow best. Let’s jump in and see all the tools that can help you get more done in less time!

🎯 AI Tools
Below is a list of high quality AI Tools based on their use-cases.

🔥Image Generation

Tool	Image	Link
Adobe Firefly		view
MidJourney		view
Leonardo AI		view
DALL-E 3		view

🔥Text Generation

Tool	Image	Link
ChatGpt		view
Perplexity AI		view
Gemini		view
Claude		view

🔥Video Generation

Tool	Image	Link
Synthesia		view
Runway		view
HeyGen		view
Colossyan		view

🔥Voice Generation

Tool	Image	Link
ElevenLabs		view
Speechify		view
Murf AI		view
Genny By Lovo		view

🔥Modern Web App Builders

Tool	Image	Link
Bolt		view
Lovable		view
FlutterFlow		view
Softr		view

🔥Coding Assistance

Tool	Image	Link
Github Copilot		view
OpenAI codex		view
Codeium		view
Tabnine		view

🔥Writing Improvement

Tool	Image	Link
Grammarly		view
CoWriter AI		view
QuillBot		view
Wordtune		view

🔥Email Management

Tool	Image	Link
ShortWave		view
Superhuman		view
Lavender		view
SaneBox		view

🔥Project Management

Tool	Image	Link
ClickUp		view
Wrike		view
Monday.com		view
Asana		view

🔥Transcription Services

Tool	Image	Link
Otter.ai		view
Happy Scribe		view
Trint		view
Sonix		view

🔥Social Media Management

Tool	Image	Link
Buffer		view
Hootsuite		view
Later		view
Zoho Social		view

Conclusion
Wow, that's a lot of AI tools at your fingertips! I hope you find the ones that suit your needs and inspire you to be more creative in your projects.
As we continue to embrace the age of artificial intelligence, remember that these resources are designed to empower you and streamline your workflows. Don’t miss out on the incredible potential that AI offers.
Thank you for making it to the end! I hope you enjoyed the content, please consider sharing it with someone who might benefit from it. Be sure to save this list so you never miss out these tools.
Feel free to reach out to me on Twitter, LinkedIn, Youtube, Github.
Thankyou Once Again!!

2025: From 'Can Someone Help?' to 'I’ve Got This!'🤩

Harshit Rawat — Fri, 10 Jan 2025 09:58:37 +0000

This is a submission for the 2025 New Year Writing challenge: Predicting 2025.

Welcome to 2025, where change is the new normal!
Since 2025 just started off let's talk about the new normal which doesn't seem to be very normal.
Confused??

This isn't going to be a tech blog but latest predictions for tech in 2025, I hope you'll enjoy this too!!

The AI

Back in 2022, November 30, the term "ChatGPT" surged in popularity among developers worldwide when OpenAI launched its groundbreaking model, GPT-3.5. While some viewed it as a passing trend, others recognized its potential.

Today it's 2025, and we all are aware of what ChatGpt is, OpenAI is now gearing up for the release of GPT-5 after successfully creating GPT-3.5 & GPT-4,
"sorry to the people who thought of it as passing trend"

GPT-5 promises to be 100 times more advanced than previous models "Just Imagine!". Over the past two years, we have witnessed remarkable changes: industries have thrived, developers have flourished, job roles have evolved, new terms like "prompt engineering" have gained popularity and AI tools have taken the market.
Today, these technologies are seamlessly integrated into our lives, as if they were always destined to be part of our everyday experiences.

Tech and 2025 🤖

The tech world in 2025 is buzzing with exciting tools and languages that are changing how businesses operate. While JavaScript still tops the list as a favorite among developers, Go (Golang) has also gained popularity due to its speed and efficiency, making it perfect for building scalable applications. Meanwhile, AI-driven platforms like Bolt.new and GitHub Copilot are revolutionizing the process of coding through prompts. Imagine being able to build an application without writing a single line of code! Other tools like Canva and Figma are making life easier by providing professional-quality designs quickly and easily. In addition to these advancements, the adoption of microservices architecture is becoming increasingly popular. Companies like Uber, Netflix, Amazon, Disney are now shifting towards microservice Architecture.

A rise of cloud computing has seen as companies increasingly migrate to platforms like AWS, Azure, and Google Cloud Platform (GCP), As organizations embrace cloud-first strategies, roles in DevOps have emerged, and tools like docker and Kubernetes have gained more popularity than before. This shift underscores the importance of adaptability in leveraging both cutting-edge tools and robust cloud infrastructures.

Double-Edged Sword: The Good's and Bad's of tech in 2025

Time Savings: AI tools like Canva and Perplexity help users create designs and generate content quickly.
Accessibility for Everyone: Even those without technical skills can produce high-quality work.
Increased Efficiency: Project Management tools like Trello, Zapier streamline workflows.
Work-Life Balance: By automating repetitive tasks, AI helps reduce workload.
Learning Opportunities: AI tools can serve as educational aids, providing instant feedback and resources for students and professionals looking to upskill.

Cybersecurity Threats: As technology becomes more integrated into our lives, the risk of cyberattacks increases, threatening personal data and organizational security.
Identity Frauds: Usage of Deepfakes, creating fake videos and audios, which can be used to spread misinformation and manipulate public opinion.
Job Displacement: Automation and advanced technologies(AI) is now replacing certain jobs.
Over-Reliance on Technology: Dependence on technology for everyday tasks can lead to a decline in critical thinking skills and problem-solving abilities

Will AI Stay on Top ? 🤔

While a lot of people now see AI as a job taker, but we can't deny the fact that it empowers individuals to work independently and creatively. With accessible AI tools, you can generate content, solve problems, and access information without extensive resources, "people are even running businesses".

Since, people are evolving, so does AI, thus it will keep getting better with time. So, yes I do think AI will stay at the top not only in 2025 but beyond. AI will become more capable and user-friendly, making it an indispensable tool in our daily lives and work.

My Predictions for 2025 and beyond ⭐

AI: Artificial intelligence will continue to lead the Tech, with more advanced tools emerging that will greatly benefit developers. However, those who do not master their skills may struggle in this evolving environment.
Rise of DevOps: As companies increasingly shift to cloud computing, there will be a growing demand for professionals skilled in DevOps practices. Learning at least one popular cloud technology will become essential.
Growth of Web 3 space: Interest in blockchain technology, cryptocurrencies, and decentralized applications will continue to rise, driving growth in the Web 3.0 space, people are taking interest in this domain.
Increased Demand for Programming Languages: There will be a higher demand for programming languages like Go (Golang) and Rust as businesses seek efficient, fast and reliable solutions.
Tech Explosion Similar to the Early 2000s: The current boom in AI and technology may lead to a situation that reminds me of the early 2000s in the USA, when major companies like Meta, Google, and Amazon emerged. We could witness a similar tech explosion soon, you saw how quickly OpenAI gained popularity? yahh! I'm talking about this. "I'm so excited for this!"

Conclusion 😁

The Summary is tech landscape of 2025 is filled with dynamic growth and exciting opportunities. I encourage you to explore new technologies and stay updated, just as the tech world.
While there are many other technologies I couldn't cover in detail, I appreciate everyone engaging with these trends. Staying informed and adaptable is very important, If you ever find yourself needing updates, don’t hesitate to follow me on social media Twitter, LinkedIn, Youtube, Github. , where I regularly share insights on these developments.
Thankyou Once Again!! ⭐

Github Gems: Top Repositories to level up in 2025 😎

Harshit Rawat — Tue, 31 Dec 2024 07:28:54 +0000

Hi everyone! Today, I will discuss some of the top evergreen GitHub repositories that you should check out in 2025. These repositories are not just popular, they are tried-and-true tools that can help you streamline your development process, learn new skills, and tackle challenges more effectively.
Whether you're looking to improve your coding abilities or find inspiration for your next project, these GitHub gems are worth exploring. Let’s jump in and discover the best repositories to elevate your programming experience in 2025!

1. OpenAI/openai-cookbook
The OpenAI Cookbook is a must-have resource for developers looking to effectively utilize OpenAI's API. This repository offers a collection of examples and guides that highlight best practices for integrating AI into various applications.
From practical tutorials on sentiment analysis to tips on securing API keys, the cookbook covers essential concepts for both beginners and experienced developers.

Stars ⭐ : 61K
Repo Link

2. TheAlgorithms/Python
TheAlgorithms/Python is a valuable repository featuring a collection of algorithms implemented in Python. This resource serves as an excellent guide for learning about algorithms and data structures, making it ideal for both beginners and experienced developers.
The repository covers a wide range of algorithms, from basic sorting to complex data structures, all presented in a clear and accessible manner.
If you're someone into DSA make sure to check this out!

Stars ⭐ : 196K
Repo Link

3. Build your own X
Build Your Own X is a popular GitHub repository that offers step-by-step guides for recreating various technologies from scratch using different programming languages. It enables developers to deepen their understanding of software principles and improve their coding skills by building projects like web apps, databases, and frameworks.

Stars ⭐ : 320K
Repo Link

4. public-apis/public-apis
The Public APIs repository is an invaluable resource for developers seeking free APIs for their software and web development projects. This collective list covers a wide range of categories, making it easy to find APIs that suit your specific needs.
This repository includes detailed information about each API, such as authentication requirements and supported protocols, allowing developers to quickly assess the best options for their projects.

Stars ⭐ : 322K
Repo Link

5. threejs/three.js
Three.js is not just another JavaScript library; it has become a cornerstone of modern web development. This popularity stems from its ability to simplify the creation of stunning 3D graphics in the browser using WebGL, making it accessible for developers of all skill levels.
As the demand for immersive experiences in augmented reality (AR) and virtual reality (VR) continues to grow, Three.js stands out as a go-to solution for building interactive visualizations and applications.

Stars ⭐ : 104K
Repo Link

6. freeCodeCamp/freeCodeCamp
freeCodeCamp is a nonprofit community that empowers people to learn coding for free, with a comprehensive curriculum covering HTML, CSS, JavaScript, and more. It has become a go-to resource for aspiring developers. Since its inception, freeCodeCamp has supported millions of learners through interactive coding challenges and project-based learning, allowing participants to earn verified certifications too.

Stars ⭐ : 408K
Repo Link

7.EbookFoundation/free-programming-books
Free Programming Books is a massive collection of free programming books, courses, and resources maintained by the Free Ebook Foundation. This repository offers over 4,000 programming books and 2,000 free courses across various languages and topics. The collaborative nature of this project allows contributors to continuously update and expand the list, ensuring that it remains comprehensive and relevant.

Stars ⭐ : 344K
Repo Link

8. jwasham/coding-interview-university
Coding Interview University is a complete study plan for aspiring software engineers focused on preparing for coding interviews. This repository covers essential topics, including algorithms and system design, providing a structured roadmap for mastering the skills needed to succeed. If you're preparing for interviews make sure to check this out!

Stars ⭐ : 309K
Repo Link

9. d3/d3
D3.js is a powerful JavaScript library for creating dynamic, interactive data visualizations in web browsers. By leveraging HTML, SVG, and CSS, D3.js enables developers to produce visually stunning graphics that can convey complex data insights effectively.
Its flexibility and extensive features make it a popular choice for building everything from simple charts to intricate visualizations.

Stars ⭐ : 109K
Repo Link

10. Significant-Gravitas/AutoGPT
AutoGPT is an open-source application that allows you to run GPT-4 with minimal user intervention. It performs tasks autonomously by breaking down complex goals into manageable subtasks and can interact with various APIs and tools. With features like internet access and memory management, AutoGPT streamlines workflows, making it a powerful tool for automation.

Stars ⭐ : 170K
Repo Link

11. awesome/awesome
Awesome is a curated collection of high-quality resources spanning various topics, from programming and web development to design and data science. Each category within the repository includes carefully selected resources, making it easy for developers and enthusiasts to find relevant information.

Stars ⭐ : 340K
Repo Link

12. RealWorld
The RealWorld repository is a comprehensive collection of full-stack applications. This project features implementations across various front-end and back-end technologies, offering developers practical insights into building scalable web applications. RealWorld serves as an excellent resource for developers seeking to enhance their skills in full-stack development with diverse frameworks.

Stars ⭐ : 81K
Repo Link

Conclusion

I hope this curated list inspires you to dive deeper into these fascinating technologies, experiment with new ideas, and contribute to the vibrant open-source community. Thank you for reading the Article, Happy coding, and may your explorations lead to incredible discoveries!
Feel free to reach out to me on Twitter, LinkedIn, Youtube, Github.
Thankyou Once Again!! ⭐

Docker Simplified: Create Your First Container in 5 mins!🐳

Harshit Rawat — Sat, 28 Dec 2024 15:44:03 +0000

Hi Everyone! Today, I'll be discussing how to run Docker containers in five minutes or less. If you are beginner this one is for you. While this isn’t a comprehensive Docker tutorial but a Project, I’ll provide enough information to get you started. If you find this topic interesting and would like a more detailed tutorial on Docker, please let me know by commenting down! Before we dive into the practical steps, let’s start with a brief of what Docker is?

Docker

Imagine you're working on a web application with your team, and each of you has a different setup on your machines. You finish your part, but when you share it with a colleague, it doesn't work because of mismatched software versions or missing dependencies. This is Frustrating!

And that's where Docker comes in. Docker allows you to package your application and everything it needs to run—like libraries and configurations—into a single unit called a Container. When you create a Docker container, it runs the same way on any machine, whether it's your local computer, a colleague's laptop, or a production server.

We will be creating those containers in this blog.

Prerequisites

Version Control: A basic Knowledge of Git & Github is required.
Docker: Docker should be installed in you system. Install from the official docs Docs or Follow these quick videos Docker for Windows, Docker for Mac, Docker for Linux.
Docker Dekstop: To see you containers running you need Docker Desktop. It provides a user-friendly graphical interface (GUI) that allows users to manage their containers, applications, and images with ease. Download Docker Dekstop Get Started
Nodejs Should be installed in your system.

Project Flow

Let's Begin

Clone the Repository : The First step is to go to github and clone this repository in your local system. Also, make sure to give it a star 🥺.

You should be able to see the project setup correctly!

Now that you have cloned the project set up the required dependencies.
Run the following commands in your terminal

cd project # Navigate to your project directory
npm install    # Install the required packages

Dockerfile

A Dockerfile is a text document that contains a series of instructions for building a Docker image. Each instruction in the Dockerfile specifies how to set up the environment, install dependencies, and configure the application. When you run the Docker build command with a Dockerfile, it processes these instructions sequentially to create an image. Once the image is built, it can be run as a container.
If you want to learn more about Dockerfiles comment down

Here's our Dockerfile

FROM node:18-alpine

WORKDIR /src/app

COPY package*.json ./

RUN npm install

COPY . .

EXPOSE 3000

CMD ["npm", "run", "dev"]

Since our project already have a Dockerfile, lets build Docker images. Open your Docker Dekstop and come back to your Code editor.

Run the following docker command to create/build a docker image, in your terminal. Don't worry about what the command is & how it is working, right now!

docker build -t taskmaster .

Don't forget to add the dot at the end .

You can name your image whatever you want i named it "taskmaster"

Now that we have build our docker image lets run it. Run the following command in your terminal

docker run -it -d -p 3000:3000 taskmaster

We are mapping the containers port to our host machine port so that it can run the application.

The command gives an id associated with our Image.

Go back to Docker Dekstop and you can see your docker image that you just build.

Click on the "In use" option and you will see the docker container running, if not click on the "Actions" icon in the containers section to run your Container.

This is the application you should see!

Your Docker container is up and running, You did it! You ran your first docker container all by yourself, Congratulations 👏🎉🎉

Conclusion

Thank you if you are still reading the blog and have implemented the project. we took a hands-on approach to running Docker containers, focusing on practical execution. We successfully launched our first Docker container, demonstrating how easy it is to get started with containerization.
Although this was not a docker tutorial but If you're interested in a more detailed explanation of Docker's features & concepts, please let me know in the comments! Your feedback really matters. Share it on socials, with your friends about the container you created all by yourself, tag me on X and keep Learning. I truly value your insights and perspectives. If you come across anything that seems off or could be improved, please don’t hesitate to leave a comment.
I hope you enjoyed the content, please consider sharing it with someone who might benefit from it. Feel free to reach out to me on Twitter, LinkedIn, Youtube, Github.
Thankyou Once Again!!

Open Source: The Easy Way, How not to break the Internet (Yet)😁

Harshit Rawat — Tue, 24 Dec 2024 14:00:26 +0000

Introduction

In the early days of computing, software was freely shared among researchers, fostering collaboration and driving innovation. By the 1970s, proprietary software gained traction, and by 1998, the term "Open Source" emerged, promoting publicly accessible source code that anyone can view, modify, and distribute.

Open Source Software (OSS) is technically defined as software licensed to grant users the rights to use, study, change, and distribute its code, That's what i have read personally. Think of OSS as a recipe anyone can tweak, inviting collaboration and making technology more adaptable and accessible.

Open Source

Why Should I contribute?

By engaging with open source projects, you not only help improve software that millions rely on but also gain invaluable real-world experience that can significantly boost your career.

Real-World Experience: You will get practical knowledge and work experience right from the first year of your university if you are making opensource contributions.
Networking Opportunities: Connect with a diverse community of developers, which can lead to mentorship, collaborations, and ultimately job opportunities.
Portfolio Building: Showcase your contributions on platforms like GitHub, creating a tangible portfolio that demonstrates your abilities to potential employers.
Community Engagement: You can be part of a collaborative environment where you can share knowledge, learn from others, and contribute to projects that matter to you.
Personal Satisfaction: It's so cool that people are actually the product you have built. Trust me! This feeling is insane.

Is there any Prerequisites ?

Yes, there are some prerequisites to consider before diving into open source contributions.

Basic Understanding of Git: Familiarity with Git commands for version control.
GitHub Proficiency: Knowledge of using GitHub for hosting and sharing code.
Open Source Licenses: Awareness of different licenses and their implications.
Project Structure Familiarity: Understanding common files like README and CONTRIBUTING.
Best Practices Knowledge: Adhering to coding standards and contribution guidelines.
Communication Skills: Engaging respectfully in discussions and feedback and not spamming in the discussions.

I'm beginner I can't Code.

Let me tell you, some of my first open source contributions involved fixing the color of text on a website and creating a video for website demonstrations. It’s important to note that open source contributions aren’t solely about coding; you can contribute in many different ways. If you’re hesitant about coding, start with documentation. Most communities are very welcoming and appreciate any help you can provide!

How do I Start there's a lot to explore?

I agree! Nowadays, there is so much information available on the internet that it can be difficult for people to find content that matches their skill level or interests. I would suggest starting with resources that are specifically designed for beginners.

Find Beginner-Friendly Repositories: Look for repositories labeled with “good first issue,” “newcomers,” or “easy” on platforms like GitHub.
Join Open Source Communities: Engage with communities on platforms like Discord or Slack.
Events: Attend meetups, conferences, or hackathons focused on open source, Introduce yourself to the community.

Here are Some resources you can checkout as a beginner!

Above I have shared some valuable resources for beginners looking to get started in open source. If you already have some experience, be sure to check out the blog I've shared Top Open Source Communities of 2024, where you'll find high-quality communities that you can contribute to!

Conclusion

If you’ve never participated in open-source projects or feel unsure about getting started, now is the perfect time to dive in. Contributing is not only valuable for the community, but it can also be incredibly rewarding for you.
Thank you for taking the time to read this blog! I appreciate your efforts. I hope you found it informative. If you enjoyed this guide, please consider sharing it with someone who needs it more, follow me for more insightful posts.
Feel free to reach out to me on Twitter, LinkedIn, Youtube, Github.
Thankyou Once Again!!

Top Open Source Communities you should not miss out in 2025🔥

Harshit Rawat — Sat, 21 Dec 2024 07:36:12 +0000

As 2024 comes to a close, it's an exciting time to explore some awesome open-source communities that are set to grow in 2025. These welcoming spaces are perfect for both beginners and seasoned developers looking to enhance their skills and make meaningful contributions.
Let’s dive into these communities that you must try that can help you grow and create a real impact in the open-source world!

1. Kestra

Kestra is an open-source data orchestration platform designed for managing complex workflows with ease. It supports both scheduled and event-driven workflows, allowing users to automate data processes efficiently.

Users can build workflows as a series of tasks, enabling modular designs that adapt to various data processing needs.
Declarative YAML Configuration: Workflows are defined using YAML, which promotes Infrastructure as Code (IaC) practices.
Real-Time Triggers: Kestra can react to events as they happen, enabling immediate responses to incoming data.

Integrating Kestra into in a project can streamline workflow management by automating repetitive tasks and enhancing team collaboration. Its built-in monitoring tools allow you to track workflow performance in real-time, making troubleshooting straightforward and efficient.

To join kestra and start building up, Checkout:
Github : Kestra
Slack : Kestra

2. Configu

Configu is a powerful tool for managing application configurations, enabling users to define, store, and retrieve configuration settings easily. It aims to eliminate the complexities associated with configuration management, making it accessible for developers of all skill levels.

Configu integrates with version control systems (like Git), allowing teams to track changes in their configuration files over time. This ensures that all modifications are documented and can be reverted if necessary.
It supports multiple environments (e.g., development, staging, production), enabling users to manage configurations specific to each environment effortlessly.

Integrating Configu into a project can streamline configuration management by simplifying the process of defining and maintaining application settings. This leads to increased efficiency, reduced errors, and enhanced collaboration among team members.

To join Configu and start building up, Checkout:
Github : Configu

3. MLH

Talking about opensource communities and MLH won't be there isn't possible. Major League Hacking (MLH) is the official student hackathon league, dedicated to empowering hackers and fostering innovation among students worldwide. Each year, MLH organizes over 300 weekend-long hackathons that attract more than 135,000 participants globally.

Community-Driven Events: Whether you’re a beginner or an experienced developer, MLH events are designed to make everyone feel welcome.
Access to Technology and Tools: Participants at MLH hackathons gain access to cutting-edge technology and tools provided by leading brands.
Incentives and Prizes: MLH events often feature exciting prizes for participants, including exclusive access to discounts on APIs and developer tools through the MLH Software Lab.

MLH empowers students to develop essential skills that will benefit them in their careers. The organization also emphasizes its commitment to social responsibility by being a Certified B Corporation, ensuring that its operations positively impact the community.

If you're interested in participating in or organizing an MLH event, you can find more information on MLH.
Join the vibrant community of hackers and innovators who are shaping the future of technology!
Discord : MLH Discord
Github : MLH Github

4. LFX

Now that we have talked about MLH, we have LFX, an innovative platform developed by the Linux Foundation that focuses on enhancing collaboration and sustainability within the open-source community. LFX serves as a comprehensive hub for developers, contributors, and organizations, providing essential tools and resources to facilitate project management and community engagement.

Mentorship Opportunities: LFX emphasizes skill development through mentorship programs that connect new contributors with experienced mentors, promoting knowledge sharing and personal growth.
Paid Internships: LFX offers paid internships that allow participants to work full-time on open-source projects for a duration of three months.
Mentorship Support: Interns are paired with experienced mentors who guide them throughout the program.
Diverse Project Options: Interns can choose from a variety of projects across different domains, including those under the Cloud Native Computing Foundation (CNCF), Linux Kernel, Hyperledger, and more.

If you're interested in applying for an internship at LFX, keep an eye on the application timelines for each term. For more information about available projects and application details, visit the LFX Mentorship page.

Join the vibrant community of hackers and innovators who are shaping the future of technology!
Community : LFX
Github : LFX

5. Meshery

Meshery is an open-source, collaborative cloud-native manager designed to simplify the management and orchestration of Kubernetes-based infrastructures. It provides developers and operators with tools to configure various service meshes, manage applications, and apply cloud-native patterns effectively. By supporting over 230 Kubernetes infrastructure operators, Meshery enables users to streamline their cloud-native workflows and enhance the performance of their applications.
One among the most welcoming communities

Cloud Native Lifecycle Management: Meshery facilitates the provisioning, configuration, and operation of Kubernetes clusters. It supports a wide range of cloud-native infrastructure integrations, allowing users to manage their resources efficiently.
Task-Based Management: Users can define and manage cloud-native systems through a model-driven approach.

Integrating Meshery into your cloud-native projects can significantly enhance your operational efficiency by providing a unified platform for managing service meshes and Kubernetes infrastructures.

To join Meshery, Checkout:
Website: Meshery's website
Github: Meshery's Github

6. The 4C Community

The 4C Developer Community, also known as the Cool Community of Content Creators is an online platform designed to support and connect content creators, particularly developers
If you are a beginner, this one is for you.

The 4C Community aims to provide a collaborative environment where content creators can share ideas, motivate each other, and enhance their creative output. It focuses on inclusivity and support for both novice and experienced creators.
You get support, activities, collaborations, free dedicated content creation webinars (yes, you got it right ! 😄), coffee chat, and a meme channel!
The community fosters growth on all levels, irrespective of prior experience —a platform where you can talk about your ideas and get opinions on how to execute them.

Joining 4C can significantly enhance your journey in the tech world.
To get started with the 4C community:
Join Discord: 4C Discord

7. Pieces Community

The GetPieces community is an open-source initiative designed to enhance developer productivity by providing tools for managing code snippets and facilitating seamless workflows.

Open-Source Contributions: Developers are encouraged to contribute to various open-source projects under the GetPieces. Contributions can range from writing code and fixing bugs to improving documentation and creating tutorials.
Community Engagement: The GetPieces community thrives on active participation. Developers can join the Discord server, where they can interact with other members, ask questions, and provide feedback.

Join the Pieces Community and meet like minded individuals like you.
To get started with getpieces:
Discord: GetPieces
Github: GetPieces

Final Thoughts ⭐
Thank you for making it to the end! I hope you will definitely join these communities. If you enjoyed the content, please consider sharing it with someone who might benefit from it.
Feel free to reach out to me on Twitter, LinkedIn, Youtube, Github.
Thankyou Once Again!!