This blog is second installment of Redis in Action blog series and if you’ve read the first blog on Ratelimiting using Redis, you are aware of what Redis is and how it works as a versatile in-memory data store. Today we’re diving into one of the Redis’s most elegant features: Pub/Sub Messaging.

In the world of microservices, communicatio is everything. Services need to talk to each other without becoming tightly coupled, maintain stability under load and often exchange information in realtime. This is where Publish/Subscribe (Pub/Sub) pattern shines.

Pub/Sub is a messaging pattern where senders or publishers don’t send messages directly to the receivers. Instead, they publish messages to channels without knowledge of which subscribers might be listening. This decoupling is particularly valuable in distributed systems. For example, Reddit works on a similar pattern, where publishers posts in a subreddit (channel) without knowing which user or receiever will get that post and read it.

Redis offers a lightweight, blazing fast implementation of this pattern that can serve as a message broker between your microservices. Let’s see how it works and when it makes sense to use it.

Core concepts of Redis Pub/Sub

Redis Pub/Sub Basics

The Pub/Sub mechanism in Redis revolves around these three simple concepts.

• Channels: Named message routes (like subreddits on Reddit) eg. user_signups or payment_events.

• Publishers: Clients that send messages to specific channels

• Subscribers: Clients that listen for messages on one or more channels.

When a publisher sends a message to a channel, Redis broadcasts that message to all subscribers of that channel in realtime. The operation is async, so publishers don’t wait for confirmations/acknowledgements that subscribers recieved the message.

The beauty of Redis Pub/Sub lies in the simplicity. The entire featues can be accessed with just a handful of commands:

PUBLISH channel message
SUBSCRIBE channel [channel ...]
PSUBSCRIBE pattern [pattern ...]
UNSUBSCRIBE [channel ...]
PUNSUBSCRIBE [pattern ...]

Redis vs Traditional Message Brokers

Unlike heavyweight message brokers like RabbitMQ and Apache Kafka. Redis Pub/Sub is remarkably lightweight. Here’s the comparison:

Strengths

• Simplicity: Minimal config, and straighforward API

• Speed: Sub-millisecond latency for message delivery

• Integration: If you’re already using Redis, it’s one less system to maintain

Limitations

• No persistance: Messages are only delivered to the currently connected subscribers

• No guaranteed delivery: If a subscriber is offline it misses the message

• No message queues: Messages can’t be processed later by reconnecting clients

Use cases for Redis Pub/Sub

Redis Pub/Sub excels in scenarios requiring realtime messaging with minimal latency:

• Realtime notifications: Chat applications, live dashboards, activity feeds

• Event driven microservices: Services reacting to events from other services

• IoT Applications: Distributing sensor data to multiple processing services

• Live monitoring systems: Broadcasting metrics to various visualization tools

Designing a Pub/Sub System with Redis

Architecture Overview

A typical Redis Pub/Sub architecture in a microservices environment looks like this:

Service A might be an order service publishing new orders, Service B a payment processor both publishing and consuming events, and Service C a notification service subscribing to relevant events.

Scalability Considerations

Redis Pub/Sub scales horizontally on the subscriber side. You can have multiple instances of the same service subscribed to the same channel, and each will receive a copy of each message.

For high-volume systems, you can consider these strategies:

• Channel segmentation: Use multiple fine-grained channels instead of a few broad ones

• Load distribution: For heavy publishing, Redis Cluster can distribute channels across nodes

• Multiple Redis instances: For complete isolation of different messaging domains

Let’s take a look at code examples

Publisher (Order Service):

const redis = require('redis');
const publisher = redis.createClient();

// When a new order is created
function createOrder(orderData) {
  // Save order to database
  const orderId = saveToDatabase(orderData);

  // Publish event to Redis
  publisher.publish('orders:created', JSON.stringify({
    id: orderId,
    amount: orderData.amount,
    customerId: orderData.customerId,
    timestamp: Date.now()
  }));

  return orderId;
}

Subscriber (Notification service):

const redis = require('redis');
const subscriber = redis.createClient();

subscriber.on('message', (channel, message) => {
  if (channel === 'orders:created') {
    const order = JSON.parse(message);
    sendOrderConfirmationEmail(order.customerId, order.id, order.amount);
  }
});

subscriber.subscribe('orders:created');

Best Practices and Patterns

Channel Naming Conventions

A good naming convention makes your system easier to understand and maintain:

• Hierarchical structure: domain:entity:action (e.g., orders:payment:succeeded)

• Service-oriented: service-name:event-type (e.g., payment-service:refund-processed)

• Versioning: Add version when message formats might change (e.g., users:created:v1)

Security

Redis Pub/Sub transmits messages in plaintext by default. For secure setups:

• Use Redis ACLs to restrict which clients can publish/subscribe to which channels

• Enable TLS for encrypted communication between Redis and clients

• Keep Redis servers in a private network, accessible only to your services

Monitoring and Debugging

Redis provides with simple commands to inspect the Pub/Sub Activity

# List all active channels with subscribers
PUBSUB CHANNELS

# Count subscribers for specific channels
PUBSUB NUMSUB channel1 channel2

# Count pattern subscribers
PUBSUB NUMPAT

For comprehensive monitoring:

• Use Redis INFO command to track overall Pub/Sub memory usage

• Implement client-side metrics for message volumes and processing times

• Log channel activity for debugging and auditing

Performance Optimization

To get the most out of Redis Pub/Sub:

• Keep messages small: Large messages consume more bandwidth and memory

• Avoid blocking operations: Subscriber callbacks should be quick and non-blocking

• Use pattern matching judiciously: PSUBSCRIBE with wildcards is powerful but more resource-intensive

Real World Example: Microservice in action

I'll walk you through an example of an ecommerce which processes order using Redis Pub/Sub.

The Players

• Order Service: Creates new orders and publishes orders:created events

• Payment Service: Processes payments and publishes payments:completed events

• Inventory Service: Updates stock levels based on order events

• Notification Service: Sends emails based on various events

• Analytics Service: Tracks business metrics based on all events

The Flow

1. Customer places an order through the web app

2. Order Service saves the order and publishes orders:created with order details

3. Payment Service receives the event, processes payment, then publishes payments:completed

4. Inventory Service receives both events, first marking items as reserved, then confirming deduction

5. Notification Service sends order confirmation after orders:created and payment confirmation after payments:completed

6. Analytics Service silently collects all events to update dashboards

This decoupled architecture allows each service to focus on its core responsibilities without direct dependencies on other services.

When to use (and avoid) Redis Pub/Sub

Ideal Scenarios

Redis Pub/Sub is perfect for:

• Real-time updates: When speed matters more than guaranteed delivery

• Broadcast notifications: When many services need the same information

• System status changes: Broadcasting state changes across a distributed system

• Non-critical events: Where occasional missed messages are acceptable

When to consider alternatives

Look elsewhere when you need:

• Guaranteed delivery: Consider Redis Streams, RabbitMQ, or Kafka

• Message persistence: Redis Streams or a dedicated message broker

• Complex routing logic: RabbitMQ's exchanges and bindings

• Exactly-once processing: Systems with robust message acknowledgment and deduplication

Conclusion

Redis Pub/Sub offers a refreshingly simple approach to event-driven communication in microservice architectures. Its minimal API, blazing speed, and seamless integration with existing Redis deployments make it an attractive option for many real-time messaging needs.

While it won't replace full-featured message brokers for complex or mission-critical messaging, Redis Pub/Sub finds its sweet spot in scenarios where simplicity and performance are paramount. It's the lightweight champion of real-time messaging.

Until then, I encourage you to experiment with Redis Pub/Sub in your own projects. Start small, perhaps with a notification system or real-time dashboard, and experience firsthand the elegant simplicity it brings to service communication.

Some Additional Resources

• Redis Pub/Sub official documentation

• Redis University

• Previous posts in this series

  • Ratelimiting using Redis

Introduction

PowerShell isn’t just a command line tool—It’s the Swiss Army knife of windows automation. Whether you’re managing files, deploying apps, or wrangling servers. But did you know you can make it even better? PowerShell Profiles; your secret weapon for aliases, shortcuts and automation spells.

Think of it like an automation script that runs everytime you launch PowerShell. Customize it, and it’ll unlock:

• Productivity boosts (type less, do more!)

• Personalized workflows (goodbye, repetitive tasks!)

• A terminal that feels like home (rainbow prompts, anyone?)

Let’s dive in!

What is PowerShell profile?

A PowerShell profile is a script file (.ps1) that runs automatically when you start a PowerShell session. It’s where you stash your favorite aliases, functions, and settings—like a “Welcome to My World” banner for your terminal.

There are four types of profiles, depending on scope:

1. All users, All hosts

   This profile applies to all users and all PowerShell hosts on the system. It is located at $PsHome\Profile.ps1.

2. All users, Current host

   This profile applies to all users but only to the specific PowerShell host (e.g., console or ISE). It is located at $PsHome\Microsoft.PowerShell_profile.ps1.

3. Current user, All hosts

   This profile applies to the current user for all PowerShell hosts. It is located at $Home\Documents\Profile.ps1 (or $Home\My Documents\Profile.ps1 in older versions).

4. Current user, Current host

   This profile applies to the current user and the specific PowerShell host. For the console, it is located at $Home\Documents\WindowsPowerShell\Microsoft.PowerShell_profile.ps1. For the ISE, it is located at $Home\Documents\WindowsPowerShell\Microsoft.PowerShellISE_profile.ps1.

The $profile variable in PowerShell contains the paths to these profiles. When PowerShell starts, it executes these profiles in a specific order, if they exist.

Check if you already have a profile:

Test-Path $PROFILE

If it returns False, time to create one!

Creating a PowerShell profile

No profile? No problem! Run this.

New-Item -Path $PROFILE -ItemType File -Force

This will create the ps1 file for the profile on the location where it should be.

Now, edit it with Notepad (for the brave) or VS Code (for the fancy).

notepad $PROFILE # Classic Vibes
code $PROFILE    # Modern Flair

Customizing your PowerShell Profile

Here’s where the fun begins!

1. Aliases: Shortcuts for Lazy Typists

   Turn Get-ChildItem into ll (because life’s short):

Set-Alias ll Get-ChildItem

Now ll lists your files.

2. Auto-Load modules:

   Hate typing Import-Module Az everytime? Add it to your profile:

Import-Module Az # Azure admins, rejoice

3. Custom functions

   Create a function to nuke temp files:

function Clear-TempFiles {  
    Write-Host "Blasting junk into oblivion..." -ForegroundColor Red  
    Remove-Item -Path $env:TEMP\* -Recurse -Force  
}

Run Clear-TempFiles anytime.

4. Fancy Prompts

   Make your prompt glow like a neon sign:

function prompt {  
    Write-Host "[$(Get-Date -Format 'HH:mm:ss')]" -NoNewline -ForegroundColor Cyan  
    Write-Host " PS $env:USERNAME@" -NoNewline -ForegroundColor Magenta  
    Write-Host "$env:COMPUTERNAME >" -ForegroundColor Yellow  
    return " "  
}

Managing and Securing your profile

1. Secure credential storage

   Never hardcode passwords! Use PowerShell’s SecretManagement module or encrypted files:

# Save credentials securely (uses Windows Data Protection API)  
$credential = Get-Credential  
$credential | Export-CliXml -Path "$env:USERPROFILE\secure_cred.xml"  

# Load credentials later  
$storedCred = Import-CliXml -Path "$env:USERPROFILE\secure_cred.xml"

2. Azure Key Vault Integration

   For cloud users, fetch secrets dynamically from Azure Key Vault:

# Ensure Az module is imported first  
function Get-MySecret {  
    param ($SecretName)  
    $secret = Get-AzKeyVaultSecret -VaultName "MyVault" -Name $SecretName -AsPlainText  
    return $secret  
}  

# Usage:  
$apiKey = Get-MySecret -SecretName "ProdAPIKey"

3. Environment Variables for Sensitive Data

   Store tokens in environment variables (safer than plain text in scripts):

# Set via PowerShell (temporary)  
$env:GITHUB_TOKEN = "ghp_abc123"  

# Or permanently in Windows:  
[System.Environment]::SetEnvironmentVariable('GITHUB_TOKEN', 'ghp_abc123', 'User')

Advanced Use Cases for Power Users

1. Automated SSH connections with logging

   Log SSH sessions and automate connections:

function Connect-DevServer {  
    $session = New-SSHSession -ComputerName "dev.example.com" -Credential $storedCred  
    Start-SSHStream -SessionId $session.SessionId -ShellStream "DevSession"  

    # Log the session  
    $timestamp = Get-Date -Format "yyyyMMdd-HHmmss"  
    Start-Transcript -Path "$env:USERPROFILE\ssh_logs\$timestamp.txt"  
}

2. Custom Command Logging

   Track every command you run in a searchable JSON file:

$global:CommandHistoryPath = "$env:USERPROFILE\ps_history.json"  

function Log-Command {  
    param ($command)  
    $logEntry = @{  
        Timestamp = Get-Date -Format "o"  
        Command   = $command  
        User      = $env:USERNAME  
        Host      = $env:COMPUTERNAME  
    } | ConvertTo-Json  

    Add-Content -Path $global:CommandHistoryPath -Value $logEntry  
}  

# Override the default Add-History to log  
$originalAddHistory = Get-Command Add-History  
function Add-History {  
    param([string[]]$Lines)  
    $Lines | ForEach-Object { Log-Command $_ }  
    & $originalAddHistory @PSBoundParameters  
}

3. Dynamic Environment Switcher

   Auto-load AWS/Azure/GCP profiles based on your current project folder:

function Set-CloudEnv {  
    param ($Environment)  

    switch ($Environment) {  
        "AWS-Prod" {  
            $env:AWS_ACCESS_KEY_ID = (Get-MySecret -SecretName "AWSProdKey")  
            $env:AWS_SECRET_ACCESS_KEY = (Get-MySecret -SecretName "AWSProdSecret")  
            Write-Host "AWS Production environment loaded!" -ForegroundColor Yellow  
        }  
        "Azure-Dev" {  
            Connect-AzAccount -Credential $storedCred  
            Set-AzContext -SubscriptionId "12345-abcde"  
            Write-Host "Azure Dev environment loaded!" -ForegroundColor Cyan  
        }  
    }  
}

Some security tips

• Rotate credentials regularly: Automate token refreshes with Azure AD or AWS IAM roles.

• Audit your profile: Use Unblock-File $PROFILE if scripts are blocked by Windows.

• Use JEA (Just Enough Administration): Restrict PowerShell capabilities for non-admin users.

Experiment with these snippets, and remember: with great power comes great automation! 🔥

Rate limiting is a technique used to control the number of requests a client can make to a server within a specified time frame. It helps prevent abuse, ensures fair resource distribution, and maintains system stability.

1. Prevents API abuse: Stops users and bots to from overwhelming the server with excessive requests.

2. Protects from attacks: Enhances security to protect from brute force attacks and Denial of Service (DoS) attacks.

3. Controls costs: Helps in avoiding excessive costs on resource consumption, reducing operational costs.

Pre-requisites

This is a very simple implementation of rate limiting, which can be improved upon a lot. But this can save your side projects to be heavily bombarded from excessive API calls.

Things you need to implement this:

• Redis up and running (locally using docker or using any cloud service like upstash)

• Golang and Gin (because Go’s default net/http is like building IKEA furniture without instructions)

Let’s implement

1. Install dependencies

   These are the dependencies we need for our ratelimiting middleware to work.

go get github.com/gin-gonic/gin
go get github.com/go-redis/redis/v8

2. Connect to Redis 🏓

   Let’s code to connect to redis.

   This code is to connect with redis when you have running it locally using docker or have a redis server on your PC.

func ConnectRedis() error {
    redisClient = redis.NewClient(&redis.Options{
        Addr:     "localhost:6379", // Redis' home address
        Password: "",               // No password? You can set your own password
        DB:       0,                // The VIP database
    })

    // Send a "PING" to check if Redis is awake
    pong, err := redisClient.Ping(ctx).Result()
    if err != nil {
        log.Fatalf("Redis connection failed harder than my diet on Thanksgiving: %v", err)
    }
    fmt.Println("Redis says:", pong) // "PONG!" means you're in business!
    return nil
}

But what if you have it up in the cloud using some service provider like upstash. Then change the fields Addr and Password to the ones you have from your provider, and add TLS config (it’s necessary)
Then the function for connecting to redis will look like this.

func ConnectRedis() error {
    redisClient = redis.NewClient(&redis.Options{
        Addr:     "your-upstash-endpoint:6379", // Replace with your Upstash Redis endpoint
        Password: "your-upstash-password",     // Replace with your Upstash Redis password
        DB:       0,                           // Default DB
        TLSConfig: &tls.Config{},              // Enable TLS (important for Upstash)
    })

    // Check if Redis connection is successful
    pong, err := redisClient.Ping(ctx).Result()
    if err != nil {
        log.Fatalf("Failed to connect to Upstash Redis: %v", err)
    }
    fmt.Println("Connected to Upstash Redis:", pong)
    return nil
}

3. The Rate Limiter Middleware

   The rules?

   5 requests per IP per minute

   More than that, you’ll get a 429 (Too many requests) error.

func RateLimiter() gin.HandlerFunc {
    return func(c *gin.Context) {
        ip := c.ClientIP() // Get that IP! (No cheating with proxies, okay?)
        key := fmt.Sprintf("rate_limit:%s", ip) // Redis key. Example: "rate_limit:127.0.0.1"
        limit := 5                              // 5 requests...
        window := 60 * time.Second              // ...per 60 seconds. Play nice!

        // Increment the request counter for this IP
        count, err := redisClient.Incr(ctx, key).Result()
        if err != nil {
            log.Printf("Redis threw a tantrum: %v", err)
            c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"message": "BRB, server's crying"})
            return
        }

        // If this is the first request, set the "self-destruct" timer
        if count == 1 {
            if _, err := redisClient.Expire(ctx, key, window).Result(); err != nil {
                log.Printf("Redis tried to ghost us: %v", err)
                c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"message": "Server's on strike"})
                return
            }
        }

        // Enforce the limit
        if count > int64(limit) {
            c.AbortWithStatusJSON(http.StatusTooManyRequests, gin.H{
                "message": "Slow your roll, cowboy! 🐄 Try again later.",
            })
            return
        }

        c.Next() // All good—proceed to the party!
    }
}

How this works?

• Incr Increments the request count for the IP

• Expire Set’s a 60 seconds TTL on the key only on the first request (so it auto deletes itself).

• Limit check: If the count exceeds 5, deny entry for the requests.

4. Add the middleware to your Gin router

   Add the middleware onto your routes and protect them from getting overwhelmed.

func main() {
    if err := ConnectRedis(); err != nil {
        log.Fatal("Redis connection: Pong")
    }

    router := gin.Default()
    router.Use(RateLimiter()) // Apply to all routes

    router.GET("/api/secret-sauce", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{"message": "🔥 Secret sauce: 3 parts caffeine, 2 parts chaos"})
    })

    router.Run(":8080")
}

You can start your server using go run main.

Now, hit /api/secret-sauce more than 5 times in a minute, and you’ll get a sassy 429 error. Test it with curl -I http://localhost:8080/api/secret-sauce and watch the headers fly!

Gotcha and Pro tips

1. IP-based limits aren’t perfect: In a shared network (like Starbucks WiFi), you might block innocent bystanders. For critical apps, use API keys or auth tokens.

2. Adjust the limits: 5 requests/minute too strict? Crank it up! (But not so high that your server melts.)

3. Upgrade to sliding windows: This example uses a fixed window. For smoother limits, try Redis’s ZSET with a sliding window algorithm.

Conclusion

Rate limiting is a technique to control the number of requests a client can make to a server in a given timeframe, helping prevent abuse, ensure fair resource distribution, and maintain system stability. This article covers a simple implementation using Redis, Golang, and Gin, allowing 5 requests per IP per minute. The guide includes setup instructions, connection details for local and cloud-based Redis, and middleware implementation to protect your API routes. Adjusting limits and considering advanced techniques like sliding windows are also discussed for better control and efficiency.

Bye !

So, in this meetup, there were many inspirational and educational talks given, but for me, there was one session that stood out from all. It was around the basics of Kubernetes, and various terminologies around it. This talk was given by Siddhant Khisty and Aakansha Priya.

I'm going to summarize that session here in this blog, so let's begin.

What is Kubernetes?

Whenever you Google this question, you'll find terms like

• DeFacto Container Orchestrator

• widely used in the industry

• amazing distributed system

• complicated

• and especially very easy to get it wrong

But we're not going to see it this way today and use our imagination to make it easier to understand.

KubeNation

Imagine you are a person who wants to make a new nation, who is bored of all the countries and everything.

What things you'll need:

• Land

• Authority

• People & Homes

• Communication

• Hard Workers

Land

You need land, your territory to rule over. How can you get land, there can be 4 major ways to get your hands on some land.

• 💵 Buy

• 🔌 Rent

• ⚔️ Conquer

• 🥷🏻 Steal

The last 2 are not recommended ☠️.

Now you have land, and you decided to divide your land into 4 cities.

1. Your national capital, where all the administration resides

2. A Park City, to keep the environment healthy

3. Industrial City, to pump up the economy

4. And Night City, coz why not (Who else likes cyberpunk 2077)

Authority

We have to distribute the power too, who'll make the decisions, who'll ensure that everyone works properly and other things too.

So, let's divide the work.

There are four posts that you created for the country's authority and administration.

1. Mr. President

   • Governs the nation

   • Makes important decisions

   • decide who should know about his decisions

   • and also represents the nation

2. Mr. Manager

   • He makes sure everyone works

   • checks if all the cities are working properly

   • Are people able to communicate

   • And checks what's for lunch today

3. Mr. Task Manager

   • Assign work to everyone

   • Decide where to give the task

4. A Central Record

   Keeps a record of everything like

   • What were the past decisions

   • Who's doing what task

   • Progress of each task

   • If tasks failed, why?

   • Who lives in the nation

   • And who are people talking to

People & Homes

Everyone in this KubeNation has his own home, where he and his family live happily.

Communication

We made communication between people easier and accessible to all.

People can communicate with each other using phones, mobiles etc.

The Hard Workers

We're going to divide some essential tasks with the workers.

We've two types of workers with us, builders and communication.

Builders

• build houses

• and rebuild any damaged or destroyed houses

• making sure people stay in their respective homes

• They are available in every city

Communications

• Make sure people talk with each other

• deliver messages to people

• enforce rules for better and hassle-free communication

• They're available in every city too

Now you have the country of your dreams.

That was an easy task, wasn't it?

Congratulations 🎉🎊🎉🎊, you just learned the entire Kubernetes architecture. Confused? Let us go through our nation again and now I'll tell you about the Kubernetes architecture on the go.

Land

Your computer, laptop, PC, server, whatever you have becomes your land.

This is your territory to make your nation the leader of the world.

Talking about cities, your capital city becomes your Control Plane Node, other cities serve as nodes.

The Control Plane Node handles everything like all the authorities in the capital city.

Authority

So, let's rename all the positions we had in our authoritative organization.

• Mr. President ➡️ Kube-API server

• Mr. Manager ➡️ Controller Manager

• Mr. Task Manager ➡️ Kube Scheduler

• The Central Records ➡️ ETC-D

Homes and People

The homes are called the pods where all the containers reside, which represent the people.

The pod contains all the containers and there can be more than one pod in a node, just like there can be more than one home in a city.

Communication

The pods communicate with each other using services. Services provide a stable endpoint for pods to communicate with each other. A service can be used to expose a set of pods to other pods within the cluster.

The Hard Workers

The hardest workers, builders and communications are replaced by Kubelet and Kube-proxy in Kubernetes respectively.

Kubelet helps in creating and maintaining pods, whereas Kube-proxy maintains the communication between the pods to run smoothly.

Conclusion

Now you can see what a cluster in Kubernetes looks like.

Here the control plane node is the capital city with all the authority and keeps a check on every node (city).

Only the control plane node consists of the Kube-API server (president), controller manager (manager), Kube Scheduler (Task Manager) and ETC-D (the central records)

Each node (city) contains its kubelet (builder) and k-proxy (communications) to maintain pods (homes) and communication between them. The pods (homes) communicate with the help of services (phones etc.)

This is how you can understand the architecture of Kubernetes. Thanks again to Siddhant Khisty and Aakansha Priya for making this complex topic so simple.

See you folks again. 👋🏻👋🏻

Unleashing the Magic of Open Source

Within the enchanting realm of Open Source, we discovered a magical force that empowers individuals and communities alike. Open Source is not just about code; it's a philosophy that embraces transparency, collaboration and the tireless pursuit of innovation. Just like Harry Potter's wand, Open-Source transforms lines of code into catalysts for remarkable creations.

Collaboration: Where Fairytales Meet Innovation

Collaboration takes center stage in this captivating world. We witnessed the true essence of collaboration, where people from different backgrounds come together, sharing their unique gifts and surpassing boundaries. Much like characters from beloved fairytales, the collaborative spirit within Open-Source ignites a symphony of ideas, fostering innovation and unlocking new possibilities.

Unveiling the Benefits of Open Source

Our journey unveiled the enchanting benefits bestowed upon those who embrace Open Source. Transparent and accessible, Open Source provides a playground for exploration. Feedback flows freely, leading to continuous improvement and the creation of remarkable solutions.

Inclusive Communities: A Tale of Growth and Empowerment

Open-Source communities are like a tapestry woven with diversity, unity, and shared purpose. We marveled at the inclusive nature of these communities, where individuals of all backgrounds and skill sets find support and inspiration. It is a realm where newcomers are welcomed, mentorship thrives, and personal growth becomes an integral part of the journey. Open-Source nurtures talents and empowers dreamers to embark on extraordinary quests. During the event, we highlighted the importance of thriving communities like WeMakeDevs, EddieHub, SuperContributors, and DevsInTech. The audience eagerly expressed their desire to become part of these dynamic communities, recognizing the immense value they provide in nurturing collaboration, fostering growth, and creating meaningful connections. These communities serve as welcoming spaces where individuals can contribute their unique talents and be part of a supportive network that propels them forward in their Open-Source journeys.

The Ripple Effect: Spreading Wonder Across Industries

As we gazed into the reflective pools of Open Source, we witnessed the magical ripple effect it creates. Every contribution, no matter how small, sets forth a chain reaction that reverberates beyond individual projects. It sparks inspiration, fueling the imaginations of others and fostering a culture of continuous learning and innovation across industries. Open-Source becomes a beacon of hope, connecting dreamers, creators, and innovators in a dance of shared progress.

In conclusion...

Our whimsical journey through the realms of Open Source has only just begun. As we bid farewell to this captivating event, we carry with us the revelations and insights that will shape our own quests. Let us embrace the magic of Open Source, forging connections, and weaving our stories into the grand tapestry of collaboration, innovation, and a truly connected world.

So, my dear reader, are you ready to step into the enchanting world of Open Source and become part of this wondrous tale? Adventure awaits, and together, we shall create something truly magical.

After working on anything, you want to save it before it is interrupted or deleted so that you may pick up where you left off, and maintain a history of the changes you made.

makes any sense?

Let's take an example, I want to create a personal website. I spent days working on the coding for it. But hold on, my system isn't working, my hard drive may have failed, or I might have made a mistaken modification to my code and I can't go back to how things were.

this has happened to me :(

This is where Git steps in to save you from all the hassles and disappointments by keeping track of your current project and all the changes you've made rather than saving every single version with a new name on your machine.

There are various programs available to help you maintain track of your work, but in this article, we will solely discuss Git. Git is a version control software that records changes to the code.

It's a talent that every company wants, and BOOM, you can add it to your résumé. :D

Ok! Perhaps you're not happy with it. Perhaps you feel safe storing every file locally.

Lemme answer that as well :)

Since numerous abilities would help the website and I need additional individuals, I am now intending to work with my friends on it. However, having it on your local makes it a little more challenging to use. Since you should always collaborate rather than operate remotely.

With a clear knowledge of where, what, and by whom changes have been made, Git may be used to merge a new version of an already existing version from another user.

Now make your friends do some work too :D

Git

Git is a distributed version control system that allows any user to modify the entirety of a repository on their computer. It makes use of the command line, and Git makes it simple to reverse changes repeatedly while providing a detailed account of what was changed. It can do the following:

1. Tracking the changes, or many iterations of the same file.

2. It also maintains a list of all the files that are included in a project.

3. Comparison and analysis of several codes with thorough justification.

Now you know why to use it, but how?

The first step in getting started with Git is to create a local repository and a remote repository.

Local repository: A local repository is a working path or directory that you have built on a local computer. Up until you push it to the remote repository, the repository where you write your code is private to you.

Remote repository: For hosting your websites, you may use a remote repository, such as GitHub or Bitbucket, which is a public directory or platform. Git makes it simple to push a section of code or a whole project to a remote directory.

Installation

You should now install it on your machine. To install it, kindly look at this link.

Git installation guide

I hope you installed it :)

Key concepts

Let's attempt to comprehend some of the main terms used here:

Version Control System: This program keeps track of various versions of the codes. likewise known as source code management.

Commit: After making your changes, you should send them from the local repository to the staging area or staging index, then to the remote repository. Your code is now saved to Git. Please click the git commit link to learn more about committing.

Checkout: When the working directory has been duplicated with all of the repository's content.

Secure Hash Algorithm, or SHA: Each commit receives its ID. Branch: When you deviate from the primary route of development and carry on working without interfering with it.

Configure your Git

You may set up the user credentials for your local and remote repositories by using the command cd to go to your working directory. The code is pushed into a remote repository using these credentials.

Add your username and user email-id

git config --global user.name "Enter your name here"
git config --global user.email "your_email_address@domain.com"

Use the following command to check the changes you made.

git config -l

Let's see how to work locally with git

A repository must first be present on a local system. The current project will be kept in this repository; it may then be uploaded to GitHub. To navigate the repositories, we utilize the command line. Go to the path using the cd command, then use the mkdir command to create a directory.

mkdir git-test

1. git init

   Use the git init command to initialize the directory after it has been created. The master branch is now the result of the git init command, which starts a fresh git repository. The source code and other development materials are kept in the repository, which is a version control system.

2. git status

   It is simple to see the changes made in a repository using git status. Let's assume I used the git status command to add a new file to the branch that Git is showing. By executing this command, any modifications may be noticed. This does not imply that the modifications are made and saved.

3. git add

   Before it is committed, the modifications made should be included. Using the git add command, the code or any file is added to the staging area.

   To add multiple files at one go we use the command git add . All the modified files present in the local repository are moved to the staging area.

4. git commit

   It is used to store the file in a repository from the staging area.

Commands to review history in Git

When working on a piece of code, you'll probably want to undo any changes you've made or want to see how the code looked before you made them. Some commands may be used to view previous modifications.

1. git log

   to see every commit that has been made to the repository. The git log command is used. By including the SHA key in the command, we can see a particular commit come first, then all the others.

2. git --stat

   Using this command, you can see which files were changed and how many lines of code were added or deleted.

3. git log -p

   Using this command, you may see the actual changes—the lines that have been added or removed—that have been made. The patch is indicated by the -p.

You may supply the SHA key to any of these commands, which may be beneficial for seeing a specific commit.

Branching in Git

Creating a new branch

One should make it a practice to make modifications in a distinct branch before making them straight to the master branch. Even though you can roll back to the prior commit if the new modifications don't work, doing so costs the organization money.

Instead, it is preferable to work on a fresh branch, test the changes, and then transfer them to the living environment.

Use the command git branch <branch-name> to add a branch that references the master. Use git branch <branch-name> SHA instead if the modifications need to be made to a commit that isn't a master right now. The new branch should be added after which commit, according to SHA.

We transfer the master branch to a new branch named <branch-name> using the command git checkout <branch-name>. By using the same procedures, we used with the previous master branch, you can now add and commit modifications to this branch. after that, your branch has been pushed to the distant repository:

<branch-name> git push -u origin

If successful, use git merge <branch-name> to combine the code with the old master branch. However, you must use the git checkout command to return to the previous master branch before executing the merge command.

Using git commands, it is also possible to rename, remove, and compare branches:

1. Rename: git branch -m <branch-name> <new-branch-name>

2. Delete: git branch -d <branch-name>

3. Compare branches: git diff <branch-name> <master-branch-name>

TL; DR

Git is an open-source, free program. It delivers at a higher speed and is simple to use. It enables you to execute your code in the cloud and keeps track of every change that has ever been made to the project, or the whole history of changes. Each commit includes the name of the author, a brief description, a date, and the SHA1 hash of the previous commit.

Git is advantageous when a team is operating remotely. Since anybody may edit as long as they have access to the remote repository.

Your local repository may be connected to any remote repository, including GitHub, GitLab, Bitbucket, and others.

In today's tech industry, the biggest mistake beginners do is jumping from one language to another as they follow trends, check out 'what is popular' and start learning it without a roadmap. That is a bad way to start in the industry and if you don't start well, the path ahead goes and becomes more and more difficult. One of the things my friend did for me when I first started in IT was to create a learning roadmap, and it was one of the things that helped me improve. Although it may appear complicated, the frontend development learning map is not that large. It won't seem daunting if you approach it to step by step.

• Foundation Knowledge

  as you will be developing websites it will be beneficial to understand the Internet, how websites work, etc. It will help you understand the rationale behind why things are done the way they are.

• Into the Basics

  

  The three pillars of Front-end development are HTML, CSS and JavaScript. 90% of websites we go on, through our phone, our laptop or tablet are made using these three languages, HTML, CSS and JavaScript. So I don't think so you have any doubt about why we should start with these three.

  Let's take the example of the human body, how our body is built with the skeletal system, muscular system and nervous system. Just like the skeletal system is responsible for all the structure of the body, HTML is responsible for the structure of the website. And the muscles on the body are responsible for how we look, just like CSS takes responsibility for how our website will look. All the aesthetics of the website is under the influence of CSS. Now comes the functionality, as the nervous system takes care of the functionality of the human body, and JavaScript takes care of all the functionality in the website.

• Now come Libraries and Frameworks

  after the basics, libraries and frameworks like React, Vue and Angular etc. make the work easier and faster. As React is a library, not a framework. The major difference between a library and a framework is that a library doesn't force the application to be in a pre-defined structure but a framework forces the application to follow a structure. For example, a project that uses bootstrap may be identified by the way it looks and functions since bootstrap is a CSS framework.

• Learn the usage of version control software

  

  Learn how to use Git, as Git is the most popular and most used version control system, and is used in 70% of software development. It is utilized to keep track of our project history and collaborate with others, hence it is virtually universally mentioned in job descriptions. Whilst there are several version control systems, it is advised to become familiar with Git because of its popularity.

• CSS pre-processors

  Because of its age and inability to handle extremely large projects, CSS is insufficient. Whenever you try to make changes to your code, a bug pops up, and the process may be quite daunting. The CSS preprocessor streamlines and expedites your work. There are other CSS preprocessors, however as SASS is more widely used, learning it is advised.

• Resources

  Front-end Libraries Certification by FCC

  Video by FCC on Front-end Development

  Portfolio Website tutorial using HTML, CSS and JavaScript

See you folks in another blog.

What is GoLang?

The Golang programming language is an open source project from Google. It was made to be a better alternative for writing large programs, especially ones that need concurrency features like channels and goroutines. Golang can also compile code into the machine’s native instruction set so it runs faster than other languages.

Why it is better than others?

GoLang bring a lot of benefits on the table, which makes it better than others, like:

1. Simple: It has a simpler syntax than many other languages, much similar to Python. No curly braces, semi-colons or parentheses for control statements. This ease in syntax and writing codes makes it easier to read Golang code which helps engineers to work faster and find errors.

2. Faster Development: It reduces development time considerably in error checking, concurrency or simplifying complex threads.

3. Portable: Golang can be compiled for any operating system and architecture. This is different from other languages that need to compile code into bytecode which only runs on the same platform they were built in.

Does any company use GoLang?

Yeah, it is used more than you think. Here are some companies which uses GO.

• Google

Not a surprise, Golang was developed by Google Engineers and is often used in internal projects. Google Chrome and Google Earth were created in this way.

• Uber

One of the biggest companies using Golang is Uber. It is used there for the geofence service, which serves the user’s location and product availability. Geofence makes it possible to precisely define the area with special requirements (e.g. taking into account places such as airports) and to implement dynamic prices.

• Twitch

In Twitch, Go is used for the most-loaded systems. It is appreciated for its simplicity, security, efficiency and readability, which means that it perfectly manages problems encountered when displaying live video and simultaneous chats of a large number of users

• Daily Motion

Dailymotion is a video streaming website. Thanks to Golang, among others, automation of APIs has been improved.

This language makes it possible to carry out a large number of automation tests, which would otherwise cause huge loads. All because of Golang simplicity and its performance, as well as the possibility of static type checking.

Advantages of GoLang

• Golang is better than other programming languages, therefore it reduces development time considerably through error checking, concurrency handling, simplifying threads and go routines that are scalable.
• It allows concurrent programming which is a big draw for companies who want to save time and resources.
• Golang has a solid standard library that includes everything developers need from math, strings, net/web connections to the more advanced topics of crypto and database access.
• Standard libraries are one less thing you have to worry about when using Golang as they already contain all the code necessary for common tasks like reading input or writing output; so no extra coding required.
• The syntax is simple enough too with just basic statements being allowed without curly brackets in favor of go-routines. Allowing programmers to focus on what their real goal is the logic and not how it’s written down.

Disadvantages of GoLang

• There are some security concerns with Golang. Since it’s not widely used in many organizations and because there are more bugs as well as less secure coding practices compared to other languages. This means that software developers need to take extra precautions when developing code for Golang-based applications.

• Golang is not an easy language due to its minimalistic style which can make debugging difficult (not impossible). Dependencies need installing (unlike with Java) so there may be some limitations when working from home or public machines such as libraries you can’t find locally.

Conclusion

According to me GoLang is highly effective, fast and adds a massive value in complex applications. And since it's introduction, GoLang has gained popularity and got famousin many business giants, like Netflix, Uber, BBC, etc. With a steady growing user base, soon a majority of companies will need to switch to Golang.

After going through a lot of search results, YouTube videos, and reading multiple blogs, I somewhat knew what is the importance of open-source. It possibly seems dreadful and daunting to read and search multiple lines of code but it is not what it seems. It is very easy to start if you have the right guidance and a welcoming community, both of it was provided with twitter.

So I started working on my skills and parallelly started Web Development. One day I came across a tweet by Eddie Jaoude on Hacktoberfest, and again my fingers ran through the keyboard searching for what it meant.

What is Hacktoberfest?

Spoiler: It is not related to Hacking or something like that.

Hacktoberfest is a month-long event that celebrates open-source contributions from 1st October to 31st October. It is presented by DigitalOcean with support from AppWrite and Docker. During this month you're encouraged to contribute to your favorite repositories marked with the label Hacktoberfest. On successfully making four pull requests merged you get swags that include a very cool T-shirt from the Hacktoberfest team, but my objective was never to get a T-shirt.

My First Pull Request

So I was actively participating and joining some VCs in a discord community named SuperContributors and from there I saw a project which was basically an HTML cheatsheet to help people in HTML. I added a section that tells about the text formatting that can be done using HTML tags.

Open-Source With Pradumna Saraf

Just three-four days before the Hacktoberfest started, I saw this repository and saw one issue which I thought was solvable and asked to get assigned (also came to know that it is a good practice to ask the maintainer to assign you the issue before start working on it). Solved it and learned how to use GitHub pages, as my issue worked around it.

This repo is just so awesome for learning new things, if you're a beginner just like me, go on to this page and learn various things which are necessary for getting used to open-source contributions.

1 2 3 4.. I'm on the roll

On October 12, my four PRs got merged and were through the 7 days verification period. I was more than happy but didn't stop learning about new things, getting better 4 PRs weren't the end of the learning stage, it was merely the beginning of a very long and awesome journey.

My fifth PR was on an issue I raised after going through the page, the best part was maintainer was already going to raise it but I did it before him, it was like I already read his mind. Any guesses who was the owner/maintainer of the repository, none other than Pradumna Saraf.

SuperContributors

SuperContributors is a community, which deserves a special place in this blog. It is a totally beginner-friendly community, which helps people like me to learn various tech-related stuff. Amazing folks like Aayush Sharma, Bhavya Sachdeva, Chirag Varshney, Jaideep Solania, Kanika Gola, and many other faces are always eager to help beginners and let them grow.

My first meet-up

As October wasn't already good enough my application for the first meet-up got accepted. The day was 16 October, I have to go to HUDA city center, Gurugram, and got the amazing company of my friend Anshum Shukla. The meetup was organized by Solana and hosted by Hack This Fall.

So the meet-up was really nice and I had a total fanboy feeling inside me. Seeing so amazing folks in person, meeting them, and asking whatever doubts I had. It was mesmerizing to see such good people in one place.

The whole theme of the meet-up was around Hacktoberfest, there were sessions about git, GitHub, and open-source. What are good contributions, and what are bad contributions?

A talk by Aditya Oberoi and Haimantika about appwrite, which provides backend-as-a-service to developers.

In a talk by Prakarsh, he told about what Solana provides to developers. Solana is a decentralized blockchain built to enable scalable, user-friendly apps for the world.

In a nutshell, the overall meet-up was probably the best day of this year.

Conclusion

Hacktoberfest isn't an event to complete 4 PRs or compete with who's gonna complete the target of 4 PRs. All I learned was code to contribute not to compete. Don't do open-source for the sake of a T-shirt. You might get a better one in a market or someplace. Open source is a pool of wisdom, you either can take a dip and learn from that or you can add your bucket of learning to it. Both will make you grow and be better.